crypticorn-utils 0.1.0rc1__py3-none-any.whl → 1.0.0rc1__py3-none-any.whl

crypticorn_utils/__init__.py

@@ -1,16 +1,50 @@
-from crypticorn_utils.ansi_colors import *
-from crypticorn_utils.auth import *
-from crypticorn_utils.decorators import *
-from crypticorn_utils.enums import *
-from crypticorn_utils.errors import *
-from crypticorn_utils.exceptions import *
-from crypticorn_utils.logging import *
-from crypticorn_utils.metrics import *
-from crypticorn_utils.middleware import *
-from crypticorn_utils.mixins import *
-from crypticorn_utils.openapi import *
-from crypticorn_utils.pagination import *
-from crypticorn_utils.router.admin_router import router as admin_router
-from crypticorn_utils.router.status_router import router as status_router
-from crypticorn_utils.utils import *
-from crypticorn_utils.warnings import *
+from crypticorn_utils.auth import AuthHandler
+from crypticorn_utils.decorators import partial_model
+from crypticorn_utils.enums import ApiEnv, BaseUrl, Exchange, MarketType
+from crypticorn_utils.errors import ErrorLevel, ErrorType
+from crypticorn_utils.exceptions import BaseError, ExceptionHandler, ExceptionType
+from crypticorn_utils.logging import configure_logging, disable_logging
+from crypticorn_utils.middleware import add_middleware
+from crypticorn_utils.pagination import (
+    FilterParams,
+    HeavyPageSortFilterParams,
+    HeavyPaginationParams,
+    PageFilterParams,
+    PageSortFilterParams,
+    PageSortParams,
+    PaginatedResponse,
+    PaginationParams,
+    SortFilterParams,
+    SortParams,
+)
+from crypticorn_utils.utils import datetime_to_timestamp, gen_random_id, optional_import
+
+__all__ = [
+    "AuthHandler",
+    "partial_model",
+    "Exchange",
+    "MarketType",
+    "ApiEnv",
+    "BaseUrl",
+    "ErrorType",
+    "ErrorLevel",
+    "BaseError",
+    "ExceptionHandler",
+    "ExceptionType",
+    "configure_logging",
+    "disable_logging",
+    "add_middleware",
+    "PaginatedResponse",
+    "PaginationParams",
+    "HeavyPaginationParams",
+    "SortParams",
+    "FilterParams",
+    "SortFilterParams",
+    "PageFilterParams",
+    "PageSortParams",
+    "PageSortFilterParams",
+    "HeavyPageSortFilterParams",
+    "gen_random_id",
+    "datetime_to_timestamp",
+    "optional_import",
+]

crypticorn_utils/_migration.py

@@ -1,5 +1,6 @@
 # This file is used to check if the crypticorn version is greater than 2.18
 # This is to be compatible with this new utils library
+# otherwise prometheus reqisters metrics twice, resulting in an exception
 
 import importlib.metadata
 from importlib.metadata import PackageNotFoundError
@@ -9,4 +10,4 @@ try:
     parts = crypticorn_version.split(".")
     has_migrated = parts[0] >= "2" and parts[1] > "18"
 except PackageNotFoundError:
-    has_migrated = False
+    has_migrated = True

crypticorn_utils/ansi_colors.py

@@ -1,7 +1,4 @@
-try:
-    from enum import StrEnum
-except ImportError:
-    from strenum import StrEnum
+from enum import StrEnum
 
 
 class AnsiColors(StrEnum):

crypticorn_utils/auth.py

@@ -1,11 +1,17 @@
 import json
+from enum import StrEnum
 from typing import Union
 
 from crypticorn.auth import AuthClient, Configuration, Verify200Response
 from crypticorn.auth.client.exceptions import ApiException
-from crypticorn_utils.enums import Scope, BaseUrl
-from crypticorn_utils.exceptions import ApiError, ExceptionContent, HTTPException
-from fastapi import Depends, Query
+from crypticorn_utils.enums import BaseUrl
+from crypticorn_utils.exceptions import (
+    BaseError,
+    ErrorLevel,
+    ErrorType,
+    ExceptionHandler,
+)
+from fastapi import Depends, HTTPException, Query, status
 from fastapi.security import (
     APIKeyHeader,
     HTTPAuthorizationCredentials,
@@ -16,6 +22,79 @@ from fastapi.security import (
 )
 from typing_extensions import Annotated
 
+
+class AuthErrorCodes(StrEnum):
+    INVALID_API_KEY = "invalid_api_key"
+    EXPIRED_API_KEY = "expired_api_key"
+    INVALID_BEARER = "invalid_bearer"
+    EXPIRED_BEARER = "expired_bearer"
+    INVALID_BASIC_AUTH = "invalid_basic_auth"
+    NO_CREDENTIALS = "no_credentials"
+    INSUFFICIENT_SCOPES = "insufficient_scopes"
+    UNKNOWN_ERROR = "unknown_error"
+
+
+class AuthError(BaseError):
+    INVALID_API_KEY = (
+        AuthErrorCodes.INVALID_API_KEY,
+        ErrorType.USER_ERROR,
+        ErrorLevel.ERROR,
+        status.HTTP_401_UNAUTHORIZED,
+        status.WS_1008_POLICY_VIOLATION,
+    )
+    INVALID_BASIC_AUTH = (
+        AuthErrorCodes.INVALID_BASIC_AUTH,
+        ErrorType.USER_ERROR,
+        ErrorLevel.ERROR,
+        status.HTTP_401_UNAUTHORIZED,
+        status.WS_1008_POLICY_VIOLATION,
+    )
+    INVALID_BEARER = (
+        AuthErrorCodes.INVALID_BEARER,
+        ErrorType.USER_ERROR,
+        ErrorLevel.ERROR,
+        status.HTTP_401_UNAUTHORIZED,
+        status.WS_1008_POLICY_VIOLATION,
+    )
+    EXPIRED_API_KEY = (
+        AuthErrorCodes.EXPIRED_API_KEY,
+        ErrorType.USER_ERROR,
+        ErrorLevel.ERROR,
+        status.HTTP_401_UNAUTHORIZED,
+        status.WS_1008_POLICY_VIOLATION,
+    )
+    EXPIRED_BEARER = (
+        AuthErrorCodes.EXPIRED_BEARER,
+        ErrorType.USER_ERROR,
+        ErrorLevel.ERROR,
+        status.HTTP_401_UNAUTHORIZED,
+        status.WS_1008_POLICY_VIOLATION,
+    )
+    NO_CREDENTIALS = (
+        AuthErrorCodes.NO_CREDENTIALS,
+        ErrorType.USER_ERROR,
+        ErrorLevel.ERROR,
+        status.HTTP_401_UNAUTHORIZED,
+        status.WS_1008_POLICY_VIOLATION,
+    )
+    INSUFFICIENT_SCOPES = (
+        AuthErrorCodes.INSUFFICIENT_SCOPES,
+        ErrorType.USER_ERROR,
+        ErrorLevel.ERROR,
+        status.HTTP_403_FORBIDDEN,
+        status.WS_1008_POLICY_VIOLATION,
+    )
+    UNKNOWN_ERROR = (
+        AuthErrorCodes.UNKNOWN_ERROR,
+        ErrorType.SERVER_ERROR,
+        ErrorLevel.ERROR,
+        status.HTTP_500_INTERNAL_SERVER_ERROR,
+        status.WS_1011_INTERNAL_ERROR,
+    )
+
+
+handler = ExceptionHandler(callback=AuthError.from_identifier)
+
 AUTHENTICATE_HEADER = "WWW-Authenticate"
 BEARER_AUTH_SCHEME = "Bearer"
 APIKEY_AUTH_SCHEME = "X-API-Key"
@@ -80,19 +159,17 @@ class AuthHandler:
         return await self.client.login.verify_basic_auth(basic.username, basic.password)
 
     async def _validate_scopes(
-        self, api_scopes: list[Scope], user_scopes: list[Scope]
-    ) -> bool:
+        self, api_scopes: list[str], user_scopes: list[str]
+    ) -> None:
         """
         Checks if the required scopes are a subset of the user scopes.
         """
         if not set(api_scopes).issubset(user_scopes):
-            raise HTTPException(
-                content=ExceptionContent(
-                    error=ApiError.INSUFFICIENT_SCOPES,
-                    message="Insufficient scopes to access this resource (required: "
-                    + ", ".join(api_scopes)
-                    + ")",
-                ),
+            raise handler.build_exception(
+                AuthErrorCodes.INSUFFICIENT_SCOPES,
+                "Insufficient scopes to access this resource (required: "
+                + ", ".join(api_scopes)
+                + ")",
             )
 
     async def _extract_message(self, e: ApiException) -> str:
@@ -119,33 +196,24 @@ class AuthHandler:
             # 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
+                error = AuthErrorCodes.INVALID_API_KEY
             elif message == "API key expired":
-                error = ApiError.EXPIRED_API_KEY
+                error = AuthErrorCodes.EXPIRED_API_KEY
             elif message == "jwt expired":
-                error = ApiError.EXPIRED_BEARER
+                error = AuthErrorCodes.EXPIRED_BEARER
             elif message == "Invalid basic authentication credentials":
-                error = ApiError.INVALID_BASIC_AUTH
+                error = AuthErrorCodes.INVALID_BASIC_AUTH
             else:
                 message = "Invalid bearer token"
                 error = (
-                    ApiError.INVALID_BEARER
+                    AuthErrorCodes.INVALID_BEARER
                 )  # jwt malformed, jwt not active (https://www.npmjs.com/package/jsonwebtoken#errors--codes)
-            return HTTPException(
-                content=ExceptionContent(
-                    error=error,
-                    message=message,
-                ),
-            )
+            return handler.build_exception(error, message)
+
         elif isinstance(e, HTTPException):
             return e
         else:
-            return HTTPException(
-                content=ExceptionContent(
-                    error=ApiError.UNKNOWN_ERROR,
-                    message=str(e),
-                ),
-            )
+            return handler.build_exception(AuthErrorCodes.UNKNOWN_ERROR, str(e))
 
     async def api_key_auth(
         self,
@@ -162,11 +230,9 @@ class AuthHandler:
                 bearer=None, api_key=api_key, basic=None, sec=sec
             )
         except HTTPException as e:
-            raise HTTPException(
-                content=ExceptionContent(
-                    error=ApiError.from_json(e.detail),
-                    message=e.detail.get("message"),
-                ),
+            raise handler.build_exception(
+                e.detail.get("code"),
+                e.detail.get("message"),
                 headers={AUTHENTICATE_HEADER: APIKEY_AUTH_SCHEME},
             )
 
@@ -188,11 +254,9 @@ class AuthHandler:
                 bearer=bearer, api_key=None, basic=None, sec=sec
             )
         except HTTPException as e:
-            raise HTTPException(
-                content=ExceptionContent(
-                    error=ApiError.from_json(e.detail),
-                    message=e.detail.get("message"),
-                ),
+            raise handler.build_exception(
+                e.detail.get("code"),
+                e.detail.get("message"),
                 headers={AUTHENTICATE_HEADER: BEARER_AUTH_SCHEME},
             )
 
@@ -208,11 +272,9 @@ class AuthHandler:
                 basic=credentials, bearer=None, api_key=None, sec=None
             )
         except HTTPException as e:
-            raise HTTPException(
-                content=ExceptionContent(
-                    error=ApiError.from_json(e.detail),
-                    message=e.detail.get("message"),
-                ),
+            raise handler.build_exception(
+                e.detail.get("code"),
+                e.detail.get("message"),
                 headers={AUTHENTICATE_HEADER: BASIC_AUTH_SCHEME},
             )
 
@@ -235,11 +297,9 @@ class AuthHandler:
                 basic=None, bearer=bearer, api_key=api_key, sec=sec
             )
         except HTTPException as e:
-            raise HTTPException(
-                content=ExceptionContent(
-                    error=ApiError.from_json(e.detail),
-                    message=e.detail.get("message"),
-                ),
+            raise handler.build_exception(
+                e.detail.get("code"),
+                e.detail.get("message"),
                 headers={
                     AUTHENTICATE_HEADER: f"{BEARER_AUTH_SCHEME}, {APIKEY_AUTH_SCHEME}"
                 },
@@ -287,11 +347,9 @@ class AuthHandler:
         if last_error:
             raise last_error
         else:
-            raise HTTPException(
-                content=ExceptionContent(
-                    error=ApiError.NO_CREDENTIALS,
-                    message="No credentials provided. Check the WWW-Authenticate header for the available authentication methods.",
-                ),
+            raise handler.build_exception(
+                AuthErrorCodes.NO_CREDENTIALS,
+                "No credentials provided. Check the WWW-Authenticate header for the available authentication methods.",
                 headers={
                     AUTHENTICATE_HEADER: f"{BEARER_AUTH_SCHEME}, {APIKEY_AUTH_SCHEME}, {BASIC_AUTH_SCHEME}"
                 },

crypticorn_utils/enums.py

@@ -1,109 +1,9 @@
 """Defines common enumerations used throughout the codebase for type safety and consistency."""
 
-try:
-    from enum import StrEnum
-except ImportError:
-    from strenum import StrEnum
+from enum import StrEnum
 
-import warnings
 
-from crypticorn_utils.mixins import ValidateEnumMixin
-from crypticorn_utils.warnings import CrypticornDeprecatedSince215
-
-
-class Scope(StrEnum):
-    """
-    The permission scopes for the API.
-    """
-
-    # If you update anything here, also update the scopes in the auth-service repository
-
-    WRITE_ADMIN = "write:admin"
-    READ_ADMIN = "read:admin"
-
-    # Scopes that can be purchased - these actually exist in the jwt token
-    READ_PREDICTIONS = "read:predictions"
-    READ_DEX_SIGNALS = "read:dex:signals"
-
-    # Hive scopes
-    READ_HIVE_MODEL = "read:hive:model"
-    READ_HIVE_DATA = "read:hive:data"
-    WRITE_HIVE_MODEL = "write:hive:model"
-
-    # Trade scopes
-    READ_TRADE_BOTS = "read:trade:bots"
-    WRITE_TRADE_BOTS = "write:trade:bots"
-    READ_TRADE_EXCHANGEKEYS = "read:trade:exchangekeys"
-    WRITE_TRADE_EXCHANGEKEYS = "write:trade:exchangekeys"
-    READ_TRADE_ORDERS = "read:trade:orders"
-    READ_TRADE_ACTIONS = "read:trade:actions"
-    WRITE_TRADE_ACTIONS = "write:trade:actions"
-    READ_TRADE_EXCHANGES = "read:trade:exchanges"
-    READ_TRADE_FUTURES = "read:trade:futures"
-    WRITE_TRADE_FUTURES = "write:trade:futures"
-    READ_TRADE_NOTIFICATIONS = "read:trade:notifications"
-    WRITE_TRADE_NOTIFICATIONS = "write:trade:notifications"
-    READ_TRADE_STRATEGIES = "read:trade:strategies"
-    WRITE_TRADE_STRATEGIES = "write:trade:strategies"
-
-    # Payment scopes
-    READ_PAY_PAYMENTS = "read:pay:payments"
-    READ_PAY_PRODUCTS = "read:pay:products"
-    WRITE_PAY_PRODUCTS = "write:pay:products"
-    READ_PAY_NOW = "read:pay:now"
-    WRITE_PAY_NOW = "write:pay:now"
-    WRITE_PAY_COUPONS = "write:pay:coupons"
-    READ_PAY_COUPONS = "read:pay:coupons"
-
-    # Metrics scopes
-    READ_METRICS_MARKETCAP = "read:metrics:marketcap"
-    READ_METRICS_INDICATORS = "read:metrics:indicators"
-    READ_METRICS_EXCHANGES = "read:metrics:exchanges"
-    READ_METRICS_TOKENS = "read:metrics:tokens"
-    READ_METRICS_MARKETS = "read:metrics:markets"
-
-    # Sentiment scopes
-    READ_SENTIMENT = "read:sentiment"
-
-    # Klines scopes
-    READ_KLINES = "read:klines"
-
-    @classmethod
-    def admin_scopes(cls) -> list["Scope"]:
-        """Scopes that are only available to admins."""
-        return [
-            cls.WRITE_TRADE_STRATEGIES,
-            cls.WRITE_PAY_PRODUCTS,
-            cls.WRITE_PAY_COUPONS,
-            cls.READ_PAY_COUPONS,
-            cls.WRITE_ADMIN,
-            cls.READ_ADMIN,
-        ]
-
-    @classmethod
-    def internal_scopes(cls) -> list["Scope"]:
-        """Scopes that are only available to internal services."""
-        return [
-            cls.WRITE_TRADE_ACTIONS,
-        ]
-
-    @classmethod
-    def purchaseable_scopes(cls) -> list["Scope"]:
-        """Scopes that can be purchased."""
-        return [
-            cls.READ_PREDICTIONS,
-            cls.READ_METRICS_MARKETCAP,
-            cls.READ_METRICS_INDICATORS,
-            cls.READ_METRICS_EXCHANGES,
-            cls.READ_METRICS_TOKENS,
-            cls.READ_METRICS_MARKETS,
-            cls.READ_KLINES,
-            cls.READ_SENTIMENT,
-            cls.READ_DEX_SIGNALS,
-        ]
-
-
-class Exchange(ValidateEnumMixin, StrEnum):
+class Exchange(StrEnum):
     """All exchanges used in the crypticorn ecosystem. Refer to the APIs for support for a specific usecase (data, trading, etc.)."""
 
     KUCOIN = "kucoin"
@@ -116,26 +16,7 @@ class Exchange(ValidateEnumMixin, StrEnum):
     BITSTAMP = "bitstamp"
 
 
-class InternalExchange(ValidateEnumMixin, StrEnum):
-    """All exchanges we are using, including public (Exchange)"""
-
-    KUCOIN = "kucoin"
-    BINGX = "bingx"
-    BINANCE = "binance"
-    BYBIT = "bybit"
-    HYPERLIQUID = "hyperliquid"
-    BITGET = "bitget"
-
-    @classmethod
-    def __getattr__(cls, name):
-        warnings.warn(
-            "The `InternalExchange` enum is deprecated; use `Exchange` instead.",
-            category=CrypticornDeprecatedSince215,
-        )
-        return super().__getattr__(name)
-
-
-class MarketType(ValidateEnumMixin, StrEnum):
+class MarketType(StrEnum):
     """
     Market types
     """
@@ -172,4 +53,3 @@ class BaseUrl(StrEnum):
             return cls.LOCAL
         elif env == ApiEnv.DOCKER:
             return cls.DOCKER
-