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

crypticorn/trade/client/models/strategy.py

@@ -50,15 +50,18 @@ class Strategy(BaseModel):
         description="Whether the strategy is enabled. If false, no bots will be created or updated for this strategy, open trades will be rejected. Existing bots will be marked as stopping."
     )
     performance_fee: Union[
-        Annotated[float, Field(le=1.0, strict=True)],
-        Annotated[int, Field(le=1, strict=True)],
+        Annotated[float, Field(le=1.0, strict=True, ge=0.0)],
+        Annotated[int, Field(le=1, strict=True, ge=0)],
     ] = Field(description="Performance fee for the strategy")
     identifier: StrictStr = Field(
         description="Unique human readable identifier for the strategy e.g. 'daily_trend_momentum'"
     )
     margin_mode: Optional[MarginMode] = None
-    leverage: StrictInt = Field(description="Leverage for the strategy")
+    leverage: Annotated[int, Field(strict=True, ge=1)] = Field(
+        description="Leverage for the strategy"
+    )
     market_type: MarketType = Field(description="Market of operation of the strategy")
+    additional_properties: Dict[str, Any] = {}
     __properties: ClassVar[List[str]] = [
         "created_at",
         "updated_at",
@@ -103,8 +106,13 @@ class Strategy(BaseModel):
         * `None` is only added to the output dict for nullable fields that
           were set at model initialization. Other fields with value `None`
           are ignored.
+        * Fields in `self.additional_properties` are added to the output dict.
         """
-        excluded_fields: Set[str] = set([])
+        excluded_fields: Set[str] = set(
+            [
+                "additional_properties",
+            ]
+        )
 
         _dict = self.model_dump(
             by_alias=True,
@@ -118,6 +126,11 @@ class Strategy(BaseModel):
                 if _item_exchanges:
                     _items.append(_item_exchanges.to_dict())
             _dict["exchanges"] = _items
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
         # set to None if margin_mode (nullable) is None
         # and model_fields_set contains the field
         if self.margin_mode is None and "margin_mode" in self.model_fields_set:
@@ -157,4 +170,9 @@ class Strategy(BaseModel):
                 "market_type": obj.get("market_type"),
             }
         )
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
         return _obj

crypticorn/trade/client/models/strategy_create.py

@@ -17,7 +17,7 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional, Union
 from typing_extensions import Annotated
 from crypticorn.trade.client.models.margin_mode import MarginMode
@@ -41,15 +41,18 @@ class StrategyCreate(BaseModel):
         description="Whether the strategy is enabled. If false, no bots will be created or updated for this strategy, open trades will be rejected. Existing bots will be marked as stopping."
     )
     performance_fee: Union[
-        Annotated[float, Field(le=1.0, strict=True)],
-        Annotated[int, Field(le=1, strict=True)],
+        Annotated[float, Field(le=1.0, strict=True, ge=0.0)],
+        Annotated[int, Field(le=1, strict=True, ge=0)],
     ] = Field(description="Performance fee for the strategy")
     identifier: StrictStr = Field(
         description="Unique human readable identifier for the strategy e.g. 'daily_trend_momentum'"
     )
     margin_mode: Optional[MarginMode] = None
-    leverage: StrictInt = Field(description="Leverage for the strategy")
+    leverage: Annotated[int, Field(strict=True, ge=1)] = Field(
+        description="Leverage for the strategy"
+    )
     market_type: MarketType = Field(description="Market of operation of the strategy")
+    additional_properties: Dict[str, Any] = {}
     __properties: ClassVar[List[str]] = [
         "name",
         "description",
@@ -91,8 +94,13 @@ class StrategyCreate(BaseModel):
         * `None` is only added to the output dict for nullable fields that
           were set at model initialization. Other fields with value `None`
           are ignored.
+        * Fields in `self.additional_properties` are added to the output dict.
         """
-        excluded_fields: Set[str] = set([])
+        excluded_fields: Set[str] = set(
+            [
+                "additional_properties",
+            ]
+        )
 
         _dict = self.model_dump(
             by_alias=True,
@@ -106,6 +114,11 @@ class StrategyCreate(BaseModel):
                 if _item_exchanges:
                     _items.append(_item_exchanges.to_dict())
             _dict["exchanges"] = _items
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
         # set to None if margin_mode (nullable) is None
         # and model_fields_set contains the field
         if self.margin_mode is None and "margin_mode" in self.model_fields_set:
@@ -142,4 +155,9 @@ class StrategyCreate(BaseModel):
                 "market_type": obj.get("market_type"),
             }
         )
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
         return _obj

crypticorn/trade/client/models/strategy_exchange_info.py

@@ -17,8 +17,8 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictInt
-from typing import Any, ClassVar, Dict, List
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
 from crypticorn.trade.client.models.exchange import Exchange
 from typing import Optional, Set
 from typing_extensions import Self
@@ -30,10 +30,14 @@ class StrategyExchangeInfo(BaseModel):
     """  # noqa: E501
 
     exchange: Exchange = Field(description="Exchange name. Of type Exchange")
+    base_asset: Optional[StrictStr] = Field(
+        default="USDT",
+        description="Base asset for the strategy. This is the asset that will be used to trade with. Default is USDT.",
+    )
     min_amount: StrictInt = Field(
         description="Minimum amount for the strategy on the exchange"
     )
-    __properties: ClassVar[List[str]] = ["exchange", "min_amount"]
+    __properties: ClassVar[List[str]] = ["exchange", "base_asset", "min_amount"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -84,6 +88,14 @@ class StrategyExchangeInfo(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate(
-            {"exchange": obj.get("exchange"), "min_amount": obj.get("min_amount")}
+            {
+                "exchange": obj.get("exchange"),
+                "base_asset": (
+                    obj.get("base_asset")
+                    if obj.get("base_asset") is not None
+                    else "USDT"
+                ),
+                "min_amount": obj.get("min_amount"),
+            }
         )
         return _obj

crypticorn/trade/client/models/strategy_update.py

@@ -36,10 +36,11 @@ class StrategyUpdate(BaseModel):
     enabled: Optional[StrictBool] = None
     performance_fee: Optional[
         Union[
-            Annotated[float, Field(le=1.0, strict=True)],
-            Annotated[int, Field(le=1, strict=True)],
+            Annotated[float, Field(le=1.0, strict=True, ge=0.0)],
+            Annotated[int, Field(le=1, strict=True, ge=0)],
         ]
     ] = None
+    additional_properties: Dict[str, Any] = {}
     __properties: ClassVar[List[str]] = [
         "name",
         "description",
@@ -77,8 +78,13 @@ class StrategyUpdate(BaseModel):
         * `None` is only added to the output dict for nullable fields that
           were set at model initialization. Other fields with value `None`
           are ignored.
+        * Fields in `self.additional_properties` are added to the output dict.
         """
-        excluded_fields: Set[str] = set([])
+        excluded_fields: Set[str] = set(
+            [
+                "additional_properties",
+            ]
+        )
 
         _dict = self.model_dump(
             by_alias=True,
@@ -92,6 +98,11 @@ class StrategyUpdate(BaseModel):
                 if _item_exchanges:
                     _items.append(_item_exchanges.to_dict())
             _dict["exchanges"] = _items
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
         # set to None if name (nullable) is None
         # and model_fields_set contains the field
         if self.name is None and "name" in self.model_fields_set:
@@ -144,4 +155,9 @@ class StrategyUpdate(BaseModel):
                 "performance_fee": obj.get("performance_fee"),
             }
         )
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
         return _obj

crypticorn/trade/client/models/tpsl.py

@@ -28,18 +28,14 @@ class TPSL(BaseModel):
     Runtime fields for take profit and stop loss
     """  # noqa: E501
 
-    price_delta: Optional[StrictStr] = None
-    price: Optional[StrictStr] = None
+    price_delta: StrictStr = Field(
+        description="The price delta to calculate the limit price from the current market price, e.g. 1.01 for a TP of 1% on long"
+    )
     allocation: StrictStr = Field(
         description="Percentage of the open order to sell. All allocations must sum up to 1. Use this allocation again when closing the order."
     )
     execution_id: Optional[StrictStr] = None
-    __properties: ClassVar[List[str]] = [
-        "price_delta",
-        "price",
-        "allocation",
-        "execution_id",
-    ]
+    __properties: ClassVar[List[str]] = ["price_delta", "allocation", "execution_id"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -78,16 +74,6 @@ class TPSL(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # set to None if price_delta (nullable) is None
-        # and model_fields_set contains the field
-        if self.price_delta is None and "price_delta" in self.model_fields_set:
-            _dict["price_delta"] = None
-
-        # set to None if price (nullable) is None
-        # and model_fields_set contains the field
-        if self.price is None and "price" in self.model_fields_set:
-            _dict["price"] = None
-
         # set to None if execution_id (nullable) is None
         # and model_fields_set contains the field
         if self.execution_id is None and "execution_id" in self.model_fields_set:
@@ -107,7 +93,6 @@ class TPSL(BaseModel):
         _obj = cls.model_validate(
             {
                 "price_delta": obj.get("price_delta"),
-                "price": obj.get("price"),
                 "allocation": obj.get("allocation"),
                 "execution_id": obj.get("execution_id"),
             }

crypticorn/trade/client/models/tpsl_create.py

@@ -18,7 +18,7 @@ import re  # noqa: F401
 import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictStr
-from typing import Any, ClassVar, Dict, List, Optional
+from typing import Any, ClassVar, Dict, List
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -28,12 +28,13 @@ class TPSLCreate(BaseModel):
     Model for take profit and stop loss
     """  # noqa: E501
 
-    price_delta: Optional[StrictStr] = None
-    price: Optional[StrictStr] = None
+    price_delta: StrictStr = Field(
+        description="The price delta to calculate the limit price from the current market price, e.g. 1.01 for a TP of 1% on long"
+    )
     allocation: StrictStr = Field(
         description="Percentage of the open order to sell. All allocations must sum up to 1. Use this allocation again when closing the order."
     )
-    __properties: ClassVar[List[str]] = ["price_delta", "price", "allocation"]
+    __properties: ClassVar[List[str]] = ["price_delta", "allocation"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -72,16 +73,6 @@ class TPSLCreate(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # set to None if price_delta (nullable) is None
-        # and model_fields_set contains the field
-        if self.price_delta is None and "price_delta" in self.model_fields_set:
-            _dict["price_delta"] = None
-
-        # set to None if price (nullable) is None
-        # and model_fields_set contains the field
-        if self.price is None and "price" in self.model_fields_set:
-            _dict["price"] = None
-
         return _dict
 
     @classmethod
@@ -94,10 +85,6 @@ class TPSLCreate(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate(
-            {
-                "price_delta": obj.get("price_delta"),
-                "price": obj.get("price"),
-                "allocation": obj.get("allocation"),
-            }
+            {"price_delta": obj.get("price_delta"), "allocation": obj.get("allocation")}
         )
         return _obj

crypticorn/trade/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/trade/main.py

@@ -1,12 +1,11 @@
 from __future__ import annotations
 from typing import TYPE_CHECKING, Optional
-from crypticorn.trade import (
+from crypticorn.trade.client import (
     ApiClient,
     APIKeysApi,
     BotsApi,
     Configuration,
     ExchangesApi,
-    FuturesTradingPanelApi,
     NotificationsApi,
     OrdersApi,
     StatusApi,
@@ -26,19 +25,23 @@ class TradeClient:
     config_class = Configuration
 
     def __init__(
-        self, config: Configuration, http_client: Optional[ClientSession] = None
+        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.bots = BotsApi(self.base_client)
-        self.exchanges = ExchangesApi(self.base_client)
-        self.notifications = NotificationsApi(self.base_client)
-        self.orders = OrdersApi(self.base_client)
-        self.status = StatusApi(self.base_client)
-        self.strategies = StrategiesApi(self.base_client)
-        self.actions = TradingActionsApi(self.base_client)
-        self.futures = FuturesTradingPanelApi(self.base_client)
-        self.keys = APIKeysApi(self.base_client)
+        self.bots = BotsApi(self.base_client, is_sync=is_sync)
+        self.exchanges = ExchangesApi(self.base_client, is_sync=is_sync)
+        self.notifications = NotificationsApi(self.base_client, is_sync=is_sync)
+        self.orders = OrdersApi(self.base_client, is_sync=is_sync)
+        self.status = StatusApi(self.base_client, is_sync=is_sync)
+        self.strategies = StrategiesApi(self.base_client, is_sync=is_sync)
+        self.actions = TradingActionsApi(self.base_client, is_sync=is_sync)
+        self.keys = APIKeysApi(self.base_client, is_sync=is_sync)

{crypticorn-2.16.0.dist-info → crypticorn-2.17.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crypticorn
-Version: 2.16.0
+Version: 2.17.0
 Summary: Maximise Your Crypto Trading Profits with Machine Learning
 Author-email: Crypticorn <timon@crypticorn.com>
 License-Expression: MIT
@@ -25,6 +25,8 @@ Requires-Dist: click<9.0.0,>=8.0.0
 Requires-Dist: psutil<8.0.0,>=7.0.0
 Requires-Dist: setuptools<81.0.0,>=80.0.0
 Requires-Dist: strenum
+Requires-Dist: prometheus-client<1.0.0,>=0.22.0
+Requires-Dist: asgiref<4.0.0,>=3.6.0
 Requires-Dist: urllib3<3.0.0,>=1.25.3
 Requires-Dist: python_dateutil<3.0.0,>=2.8.2
 Requires-Dist: aiohttp<4.0.0,>=3.8.4
@@ -49,6 +51,7 @@ Requires-Dist: pytest-asyncio==0.26.0; extra == "test"
 Requires-Dist: pytest-cov==6.1.1; extra == "test"
 Requires-Dist: python-dotenv==1.0.1; extra == "test"
 Requires-Dist: PyJWT==2.10.0; extra == "test"
+Requires-Dist: httpx>=0.27.0; extra == "test"
 Provides-Extra: extra
 Requires-Dist: pandas<3.0.0,>=2.2.0; extra == "extra"
 Dynamic: license-file
@@ -78,11 +81,15 @@ You can install extra dependencies grouped in the extras `extra`, `dev` (develop
 
 ## Structure
 
-Our API is available as an asynchronous Python SDK. The main entry point you need is the `ApiClient` class, which you would import like this:
+Our API is available as both an asynchronous and synchronous Python SDK. The main entry points are:
+
+- `AsyncClient` - Asynchronous client for async/await usage
+- `SyncClient` - Synchronous client for traditional blocking calls
+
 ```python
-from crypticorn import ApiClient
+from crypticorn import AsyncClient, SyncClient
 ```
-The ApiClient serves as the central interface for API operations. It instantiates multiple API wrappers corresponding to our micro services. These are structured the following:
+Both clients serve as the central interface for API operations and instantiate multiple API wrappers corresponding to our micro services. These are structured the following:
 
 <img src="static/pip-structure.svg" alt="pip package structure" />
 
@@ -110,20 +117,22 @@ There are scopes which don't follow this structure. Those are either scopes that
 
 ## Basic Usage
 
-You can use the client with the async context protocol...
+### Asynchronous Client
+
+You can use the async client with the context manager protocol...
 ```python
-async with ApiClient(api_key="your-api-key") as client:
-        await client.pay.products.get_products()
+async with AsyncClient(api_key="your-api-key") as client:
+    await client.pay.products.get_products()
 ```
 ...or without it like this...
 ```python
-client = ApiClient(api_key="your-api-key")
-asyncio.run(client.pay.models.get_products())
+client = AsyncClient(api_key="your-api-key")
+asyncio.run(client.pay.products.get_products())
 asyncio.run(client.close())
 ```
 ...or this.
 ```python
-client = ApiClient(api_key="your-api-key")
+client = AsyncClient(api_key="your-api-key")
 
 async def main():
     await client.pay.products.get_products()
@@ -132,6 +141,29 @@ asyncio.run(main())
 asyncio.run(client.close())
 ```
 
+### Synchronous Client
+
+For traditional synchronous usage without async/await, use the `SyncClient`:
+
+```python
+from crypticorn import SyncClient
+
+# With context manager (recommended)
+with SyncClient(api_key="your-api-key") as client:
+    products = client.pay.products.get_products()
+    status = client.trade.status.ping()
+
+# Or without context manager
+client = SyncClient(api_key="your-api-key")
+try:
+    products = client.pay.products.get_products()
+    status = client.trade.status.ping()
+finally:
+    client.close()  # Manual cleanup required
+```
+
+The sync client provides the same API surface as the async client, but all methods return results directly instead of coroutines. Under the hood, it uses `asgiref.async_to_sync` to bridge async operations to synchronous calls, ensuring reliable operation without requiring async/await syntax.
+
 ## Response Types
 
 There are three different available output formats you can choose from:
@@ -139,7 +171,10 @@ There are three different available output formats you can choose from:
 ### Serialized Response
 You can get fully serialized responses as pydantic models. Using this, you get the full benefits of pydantic's type checking.
 ```python
+# Async client
 res = await client.pay.products.get_products()
+# Sync client  
+res = client.pay.products.get_products()
 print(res)
 ```
 The output would look like this:
@@ -149,7 +184,10 @@ The output would look like this:
 
 ### Serialized Response with HTTP Info
 ```python
+# Async client
 res = await client.pay.products.get_products_with_http_info()
+# Sync client
+res = client.pay.products.get_products_with_http_info()
 print(res)
 ```
 The output would look like this:
@@ -170,8 +208,12 @@ print(res.headers)
 ### JSON Response
 You can receive a classical JSON response by suffixing the function name with `_without_preload_content`
 ```python
+# Async client
 response = await client.pay.products.get_products_without_preload_content()
 print(await response.json())
+
+# Sync client - Note: use regular methods instead as response.json() returns a coroutine
+response = client.pay.products.get_products_without_preload_content()
 ```
 The output would look like this:
 ```python
@@ -201,33 +243,36 @@ To override e.g. the host for the Hive client to connect to localhost:8000 inste
 from crypticorn.hive import Configuration as HiveConfig
 from crypticorn.common import Service
 
-async with ApiClient() as client:
+# Async client
+async with AsyncClient() as client:
+    client.configure(config=HiveConfig(host="http://localhost:8000"), service=Service.HIVE)
+
+# Sync client
+with SyncClient() as client:
     client.configure(config=HiveConfig(host="http://localhost:8000"), service=Service.HIVE)
 ```
 
 ### Session Management
 
-By default, `ApiClient` manages a single shared `aiohttp.ClientSession` for all service wrappers.  
+By default, `AsyncClient` manages a single shared `aiohttp.ClientSession` for all service wrappers.  
 However, you can pass your own pre-configured `aiohttp.ClientSession` if you need advanced control — for example, to add retries, custom headers, logging, or mocking behavior.
 
 When you inject a custom session, you are responsible for managing its lifecycle, including closing when you're done.
 
 ```python
 import aiohttp
-from crypticorn import ApiClient
+from crypticorn import AsyncClient
 
 async def main():
     custom_session = aiohttp.ClientSession()
-    async with ApiClient(api_key="your-key", http_client=custom_session) as client:
+    async with AsyncClient(api_key="your-key", http_client=custom_session) as client:
         await client.trade.status.ping()
     await custom_session.close()
-    # or
-    custom_session = aiohttp.ClientSession()
-    client = ApiClient(api_key="your-key", http_client=custom_session)
-    await client.trade.status.ping()
-    await custom_session.close()
+
 ```
-If you don’t pass a session, `ApiClient` will create and manage one internally. In that case, it will be automatically closed when using `async with` or when calling `await client.close()` manually.
+If you don’t pass a session, `AsyncClient` will create and manage one internally. In that case, it will be automatically closed when using `async with` or when calling `await client.close()` manually.
+
+**Note on Sync Client**: The `SyncClient` uses per-operation sessions (creates and closes a session for each API call) to ensure reliable synchronous behavior. Custom sessions are accepted but not used. This approach prevents event loop conflicts at the cost of slightly higher overhead per operation.
 
 ### Disable Logging