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

crypticorn/hive/client/api/status_api.py

@@ -11,18 +11,33 @@ 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 StrictStr, field_validator
-from typing import Optional
 
 from crypticorn.hive.client.api_client import ApiClient, RequestSerialized
 from crypticorn.hive.client.api_response import ApiResponse
 from crypticorn.hive.client.rest import RESTResponseType
 
+# Import async_to_sync for sync methods
+try:
+    from asgiref.sync import async_to_sync
+
+    _HAS_ASGIREF = True
+except ImportError:
+    _HAS_ASGIREF = False
+
+    def async_to_sync(async_func):
+        """Fallback decorator that raises an error if asgiref is not available."""
+
+        def wrapper(*args, **kwargs):
+            raise ImportError(
+                "asgiref is required for sync methods. Install with: pip install asgiref"
+            )
+
+        return wrapper
+
 
 class StatusApi:
     """NOTE: This class is auto generated by OpenAPI Generator
@@ -31,13 +46,126 @@ class StatusApi:
     Do not edit the class manually.
     """
 
-    def __init__(self, api_client=None) -> None:
+    def __init__(self, api_client=None, is_sync: bool = False) -> None:
         if api_client is None:
             api_client = ApiClient.get_default()
         self.api_client = api_client
+        self.is_sync = is_sync
+
+    @validate_call
+    def get_time(
+        self,
+        type: Optional[StrictStr] = 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,
+    ) -> str:
+        """Time"""
+        if self.is_sync:
+            return self._get_time_sync(
+                type=type,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_time_async(
+                type=type,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    @validate_call
+    def get_time_with_http_info(
+        self,
+        type: Optional[StrictStr] = 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[str]:
+        """Time with HTTP info"""
+        if self.is_sync:
+            return self._get_time_sync_with_http_info(
+                type=type,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_time_async_with_http_info(
+                type=type,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    @validate_call
+    def get_time_without_preload_content(
+        self,
+        type: Optional[StrictStr] = 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:
+        """Time without preloading content"""
+        if self.is_sync:
+            return self._get_time_sync_without_preload_content(
+                type=type,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._get_time_async_without_preload_content(
+                type=type,
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
 
+    # Private async implementation methods
     @validate_call
-    async def get_time(
+    async def _get_time_async(
         self,
         type: Optional[StrictStr] = None,
         _request_timeout: Union[
@@ -101,7 +229,7 @@ class StatusApi:
         ).data
 
     @validate_call
-    async def get_time_with_http_info(
+    async def _get_time_async_with_http_info(
         self,
         type: Optional[StrictStr] = None,
         _request_timeout: Union[
@@ -160,12 +288,11 @@ class StatusApi:
         )
         await response_data.read()
         return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
+            response_data=response_data, response_types_map=_response_types_map
         )
 
     @validate_call
-    async def get_time_without_preload_content(
+    async def _get_time_async_without_preload_content(
         self,
         type: Optional[StrictStr] = None,
         _request_timeout: Union[
@@ -222,7 +349,86 @@ class StatusApi:
         response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
-        return response_data.response
+        return response_data
+
+    # Private sync implementation methods
+    @validate_call
+    def _get_time_sync(
+        self,
+        type: Optional[StrictStr] = 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,
+    ) -> str:
+        """Synchronous version of get_time"""
+        return async_to_sync(self._get_time_async)(
+            type=type,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    @validate_call
+    def _get_time_sync_with_http_info(
+        self,
+        type: Optional[StrictStr] = 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[str]:
+        """Synchronous version of get_time_with_http_info"""
+        return async_to_sync(self._get_time_async_with_http_info)(
+            type=type,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    @validate_call
+    def _get_time_sync_without_preload_content(
+        self,
+        type: Optional[StrictStr] = 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:
+        """Synchronous version of get_time_without_preload_content"""
+        return async_to_sync(self._get_time_async_without_preload_content)(
+            type=type,
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
 
     def _get_time_serialize(
         self,
@@ -281,7 +487,110 @@ class StatusApi:
         )
 
     @validate_call
-    async def ping(
+    def ping(
+        self,
+        _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,
+    ) -> str:
+        """Ping"""
+        if self.is_sync:
+            return self._ping_sync(
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._ping_async(
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    @validate_call
+    def ping_with_http_info(
+        self,
+        _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[str]:
+        """Ping with HTTP info"""
+        if self.is_sync:
+            return self._ping_sync_with_http_info(
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._ping_async_with_http_info(
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    @validate_call
+    def ping_without_preload_content(
+        self,
+        _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:
+        """Ping without preloading content"""
+        if self.is_sync:
+            return self._ping_sync_without_preload_content(
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+        else:
+            return self._ping_async_without_preload_content(
+                _request_timeout=_request_timeout,
+                _request_auth=_request_auth,
+                _content_type=_content_type,
+                _headers=_headers,
+                _host_index=_host_index,
+            )
+
+    # Private async implementation methods
+    @validate_call
+    async def _ping_async(
         self,
         _request_timeout: Union[
             None,
@@ -341,7 +650,7 @@ class StatusApi:
         ).data
 
     @validate_call
-    async def ping_with_http_info(
+    async def _ping_async_with_http_info(
         self,
         _request_timeout: Union[
             None,
@@ -396,12 +705,11 @@ class StatusApi:
         )
         await response_data.read()
         return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
+            response_data=response_data, response_types_map=_response_types_map
         )
 
     @validate_call
-    async def ping_without_preload_content(
+    async def _ping_async_without_preload_content(
         self,
         _request_timeout: Union[
             None,
@@ -454,7 +762,80 @@ class StatusApi:
         response_data = await self.api_client.call_api(
             *_param, _request_timeout=_request_timeout
         )
-        return response_data.response
+        return response_data
+
+    # Private sync implementation methods
+    @validate_call
+    def _ping_sync(
+        self,
+        _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,
+    ) -> str:
+        """Synchronous version of ping"""
+        return async_to_sync(self._ping_async)(
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    @validate_call
+    def _ping_sync_with_http_info(
+        self,
+        _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[str]:
+        """Synchronous version of ping_with_http_info"""
+        return async_to_sync(self._ping_async_with_http_info)(
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
+
+    @validate_call
+    def _ping_sync_without_preload_content(
+        self,
+        _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:
+        """Synchronous version of ping_without_preload_content"""
+        return async_to_sync(self._ping_async_without_preload_content)(
+            _request_timeout=_request_timeout,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index,
+        )
 
     def _ping_serialize(
         self,

crypticorn/hive/client/api_client.py

@@ -33,11 +33,6 @@ from crypticorn.hive.client import rest
 from crypticorn.hive.client.exceptions import (
     ApiValueError,
     ApiException,
-    BadRequestException,
-    UnauthorizedException,
-    ForbiddenException,
-    NotFoundException,
-    ServiceException,
 )
 
 RequestSerialized = Tuple[str, str, Dict[str, str], Optional[str], List[str]]

crypticorn/hive/client/models/api_error_identifier.py

@@ -68,7 +68,7 @@ class ApiErrorIdentifier(str, Enum):
     INVALID_EXCHANGE_KEY = "invalid_exchange_key"
     INVALID_MARGIN_MODE = "invalid_margin_mode"
     INVALID_MODEL_NAME = "invalid_model_name"
-    INVALID_PARAMETER_PROVIDED = "exchange_invalid_parameter"
+    INVALID_PARAMETER_PROVIDED = "invalid_parameter_provided"
     LEVERAGE_LIMIT_EXCEEDED = "leverage_limit_exceeded"
     ORDER_VIOLATES_LIQUIDATION_PRICE_CONSTRAINTS = (
         "order_violates_liquidation_price_constraints"

crypticorn/hive/client/models/coin_info.py

@@ -21,7 +21,7 @@ from pydantic import BaseModel, ConfigDict, Field
 from typing import Any, ClassVar, Dict, List, Optional
 from crypticorn.hive.client.models.coins import Coins
 from crypticorn.hive.client.models.data_version import DataVersion
-from typing import Optional, Set
+from typing import Set
 from typing_extensions import Self
 
 

crypticorn/hive/client/models/exception_detail.py

@@ -22,7 +22,7 @@ from typing import Any, ClassVar, Dict, List, Optional
 from crypticorn.hive.client.models.api_error_identifier import ApiErrorIdentifier
 from crypticorn.hive.client.models.api_error_level import ApiErrorLevel
 from crypticorn.hive.client.models.api_error_type import ApiErrorType
-from typing import Optional, Set
+from typing import Set
 from typing_extensions import Self
 
 

crypticorn/hive/client/models/target_info.py

@@ -22,7 +22,7 @@ from typing import Any, ClassVar, Dict, List, Optional
 from crypticorn.hive.client.models.data_version import DataVersion
 from crypticorn.hive.client.models.target import Target
 from crypticorn.hive.client.models.target_type import TargetType
-from typing import Optional, Set
+from typing import Set
 from typing_extensions import Self
 
 

crypticorn/hive/client/rest.py

@@ -77,6 +77,7 @@ class RESTClientObject:
 
         self.pool_manager: Optional[aiohttp.ClientSession] = None
         self.retry_client: Optional[aiohttp_retry.RetryClient] = None
+        self.is_sync: bool = False  # Track whether this is sync or async mode
 
     async def close(self) -> None:
         if self.pool_manager:
@@ -170,7 +171,9 @@ class RESTClientObject:
 
         pool_manager: Union[aiohttp.ClientSession, aiohttp_retry.RetryClient]
 
-        # https pool manager
+        # For sync operations, always use a fresh session
+        should_close_session = False
+
         if self.pool_manager is None:
             self.pool_manager = aiohttp.ClientSession(
                 connector=aiohttp.TCPConnector(
@@ -178,6 +181,9 @@ class RESTClientObject:
                 ),
                 trust_env=True,
             )
+            # Only close session automatically in sync mode
+            should_close_session = self.is_sync
+
         pool_manager = self.pool_manager
 
         if self.retries is not None and method in ALLOW_RETRY_METHODS:
@@ -193,6 +199,19 @@ class RESTClientObject:
                 )
             pool_manager = self.retry_client
 
-        r = await pool_manager.request(**args)
-
-        return RESTResponse(r)
+        try:
+            r = await pool_manager.request(**args)
+            # For sessions we're about to close, read the data immediately
+            if should_close_session:
+                response = RESTResponse(r)
+                await response.read()  # Read data before closing session
+                return response
+            else:
+                return RESTResponse(r)
+        finally:
+            if should_close_session:
+                if self.retry_client is not None:
+                    await self.retry_client.close()
+                    self.retry_client = None
+                await self.pool_manager.close()
+                self.pool_manager = None