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

crypticorn/klines/client/models/api_error_identifier.py

@@ -68,17 +68,19 @@ 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"
     )
+    MARGIN_MODE_CLASH = "margin_mode_clash"
     MODEL_NAME_NOT_UNIQUE = "model_name_not_unique"
     NO_CREDENTIALS = "no_credentials"
     NOW_API_DOWN = "now_api_down"
     OBJECT_ALREADY_EXISTS = "object_already_exists"
     OBJECT_CREATED = "object_created"
     OBJECT_DELETED = "object_deleted"
+    OBJECT_LOCKED = "object_locked"
     OBJECT_NOT_FOUND = "object_not_found"
     OBJECT_UPDATED = "object_updated"
     ORDER_IS_ALREADY_FILLED = "order_is_already_filled"

crypticorn/klines/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

crypticorn/klines/main.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Optional, Union, Coroutine, Any
 from crypticorn.klines import (
     ApiClient,
     Configuration,
@@ -26,17 +26,20 @@ class KlinesClient:
         self,
         config: Configuration,
         http_client: Optional[ClientSession] = None,
+        is_sync: bool = False,
     ):
         self.config = config
         self.base_client = ApiClient(configuration=self.config)
         if http_client is not None:
             self.base_client.rest_client.pool_manager = http_client
+        # Pass sync context to REST client for proper session management
+        self.base_client.rest_client.is_sync = is_sync
         # Instantiate all the endpoint clients
-        self.funding = FundingRatesApiWrapper(self.base_client)
-        self.ohlcv = OHLCVDataApiWrapper(self.base_client)
-        self.symbols = SymbolsApiWrapper(self.base_client)
-        self.udf = UDFApi(self.base_client)
-        self.status = StatusApi(self.base_client)
+        self.funding = FundingRatesApiWrapper(self.base_client, is_sync=is_sync)
+        self.ohlcv = OHLCVDataApiWrapper(self.base_client, is_sync=is_sync)
+        self.symbols = SymbolsApiWrapper(self.base_client, is_sync=is_sync)
+        self.udf = UDFApi(self.base_client, is_sync=is_sync)
+        self.status = StatusApi(self.base_client, is_sync=is_sync)
 
 
 class FundingRatesApiWrapper(FundingRatesApi):
@@ -44,12 +47,38 @@ class FundingRatesApiWrapper(FundingRatesApi):
     A wrapper for the FundingRatesApi class.
     """
 
-    async def get_funding_rates_fmt(self, *args, **kwargs) -> pd.DataFrame:  # type: ignore
+    def get_funding_rates_fmt(self, *args, **kwargs) -> Union[pd.DataFrame, Coroutine[Any, Any, pd.DataFrame]]:  # type: ignore
         """
         Get the funding rates in a pandas DataFrame.
+        Works in both sync and async contexts.
+        """
+        if self.is_sync:
+            return self._get_funding_rates_fmt_sync(*args, **kwargs)
+        else:
+            return self._get_funding_rates_fmt_async(*args, **kwargs)
+
+    def _get_funding_rates_fmt_sync(self, *args, **kwargs) -> pd.DataFrame:  # type: ignore
+        """
+        Get the funding rates in a pandas DataFrame (sync version).
+        """
+        pd = optional_import("pandas", "extra")
+        response = self._get_funding_rates_sync(*args, **kwargs)
+        response = [
+            {
+                "timestamp": int(m.timestamp.timestamp()),
+                "symbol": m.symbol,
+                "funding_rate": m.funding_rate,
+            }
+            for m in response
+        ]
+        return pd.DataFrame(response)
+
+    async def _get_funding_rates_fmt_async(self, *args, **kwargs) -> pd.DataFrame:  # type: ignore
+        """
+        Get the funding rates in a pandas DataFrame (async version).
         """
         pd = optional_import("pandas", "extra")
-        response = await self.get_funding_rates(*args, **kwargs)
+        response = await self._get_funding_rates_async(*args, **kwargs)
         response = [
             {
                 "timestamp": int(m.timestamp.timestamp()),
@@ -66,12 +95,42 @@ class OHLCVDataApiWrapper(OHLCVDataApi):
     A wrapper for the OHLCVDataApi class.
     """
 
-    async def get_ohlcv_data_fmt(self, *args, **kwargs) -> pd.DataFrame:  # type: ignore
+    def get_ohlcv_data_fmt(self, *args, **kwargs) -> Union[pd.DataFrame, Coroutine[Any, Any, pd.DataFrame]]:  # type: ignore
         """
         Get the OHLCV data in a pandas DataFrame.
+        Works in both sync and async contexts.
+        """
+        if self.is_sync:
+            return self._get_ohlcv_data_fmt_sync(*args, **kwargs)
+        else:
+            return self._get_ohlcv_data_fmt_async(*args, **kwargs)
+
+    def _get_ohlcv_data_fmt_sync(self, *args, **kwargs) -> pd.DataFrame:  # type: ignore
+        """
+        Get the OHLCV data in a pandas DataFrame (sync version).
+        """
+        pd = optional_import("pandas", "extra")
+        response = self._get_ohlcv_sync(*args, **kwargs)
+        rows = []
+        for item in response:
+            row = {
+                "timestamp": item.timestamp,
+                "open": item.open,
+                "high": item.high,
+                "low": item.low,
+                "close": item.close,
+                "volume": item.volume,
+            }
+            rows.append(row)
+        df = pd.DataFrame(rows)
+        return df
+
+    async def _get_ohlcv_data_fmt_async(self, *args, **kwargs) -> pd.DataFrame:  # type: ignore
+        """
+        Get the OHLCV data in a pandas DataFrame (async version).
         """
         pd = optional_import("pandas", "extra")
-        response = await self.get_ohlcv(*args, **kwargs)
+        response = await self._get_ohlcv_async(*args, **kwargs)
         rows = []
         for item in response:
             row = {
@@ -92,10 +151,28 @@ class SymbolsApiWrapper(SymbolsApi):
     A wrapper for the SymbolsApi class.
     """
 
-    async def get_symbols_fmt(self, *args, **kwargs) -> pd.DataFrame:  # type: ignore
+    def get_symbols_fmt(self, *args, **kwargs) -> Union[pd.DataFrame, Coroutine[Any, Any, pd.DataFrame]]:  # type: ignore
         """
         Get the symbols in a pandas DataFrame.
+        Works in both sync and async contexts.
+        """
+        if self.is_sync:
+            return self._get_symbols_fmt_sync(*args, **kwargs)
+        else:
+            return self._get_symbols_fmt_async(*args, **kwargs)
+
+    def _get_symbols_fmt_sync(self, *args, **kwargs) -> pd.DataFrame:  # type: ignore
+        """
+        Get the symbols in a pandas DataFrame (sync version).
+        """
+        pd = optional_import("pandas", "extra")
+        response = self._get_klines_symbols_sync(*args, **kwargs)
+        return pd.DataFrame(response, columns=["symbol"])
+
+    async def _get_symbols_fmt_async(self, *args, **kwargs) -> pd.DataFrame:  # type: ignore
+        """
+        Get the symbols in a pandas DataFrame (async version).
         """
         pd = optional_import("pandas", "extra")
-        response = await self.get_klines_symbols(*args, **kwargs)
+        response = await self._get_klines_symbols_async(*args, **kwargs)
         return pd.DataFrame(response, columns=["symbol"])