compass_api_sdk 0.0.1__py3-none-any.whl

compass_api_sdk/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561. The package enables type hints.

compass_api_sdk/sdk.py

@@ -0,0 +1,155 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from .basesdk import BaseSDK
+from .httpclient import AsyncHttpClient, ClientOwner, HttpClient, close_clients
+from .sdkconfiguration import SDKConfiguration
+from .utils.logger import Logger, get_default_logger
+from .utils.retries import RetryConfig
+from compass_api_sdk import models, utils
+from compass_api_sdk._hooks import SDKHooks
+from compass_api_sdk.aave_v3 import AaveV3
+from compass_api_sdk.aerodrome_slipstream import AerodromeSlipstream
+from compass_api_sdk.morpho import Morpho
+from compass_api_sdk.token_sdk import TokenSDK
+from compass_api_sdk.types import OptionalNullable, UNSET
+from compass_api_sdk.uniswap_v3 import UniswapV3
+from compass_api_sdk.universal import Universal
+import httpx
+from typing import Any, Callable, Dict, Optional, Union, cast
+import weakref
+
+
+class CompassAPISDK(BaseSDK):
+    r"""Compass API: Compass Labs DeFi API"""
+
+    aave_v3: AaveV3
+    aerodrome_slipstream: AerodromeSlipstream
+    morpho: Morpho
+    token: TokenSDK
+    uniswap_v3: UniswapV3
+    universal: Universal
+
+    def __init__(
+        self,
+        api_key_auth: Union[str, Callable[[], str]],
+        server_idx: Optional[int] = None,
+        server_url: Optional[str] = None,
+        url_params: Optional[Dict[str, str]] = None,
+        client: Optional[HttpClient] = None,
+        async_client: Optional[AsyncHttpClient] = None,
+        retry_config: OptionalNullable[RetryConfig] = UNSET,
+        timeout_ms: Optional[int] = None,
+        debug_logger: Optional[Logger] = None,
+    ) -> None:
+        r"""Instantiates the SDK configuring it with the provided parameters.
+
+        :param api_key_auth: The api_key_auth required for authentication
+        :param server_idx: The index of the server to use for all methods
+        :param server_url: The server URL to use for all methods
+        :param url_params: Parameters to optionally template the server URL with
+        :param client: The HTTP client to use for all synchronous methods
+        :param async_client: The Async HTTP client to use for all asynchronous methods
+        :param retry_config: The retry configuration to use for all supported methods
+        :param timeout_ms: Optional request timeout applied to each operation in milliseconds
+        """
+        client_supplied = True
+        if client is None:
+            client = httpx.Client()
+            client_supplied = False
+
+        assert issubclass(
+            type(client), HttpClient
+        ), "The provided client must implement the HttpClient protocol."
+
+        async_client_supplied = True
+        if async_client is None:
+            async_client = httpx.AsyncClient()
+            async_client_supplied = False
+
+        if debug_logger is None:
+            debug_logger = get_default_logger()
+
+        assert issubclass(
+            type(async_client), AsyncHttpClient
+        ), "The provided async_client must implement the AsyncHttpClient protocol."
+
+        security: Any = None
+        if callable(api_key_auth):
+            # pylint: disable=unnecessary-lambda-assignment
+            security = lambda: models.Security(api_key_auth=api_key_auth())
+        else:
+            security = models.Security(api_key_auth=api_key_auth)
+
+        if server_url is not None:
+            if url_params is not None:
+                server_url = utils.template_url(server_url, url_params)
+
+        BaseSDK.__init__(
+            self,
+            SDKConfiguration(
+                client=client,
+                client_supplied=client_supplied,
+                async_client=async_client,
+                async_client_supplied=async_client_supplied,
+                security=security,
+                server_url=server_url,
+                server_idx=server_idx,
+                retry_config=retry_config,
+                timeout_ms=timeout_ms,
+                debug_logger=debug_logger,
+            ),
+        )
+
+        hooks = SDKHooks()
+
+        current_server_url, *_ = self.sdk_configuration.get_server_details()
+        server_url, self.sdk_configuration.client = hooks.sdk_init(
+            current_server_url, client
+        )
+        if current_server_url != server_url:
+            self.sdk_configuration.server_url = server_url
+
+        # pylint: disable=protected-access
+        self.sdk_configuration.__dict__["_hooks"] = hooks
+
+        weakref.finalize(
+            self,
+            close_clients,
+            cast(ClientOwner, self.sdk_configuration),
+            self.sdk_configuration.client,
+            self.sdk_configuration.client_supplied,
+            self.sdk_configuration.async_client,
+            self.sdk_configuration.async_client_supplied,
+        )
+
+        self._init_sdks()
+
+    def _init_sdks(self):
+        self.aave_v3 = AaveV3(self.sdk_configuration)
+        self.aerodrome_slipstream = AerodromeSlipstream(self.sdk_configuration)
+        self.morpho = Morpho(self.sdk_configuration)
+        self.token = TokenSDK(self.sdk_configuration)
+        self.uniswap_v3 = UniswapV3(self.sdk_configuration)
+        self.universal = Universal(self.sdk_configuration)
+
+    def __enter__(self):
+        return self
+
+    async def __aenter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if (
+            self.sdk_configuration.client is not None
+            and not self.sdk_configuration.client_supplied
+        ):
+            self.sdk_configuration.client.close()
+        self.sdk_configuration.client = None
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if (
+            self.sdk_configuration.async_client is not None
+            and not self.sdk_configuration.async_client_supplied
+        ):
+            await self.sdk_configuration.async_client.aclose()
+        self.sdk_configuration.async_client = None

compass_api_sdk/sdkconfiguration.py

@@ -0,0 +1,56 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from ._hooks import SDKHooks
+from ._version import (
+    __gen_version__,
+    __openapi_doc_version__,
+    __user_agent__,
+    __version__,
+)
+from .httpclient import AsyncHttpClient, HttpClient
+from .utils import Logger, RetryConfig, remove_suffix
+from compass_api_sdk import models
+from compass_api_sdk.types import OptionalNullable, UNSET
+from dataclasses import dataclass
+from pydantic import Field
+from typing import Callable, Dict, Optional, Tuple, Union
+
+
+SERVERS = [
+    "https://api.compasslabs.ai",
+    # Production server
+]
+"""Contains the list of servers available to the SDK"""
+
+
+@dataclass
+class SDKConfiguration:
+    client: Union[HttpClient, None]
+    client_supplied: bool
+    async_client: Union[AsyncHttpClient, None]
+    async_client_supplied: bool
+    debug_logger: Logger
+    security: Optional[Union[models.Security, Callable[[], models.Security]]] = None
+    server_url: Optional[str] = ""
+    server_idx: Optional[int] = 0
+    language: str = "python"
+    openapi_doc_version: str = __openapi_doc_version__
+    sdk_version: str = __version__
+    gen_version: str = __gen_version__
+    user_agent: str = __user_agent__
+    retry_config: OptionalNullable[RetryConfig] = Field(default_factory=lambda: UNSET)
+    timeout_ms: Optional[int] = None
+
+    def __post_init__(self):
+        self._hooks = SDKHooks()
+
+    def get_server_details(self) -> Tuple[str, Dict[str, str]]:
+        if self.server_url is not None and self.server_url:
+            return remove_suffix(self.server_url, "/"), {}
+        if self.server_idx is None:
+            self.server_idx = 0
+
+        return SERVERS[self.server_idx], {}
+
+    def get_hooks(self) -> SDKHooks:
+        return self._hooks