crypticorn 2.16.0__py3-none-any.whl → 2.17.0__py3-none-any.whl

crypticorn/common/decorators.py

@@ -1,8 +1,7 @@
-from datetime import datetime
 from typing import Optional, Type, Any, Tuple
 from copy import deepcopy
 
-from pydantic import BaseModel, create_model, field_validator, BeforeValidator
+from pydantic import BaseModel, create_model
 from pydantic.fields import FieldInfo
 
 

crypticorn/common/enums.py

@@ -5,9 +5,7 @@ try:
 except ImportError:
     from strenum import StrEnum
 
-from enum import Enum
 import warnings
-import typing_extensions
 from crypticorn.common.mixins import ValidateEnumMixin
 from crypticorn.common.warnings import CrypticornDeprecatedSince215
 

crypticorn/common/errors.py

@@ -70,6 +70,7 @@ class ApiErrorIdentifier(StrEnum):
     INSUFFICIENT_MARGIN = "insufficient_margin"
     INSUFFICIENT_SCOPES = "insufficient_scopes"
     INVALID_API_KEY = "invalid_api_key"
+    INVALID_BASIC_AUTH = "invalid_basic_auth"
     INVALID_BEARER = "invalid_bearer"
     INVALID_DATA_REQUEST = "invalid_data"
     INVALID_DATA_RESPONSE = "invalid_data_response"
@@ -302,6 +303,11 @@ class ApiError(Enum, metaclass=ApiErrorFallback):
         ApiErrorType.USER_ERROR,
         ApiErrorLevel.ERROR,
     )
+    INVALID_BASIC_AUTH = (
+        ApiErrorIdentifier.INVALID_BASIC_AUTH,
+        ApiErrorType.USER_ERROR,
+        ApiErrorLevel.ERROR,
+    )
     INVALID_BEARER = (
         ApiErrorIdentifier.INVALID_BEARER,
         ApiErrorType.USER_ERROR,
@@ -569,6 +575,10 @@ class StatusCodeMapper:
             status.HTTP_401_UNAUTHORIZED,
             status.WS_1008_POLICY_VIOLATION,
         ),
+        ApiError.INVALID_BASIC_AUTH: (
+            status.HTTP_401_UNAUTHORIZED,
+            status.WS_1008_POLICY_VIOLATION,
+        ),
         ApiError.INVALID_BEARER: (
             status.HTTP_401_UNAUTHORIZED,
             status.WS_1008_POLICY_VIOLATION,

crypticorn/common/metrics.py

@@ -0,0 +1,30 @@
+# metrics/registry.py
+from prometheus_client import Counter, Histogram, CollectorRegistry
+
+registry = CollectorRegistry()
+
+HTTP_REQUESTS_COUNT = Counter(
+    "http_requests_total",
+    "Total HTTP requests",
+    ["method", "endpoint", "status_code", "auth_type"],
+    registry=registry,
+)
+
+HTTP_REQUEST_DURATION = Histogram(
+    "http_request_duration_seconds",
+    "HTTP request duration in seconds",
+    ["endpoint", "method"],
+    registry=registry,
+)
+
+REQUEST_SIZE = Histogram(
+    "http_request_size_bytes", "Size of HTTP request bodies", ["method", "endpoint"]
+)
+
+
+RESPONSE_SIZE = Histogram(
+    "http_response_size_bytes",
+    "Size of HTTP responses",
+    ["method", "endpoint"],
+    registry=registry,
+)

crypticorn/common/middleware.py

@@ -1,10 +1,102 @@
-from fastapi import FastAPI
+import time
+from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
+from starlette.middleware.base import BaseHTTPMiddleware
 from crypticorn.common.logging import configure_logging
 from contextlib import asynccontextmanager
+from typing_extensions import deprecated
+import warnings
+from crypticorn.common.warnings import CrypticornDeprecatedSince217
+from crypticorn.common.metrics import (
+    HTTP_REQUESTS_COUNT,
+    HTTP_REQUEST_DURATION,
+    REQUEST_SIZE,
+    RESPONSE_SIZE,
+)
 
 
+class PrometheusMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+
+        if "authorization" in request.headers:
+            auth_type = (
+                request.headers["authorization"].split()[0]
+                if " " in request.headers["authorization"]
+                else "none"
+            )
+        elif "x-api-key" in request.headers:
+            auth_type = "X-API-KEY"
+        else:
+            auth_type = "none"
+
+        try:
+            endpoint = request.get(
+                "route"
+            ).path  # use /time/{type} instead of dynamic route to avoid high cardinality
+        except Exception:
+            endpoint = request.url.path
+
+        start = time.perf_counter()
+        response = await call_next(request)
+        duration = time.perf_counter() - start
+
+        HTTP_REQUESTS_COUNT.labels(
+            method=request.method,
+            endpoint=endpoint,
+            status_code=response.status_code,
+            auth_type=auth_type,
+        ).inc()
+
+        try:
+            body = await request.body()
+            size = len(body)
+        except Exception:
+            size = 0
+
+        REQUEST_SIZE.labels(
+            method=request.method,
+            endpoint=endpoint,
+        ).observe(size)
+
+        try:
+            body = await response.body()
+            size = len(body)
+        except Exception:
+            size = 0
+
+        RESPONSE_SIZE.labels(
+            method=request.method,
+            endpoint=endpoint,
+        ).observe(size)
+
+        HTTP_REQUEST_DURATION.labels(
+            endpoint=endpoint,
+            method=request.method,
+        ).observe(duration)
+
+        return response
+
+
+@deprecated("Use add_middleware instead", category=None)
 def add_cors_middleware(app: "FastAPI"):
+    warnings.warn(
+        "add_cors_middleware is deprecated. Use add_middleware instead.",
+        CrypticornDeprecatedSince217,
+    )
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=[
+            "http://localhost:5173",  # vite dev server
+            "http://localhost:4173",  # vite preview server
+        ],
+        allow_origin_regex="^https://([a-zA-Z0-9-]+.)*crypticorn.(dev|com)/?$",  # matches (multiple or no) subdomains of crypticorn.dev and crypticorn.com
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+
+def add_middleware(app: "FastAPI"):
     app.add_middleware(
         CORSMiddleware,
         allow_origins=[
@@ -16,6 +108,7 @@ def add_cors_middleware(app: "FastAPI"):
         allow_methods=["*"],
         allow_headers=["*"],
     )
+    app.add_middleware(PrometheusMiddleware)
 
 
 @asynccontextmanager

crypticorn/common/pagination.py

@@ -1,53 +1,285 @@
-"""Utilities for handling paginated API responses and cursor-based pagination."""
+"""Utilities for handling paginated API responses, cursor-based pagination, filtering, sorting, etc."""
 
-from typing import Generic, Type, TypeVar, Optional, Literal
+from typing import Annotated, Any, Generic, Type, TypeVar, Optional, Literal
 from pydantic import BaseModel, Field, model_validator
+import math
 
 T = TypeVar("T")
 
 
 class PaginatedResponse(BaseModel, Generic[T]):
     """Pydantic model for paginated response
-    >>> PaginatedResponse[ItemModel](data=items, total=total_items, page=1, size=10, prev=None, next=2)
+    >>> @router.get("", operation_id="getOrders")
+    >>> async def get_orders(
+    >>>     params: Annotated[PaginationParams, Query()],
+    >>> ) -> PaginatedResponse[Order]:
+    >>>     ...
+    >>> return PaginatedResponse[Order](
+            data=orders,
+            total=count,
+            page=params.page,
+            page_size=params.page_size,
+            prev=PaginatedResponse.get_prev_page(params.page),
+            next=PaginatedResponse.get_next_page(count, params.page_size, params.page),
+            last=PaginatedResponse.get_last_page(count, params.page_size),
+        )
     """
 
     data: list[T]
     total: int = Field(description="The total number of items")
     page: int = Field(description="The current page number")
-    size: int = Field(description="The number of items per page")
+    page_size: int = Field(description="The number of items per page")
     prev: Optional[int] = Field(None, description="The previous page number")
     next: Optional[int] = Field(None, description="The next page number")
+    last: Optional[int] = Field(None, description="The last page number")
+
+    @staticmethod
+    def get_next_page(total: int, page_size: int, page: int) -> Optional[int]:
+        """Get the next page number"""
+        if page < math.ceil(total / page_size):
+            return page + 1
+        return None
+
+    @staticmethod
+    def get_prev_page(page: int) -> Optional[int]:
+        """Get the previous page number"""
+        if page > 1:
+            return page - 1
+        return None
+
+    @staticmethod
+    def get_last_page(total: int, page_size: int) -> int:
+        """Get the last page number"""
+        return max(1, math.ceil(total / page_size))
 
 
 class PaginationParams(BaseModel, Generic[T]):
     """Standard pagination parameters for usage in API endpoints. Check the [fastapi docs](https://fastapi.tiangolo.com/tutorial/query-param-models/?h=qu#query-parameters-with-a-pydantic-model) for usage examples.
-    The default size is 10 items per page, but can be overridden:
-    >>> class HeavyPaginationParams(PaginationParams[T]):
-    >>>     size: int = Field(default=100, description="The number of items per page")
+    You should inherit from this class when adding additional parameters. You should use this class in combination with `PaginatedResponse` to return the paginated response.
+    Usage:
+    >>> @router.get("", operation_id="getOrders")
+    >>> async def get_orders(
+    >>>     params: Annotated[PaginationParams[Order], Query()],
+    >>> ) -> PaginatedResponse[Order]:
+    >>>     ...
+
+    The default size is 10 items per page and there is a `HeavyPaginationParams` class with 100 items per page. You can override this default:
+    >>> class LightPaginationParams(PaginationParams):
+    >>>     page_size: int = Field(default=5, description="The number of items per page")
+    """
+
+    page: Optional[int] = Field(default=1, description="The current page number")
+    page_size: Annotated[int, Field(ge=1, le=100)] = Field(
+        10, description="The number of items per page. Default is 10, max is 100."
+    )
+
+
+class HeavyPaginationParams(PaginationParams[T]):
+    """Pagination parameters with a higher default size. Refer to `PaginationParams` for usage examples."""
+
+    page_size: Annotated[int, Field(ge=1, le=1000)] = Field(
+        100, description="The number of items per page. Default is 100, max is 1000."
+    )
+
+
+class SortParams(BaseModel, Generic[T]):
+    """Standard sort parameters for usage in API endpoints. Check the [fastapi docs](https://fastapi.tiangolo.com/tutorial/query-param-models/?h=qu#query-parameters-with-a-pydantic-model) for usage examples.
+    You should inherit from this class when adding additional parameters.
+    Usage:
+    >>> @router.get("", operation_id="getOrders")
+    >>> async def get_orders(
+    >>>     params: Annotated[SortParams[Order], Query()],
+    >>> ) -> PaginatedResponse[Order]:
+    >>>     ...
     """
 
-    page: int = Field(default=1, description="The current page number")
-    size: int = Field(default=10, description="The number of items per page")
-    order: Optional[Literal["asc", "desc"]] = Field(None, description="The order to sort by")
-    sort: Optional[str] = Field(None, description="The field to sort by")
+    sort_order: Optional[Literal["asc", "desc"]] = Field(
+        None, description="The order to sort by"
+    )
+    sort_by: Optional[str] = Field(None, description="The field to sort by")
 
     @model_validator(mode="after")
-    def validate(self):
+    def validate_sort(self):
         # Extract the generic argument type
         args: tuple = self.__pydantic_generic_metadata__.get("args")
         if not args or not issubclass(args[0], BaseModel):
             raise TypeError(
-                "PaginationParams must be used with a Pydantic BaseModel as a generic parameter"
+                "SortParams must be used with a Pydantic BaseModel as a generic parameter"
             )
-        if self.sort:
+        if self.sort_by:
             # check if the sort field is valid
             model: Type[BaseModel] = args[0]
-            if self.sort and self.sort not in model.model_fields:
+            if self.sort_by not in model.model_fields:
+                raise ValueError(
+                    f"Invalid field: '{self.sort_by}'. Must be one of: {list(model.model_fields)}"
+                )
+        if self.sort_order and self.sort_order not in ["asc", "desc"]:
+            raise ValueError(
+                f"Invalid order: '{self.sort_order}' — must be one of: ['asc', 'desc']"
+            )
+        if (
+            self.sort_order
+            and self.sort_by is None
+            or self.sort_by
+            and self.sort_order is None
+        ):
+            raise ValueError("sort_order and sort_by must be provided together")
+        return self
+
+
+class FilterParams(BaseModel, Generic[T]):
+    """Standard filter parameters for usage in API endpoints. Check the [fastapi docs](https://fastapi.tiangolo.com/tutorial/query-param-models/?h=qu#query-parameters-with-a-pydantic-model) for usage examples.
+    You should inherit from this class when adding additional parameters.
+    Usage:
+    >>> @router.get("", operation_id="getOrders")
+    >>> async def get_orders(
+    >>>     params: Annotated[FilterParams[Order], Query()],
+    >>> ) -> PaginatedResponse[Order]:
+    >>>     ...
+    """
+
+    filter_by: Optional[str] = Field(None, description="The field to filter by")
+    filter_value: Optional[str] = Field(None, description="The value to filter with")
+    # currently openapi-gen does not support typing.Any in combo with None, so we use str
+    # this is fine since the input is a string anyways from the request and the correct type is enforced by the model validator from the filter_by field
+
+    @model_validator(mode="after")
+    def validate_filter(self):
+        if self.filter_by and not self.filter_value:
+            raise ValueError("filter_by and filter_value must be provided together")
+        if self.filter_by:
+            # Extract the generic argument type
+            args: tuple = self.__pydantic_generic_metadata__.get("args")
+            if not args or not issubclass(args[0], BaseModel):
+                raise TypeError(
+                    "FilterParams must be used with a Pydantic BaseModel as a generic parameter"
+                )
+            # check if the filter field is valid
+            model: Type[BaseModel] = args[0]
+            if self.filter_by not in model.model_fields:
                 raise ValueError(
-                    f"Invalid sort field: '{self.sort}' — must be one of: {list(model.model_fields)}"
+                    f"Invalid field: '{self.filter_by}'. Must be one of: {list(model.model_fields)}"
                 )
-        if self.order and self.order not in ["asc", "desc"]:
-            raise ValueError(f"Invalid order: '{self.order}' — must be one of: ['asc', 'desc']")
-        if self.order and not self.sort or self.sort and not self.order:
-            raise ValueError("Sort and order must be provided together")
+            self.filter_value = _enforce_field_type(
+                model, self.filter_by, self.filter_value
+            )
         return self
+
+
+class SortFilterParams(SortParams[T], FilterParams[T]):
+    """Combines sort and filter parameters. Just a convenience class for when you need to combine sort and filter parameters.
+    You should inherit from this class when adding additional parameters.
+    Usage:
+    >>> @router.get("", operation_id="getOrders")
+    >>> async def get_orders(
+    >>>     params: Annotated[SortFilterParams[Order], Query()],
+    >>> ) -> PaginatedResponse[Order]:
+    >>>     ...
+    """
+
+    @model_validator(mode="after")
+    def validate_sort_filter(self):
+        self.validate_sort()
+        self.validate_filter()
+        return self
+
+
+class PageFilterParams(PaginationParams[T], FilterParams[T]):
+    """Combines pagination and filter parameters. Just a convenience class for when you need to combine pagination and filter parameters.
+    You should inherit from this class when adding additional parameters.
+    Usage:
+    >>> @router.get("", operation_id="getOrders")
+    >>> async def get_orders(
+    >>>     params: Annotated[PageFilterParams[Order], Query()],
+    >>> ) -> PaginatedResponse[Order]:
+    >>>     ...
+    """
+
+    @model_validator(mode="after")
+    def validate_page_filter(self):
+        self.validate_filter()
+        return self
+
+
+class PageSortParams(PaginationParams[T], SortParams[T]):
+    """Combines pagination and sort parameters. Just a convenience class for when you need to combine pagination and sort parameters.
+    You should inherit from this class when adding additional parameters.
+    Usage:
+    >>> @router.get("", operation_id="getOrders")
+    >>> async def get_orders(
+    >>>     params: Annotated[PageSortParams[Order], Query()],
+    >>> ) -> PaginatedResponse[Order]:
+    >>>     ...
+    """
+
+    @model_validator(mode="after")
+    def validate_page_sort(self):
+        self.validate_sort()
+        return self
+
+
+class PageSortFilterParams(
+    PaginationParams[T],
+    SortParams[T],
+    FilterParams[T],
+):
+    """Combines pagination, filter, and sort parameters. Just a convenience class for when you need to combine pagination, filter, and sort parameters.
+    You should inherit from this class when adding additional parameters.
+    Usage:
+    >>> @router.get("", operation_id="getOrders")
+    >>> async def get_orders(
+    >>>     params: Annotated[PageSortFilterParams[Order], Query()],
+    >>> ) -> PaginatedResponse[Order]:
+    >>>     ...
+    """
+
+    @model_validator(mode="after")
+    def validate_filter_combo(self):
+        self.validate_filter()
+        self.validate_sort()
+        return self
+
+
+class HeavyPageSortFilterParams(
+    HeavyPaginationParams[T], FilterParams[T], SortParams[T]
+):
+    """Combines heavy pagination, filter, and sort parameters. Just a convenience class for when you need to combine heavy pagination, filter, and sort parameters.
+    You should inherit from this class when adding additional parameters.
+    Usage:
+    >>> @router.get("", operation_id="getOrders")
+    >>> async def get_orders(
+    >>>     params: Annotated[HeavyPageSortFilterParams[Order], Query()],
+    >>> ) -> PaginatedResponse[Order]:
+    >>>     ...
+    """
+
+    @model_validator(mode="after")
+    def validate_heavy_page_sort_filter(self):
+        self.validate_filter()
+        self.validate_sort()
+        return self
+
+
+def _enforce_field_type(model: Type[BaseModel], field_name: str, value: Any) -> Any:
+    """
+    Coerce or validate `value` to match the type of `field_name` on the given `model`. Should be used after checking that the field is valid.
+
+    :param model: The Pydantic model.
+    :param field_name: The name of the field to match.
+    :param value: The value to validate or coerce.
+
+    :return: The value cast to the expected type.
+
+    :raises: ValueError: If the field doesn't exist or coercion fails.
+    """
+    expected_type = model.model_fields[field_name].annotation
+
+    if isinstance(value, expected_type):
+        return value
+
+    try:
+        return expected_type(value)
+    except Exception:
+        raise ValueError(
+            f"Expected {expected_type} for field {field_name}, got {type(value)}"
+        )

crypticorn/common/router/admin_router.py

@@ -11,10 +11,10 @@ import threading
 import time
 import psutil
 import re
-from fastapi import APIRouter, Query
+import logging
 from typing import Literal
+from fastapi import APIRouter, Query
 from crypticorn.common.logging import LogLevel
-import logging
 
 router = APIRouter(tags=["Admin"], prefix="/admin")
 

crypticorn/common/router/status_router.py

@@ -2,14 +2,42 @@
 This module contains the status router for the API.
 It provides endpoints for checking the status of the API and get the server's time.
 SHOULD ALLOW ACCESS TO THIS ROUTER WITHOUT AUTH.
+To enable metrics, pass enable_metrics=True and the auth_handler to the router.
+>>> status_router.enable_metrics = True
+>>> status_router.auth_handler = auth_handler
+Then include the router in the FastAPI app.
 >>> app.include_router(status_router)
 """
 
 from datetime import datetime
-from typing import Literal
 from fastapi import APIRouter, Request
+from typing import Annotated, Literal
+from fastapi import APIRouter, Response, Depends
+from fastapi.security import HTTPBasicCredentials
+from prometheus_client import generate_latest, CONTENT_TYPE_LATEST
+from crypticorn.common.metrics import registry
+from crypticorn.common.auth import AuthHandler
 
-router = APIRouter(tags=["Status"], prefix="")
+
+class EnhancedApiRouter(APIRouter):
+    def __init__(
+        self,
+        enable_metrics: bool = False,
+        auth_handler: AuthHandler = AuthHandler(),
+        *args,
+        **kwargs
+    ):
+        """
+        Enhanced API Router that allows for metrics and authentication.
+        If enable_metrics is True, the router will include the metrics endpoint.
+        If auth_handler is provided, the router will use the auth handler to authenticate requests with
+        """
+        super().__init__(*args, **kwargs)
+        self.enable_metrics = enable_metrics
+        self.auth_handler = auth_handler
+
+
+router = EnhancedApiRouter(tags=["Status"], prefix="")
 
 
 @router.get("/", operation_id="ping")
@@ -29,3 +57,13 @@ async def time(type: Literal["iso", "unix"] = "iso") -> str:
         return datetime.now().isoformat()
     elif type == "unix":
         return str(int(datetime.now().timestamp()))
+
+
+@router.get("/metrics", operation_id="getMetrics", include_in_schema=True)
+def metrics(
+    username: Annotated[HTTPBasicCredentials, Depends(router.auth_handler.basic_auth)],
+):
+    """
+    Get Prometheus metrics for the application. Returns plain text.
+    """
+    return Response(generate_latest(registry), media_type=CONTENT_TYPE_LATEST)

crypticorn/common/scopes.py

@@ -16,7 +16,7 @@ class Scope(StrEnum):
 
     # Scopes that can be purchased - these actually exist in the jwt token
     READ_PREDICTIONS = "read:predictions"
-    READ_DEXSIGNALS = "read:dexsignals"
+    READ_DEX_SIGNALS = "read:dex:signals"
 
     # Hive scopes
     READ_HIVE_MODEL = "read:hive:model"
@@ -88,5 +88,5 @@ class Scope(StrEnum):
             cls.READ_METRICS_MARKETS,
             cls.READ_KLINES,
             cls.READ_SENTIMENT,
-            cls.READ_DEXSIGNALS,
+            cls.READ_DEX_SIGNALS,
         ]

crypticorn/common/warnings.py

@@ -63,6 +63,13 @@ class CrypticornDeprecatedSince215(CrypticornDeprecationWarning):
         super().__init__(message, *args, since=(2, 15), expected_removal=(3, 0))
 
 
+class CrypticornDeprecatedSince217(CrypticornDeprecationWarning):
+    """A specific `CrypticornDeprecationWarning` subclass defining functionality deprecated since Crypticorn 2.17."""
+
+    def __init__(self, message: str, *args: object) -> None:
+        super().__init__(message, *args, since=(2, 17), expected_removal=(3, 0))
+
+
 class CrypticornExperimentalWarning(Warning):
     """A Crypticorn specific experimental functionality warning.
 

crypticorn/dex/__init__.py

@@ -0,0 +1,6 @@
+from crypticorn.dex.client import *
+from crypticorn.dex.main import DexClient
+
+__all__ = [
+    "DexClient",
+]

crypticorn/dex/client/__init__.py

@@ -0,0 +1,49 @@
+# coding: utf-8
+
+# flake8: noqa
+
+"""
+DEX AI API
+
+API for DEX AI
+
+The version of the OpenAPI document: 1.0.0
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""  # noqa: E501
+
+
+__version__ = "1.0.0"
+
+# import apis into sdk package
+from crypticorn.dex.client.api.admin_api import AdminApi
+from crypticorn.dex.client.api.signals_api import SignalsApi
+from crypticorn.dex.client.api.status_api import StatusApi
+
+# import ApiClient
+from crypticorn.dex.client.api_response import ApiResponse
+from crypticorn.dex.client.api_client import ApiClient
+from crypticorn.dex.client.configuration import Configuration
+from crypticorn.dex.client.exceptions import OpenApiException
+from crypticorn.dex.client.exceptions import ApiTypeError
+from crypticorn.dex.client.exceptions import ApiValueError
+from crypticorn.dex.client.exceptions import ApiKeyError
+from crypticorn.dex.client.exceptions import ApiAttributeError
+from crypticorn.dex.client.exceptions import ApiException
+
+# import models into sdk package
+from crypticorn.dex.client.models.api_error_identifier import ApiErrorIdentifier
+from crypticorn.dex.client.models.api_error_level import ApiErrorLevel
+from crypticorn.dex.client.models.api_error_type import ApiErrorType
+from crypticorn.dex.client.models.exception_detail import ExceptionDetail
+from crypticorn.dex.client.models.log_level import LogLevel
+from crypticorn.dex.client.models.paginated_response_signal_with_token import (
+    PaginatedResponseSignalWithToken,
+)
+from crypticorn.dex.client.models.risk import Risk
+from crypticorn.dex.client.models.signal_overview_stats import SignalOverviewStats
+from crypticorn.dex.client.models.signal_volume import SignalVolume
+from crypticorn.dex.client.models.signal_with_token import SignalWithToken
+from crypticorn.dex.client.models.token_data import TokenData
+from crypticorn.dex.client.models.token_detail import TokenDetail

crypticorn/dex/client/api/__init__.py

@@ -0,0 +1,6 @@
+# flake8: noqa
+
+# import apis into api package
+from crypticorn.dex.client.api.admin_api import AdminApi
+from crypticorn.dex.client.api.signals_api import SignalsApi
+from crypticorn.dex.client.api.status_api import StatusApi