crypticorn 2.5.0rc4__py3-none-any.whl → 2.5.1__py3-none-any.whl

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/client.py

@@ -1,13 +1,14 @@
-from typing import Union
-
-from crypticorn.hive import HiveClient, Configuration as HiveConfig
-from crypticorn.klines import KlinesClient, Configuration as KlinesConfig
-from crypticorn.pay import PayClient, Configuration as PayConfig
-from crypticorn.trade import TradeClient, Configuration as TradeConfig
-from crypticorn.metrics import MetricsClient, Configuration as MetricsConfig
-from crypticorn.auth import AuthClient, Configuration as AuthConfig
+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
-import warnings
+
+ConfigT = TypeVar("ConfigT")
+SubClient = TypeVar("SubClient")
 
 
 class ApiClient:
@@ -30,35 +31,49 @@ class ApiClient:
         self.jwt = jwt
         """The JWT to use for authentication."""
 
-        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)
+        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."""
-        clients = [
-            self.hive.base_client,
-            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()
+        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
@@ -66,63 +81,39 @@ class ApiClient:
         """
         Get the default configuration for a given service.
         """
-        config_class = {
-            Service.HIVE: HiveConfig,
-            Service.TRADE: TradeConfig,
-            Service.KLINES: KlinesConfig,
-            Service.PAY: PayConfig,
-            Service.METRICS: MetricsConfig,
-            Service.AUTH: AuthConfig,
-        }[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,
-            # not necessary
-            # api_key_prefix=(
-            #     {aph.scheme_name: aph.model.name} if self.api_key else None
-            # ),
         )
 
     def configure(
         self,
-        config: Union[
-            HiveConfig, TradeConfig, KlinesConfig, PayConfig, MetricsConfig, AuthConfig
-        ],
-        sub_client: any,
+        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 sub_client: The sub-client to configure.
+        :param service: The service 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)
+        >>>     client.configure(config=HiveConfig(host="http://localhost:8000"), client=client.hive)
         """
-        new_config = sub_client.config
+        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)
 
-        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}")
+        self.services[service] = type(client)(new_config)
 
     async def __aenter__(self):
         return self

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/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/common/enums.py

@@ -1,42 +1,13 @@
 from enum import StrEnum
-
-
-class ValidateEnumMixin:
-    """
-    Mixin for validating enum values manually.
-
-    ⚠️ Note:
-    This does NOT enforce validation automatically on enum creation.
-    It's up to the developer to call `Class.validate(value)` where needed.
-
-    Usage:
-        >>> class Color(ValidateEnumMixin, StrEnum):
-        >>>     RED = "red"
-        >>>     GREEN = "green"
-
-        >>> Color.validate("red")     # True
-        >>> Color.validate("yellow")  # False
-
-    Order of inheritance matters — the mixin must come first.
-    """
-
-    @classmethod
-    def validate(cls, value) -> bool:
-        try:
-            cls(value)
-            return True
-        except ValueError:
-            return False
-
-
-class Exchange(ValidateEnumMixin, StrEnum):
+from crypticorn.common.mixins import ValidateEnumMixin, ExcludeEnumMixin
+class Exchange(ValidateEnumMixin, ExcludeEnumMixin, StrEnum):
     """Supported exchanges for trading"""
 
     KUCOIN = "kucoin"
     BINGX = "bingx"
 
 
-class InternalExchange(ValidateEnumMixin, StrEnum):
+class InternalExchange(ValidateEnumMixin, ExcludeEnumMixin, StrEnum):
     """All exchanges we are using, including public (Exchange)"""
 
     KUCOIN = "kucoin"
@@ -47,10 +18,10 @@ class InternalExchange(ValidateEnumMixin, StrEnum):
     BITGET = "bitget"
 
 
-class MarketType(ValidateEnumMixin, StrEnum):
+class MarketType(ValidateEnumMixin, ExcludeEnumMixin, StrEnum):
     """
     Market types
     """
 
     SPOT = "spot"
-    FUTURES = "futures"
+    FUTURES = "futures"

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/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/common/mixins.py

@@ -0,0 +1,36 @@
+class ValidateEnumMixin:
+    """
+    Mixin for validating enum values manually.
+
+    ⚠️ Note:
+    This does NOT enforce validation automatically on enum creation.
+    It's up to the developer to call `Class.validate(value)` where needed.
+
+    Usage:
+        >>> class Color(ValidateEnumMixin, StrEnum):
+        >>>     RED = "red"
+        >>>     GREEN = "green"
+
+        >>> Color.validate("red")     # True
+        >>> Color.validate("yellow")  # False
+
+    Order of inheritance matters — the mixin must come first.
+    """
+
+    @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."""
+
+    @classmethod
+    def __get_pydantic_json_schema__(cls, core_schema, handler):
+        schema = handler(core_schema)
+        schema.pop("enum", None)
+        return schema

crypticorn/common/urls.py

@@ -1,4 +1,5 @@
 from enum import StrEnum
+from crypticorn.common.enums import ValidateEnumMixin
 
 
 class ApiEnv(StrEnum):
@@ -30,7 +31,7 @@ class ApiVersion(StrEnum):
     V1 = "v1"
 
 
-class Service(StrEnum):
+class Service(ValidateEnumMixin, StrEnum):
     HIVE = "hive"
     KLINES = "klines"
     PAY = "pay"