crypticorn 2.1.5__py3-none-any.whl → 2.2.0__py3-none-any.whl

crypticorn/auth/main.py

@@ -7,7 +7,6 @@ from crypticorn.auth import (
     WalletApi,
     AuthApi,
 )
-from crypticorn.common import BaseURL, ApiVersion, Service, apikey_header as aph
 
 
 class AuthClient:
@@ -17,19 +16,9 @@ class AuthClient:
 
     def __init__(
         self,
-        base_url: BaseURL,
-        api_version: ApiVersion,
-        api_key: str = None,
-        jwt: str = None,
+        config: Configuration,
     ):
-        self.host = f"{base_url.value}/{api_version.value}/{Service.AUTH.value}"
-        self.config = Configuration(
-            host=self.host,
-            access_token=jwt,
-            api_key={aph.scheme_name: api_key} if api_key else None,
-            api_key_prefix=({aph.scheme_name: aph.model.name} if api_key else None),
-            debug=True,
-        )
+        self.config = config
         self.base_client = ApiClient(configuration=self.config)
         # Instantiate all the endpoint clients
         self.admin = AdminApi(self.base_client)
@@ -37,9 +26,3 @@ class AuthClient:
         self.user = UserApi(self.base_client)
         self.wallet = WalletApi(self.base_client)
         self.login = AuthApi(self.base_client)
-
-    async def __aenter__(self):
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        await self.base_client.close()

crypticorn/client.py

@@ -1,10 +1,11 @@
-from crypticorn.hive import HiveClient
+from crypticorn.hive import HiveClient, Configuration
 from crypticorn.klines import KlinesClient
 from crypticorn.pay import PayClient
 from crypticorn.trade import TradeClient
-from crypticorn.common import BaseURL, ApiVersion
-
-
+from crypticorn.metrics import MetricsClient
+from crypticorn.auth import AuthClient
+from crypticorn.common import BaseUrl, ApiVersion, Service, apikey_header as aph
+import warnings
 class ApiClient:
     """
     The official client for interacting with the Crypticorn API.
@@ -14,32 +15,30 @@ class ApiClient:
 
     def __init__(
         self,
-        base_url: BaseURL = BaseURL.PROD,
         api_key: str = None,
         jwt: str = None,
-        hive_version: ApiVersion = ApiVersion.V1,
-        klines_version: ApiVersion = ApiVersion.V1,
-        pay_version: ApiVersion = ApiVersion.V1,
-        trade_version: ApiVersion = ApiVersion.V1,
-        auth_version: ApiVersion = ApiVersion.V1,
+        base_url: BaseUrl = BaseUrl.PROD,
     ):
         self.base_url = base_url
+        '''The base URL the client will use to connect to the API.'''
         self.api_key = api_key
+        '''The API key to use for authentication.'''
         self.jwt = jwt
-        self.hive = HiveClient(base_url, hive_version, api_key, jwt)
-        self.trade = TradeClient(base_url, trade_version, api_key, jwt)
-        self.klines = KlinesClient(base_url, klines_version, api_key, jwt)
-        self.pay = PayClient(base_url, pay_version, api_key, jwt)
-        # currently not working due to circular import since the AUTH_Handler
-        # is also using the ApiClient
-        # self.auth = AuthClient(base_url, auth_version, api_key, jwt)
+        '''The JWT to use for authentication.'''
 
-    async def __aenter__(self):
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        await self.close()
+        self.hive = HiveClient(self._get_default_config(Service.HIVE))
+        self.trade = TradeClient(self._get_default_config(Service.TRADE))
+        self.klines = KlinesClient(self._get_default_config(Service.KLINES))
+        self.pay = PayClient(self._get_default_config(Service.PAY))
+        self.metrics = MetricsClient(self._get_default_config(Service.METRICS))
+        self.auth = AuthClient(self._get_default_config(Service.AUTH)) 
 
+    def __new__(cls, *args, **kwargs):
+        if kwargs.get("api_key") and not kwargs.get("jwt"):
+            # auth-service does not allow api_key
+            warnings.warn("The auth module does only accept JWT to be used to authenticate. If you use this module, you need to provide a JWT.")
+        return super().__new__(cls)
+    
     async def close(self):
         """Close all client sessions."""
         clients = [
@@ -47,8 +46,62 @@ class ApiClient:
             self.trade.base_client,
             self.klines.base_client,
             self.pay.base_client,
+            self.metrics.base_client,
+            self.auth.base_client,
         ]
 
         for client in clients:
             if hasattr(client, "close"):
                 await client.close()
+
+    def _get_default_config(self, service: Service, version: ApiVersion = ApiVersion.V1):
+        """
+        Get the default configuration for a given service.
+        """
+        return Configuration(
+            host=f"{self.base_url}/{version}/{service}",
+            access_token=self.jwt,
+            api_key={aph.scheme_name: self.api_key} if self.api_key else None,
+            api_key_prefix=({aph.scheme_name: aph.model.name} if self.api_key else None),
+        )
+    
+    def configure(self, config: Configuration, sub_client: any):
+        """
+        Update a sub-client's configuration by overriding with the values set in the new config.
+        Useful for testing a specific service against a local server instead of the default proxy.
+
+        :param config: The new configuration to use for the sub-client.
+        :param sub_client: The sub-client to configure.
+
+        Example:
+        This will override the host for the Hive client to connect to http://localhost:8000 instead of the default proxy:
+        >>> async with ApiClient(base_url=BaseUrl.DEV, jwt=jwt) as client:
+        >>>     client.configure(config=HiveConfig(host="http://localhost:8000"), sub_client=client.hive)
+        """
+        new_config = sub_client.config
+        for attr in vars(config):
+            new_value = getattr(config, attr)
+            if new_value is not None:
+                setattr(new_config, attr, new_value)
+
+        if sub_client == self.hive:
+            self.hive = HiveClient(new_config)
+        elif sub_client == self.trade:
+            self.trade = TradeClient(new_config)
+        elif sub_client == self.klines:
+            self.klines = KlinesClient(new_config)
+        elif sub_client == self.pay:
+            self.pay = PayClient(new_config)
+        elif sub_client == self.metrics:
+            self.metrics = MetricsClient(new_config)
+        elif sub_client == self.auth:
+            self.auth = AuthClient(new_config)
+        else:
+            raise ValueError(f"Unknown sub-client: {sub_client}")
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+

crypticorn/common/__init__.py

@@ -1,5 +1,4 @@
 from crypticorn.common.errors import *
 from crypticorn.common.scopes import *
 from crypticorn.common.urls import *
-from crypticorn.common.auth import *
-from crypticorn.common.auth_client import *
+from crypticorn.common.auth import *

crypticorn/common/auth.py

@@ -1,6 +1,24 @@
-from fastapi.security import APIKeyHeader, HTTPBearer
+import json
 
+from crypticorn.auth import Verify200Response, AuthClient, Configuration
+from crypticorn.auth.client.exceptions import ApiException
+from crypticorn.common import (
+    ApiError,
+    ApiVersion,
+    BaseUrl,
+    Scope,
+    Service,
+)
+from fastapi import Depends, HTTPException, Query, status
+from fastapi.security import (
+    HTTPAuthorizationCredentials,
+    SecurityScopes,
+    HTTPBearer,
+    APIKeyHeader,
+)
+from typing_extensions import Annotated
 
+# Auth Schemes
 http_bearer = HTTPBearer(
     bearerFormat="JWT",
     auto_error=False,
@@ -12,3 +30,189 @@ apikey_header = APIKeyHeader(
     auto_error=False,
     description="The API key to use for authentication.",
 )
+
+# Auth Handler
+class AuthHandler:
+    """
+    Middleware for verifying API requests. Verifies the validity of the authentication token, scopes, etc.
+
+    @param base_url: The base URL of the API.
+    @param api_version: The version of the API.
+    """
+
+    def __init__(
+        self,
+        base_url: BaseUrl = BaseUrl.PROD,
+    ):
+        self.url = f"{base_url}/{ApiVersion.V1}/{Service.AUTH}"
+        self.client = AuthClient(Configuration(host=self.url))
+
+        self.no_credentials_exception = HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail=ApiError.NO_CREDENTIALS.identifier,
+        )
+
+    async def _verify_api_key(self, api_key: str) -> None:
+        """
+        Verifies the API key.
+        """
+        return await self.client.login.verify_api_key(api_key)
+
+    async def _verify_bearer(
+        self, bearer: HTTPAuthorizationCredentials
+    ) -> Verify200Response:
+        """
+        Verifies the bearer token.
+        """
+        self.client.config.access_token = bearer.credentials
+        return await self.client.login.verify()
+
+    async def _validate_scopes(
+        self, api_scopes: list[Scope], user_scopes: list[Scope]
+    ) -> bool:
+        """
+        Checks if the user scopes are a subset of the API scopes.
+        """
+        if not set(api_scopes).issubset(user_scopes):
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail=ApiError.INSUFFICIENT_SCOPES.identifier,
+            )
+
+    async def _extract_message(self, e: ApiException) -> str:
+        """
+        Tries to extract the message from the body of the exception.
+        """
+        try:
+            load = json.loads(e.body)
+        except (json.JSONDecodeError, TypeError):
+            return e.body
+        else:
+            common_keys = ["message"]
+            for key in common_keys:
+                if key in load:
+                    return load[key]
+            return load
+
+    async def _handle_exception(self, e: Exception) -> HTTPException:
+        """
+        Handles exceptions and returns a HTTPException with the appropriate status code and detail.
+        """
+        if isinstance(e, ApiException):
+            return HTTPException(
+                status_code=e.status,
+                detail=await self._extract_message(e),
+            )
+        elif isinstance(e, HTTPException):
+            return e
+        else:
+            return HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail=str(e),
+            )
+
+    async def api_key_auth(
+        self,
+        api_key: Annotated[str | None, Depends(apikey_header)] = None,
+        sec: SecurityScopes = SecurityScopes(),
+    ) -> Verify200Response:
+        """
+        Verifies the API key and checks if the user scopes are a subset of the API scopes.
+        Use this function if you only want to allow access via the API key.
+        """
+        return await self.combined_auth(bearer=None, api_key=api_key, sec=sec)
+
+    async def bearer_auth(
+        self,
+        bearer: Annotated[
+            HTTPAuthorizationCredentials | None,
+            Depends(http_bearer),
+        ] = None,
+        sec: SecurityScopes = SecurityScopes(),
+    ) -> Verify200Response:
+        """
+        Verifies the bearer token and checks if the user scopes are a subset of the API scopes.
+        Use this function if you only want to allow access via the bearer token.
+        """
+        return await self.combined_auth(bearer=bearer, api_key=None, sec=sec)
+
+    async def combined_auth(
+        self,
+        bearer: Annotated[
+            HTTPAuthorizationCredentials | None, Depends(http_bearer)
+        ] = None,
+        api_key: Annotated[str | None, Depends(apikey_header)] = None,
+        sec: SecurityScopes = SecurityScopes(),
+    ) -> Verify200Response:
+        """
+        Verifies the bearer token and/or API key and checks if the user scopes are a subset of the API scopes.
+        Returns early on the first successful verification, otherwise tries all available tokens.
+        Use this function if you want to allow access via either the bearer token or the API key.
+        """
+        tokens = [bearer, api_key]
+
+        last_error = None
+        for token in tokens:
+            try:
+                if token is None:
+                    continue
+                res = None
+                if isinstance(token, str):
+                    res = await self._verify_api_key(token)
+                elif isinstance(token, HTTPAuthorizationCredentials):
+                    res = await self._verify_bearer(token)
+                if res is None:
+                    continue
+                if sec:
+                    await self._validate_scopes(sec.scopes, res.scopes)
+                return res
+
+            except Exception as e:
+                last_error = await self._handle_exception(e)
+                continue
+
+        raise last_error or self.no_credentials_exception
+
+    async def ws_api_key_auth(
+        self,
+        api_key: Annotated[str | None, Query()] = None,
+        sec: SecurityScopes = SecurityScopes(),
+    ) -> Verify200Response:
+        """
+        Verifies the API key and checks if the user scopes are a subset of the API scopes.
+        Use this function if you only want to allow access via the API key.
+        """
+        return await self.api_key_auth(api_key=api_key, sec=sec)
+
+    async def ws_bearer_auth(
+        self,
+        bearer: Annotated[str | None, Query()] = None,
+        sec: SecurityScopes = SecurityScopes(),
+    ) -> Verify200Response:
+        """
+        Verifies the bearer token and checks if the user scopes are a subset of the API scopes.
+        Use this function if you only want to allow access via the bearer token.
+        """
+        credentials = (
+            HTTPAuthorizationCredentials(scheme="Bearer", credentials=bearer)
+            if bearer
+            else None
+        )
+        return await self.bearer_auth(bearer=credentials, sec=sec)
+
+    async def ws_combined_auth(
+        self,
+        bearer: Annotated[str | None, Query()] = None,
+        api_key: Annotated[str | None, Query()] = None,
+        sec: SecurityScopes = SecurityScopes(),
+    ) -> Verify200Response:
+        """
+        Verifies the bearer token and/or API key and checks if the user scopes are a subset of the API scopes.
+        Use this function if you want to allow access via either the bearer token or the API key.
+        """
+        credentials = (
+            HTTPAuthorizationCredentials(scheme="Bearer", credentials=bearer)
+            if bearer
+            else None
+        )
+        return await self.combined_auth(bearer=credentials, api_key=api_key, sec=sec)

crypticorn/common/scopes.py

@@ -1,7 +1,7 @@
-from enum import Enum
+from enum import StrEnum
 
 
-class Scope(str, Enum):
+class Scope(StrEnum):
     """
     The permission scopes for the API.
     """

crypticorn/common/urls.py

@@ -1,25 +1,37 @@
-from enum import Enum
+from enum import StrEnum
 
+class ApiEnv(StrEnum):
+    PROD = "prod"
+    DEV = "dev"
+    LOCAL = "local"
+    DOCKER = "docker"
 
-class Domain(Enum):
-    PROD = "crypticorn.com"
-    DEV = "crypticorn.dev"
-
-
-class BaseURL(Enum):
+class BaseUrl(StrEnum):
     PROD = "https://api.crypticorn.com"
     DEV = "https://api.crypticorn.dev"
     LOCAL = "http://localhost"
     DOCKER = "http://host.docker.internal"
 
+    @classmethod
+    def from_env(cls, env: ApiEnv) -> "BaseUrl":
+        if env == ApiEnv.PROD:
+            return cls.PROD
+        elif env == ApiEnv.DEV:
+            return cls.DEV
+        elif env == ApiEnv.LOCAL:
+            return cls.LOCAL
+        elif env == ApiEnv.DOCKER:
+            return cls.DOCKER
+
 
-class ApiVersion(Enum):
+class ApiVersion(StrEnum):
     V1 = "v1"
 
 
-class Service(Enum):
+class Service(StrEnum):
     HIVE = "hive"
     KLINES = "klines"
     PAY = "pay"
     TRADE = "trade"
     AUTH = "auth"
+    METRICS = "metrics"

crypticorn/hive/main.py

@@ -4,8 +4,9 @@ from crypticorn.hive import (
     ModelsApi,
     DataApi,
     StatusApi,
+    Configuration,
 )
-from crypticorn.common import BaseURL, ApiVersion, Service, apikey_header as aph
+from crypticorn.common import apikey_header as aph
 
 
 class HiveClient:
@@ -15,18 +16,9 @@ class HiveClient:
 
     def __init__(
         self,
-        base_url: BaseURL,
-        api_version: ApiVersion,
-        api_key: str = None,
-        jwt: str = None,
+        config: Configuration,
     ):
-        self.host = f"{base_url.value}/{api_version.value}/{Service.HIVE.value}"
-        self.config = Configuration(
-            host=self.host,
-            access_token=jwt,
-            api_key={aph.scheme_name: api_key} if api_key else None,
-            api_key_prefix=({aph.scheme_name: aph.model.name} if api_key else None),
-        )
+        self.config = config
         self.base_client = ApiClient(configuration=self.config)
         # Instantiate all the endpoint clients
         self.models = ModelsApi(self.base_client)

crypticorn/klines/client/configuration.py

@@ -191,7 +191,7 @@ class Configuration:
     ) -> None:
         """Constructor"""
         self._base_path = (
-            "https://api.crypticorn.dev/v1/klines" if host is None else host
+            "http://localhost/v1/klines" if host is None else host
         )
         """Default Base url
         """
@@ -516,7 +516,7 @@ class Configuration:
         """
         return [
             {
-                "url": "https://api.crypticorn.dev/v1/klines",
+                "url": "http://localhost/v1/klines",
                 "description": "No description provided",
             }
         ]

crypticorn/klines/main.py

@@ -8,7 +8,6 @@ from crypticorn.klines import (
     SymbolsApi,
     UDFApi,
 )
-from crypticorn.common import BaseURL, ApiVersion, Service, apikey_header as aph
 
 
 class FundingRatesApiWrapper(FundingRatesApi):
@@ -58,18 +57,9 @@ class KlinesClient:
 
     def __init__(
         self,
-        base_url: BaseURL,
-        api_version: ApiVersion,
-        api_key: str = None,
-        jwt: str = None,
+        config: Configuration,
     ):
-        self.host = f"{base_url.value}/{api_version.value}/{Service.KLINES.value}"
-        self.config = Configuration(
-            host=self.host,
-            access_token=jwt,
-            api_key={aph.scheme_name: api_key} if api_key else None,
-            api_key_prefix=({aph.scheme_name: aph.model.name} if api_key else None),
-        )
+        self.config = config
         self.base_client = ApiClient(configuration=self.config)
         # Instantiate all the endpoint clients
         self.funding = FundingRatesApiWrapper(self.base_client)

crypticorn/metrics/__init__.py

@@ -0,0 +1,4 @@
+from crypticorn.metrics.client import *
+from crypticorn.metrics.main import MetricsClient
+
+__all__ = ["MetricsClient", ]

crypticorn/metrics/client/__init__.py

@@ -0,0 +1,60 @@
+# coding: utf-8
+
+# flake8: noqa
+
+"""
+    Marketcap Service API
+
+         API for retrieving historical marketcap data, available exchanges, and indicators.          ## Features     - Historical marketcap data     - OHLCV data with marketcap     - Technical indicators (KER, SMA)     - Exchange and symbol mappings     - Error logs     
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+__version__ = "1.0.0"
+
+# import apis into sdk package
+from crypticorn.metrics.client.api.exchanges_api import ExchangesApi
+from crypticorn.metrics.client.api.health_check_api import HealthCheckApi
+from crypticorn.metrics.client.api.indicators_api import IndicatorsApi
+from crypticorn.metrics.client.api.logs_api import LogsApi
+from crypticorn.metrics.client.api.marketcap_api import MarketcapApi
+from crypticorn.metrics.client.api.markets_api import MarketsApi
+from crypticorn.metrics.client.api.tokens_api import TokensApi
+
+# import ApiClient
+from crypticorn.metrics.client.api_response import ApiResponse
+from crypticorn.metrics.client.api_client import ApiClient
+from crypticorn.metrics.client.configuration import Configuration
+from crypticorn.metrics.client.exceptions import OpenApiException
+from crypticorn.metrics.client.exceptions import ApiTypeError
+from crypticorn.metrics.client.exceptions import ApiValueError
+from crypticorn.metrics.client.exceptions import ApiKeyError
+from crypticorn.metrics.client.exceptions import ApiAttributeError
+from crypticorn.metrics.client.exceptions import ApiException
+
+# import models into sdk package
+from crypticorn.metrics.client.models.base_response_dict import BaseResponseDict
+from crypticorn.metrics.client.models.base_response_health_check_response import (
+    BaseResponseHealthCheckResponse,
+)
+from crypticorn.metrics.client.models.base_response_list_dict import (
+    BaseResponseListDict,
+)
+from crypticorn.metrics.client.models.base_response_list_exchange_mapping import (
+    BaseResponseListExchangeMapping,
+)
+from crypticorn.metrics.client.models.base_response_list_str import BaseResponseListStr
+from crypticorn.metrics.client.models.error_response import ErrorResponse
+from crypticorn.metrics.client.models.exchange_mapping import ExchangeMapping
+from crypticorn.metrics.client.models.http_validation_error import HTTPValidationError
+from crypticorn.metrics.client.models.health_check_response import HealthCheckResponse
+from crypticorn.metrics.client.models.market import Market
+from crypticorn.metrics.client.models.severity import Severity
+from crypticorn.metrics.client.models.validation_error import ValidationError
+from crypticorn.metrics.client.models.validation_error_loc_inner import (
+    ValidationErrorLocInner,
+)

crypticorn/metrics/client/api/__init__.py

@@ -0,0 +1,10 @@
+# flake8: noqa
+
+# import apis into api package
+from crypticorn.metrics.client.api.exchanges_api import ExchangesApi
+from crypticorn.metrics.client.api.health_check_api import HealthCheckApi
+from crypticorn.metrics.client.api.indicators_api import IndicatorsApi
+from crypticorn.metrics.client.api.logs_api import LogsApi
+from crypticorn.metrics.client.api.marketcap_api import MarketcapApi
+from crypticorn.metrics.client.api.markets_api import MarketsApi
+from crypticorn.metrics.client.api.tokens_api import TokensApi