crypticorn 2.4.6__py3-none-any.whl → 2.5.0__py3-none-any.whl

crypticorn/cli/init.py

@@ -57,7 +57,10 @@ def init_ruff(force):
 def init_docker(output, force):
     """Add Dockerfile"""
     root = get_git_root()
-    target = Path(output) if output else root / "Dockerfile"
+    if output and Path(output).is_file():
+        click.secho("Output path is a file, please provide a directory path", fg="red")
+        return
+    target = (Path(output) if output else root) / "Dockerfile"
     if target.exists() and not force:
         click.secho("File already exists, use --force / -f to overwrite", fg="red")
         return
@@ -73,10 +76,10 @@ def init_docker(output, force):
 def init_auth(output, force):
     """Add auth.py with auth handler. Everything you need to start using the auth service."""
     root = get_git_root()
-    if Path(output).is_dir():
-        click.secho("Output path is a directory, please provide a file path", fg="red")
+    if output and Path(output).is_file():
+        click.secho("Output path is a file, please provide a directory path", fg="red")
         return
-    target = Path(output) if output else root / "src/auth.py"
+    target = (Path(output) if output else root) / "auth.py"
     if target.exists() and not force:
         click.secho("File already exists, use --force / -f to overwrite", fg="red")
         return

crypticorn/common/__init__.py

@@ -5,3 +5,4 @@ from crypticorn.common.pydantic import *
 from crypticorn.common.auth import *
 from crypticorn.common.enums import *
 from crypticorn.common.utils import *
+from crypticorn.common.exceptions import *

crypticorn/common/auth.py

@@ -9,7 +9,7 @@ from crypticorn.common import (
     Scope,
     Service,
 )
-from fastapi import Depends, HTTPException, Query, status
+from fastapi import Depends, HTTPException, Query, status, WebSocketException
 from fastapi.security import (
     HTTPAuthorizationCredentials,
     SecurityScopes,
@@ -183,7 +183,7 @@ class AuthHandler:
         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)
+        return await self.ws_combined_auth(bearer=None, api_key=api_key, sec=sec)
 
     async def ws_bearer_auth(
         self,
@@ -194,12 +194,7 @@ class AuthHandler:
         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)
+        return await self.ws_combined_auth(bearer=bearer, api_key=None, sec=sec)
 
     async def ws_combined_auth(
         self,
@@ -216,4 +211,11 @@ class AuthHandler:
             if bearer
             else None
         )
-        return await self.combined_auth(bearer=credentials, api_key=api_key, sec=sec)
+        response = await self.combined_auth(
+            bearer=credentials, api_key=api_key, sec=sec
+        )
+        if isinstance(response, HTTPException):
+            raise WebSocketException(
+                code=status.WS_1008_POLICY_VIOLATION, reason=response.detail
+            )
+        return response

crypticorn/common/errors.py

@@ -36,6 +36,7 @@ class ApiErrorIdentifier(StrEnum):
 
     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 +57,7 @@ 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"
+    FORBIDDEN = "forbidden"
     HEDGE_MODE_NOT_ACTIVE = "hedge_mode_not_active"
     HTTP_ERROR = "http_request_error"
     INSUFFICIENT_BALANCE = "insufficient_balance"
@@ -63,6 +65,8 @@ class ApiErrorIdentifier(StrEnum):
     INSUFFICIENT_SCOPES = "insufficient_scopes"
     INVALID_API_KEY = "invalid_api_key"
     INVALID_BEARER = "invalid_bearer"
+    INVALID_DATA_REQUEST = "invalid_data"
+    INVALID_DATA_RESPONSE = "invalid_data_response"
     INVALID_EXCHANGE_KEY = "invalid_exchange_key"
     INVALID_MARGIN_MODE = "invalid_margin_mode"
     INVALID_PARAMETER = "invalid_parameter_provided"
@@ -100,6 +104,11 @@ class ApiErrorIdentifier(StrEnum):
     UNKNOWN_ERROR = "unknown_error_occurred"
     URL_NOT_FOUND = "requested_resource_not_found"
 
+    @property
+    def get_error_code(self) -> str:
+        """Get the corresponding ApiError."""
+        return ApiError[self.value]
+
 
 class ApiErrorLevel(StrEnum):
     """API error levels"""
@@ -123,6 +132,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,
@@ -258,6 +272,16 @@ class ApiError(Enum, metaclass=Fallback):
         ApiErrorType.USER_ERROR,
         ApiErrorLevel.ERROR,
     )
+    INVALID_DATA_REQUEST = (
+        ApiErrorIdentifier.INVALID_DATA_REQUEST,
+        ApiErrorType.USER_ERROR,
+        ApiErrorLevel.ERROR,
+    )
+    INVALID_DATA_RESPONSE = (
+        ApiErrorIdentifier.INVALID_DATA_RESPONSE,
+        ApiErrorType.USER_ERROR,
+        ApiErrorLevel.ERROR,
+    )
     INVALID_EXCHANGE_KEY = (
         ApiErrorIdentifier.INVALID_EXCHANGE_KEY,
         ApiErrorType.SERVER_ERROR,
@@ -484,6 +508,8 @@ class HttpStatusMapper:
         ApiError.BOT_ALREADY_DELETED: status.HTTP_409_CONFLICT,
         # Invalid Content
         ApiError.CONTENT_TYPE_ERROR: status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
+        ApiError.INVALID_DATA_REQUEST: status.HTTP_422_UNPROCESSABLE_ENTITY,
+        ApiError.INVALID_DATA_RESPONSE: status.HTTP_422_UNPROCESSABLE_ENTITY,
         # Rate Limits
         ApiError.EXCHANGE_RATE_LIMIT: status.HTTP_429_TOO_MANY_REQUESTS,
         ApiError.REQUEST_SCOPE_EXCEEDED: status.HTTP_429_TOO_MANY_REQUESTS,

crypticorn/common/exceptions.py

@@ -0,0 +1,83 @@
+from enum import Enum
+from typing import Optional, Dict, Type, 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 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 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) -> 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.
+        The ApiError class is the source of truth for everything. If the error is not yet implemented, there are fallbacks to avoid errors while testing.
+    """
+
+    def __init__(
+        self,
+        content: ExceptionContent,
+        headers: Optional[Dict[str, str]] = None,
+    ):
+        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 = 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 = 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 = 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.'''
+    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.'''
+    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": ExceptionDetail, "description": "Error response"}
+}

crypticorn/common/utils.py

@@ -1,27 +1,29 @@
-from typing import Any
+from typing import Any, Union
 from decimal import Decimal
 import string
 import random
-
 from fastapi import HTTPException
 from fastapi import status
+from typing_extensions import deprecated
 
 from crypticorn.common import ApiError
 
 
-def throw_if_none(value: Any, message: ApiError) -> None:
+def throw_if_none(value: Any, message: Union[ApiError, str]) -> None:
     """Throws an FastAPI HTTPException if the value is None."""
     if value is None:
         raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND, detail=message.identifier
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=message.identifier if isinstance(message, ApiError) else message,
         )
 
 
-def throw_if_falsy(value: Any, message: ApiError) -> None:
+def throw_if_falsy(value: Any, message: Union[ApiError, str]) -> None:
     """Throws an FastAPI HTTPException if the value is False."""
     if not value:
         raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST, detail=message.identifier
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=message.identifier if isinstance(message, ApiError) else message,
         )
 
 
@@ -32,6 +34,7 @@ def gen_random_id(length: int = 20) -> str:
     return "".join(random.choice(charset) for _ in range(length))
 
 
+@deprecated("Use math.isclose instead. Will be removed in a future version.")
 def is_equal(
     a: float | Decimal,
     b: float | Decimal,
@@ -50,3 +53,17 @@ def is_equal(
     return Decimal(abs(a - b)) <= max(
         Decimal(str(rel_tol)) * max(abs(a), abs(b)), Decimal(str(abs_tol))
     )
+
+
+def optional_import(module_name: str, extra_name: str) -> Any:
+    """
+    Import a module optionally.
+    """
+    try:
+        return __import__(module_name)
+    except ImportError as e:
+        extra = f"[{extra_name}]"
+        raise ImportError(
+            f"Optional dependency '{module_name}' is required for this feature. "
+            f"Install it with: pip install crypticorn{extra}"
+        ) from e

crypticorn/klines/client/__init__.py

@@ -17,6 +17,7 @@ Do not edit the class manually.
 __version__ = "1.0.0"
 
 # import apis into sdk package
+from crypticorn.klines.client.api.change_in_timeframe_api import ChangeInTimeframeApi
 from crypticorn.klines.client.api.funding_rates_api import FundingRatesApi
 from crypticorn.klines.client.api.health_check_api import HealthCheckApi
 from crypticorn.klines.client.api.ohlcv_data_api import OHLCVDataApi
@@ -38,6 +39,9 @@ from crypticorn.klines.client.exceptions import ApiException
 from crypticorn.klines.client.models.base_response_health_check_response import (
     BaseResponseHealthCheckResponse,
 )
+from crypticorn.klines.client.models.base_response_list_change_in_timeframe_response import (
+    BaseResponseListChangeInTimeframeResponse,
+)
 from crypticorn.klines.client.models.base_response_list_funding_rate_response import (
     BaseResponseListFundingRateResponse,
 )
@@ -45,6 +49,9 @@ from crypticorn.klines.client.models.base_response_list_str import BaseResponseL
 from crypticorn.klines.client.models.base_response_ohlcv_response import (
     BaseResponseOHLCVResponse,
 )
+from crypticorn.klines.client.models.change_in_timeframe_response import (
+    ChangeInTimeframeResponse,
+)
 from crypticorn.klines.client.models.error_response import ErrorResponse
 from crypticorn.klines.client.models.exchange import Exchange
 from crypticorn.klines.client.models.funding_rate_response import FundingRateResponse
@@ -57,11 +64,11 @@ from crypticorn.klines.client.models.history_no_data_response import (
 from crypticorn.klines.client.models.history_success_response import (
     HistorySuccessResponse,
 )
-from crypticorn.klines.client.models.market import Market
+from crypticorn.klines.client.models.market_type import MarketType
 from crypticorn.klines.client.models.ohlcv_response import OHLCVResponse
 from crypticorn.klines.client.models.resolution import Resolution
-from crypticorn.klines.client.models.response_get_history_udf_history_get import (
-    ResponseGetHistoryUdfHistoryGet,
+from crypticorn.klines.client.models.response_get_udf_history import (
+    ResponseGetUdfHistory,
 )
 from crypticorn.klines.client.models.search_symbol_response import SearchSymbolResponse
 from crypticorn.klines.client.models.sort_direction import SortDirection

crypticorn/klines/client/api/__init__.py

@@ -1,6 +1,7 @@
 # flake8: noqa
 
 # import apis into api package
+from crypticorn.klines.client.api.change_in_timeframe_api import ChangeInTimeframeApi
 from crypticorn.klines.client.api.funding_rates_api import FundingRatesApi
 from crypticorn.klines.client.api.health_check_api import HealthCheckApi
 from crypticorn.klines.client.api.ohlcv_data_api import OHLCVDataApi

crypticorn/klines/client/api/change_in_timeframe_api.py

@@ -0,0 +1,331 @@
+# coding: utf-8
+
+"""
+Klines Service API
+
+     API for retrieving OHLCV data, funding rates, and symbol information from Binance.          ## WebSocket Support     Connect to `/ws` to receive real-time OHLCV updates.          Example subscription message:     ```json     {         \"action\": \"subscribe\",         \"market\": \"spot\",         \"symbol\": \"BTCUSDT\",         \"timeframe\": \"15m\"     }     ```
+
+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
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field
+from typing import Optional
+from typing_extensions import Annotated
+from crypticorn.klines.client.models.base_response_list_change_in_timeframe_response import (
+    BaseResponseListChangeInTimeframeResponse,
+)
+from crypticorn.klines.client.models.market_type import MarketType
+from crypticorn.klines.client.models.timeframe import Timeframe
+
+from crypticorn.klines.client.api_client import ApiClient, RequestSerialized
+from crypticorn.klines.client.api_response import ApiResponse
+from crypticorn.klines.client.rest import RESTResponseType
+
+
+class ChangeInTimeframeApi:
+    """NOTE: This class is auto generated by OpenAPI Generator
+    Ref: https://openapi-generator.tech
+
+    Do not edit the class manually.
+    """
+
+    def __init__(self, api_client=None) -> None:
+        if api_client is None:
+            api_client = ApiClient.get_default()
+        self.api_client = api_client
+
+    @validate_call
+    async def get_change_in_timeframe(
+        self,
+        market: Annotated[
+            Optional[MarketType], Field(description="Market type: 'spot' or 'futures'")
+        ] = None,
+        timeframe: Annotated[
+            Optional[Timeframe],
+            Field(description="Timeframe: '15m', '30m', '1h', '4h', '1d'"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> BaseResponseListChangeInTimeframeResponse:
+        """Get Change In Timeframe
+
+        Retrieve price change percentage between last two completed timestamps for all pairs.  Valid markets: spot, futures Valid timeframes: 15m, 30m, 1h, 4h, 1d
+
+        :param market: Market type: 'spot' or 'futures'
+        :type market: MarketType
+        :param timeframe: Timeframe: '15m', '30m', '1h', '4h', '1d'
+        :type timeframe: Timeframe
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """  # noqa: E501
+
+        _param = self._get_change_in_timeframe_serialize(
+            market=market,
+            timeframe=timeframe,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            "200": "BaseResponseListChangeInTimeframeResponse",
+            "400": "ErrorResponse",
+            "404": "ErrorResponse",
+            "500": "ErrorResponse",
+            "422": "HTTPValidationError",
+        }
+        response_data = await self.api_client.call_api(
+            *_param, _request_timeout=_request_timeout
+        )
+        await response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+    @validate_call
+    async def get_change_in_timeframe_with_http_info(
+        self,
+        market: Annotated[
+            Optional[MarketType], Field(description="Market type: 'spot' or 'futures'")
+        ] = None,
+        timeframe: Annotated[
+            Optional[Timeframe],
+            Field(description="Timeframe: '15m', '30m', '1h', '4h', '1d'"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[BaseResponseListChangeInTimeframeResponse]:
+        """Get Change In Timeframe
+
+        Retrieve price change percentage between last two completed timestamps for all pairs.  Valid markets: spot, futures Valid timeframes: 15m, 30m, 1h, 4h, 1d
+
+        :param market: Market type: 'spot' or 'futures'
+        :type market: MarketType
+        :param timeframe: Timeframe: '15m', '30m', '1h', '4h', '1d'
+        :type timeframe: Timeframe
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """  # noqa: E501
+
+        _param = self._get_change_in_timeframe_serialize(
+            market=market,
+            timeframe=timeframe,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            "200": "BaseResponseListChangeInTimeframeResponse",
+            "400": "ErrorResponse",
+            "404": "ErrorResponse",
+            "500": "ErrorResponse",
+            "422": "HTTPValidationError",
+        }
+        response_data = await self.api_client.call_api(
+            *_param, _request_timeout=_request_timeout
+        )
+        await response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+    @validate_call
+    async def get_change_in_timeframe_without_preload_content(
+        self,
+        market: Annotated[
+            Optional[MarketType], Field(description="Market type: 'spot' or 'futures'")
+        ] = None,
+        timeframe: Annotated[
+            Optional[Timeframe],
+            Field(description="Timeframe: '15m', '30m', '1h', '4h', '1d'"),
+        ] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]
+            ],
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Get Change In Timeframe
+
+        Retrieve price change percentage between last two completed timestamps for all pairs.  Valid markets: spot, futures Valid timeframes: 15m, 30m, 1h, 4h, 1d
+
+        :param market: Market type: 'spot' or 'futures'
+        :type market: MarketType
+        :param timeframe: Timeframe: '15m', '30m', '1h', '4h', '1d'
+        :type timeframe: Timeframe
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """  # noqa: E501
+
+        _param = self._get_change_in_timeframe_serialize(
+            market=market,
+            timeframe=timeframe,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            "200": "BaseResponseListChangeInTimeframeResponse",
+            "400": "ErrorResponse",
+            "404": "ErrorResponse",
+            "500": "ErrorResponse",
+            "422": "HTTPValidationError",
+        }
+        response_data = await self.api_client.call_api(
+            *_param, _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+    def _get_change_in_timeframe_serialize(
+        self,
+        market,
+        timeframe,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {}
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        # process the query parameters
+        if market is not None:
+
+            _query_params.append(("market", market.value))
+
+        if timeframe is not None:
+
+            _query_params.append(("timeframe", timeframe.value))
+
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+        # set the HTTP header `Accept`
+        if "Accept" not in _header_params:
+            _header_params["Accept"] = self.api_client.select_header_accept(
+                ["application/json"]
+            )
+
+        # authentication setting
+        _auth_settings: List[str] = ["APIKeyHeader", "HTTPBearer"]
+
+        return self.api_client.param_serialize(
+            method="GET",
+            resource_path="/change",
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth,
+        )