crypticorn 2.17.0rc3__py3-none-any.whl → 2.17.0rc5__py3-none-any.whl

crypticorn/common/pagination.py

@@ -2,13 +2,27 @@
 
 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]
@@ -17,20 +31,40 @@ class PaginatedResponse(BaseModel, Generic[T]):
     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.
-    Can only be used isolated, not in combination with other parameters. If you need to combine with other parameters, use `FilterComboParams` or refer to this [workaround](https://github.com/fastapi/fastapi/discussions/13448#discussioncomment-12440374).
+    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(
-    >>>     paginate: Annotated[PaginationParams[Order], Query()],
+    >>>     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[T]):
+    >>> class LightPaginationParams(PaginationParams):
     >>>     page_size: int = Field(default=5, description="The number of items per page")
     """
 
@@ -50,11 +84,11 @@ class HeavyPaginationParams(PaginationParams[T]):
 
 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.
-    Can only be used isolated, not in combination with other parameters. If you need to combine with other parameters, use `FilterComboParams` or refer to this [workaround](https://github.com/fastapi/fastapi/discussions/13448#discussioncomment-12440374).
+    You should inherit from this class when adding additional parameters.
     Usage:
     >>> @router.get("", operation_id="getOrders")
     >>> async def get_orders(
-    >>>     sort: Annotated[SortParams[Order], Query()],
+    >>>     params: Annotated[SortParams[Order], Query()],
     >>> ) -> PaginatedResponse[Order]:
     >>>     ...
     """
@@ -70,7 +104,7 @@ class SortParams(BaseModel, Generic[T]):
         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_by:
             # check if the sort field is valid
@@ -83,24 +117,31 @@ class SortParams(BaseModel, Generic[T]):
             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:
+        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.
-    Can only be used isolated, not in combination with other parameters. If you need to combine with other parameters, use `FilterComboParams` or refer to this [workaround](https://github.com/fastapi/fastapi/discussions/13448#discussioncomment-12440374).
+    You should inherit from this class when adding additional parameters.
     Usage:
     >>> @router.get("", operation_id="getOrders")
     >>> async def get_orders(
-    >>>     filter: Annotated[FilterParams[Order], Query()],
+    >>>     params: Annotated[FilterParams[Order], Query()],
     >>> ) -> PaginatedResponse[Order]:
     >>>     ...
     """
 
     filter_by: Optional[str] = Field(None, description="The field to filter by")
-    filter_value: Optional[Any] = Field(None, description="The value to filter with")
+    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):
@@ -119,34 +160,104 @@ class FilterParams(BaseModel, Generic[T]):
                 raise ValueError(
                     f"Invalid field: '{self.filter_by}'. Must be one of: {list(model.model_fields)}"
                 )
-            self.filter_value = _enforce_field_type(model, self.filter_by, self.filter_value)
+            self.filter_value = _enforce_field_type(
+                model, self.filter_by, self.filter_value
+            )
         return self
 
 
-class FilterComboParams(PaginationParams[T], SortParams[T], FilterParams[T], ):
-    """Combines pagination, filter, and sort parameters.
+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(
-    >>>     filter_combo: Annotated[FilterComboParams[Order], Query()],
+    >>>     params: Annotated[SortFilterParams[Order], Query()],
     >>> ) -> PaginatedResponse[Order]:
     >>>     ...
     """
 
-    pass
+    @model_validator(mode="after")
+    def validate_sort_filter(self):
+        self.validate_sort()
+        self.validate_filter()
+        return self
 
 
-class HeavyFilterComboParams(HeavyPaginationParams[T], FilterParams[T], SortParams[T]):
-    """Combines pagination, filter, and sort parameters.
+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(
-    >>>     filter_combo: Annotated[HeavyFilterComboParams[Order], Query()],
+    >>>     params: Annotated[PageFilterParams[Order], Query()],
     >>> ) -> PaginatedResponse[Order]:
     >>>     ...
     """
 
-    pass
+    @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:
@@ -168,5 +279,7 @@ def _enforce_field_type(model: Type[BaseModel], field_name: str, value: Any) ->
 
     try:
         return expected_type(value)
-    except Exception as e:
-        raise ValueError(f"Expected {expected_type} for field {field_name}, got {type(value)}")
+    except Exception:
+        raise ValueError(
+            f"Expected {expected_type} for field {field_name}, got {type(value)}"
+        )

crypticorn/common/utils.py

@@ -1,11 +1,10 @@
 """General utility functions and helper methods used across the codebase."""
 
 from datetime import datetime
-from typing import Any, Type, Union
+from typing import Any, Union
 from decimal import Decimal
 import string
 import random
-from pydantic import BaseModel
 import typing_extensions
 import warnings
 

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