crypticorn 2.17.0rc4__py3-none-any.whl → 2.17.0rc6__py3-none-any.whl

crypticorn/trade/client/models/spot_trading_action.py

@@ -0,0 +1,207 @@
+# coding: utf-8
+
+"""
+Trading API
+
+API for automated trading and exchange interface. This API is used to trade on the exchange and manage bots, API keys, orders, and more.
+
+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
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+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
+
+    created_at: Optional[StrictInt] = Field(
+        default=None, description="Timestamp of creation"
+    )
+    updated_at: Optional[StrictInt] = Field(
+        default=None, description="Timestamp of last update"
+    )
+    id: Optional[StrictStr] = Field(
+        default=None, description="Unique identifier for the resource"
+    )
+    execution_id: Optional[StrictStr] = None
+    open_order_execution_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[StrictStr] = None
+    allocation: StrictStr = Field(
+        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
+    __properties: ClassVar[List[str]] = [
+        "created_at",
+        "updated_at",
+        "id",
+        "execution_id",
+        "open_order_execution_id",
+        "action_type",
+        "market_type",
+        "strategy_id",
+        "symbol",
+        "is_limit",
+        "limit_price",
+        "allocation",
+        "take_profit",
+        "stop_loss",
+        "expiry_timestamp",
+    ]
+
+    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 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 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
+
+        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(
+            {
+                "created_at": obj.get("created_at"),
+                "updated_at": obj.get("updated_at"),
+                "id": obj.get("id"),
+                "execution_id": obj.get("execution_id"),
+                "open_order_execution_id": obj.get("open_order_execution_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"),
+            }
+        )
+        return _obj

crypticorn/trade/client/models/strategy.py

@@ -61,6 +61,7 @@ class Strategy(BaseModel):
         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",
@@ -105,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,
@@ -120,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:
@@ -159,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

@@ -52,6 +52,7 @@ class StrategyCreate(BaseModel):
         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",
@@ -93,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,
@@ -108,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:
@@ -144,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_update.py

@@ -40,6 +40,7 @@ class StrategyUpdate(BaseModel):
             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-2.17.0rc4.dist-info → crypticorn-2.17.0rc6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crypticorn
-Version: 2.17.0rc4
+Version: 2.17.0rc6
 Summary: Maximise Your Crypto Trading Profits with Machine Learning
 Author-email: Crypticorn <timon@crypticorn.com>
 License-Expression: MIT
@@ -272,6 +272,8 @@ async def main():
 ```
 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
 
 In case you don't want any logging statements by the `crypticorn` logger to be logged to stdout, you can disable it with:
@@ -280,5 +282,3 @@ In case you don't want any logging statements by the `crypticorn` logger to be l
 from crypticorn.common import disable_logging
 disable_logging()
 ```
-
-**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.