crypticorn 2.5.0rc4__tar.gz → 2.5.1__tar.gz

{crypticorn-2.5.0rc4 → crypticorn-2.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crypticorn
-Version: 2.5.0rc4
+Version: 2.5.1
 Summary: Maximise Your Crypto Trading Profits with AI Predictions
 Author-email: Crypticorn <timon@crypticorn.com>
 Project-URL: Homepage, https://crypticorn.com
@@ -36,6 +36,7 @@ Requires-Dist: pytest==8.3.5; extra == "test"
 Requires-Dist: pytest-asyncio==0.26.0; extra == "test"
 Requires-Dist: pytest-cov==6.1.1; extra == "test"
 Requires-Dist: python-dotenv==1.0.1; extra == "test"
+Requires-Dist: PyJWT==2.10.0; extra == "test"
 Provides-Extra: extra
 Requires-Dist: pandas<3.0.0,>=2.2.0; extra == "extra"
 
@@ -86,7 +87,7 @@ The `common` submodule contains shared classes not bound to a specific API.
 from crypticorn.common import Scope, Exchange
 ```
 
-## Usage
+## Basic Usage
 
 ### With Async Context Protocol
 ```python
@@ -107,6 +108,7 @@ async def main():
 
 asyncio.run(main())
 asyncio.run(client.close())
+
 ## Response Types
 
 There are three different available output formats you can choose from:
@@ -155,12 +157,12 @@ The output would look like this:
 
 ## Advanced Usage
 
-You can override some configuration for specific sub clients. If you just want to use the API as is, you don't need to configure anything.
+You can override some configuration for specific services. If you just want to use the API as is, you don't need to configure anything.
 This might be of use if you are testing a specific API locally.
 
-To override e.g. the host for the Hive client to connect to http://localhost:8000 instead of the default caddy proxy, you would do:
+To override e.g. the host for the Hive client to connect to http://localhost:8000 instead of the default proxy, you would do:
 ```python
 from crypticorn.hive import Configuration as Hiveconfig
 async with ApiClient(base_url=BaseUrl.DEV) as client:
-        client.configure(config=HiveConfig(host="http://localhost:8000"), sub_client=client.hive)
+        client.configure(config=HiveConfig(host="http://localhost:8000"), client=client.hive)
 ```

{crypticorn-2.5.0rc4 → crypticorn-2.5.1}/README.md

@@ -45,7 +45,7 @@ The `common` submodule contains shared classes not bound to a specific API.
 from crypticorn.common import Scope, Exchange
 ```
 
-## Usage
+## Basic Usage
 
 ### With Async Context Protocol
 ```python
@@ -66,6 +66,7 @@ async def main():
 
 asyncio.run(main())
 asyncio.run(client.close())
+
 ## Response Types
 
 There are three different available output formats you can choose from:
@@ -114,12 +115,12 @@ The output would look like this:
 
 ## Advanced Usage
 
-You can override some configuration for specific sub clients. If you just want to use the API as is, you don't need to configure anything.
+You can override some configuration for specific services. If you just want to use the API as is, you don't need to configure anything.
 This might be of use if you are testing a specific API locally.
 
-To override e.g. the host for the Hive client to connect to http://localhost:8000 instead of the default caddy proxy, you would do:
+To override e.g. the host for the Hive client to connect to http://localhost:8000 instead of the default proxy, you would do:
 ```python
 from crypticorn.hive import Configuration as Hiveconfig
 async with ApiClient(base_url=BaseUrl.DEV) as client:
-        client.configure(config=HiveConfig(host="http://localhost:8000"), sub_client=client.hive)
+        client.configure(config=HiveConfig(host="http://localhost:8000"), client=client.hive)
 ```

{crypticorn-2.5.0rc4 → crypticorn-2.5.1}/crypticorn/auth/main.py

@@ -14,6 +14,8 @@ class AuthClient:
     A client for interacting with the Crypticorn Auth API.
     """
 
+    config_class = Configuration
+
     def __init__(
         self,
         config: Configuration,

crypticorn-2.5.1/crypticorn/client.py

@@ -0,0 +1,122 @@
+from typing import TypeVar
+from crypticorn.hive import HiveClient
+from crypticorn.klines import KlinesClient
+from crypticorn.pay import PayClient
+from crypticorn.trade import TradeClient
+from crypticorn.metrics import MetricsClient
+from crypticorn.auth import AuthClient
+from crypticorn.common import BaseUrl, ApiVersion, Service, apikey_header as aph
+
+ConfigT = TypeVar("ConfigT")
+SubClient = TypeVar("SubClient")
+
+
+class ApiClient:
+    """
+    The official client for interacting with the Crypticorn API.
+
+    It is consisting of multiple microservices covering the whole stack of the Crypticorn project.
+    """
+
+    def __init__(
+        self,
+        api_key: str = None,
+        jwt: str = None,
+        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
+        """The JWT to use for authentication."""
+
+        self.service_classes: dict[Service, type[SubClient]] = {
+            Service.HIVE: HiveClient,
+            Service.TRADE: TradeClient,
+            Service.KLINES: KlinesClient,
+            Service.PAY: PayClient,
+            Service.METRICS: MetricsClient,
+            Service.AUTH: AuthClient,
+        }
+
+        self.services: dict[Service, SubClient] = {
+            service: client_class(self._get_default_config(service))
+            for service, client_class in self.service_classes.items()
+        }
+
+    @property
+    def hive(self) -> HiveClient:
+        return self.services[Service.HIVE]
+
+    @property
+    def trade(self) -> TradeClient:
+        return self.services[Service.TRADE]
+
+    @property
+    def klines(self) -> KlinesClient:
+        return self.services[Service.KLINES]
+
+    @property
+    def metrics(self) -> MetricsClient:
+        return self.services[Service.METRICS]
+
+    @property
+    def pay(self) -> PayClient:
+        return self.services[Service.PAY]
+
+    @property
+    def auth(self) -> AuthClient:
+        return self.services[Service.AUTH]
+
+    async def close(self):
+        """Close all client sessions."""
+        for service in self.services.values():
+            if hasattr(service.base_client, "close"):
+                await service.base_client.close()
+
+    def _get_default_config(
+        self, service: Service, version: ApiVersion = ApiVersion.V1
+    ):
+        """
+        Get the default configuration for a given service.
+        """
+        config_class = self.service_classes[service].config_class
+        return config_class(
+            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,
+        )
+
+    def configure(
+        self,
+        config: ConfigT,
+        service: Service,
+    ):
+        """
+        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 service: The service to configure.
+
+        Example:
+        >>> async with ApiClient(base_url=BaseUrl.DEV, jwt=jwt) as client:
+        >>>     client.configure(config=HiveConfig(host="http://localhost:8000"), client=client.hive)
+        """
+        assert Service.validate(service), f"Invalid service: {service}"
+        client = self.services[service]
+        new_config = client.config
+
+        for attr in vars(config):
+            new_value = getattr(config, attr)
+            if new_value:
+                setattr(new_config, attr, new_value)
+
+        self.services[service] = type(client)(new_config)
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()

{crypticorn-2.5.0rc4 → crypticorn-2.5.1}/crypticorn/common/__init__.py

@@ -1,7 +1,8 @@
 from crypticorn.common.errors import *
 from crypticorn.common.scopes import *
 from crypticorn.common.urls import *
-from crypticorn.common.pydantic import *
+from crypticorn.common.decorators import *
+from crypticorn.common.mixins import *
 from crypticorn.common.auth import *
 from crypticorn.common.enums import *
 from crypticorn.common.utils import *

{crypticorn-2.5.0rc4 → crypticorn-2.5.1}/crypticorn/common/auth.py

@@ -2,14 +2,10 @@ 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, WebSocketException
+from crypticorn.common.scopes import Scope
+from crypticorn.common.exceptions import ApiError, HTTPException, ExceptionContent
+from crypticorn.common.urls import BaseUrl, Service, ApiVersion
+from fastapi import Depends, Query, status, WebSocketException
 from fastapi.security import (
     HTTPAuthorizationCredentials,
     SecurityScopes,
@@ -48,11 +44,6 @@ class AuthHandler:
         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) -> Verify200Response:
         """
         Verifies the API key.
@@ -76,8 +67,10 @@ class AuthHandler:
         """
         if not set(api_scopes).issubset(user_scopes):
             raise HTTPException(
-                status_code=status.HTTP_403_FORBIDDEN,
-                detail=ApiError.INSUFFICIENT_SCOPES.identifier,
+                content=ExceptionContent(
+                    error=ApiError.INSUFFICIENT_SCOPES,
+                    message="Insufficient scopes to access this resource",
+                ),
             )
 
     async def _extract_message(self, e: ApiException) -> str:
@@ -100,16 +93,33 @@ class AuthHandler:
         Handles exceptions and returns a HTTPException with the appropriate status code and detail.
         """
         if isinstance(e, ApiException):
+            # handle the TRPC Zod errors from auth-service
+            # Unfortunately, we cannot share the error messages defined in python/crypticorn/common/errors.py with the typescript client
+            message = await self._extract_message(e)
+            if message == "Invalid API key":
+                error = ApiError.INVALID_API_KEY
+            elif message == "API key expired":
+                error = ApiError.EXPIRED_API_KEY
+            elif message == "jwt expired":
+                error = ApiError.EXPIRED_BEARER
+            else:
+                error = (
+                    ApiError.INVALID_BEARER
+                )  # jwt malformed, jwt not active (https://www.npmjs.com/package/jsonwebtoken#errors--codes)
             return HTTPException(
-                status_code=e.status,
-                detail=await self._extract_message(e),
+                content=ExceptionContent(
+                    error=error,
+                    message=message,
+                ),
             )
         elif isinstance(e, HTTPException):
             return e
         else:
             return HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                detail=str(e),
+                content=ExceptionContent(
+                    error=ApiError.UNKNOWN_ERROR,
+                    message=str(e),
+                ),
             )
 
     async def api_key_auth(
@@ -172,7 +182,15 @@ class AuthHandler:
                 last_error = await self._handle_exception(e)
                 continue
 
-        raise last_error or self.no_credentials_exception
+        if last_error:
+            raise last_error
+        else:
+            raise HTTPException(
+                content=ExceptionContent(
+                    error=ApiError.NO_CREDENTIALS,
+                    message="No credentials provided",
+                ),
+            )
 
     async def ws_api_key_auth(
         self,

crypticorn-2.5.1/crypticorn/common/enums.py

@@ -0,0 +1,27 @@
+from enum import StrEnum
+from crypticorn.common.mixins import ValidateEnumMixin, ExcludeEnumMixin
+class Exchange(ValidateEnumMixin, ExcludeEnumMixin, StrEnum):
+    """Supported exchanges for trading"""
+
+    KUCOIN = "kucoin"
+    BINGX = "bingx"
+
+
+class InternalExchange(ValidateEnumMixin, ExcludeEnumMixin, StrEnum):
+    """All exchanges we are using, including public (Exchange)"""
+
+    KUCOIN = "kucoin"
+    BINGX = "bingx"
+    BINANCE = "binance"
+    BYBIT = "bybit"
+    HYPERLIQUID = "hyperliquid"
+    BITGET = "bitget"
+
+
+class MarketType(ValidateEnumMixin, ExcludeEnumMixin, StrEnum):
+    """
+    Market types
+    """
+
+    SPOT = "spot"
+    FUTURES = "futures"

{crypticorn-2.5.0rc4 → crypticorn-2.5.1}/crypticorn/common/errors.py

@@ -1,6 +1,7 @@
 from enum import Enum, EnumMeta, StrEnum
 import logging
 from fastapi import status
+from crypticorn.common.mixins import ExcludeEnumMixin
 
 logger = logging.getLogger(__name__)
 
@@ -18,7 +19,7 @@ class Fallback(EnumMeta):
         return cls.UNKNOWN_ERROR
 
 
-class ApiErrorType(StrEnum):
+class ApiErrorType(ExcludeEnumMixin, StrEnum):
     """Type of API error"""
 
     USER_ERROR = "user error"
@@ -31,11 +32,12 @@ class ApiErrorType(StrEnum):
     """error that does not need to be handled or does not affect the program or is a placeholder."""
 
 
-class ApiErrorIdentifier(StrEnum):
+class ApiErrorIdentifier(ExcludeEnumMixin, StrEnum):
     """API error identifiers"""
 
     ALLOCATION_BELOW_EXPOSURE = "allocation_below_current_exposure"
     ALLOCATION_BELOW_MINIMUM = "allocation_below_min_amount"
+    ALPHANUMERIC_CHARACTERS_ONLY = "alphanumeric_characters_only"
     BLACK_SWAN = "black_swan"
     BOT_ALREADY_DELETED = "bot_already_deleted"
     BOT_DISABLED = "bot_disabled"
@@ -56,6 +58,9 @@ class ApiErrorIdentifier(StrEnum):
     EXCHANGE_SYSTEM_CONFIG_ERROR = "exchange_system_configuration_error"
     EXCHANGE_SYSTEM_ERROR = "exchange_internal_system_error"
     EXCHANGE_USER_FROZEN = "exchange_user_account_is_frozen"
+    EXPIRED_API_KEY = "api_key_expired"
+    EXPIRED_BEARER = "bearer_token_expired"
+    FORBIDDEN = "forbidden"
     HEDGE_MODE_NOT_ACTIVE = "hedge_mode_not_active"
     HTTP_ERROR = "http_request_error"
     INSUFFICIENT_BALANCE = "insufficient_balance"
@@ -68,7 +73,6 @@ class ApiErrorIdentifier(StrEnum):
     INVALID_EXCHANGE_KEY = "invalid_exchange_key"
     INVALID_MARGIN_MODE = "invalid_margin_mode"
     INVALID_PARAMETER = "invalid_parameter_provided"
-    JWT_EXPIRED = "jwt_expired"
     LEVERAGE_EXCEEDED = "leverage_limit_exceeded"
     LIQUIDATION_PRICE_VIOLATION = "order_violates_liquidation_price_constraints"
     NO_CREDENTIALS = "no_credentials"
@@ -108,7 +112,7 @@ class ApiErrorIdentifier(StrEnum):
         return ApiError[self.value]
 
 
-class ApiErrorLevel(StrEnum):
+class ApiErrorLevel(ExcludeEnumMixin, StrEnum):
     """API error levels"""
 
     ERROR = "error"
@@ -117,7 +121,7 @@ class ApiErrorLevel(StrEnum):
     WARNING = "warning"
 
 
-class ApiError(Enum, metaclass=Fallback):
+class ApiError(ExcludeEnumMixin, Enum, metaclass=Fallback):
     """API error codes. Fallback to UNKNOWN_ERROR for error codes not yet published to PyPI."""
 
     ALLOCATION_BELOW_EXPOSURE = (
@@ -130,6 +134,11 @@ class ApiError(Enum, metaclass=Fallback):
         ApiErrorType.USER_ERROR,
         ApiErrorLevel.ERROR,
     )
+    ALPHANUMERIC_CHARACTERS_ONLY = (
+        ApiErrorIdentifier.ALPHANUMERIC_CHARACTERS_ONLY,
+        ApiErrorType.USER_ERROR,
+        ApiErrorLevel.ERROR,
+    )
     BLACK_SWAN = (
         ApiErrorIdentifier.BLACK_SWAN,
         ApiErrorType.USER_ERROR,
@@ -230,6 +239,21 @@ class ApiError(Enum, metaclass=Fallback):
         ApiErrorType.USER_ERROR,
         ApiErrorLevel.ERROR,
     )
+    EXPIRED_API_KEY = (
+        ApiErrorIdentifier.EXPIRED_API_KEY,
+        ApiErrorType.USER_ERROR,
+        ApiErrorLevel.ERROR,
+    )
+    EXPIRED_BEARER = (
+        ApiErrorIdentifier.EXPIRED_BEARER,
+        ApiErrorType.USER_ERROR,
+        ApiErrorLevel.ERROR,
+    )
+    FORBIDDEN = (
+        ApiErrorIdentifier.FORBIDDEN,
+        ApiErrorType.USER_ERROR,
+        ApiErrorLevel.ERROR,
+    )
     HEDGE_MODE_NOT_ACTIVE = (
         ApiErrorIdentifier.HEDGE_MODE_NOT_ACTIVE,
         ApiErrorType.USER_ERROR,
@@ -290,11 +314,6 @@ class ApiError(Enum, metaclass=Fallback):
         ApiErrorType.SERVER_ERROR,
         ApiErrorLevel.ERROR,
     )
-    JWT_EXPIRED = (
-        ApiErrorIdentifier.JWT_EXPIRED,
-        ApiErrorType.SERVER_ERROR,
-        ApiErrorLevel.ERROR,
-    )
     LEVERAGE_EXCEEDED = (
         ApiErrorIdentifier.LEVERAGE_EXCEEDED,
         ApiErrorType.SERVER_ERROR,
@@ -475,19 +494,18 @@ class ApiError(Enum, metaclass=Fallback):
 
 class HttpStatusMapper:
     """Map API errors to HTTP status codes."""
-
-    # TODO: decide if we need all of these mappings, since most errors are not exposed to the client via HTTP
-    # in case we remove some, update the pytest length check
     _mapping = {
         # Authentication/Authorization
-        ApiError.JWT_EXPIRED: status.HTTP_401_UNAUTHORIZED,
+        ApiError.EXPIRED_BEARER: status.HTTP_401_UNAUTHORIZED,
         ApiError.INVALID_BEARER: status.HTTP_401_UNAUTHORIZED,
+        ApiError.EXPIRED_API_KEY: status.HTTP_401_UNAUTHORIZED,
         ApiError.INVALID_API_KEY: status.HTTP_401_UNAUTHORIZED,
         ApiError.NO_CREDENTIALS: status.HTTP_401_UNAUTHORIZED,
         ApiError.INSUFFICIENT_SCOPES: status.HTTP_403_FORBIDDEN,
         ApiError.EXCHANGE_PERMISSION_DENIED: status.HTTP_403_FORBIDDEN,
         ApiError.EXCHANGE_USER_FROZEN: status.HTTP_403_FORBIDDEN,
         ApiError.TRADING_LOCKED: status.HTTP_403_FORBIDDEN,
+        ApiError.FORBIDDEN: status.HTTP_403_FORBIDDEN,
         # Not Found
         ApiError.URL_NOT_FOUND: status.HTTP_404_NOT_FOUND,
         ApiError.OBJECT_NOT_FOUND: status.HTTP_404_NOT_FOUND,
@@ -519,6 +537,7 @@ class HttpStatusMapper:
         ApiError.POSITION_SUSPENDED: status.HTTP_503_SERVICE_UNAVAILABLE,
         ApiError.TRADING_SUSPENDED: status.HTTP_503_SERVICE_UNAVAILABLE,
         # Bad Requests (400) - Invalid parameters or states
+        ApiError.ALPHANUMERIC_CHARACTERS_ONLY: status.HTTP_400_BAD_REQUEST,
         ApiError.ALLOCATION_BELOW_EXPOSURE: status.HTTP_400_BAD_REQUEST,
         ApiError.ALLOCATION_BELOW_MINIMUM: status.HTTP_400_BAD_REQUEST,
         ApiError.BLACK_SWAN: status.HTTP_400_BAD_REQUEST,

{crypticorn-2.5.0rc4 → crypticorn-2.5.1}/crypticorn/common/exceptions.py

@@ -1,35 +1,40 @@
-from enum import Enum
-from typing import Optional, Dict, Type
+from typing import Optional, Dict, Any
 from pydantic import BaseModel, Field
 from fastapi import HTTPException as FastAPIHTTPException, Request, FastAPI
 from fastapi.exceptions import RequestValidationError, ResponseValidationError
-from fastapi.openapi.utils import get_openapi
 from fastapi.responses import JSONResponse
 from crypticorn.common import ApiError, ApiErrorIdentifier, ApiErrorType, ApiErrorLevel
 
-class EnrichedDetail(BaseModel):
-    '''This is the detail of the exception. It is used to enrich the exception with additional information by unwrapping the ApiError into its components.'''
+
+class ExceptionDetail(BaseModel):
+    """This is the detail of the exception. It is used to enrich the exception with additional information by unwrapping the ApiError into its components."""
+
     message: Optional[str] = Field(None, description="An additional error message")
     code: ApiErrorIdentifier = Field(..., description="The unique error code")
     type: ApiErrorType = Field(..., description="The type of error")
     level: ApiErrorLevel = Field(..., description="The level of the error")
     status_code: int = Field(..., description="The HTTP status code")
+    details: Any = Field(None, description="Additional details about the error")
 
 
-class ExceptionDetail(BaseModel):
-    '''This is the detail of the exception. Pass an ApiError to the constructor and an optional human readable message.'''
+class ExceptionContent(BaseModel):
+    """This is the detail of the exception. Pass an ApiError to the constructor and an optional human readable message."""
+
     error: ApiError = Field(..., description="The unique error code")
     message: Optional[str] = Field(None, description="An additional error message")
+    details: Any = Field(None, description="Additional details about the error")
 
-    def enrich(self) -> EnrichedDetail:
-        return EnrichedDetail(
+    def enrich(self) -> ExceptionDetail:
+        return ExceptionDetail(
             message=self.message,
             code=self.error.identifier,
             type=self.error.type,
             level=self.error.level,
             status_code=self.error.status_code,
+            details=self.details,
         )
 
+
 class HTTPException(FastAPIHTTPException):
     """A custom HTTP exception wrapper around FastAPI's HTTPException.
     It allows for a more structured way to handle errors, with a message and an error code. The status code is being derived from the detail's error.
@@ -38,43 +43,55 @@ class HTTPException(FastAPIHTTPException):
 
     def __init__(
         self,
-        detail: ExceptionDetail,
+        content: ExceptionContent,
         headers: Optional[Dict[str, str]] = None,
     ):
-        assert isinstance(detail, ExceptionDetail)
-        body = detail.enrich()
+        assert isinstance(content, ExceptionContent)
+        body = content.enrich()
         super().__init__(
             status_code=body.status_code,
             detail=body.model_dump(mode="json"),
             headers=headers,
         )
 
+
 async def general_handler(request: Request, exc: Exception):
-    '''This is the default exception handler for all exceptions.'''
-    body = ExceptionDetail(message=str(exc), error=ApiError.UNKNOWN_ERROR)
-    return JSONResponse(status_code=body.error.status_code, content=HTTPException(detail=body).detail)
+    """This is the default exception handler for all exceptions."""
+    body = ExceptionContent(message=str(exc), error=ApiError.UNKNOWN_ERROR)
+    return JSONResponse(
+        status_code=body.error.status_code, content=HTTPException(content=body).detail
+    )
+
 
 async def request_validation_handler(request: Request, exc: RequestValidationError):
-    '''This is the exception handler for all request validation errors.'''
-    body = ExceptionDetail(message=str(exc), error=ApiError.INVALID_DATA_REQUEST)
-    return JSONResponse(status_code=body.error.status_code, content=HTTPException(detail=body).detail)
+    """This is the exception handler for all request validation errors."""
+    body = ExceptionContent(message=str(exc), error=ApiError.INVALID_DATA_REQUEST)
+    return JSONResponse(
+        status_code=body.error.status_code, content=HTTPException(content=body).detail
+    )
+
 
 async def response_validation_handler(request: Request, exc: ResponseValidationError):
-    '''This is the exception handler for all response validation errors.'''
-    body = ExceptionDetail(message=str(exc), error=ApiError.INVALID_DATA_RESPONSE)
-    return JSONResponse(status_code=body.error.status_code, content=HTTPException(detail=body).detail)
+    """This is the exception handler for all response validation errors."""
+    body = ExceptionContent(message=str(exc), error=ApiError.INVALID_DATA_RESPONSE)
+    return JSONResponse(
+        status_code=body.error.status_code, content=HTTPException(content=body).detail
+    )
+
 
 async def http_handler(request: Request, exc: HTTPException):
-    '''This is the exception handler for HTTPExceptions. It unwraps the HTTPException and returns the detail in a flat JSON response.'''
+    """This is the exception handler for HTTPExceptions. It unwraps the HTTPException and returns the detail in a flat JSON response."""
     return JSONResponse(status_code=exc.status_code, content=exc.detail)
 
+
 def register_exception_handlers(app: FastAPI):
-    '''Utility to register serveral exception handlers in one go. Catches Exception, HTTPException and Data Validation errors and responds with a unified json body.'''
+    """Utility to register serveral exception handlers in one go. Catches Exception, HTTPException and Data Validation errors and responds with a unified json body."""
     app.add_exception_handler(Exception, general_handler)
     app.add_exception_handler(FastAPIHTTPException, http_handler)
     app.add_exception_handler(RequestValidationError, request_validation_handler)
     app.add_exception_handler(ResponseValidationError, response_validation_handler)
 
+
 exception_response = {
-    "default": {"model": EnrichedDetail, "description": "Error response"}
-}
+    "default": {"model": ExceptionDetail, "description": "Error response"}
+}

crypticorn-2.5.0rc4/crypticorn/common/enums.py → crypticorn-2.5.1/crypticorn/common/mixins.py

@@ -1,6 +1,3 @@
-from enum import StrEnum
-
-
 class ValidateEnumMixin:
     """
     Mixin for validating enum values manually.
@@ -22,35 +19,18 @@ class ValidateEnumMixin:
 
     @classmethod
     def validate(cls, value) -> bool:
+        """Validate if a value is in the enum. True if so, False otherwise."""
         try:
             cls(value)
             return True
         except ValueError:
             return False
 
+class ExcludeEnumMixin:
+    """Mixin to exclude enum from OpenAPI schema. We use this to avoid duplicating enums when generating client code from the openapi spec."""
 
-class Exchange(ValidateEnumMixin, StrEnum):
-    """Supported exchanges for trading"""
-
-    KUCOIN = "kucoin"
-    BINGX = "bingx"
-
-
-class InternalExchange(ValidateEnumMixin, StrEnum):
-    """All exchanges we are using, including public (Exchange)"""
-
-    KUCOIN = "kucoin"
-    BINGX = "bingx"
-    BINANCE = "binance"
-    BYBIT = "bybit"
-    HYPERLIQUID = "hyperliquid"
-    BITGET = "bitget"
-
-
-class MarketType(ValidateEnumMixin, StrEnum):
-    """
-    Market types
-    """
-
-    SPOT = "spot"
-    FUTURES = "futures"
+    @classmethod
+    def __get_pydantic_json_schema__(cls, core_schema, handler):
+        schema = handler(core_schema)
+        schema.pop("enum", None)
+        return schema