crypticorn 2.5.0rc4__py3-none-any.whl → 2.5.1__py3-none-any.whl

crypticorn/trade/client/models/bot_model.py

@@ -19,7 +19,6 @@ import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional, Union
-from crypticorn.trade.client.models.api_error_identifier import ApiErrorIdentifier
 from crypticorn.trade.client.models.bot_status import BotStatus
 from typing import Optional, Set
 from typing_extensions import Self
@@ -40,7 +39,9 @@ class BotModel(BaseModel):
     api_key_id: StrictStr = Field(description="UID for the API key")
     allocation: StrictInt = Field(description="Initial allocation for the bot")
     status: BotStatus = Field(description="Status of the bot")
-    status_code: Optional[ApiErrorIdentifier] = None
+    status_code: Optional[StrictStr] = Field(
+        default=None, description="API error identifiers"
+    )
     user_id: Optional[StrictStr] = None
     current_allocation: Optional[Union[StrictFloat, StrictInt]] = None
     current_exposure: Optional[Union[StrictFloat, StrictInt]] = None
@@ -111,11 +112,6 @@ class BotModel(BaseModel):
         if self.id is None and "id" in self.model_fields_set:
             _dict["id"] = None
 
-        # set to None if status_code (nullable) is None
-        # and model_fields_set contains the field
-        if self.status_code is None and "status_code" in self.model_fields_set:
-            _dict["status_code"] = None
-
         # set to None if user_id (nullable) is None
         # and model_fields_set contains the field
         if self.user_id is None and "user_id" in self.model_fields_set:

crypticorn/trade/client/models/execution_ids.py

@@ -28,7 +28,7 @@ class ExecutionIds(BaseModel):
     ExecutionIds
     """  # noqa: E501
 
-    main: List[StrictStr] = Field(description="Main execution ID. List with one item.")
+    main: StrictStr = Field(description="Main execution ID.")
     sl: List[StrictStr] = Field(
         description="Stop loss execution IDs. List with multiple items ordered by the next stop loss, e.g. price = 10000 => SLs: ['900', '700', '500']."
     )

crypticorn/trade/client/models/notification_model.py

@@ -19,9 +19,6 @@ import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
-from crypticorn.trade.client.models.api_error_identifier import ApiErrorIdentifier
-from crypticorn.trade.client.models.api_error_level import ApiErrorLevel
-from crypticorn.trade.client.models.api_error_type import ApiErrorType
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -34,15 +31,9 @@ class NotificationModel(BaseModel):
     created_at: Optional[StrictInt] = None
     updated_at: Optional[StrictInt] = None
     id: Optional[StrictStr] = None
-    identifier: ApiErrorIdentifier = Field(
-        description="Identifier string. Must match the mapping key in the frontend."
-    )
-    level: ApiErrorLevel = Field(
-        description="Level of the notification. Of type ApiErrorLevel"
-    )
-    type: ApiErrorType = Field(
-        description="Type of the notification. Of type ApiErrorType"
-    )
+    identifier: StrictStr = Field(description="API error identifiers")
+    level: StrictStr = Field(description="API error levels")
+    type: StrictStr = Field(description="Type of API error")
     user_id: Optional[StrictStr] = None
     viewed: Optional[StrictBool] = Field(
         default=False, description="Whether the notification has been marked as seen"

crypticorn/trade/client/models/order_model.py

@@ -19,7 +19,6 @@ import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional, Union
-from crypticorn.trade.client.models.api_error_identifier import ApiErrorIdentifier
 from crypticorn.trade.client.models.exchange import Exchange
 from crypticorn.trade.client.models.margin_mode import MarginMode
 from crypticorn.trade.client.models.market_type import MarketType
@@ -52,7 +51,9 @@ class OrderModel(BaseModel):
     action_type: Optional[TradingActionType] = None
     market_type: Optional[MarketType] = None
     margin_mode: Optional[MarginMode] = None
-    status_code: Optional[ApiErrorIdentifier] = None
+    status_code: Optional[StrictStr] = Field(
+        default=None, description="API error identifiers"
+    )
     status: Optional[OrderStatus] = None
     filled_perc: Optional[Union[StrictFloat, StrictInt]] = None
     filled_qty: Optional[Union[StrictFloat, StrictInt]] = None
@@ -229,11 +230,6 @@ class OrderModel(BaseModel):
         if self.margin_mode is None and "margin_mode" in self.model_fields_set:
             _dict["margin_mode"] = None
 
-        # set to None if status_code (nullable) is None
-        # and model_fields_set contains the field
-        if self.status_code is None and "status_code" in self.model_fields_set:
-            _dict["status_code"] = None
-
         # set to None if status (nullable) is None
         # and model_fields_set contains the field
         if self.status is None and "status" in self.model_fields_set:

crypticorn/trade/client/models/spot_trading_action.py

@@ -0,0 +1,231 @@
+# coding: utf-8
+
+"""
+Trading API
+
+No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+The version of the OpenAPI document: 0.1.0
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    StrictBool,
+    StrictFloat,
+    StrictInt,
+    StrictStr,
+)
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from crypticorn.trade.client.models.market_type import MarketType
+from crypticorn.trade.client.models.tpsl import TPSL
+from crypticorn.trade.client.models.trading_action_type import TradingActionType
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class SpotTradingAction(BaseModel):
+    """
+    Model for spot trading actions
+    """  # noqa: E501
+
+    id: Optional[StrictStr] = None
+    execution_id: Optional[StrictStr] = None
+    open_order_execution_id: Optional[StrictStr] = None
+    client_order_id: Optional[StrictStr] = None
+    action_type: TradingActionType = Field(description="The type of action.")
+    market_type: MarketType = Field(description="The type of market the action is for.")
+    strategy_id: StrictStr = Field(description="UID for the strategy.")
+    symbol: StrictStr = Field(
+        description="Trading symbol or asset pair in format: 'symbol/quote_currency' (see market service for valid symbols)"
+    )
+    is_limit: Optional[StrictBool] = None
+    limit_price: Optional[Union[StrictFloat, StrictInt]] = None
+    allocation: Optional[
+        Union[
+            Annotated[float, Field(le=1.0, strict=True)],
+            Annotated[int, Field(le=1, strict=True)],
+        ]
+    ] = Field(
+        default=None,
+        description="How much of bot's balance to use for the order (for open actions). How much of the reference open order (open_order_execution_id) to close (for close actions). 0=0%, 1=100%.",
+    )
+    take_profit: Optional[List[TPSL]] = None
+    stop_loss: Optional[List[TPSL]] = None
+    expiry_timestamp: Optional[StrictInt] = None
+    position_id: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = [
+        "id",
+        "execution_id",
+        "open_order_execution_id",
+        "client_order_id",
+        "action_type",
+        "market_type",
+        "strategy_id",
+        "symbol",
+        "is_limit",
+        "limit_price",
+        "allocation",
+        "take_profit",
+        "stop_loss",
+        "expiry_timestamp",
+        "position_id",
+    ]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of SpotTradingAction from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in take_profit (list)
+        _items = []
+        if self.take_profit:
+            for _item_take_profit in self.take_profit:
+                if _item_take_profit:
+                    _items.append(_item_take_profit.to_dict())
+            _dict["take_profit"] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in stop_loss (list)
+        _items = []
+        if self.stop_loss:
+            for _item_stop_loss in self.stop_loss:
+                if _item_stop_loss:
+                    _items.append(_item_stop_loss.to_dict())
+            _dict["stop_loss"] = _items
+        # set to None if id (nullable) is None
+        # and model_fields_set contains the field
+        if self.id is None and "id" in self.model_fields_set:
+            _dict["id"] = 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:
+            _dict["execution_id"] = None
+
+        # set to None if open_order_execution_id (nullable) is None
+        # and model_fields_set contains the field
+        if (
+            self.open_order_execution_id is None
+            and "open_order_execution_id" in self.model_fields_set
+        ):
+            _dict["open_order_execution_id"] = None
+
+        # set to None if client_order_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.client_order_id is None and "client_order_id" in self.model_fields_set:
+            _dict["client_order_id"] = None
+
+        # set to None if is_limit (nullable) is None
+        # and model_fields_set contains the field
+        if self.is_limit is None and "is_limit" in self.model_fields_set:
+            _dict["is_limit"] = None
+
+        # set to None if limit_price (nullable) is None
+        # and model_fields_set contains the field
+        if self.limit_price is None and "limit_price" in self.model_fields_set:
+            _dict["limit_price"] = None
+
+        # set to None if take_profit (nullable) is None
+        # and model_fields_set contains the field
+        if self.take_profit is None and "take_profit" in self.model_fields_set:
+            _dict["take_profit"] = None
+
+        # set to None if stop_loss (nullable) is None
+        # and model_fields_set contains the field
+        if self.stop_loss is None and "stop_loss" in self.model_fields_set:
+            _dict["stop_loss"] = None
+
+        # set to None if expiry_timestamp (nullable) is None
+        # and model_fields_set contains the field
+        if (
+            self.expiry_timestamp is None
+            and "expiry_timestamp" in self.model_fields_set
+        ):
+            _dict["expiry_timestamp"] = None
+
+        # set to None if position_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.position_id is None and "position_id" in self.model_fields_set:
+            _dict["position_id"] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SpotTradingAction from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "id": obj.get("id"),
+                "execution_id": obj.get("execution_id"),
+                "open_order_execution_id": obj.get("open_order_execution_id"),
+                "client_order_id": obj.get("client_order_id"),
+                "action_type": obj.get("action_type"),
+                "market_type": obj.get("market_type"),
+                "strategy_id": obj.get("strategy_id"),
+                "symbol": obj.get("symbol"),
+                "is_limit": obj.get("is_limit"),
+                "limit_price": obj.get("limit_price"),
+                "allocation": obj.get("allocation"),
+                "take_profit": (
+                    [TPSL.from_dict(_item) for _item in obj["take_profit"]]
+                    if obj.get("take_profit") is not None
+                    else None
+                ),
+                "stop_loss": (
+                    [TPSL.from_dict(_item) for _item in obj["stop_loss"]]
+                    if obj.get("stop_loss") is not None
+                    else None
+                ),
+                "expiry_timestamp": obj.get("expiry_timestamp"),
+                "position_id": obj.get("position_id"),
+            }
+        )
+        return _obj

crypticorn/trade/main.py

@@ -18,6 +18,8 @@ class TradeClient:
     A client for interacting with the Crypticorn Trade API.
     """
 
+    config_class = Configuration
+
     def __init__(
         self,
         config: Configuration,

{crypticorn-2.5.0rc4.dist-info → crypticorn-2.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crypticorn
-Version: 2.5.0rc4
+Version: 2.5.1
 Summary: Maximise Your Crypto Trading Profits with AI Predictions
 Author-email: Crypticorn <timon@crypticorn.com>
 Project-URL: Homepage, https://crypticorn.com
@@ -36,6 +36,7 @@ Requires-Dist: pytest==8.3.5; extra == "test"
 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"
 Provides-Extra: extra
 Requires-Dist: pandas<3.0.0,>=2.2.0; extra == "extra"
 
@@ -86,7 +87,7 @@ The `common` submodule contains shared classes not bound to a specific API.
 from crypticorn.common import Scope, Exchange
 ```
 
-## Usage
+## Basic Usage
 
 ### With Async Context Protocol
 ```python
@@ -107,6 +108,7 @@ async def main():
 
 asyncio.run(main())
 asyncio.run(client.close())
+
 ## Response Types
 
 There are three different available output formats you can choose from:
@@ -155,12 +157,12 @@ The output would look like this:
 
 ## Advanced Usage
 
-You can override some configuration for specific sub clients. If you just want to use the API as is, you don't need to configure anything.
+You can override some configuration for specific services. If you just want to use the API as is, you don't need to configure anything.
 This might be of use if you are testing a specific API locally.
 
-To override e.g. the host for the Hive client to connect to http://localhost:8000 instead of the default caddy proxy, you would do:
+To override e.g. the host for the Hive client to connect to http://localhost:8000 instead of the default proxy, you would do:
 ```python
 from crypticorn.hive import Configuration as Hiveconfig
 async with ApiClient(base_url=BaseUrl.DEV) as client:
-        client.configure(config=HiveConfig(host="http://localhost:8000"), sub_client=client.hive)
+        client.configure(config=HiveConfig(host="http://localhost:8000"), client=client.hive)
 ```