crypticorn 2.17.0rc5__py3-none-any.whl → 2.17.0rc7__py3-none-any.whl

crypticorn/trade/client/configuration.py

@@ -215,7 +215,7 @@ class Configuration:
         debug: Optional[bool] = None,
     ) -> None:
         """Constructor"""
-        self._base_path = "http://localhost:8000/v1/trade" if host is None else host
+        self._base_path = "http://localhost/v1/trade" if host is None else host
         """Default Base url
         """
         self.server_index = 0 if server_index is None and host is None else server_index
@@ -557,7 +557,7 @@ class Configuration:
         """
         return [
             {
-                "url": "http://localhost:8000/v1/trade",
+                "url": "http://localhost/v1/trade",
                 "description": "No description provided",
             }
         ]

crypticorn/trade/client/models/__init__.py

@@ -42,12 +42,22 @@ from crypticorn.trade.client.models.notification_update import NotificationUpdat
 from crypticorn.trade.client.models.order import Order
 from crypticorn.trade.client.models.order_status import OrderStatus
 from crypticorn.trade.client.models.orders_count import OrdersCount
+from crypticorn.trade.client.models.paginated_response_futures_trading_action import (
+    PaginatedResponseFuturesTradingAction,
+)
 from crypticorn.trade.client.models.paginated_response_order import (
     PaginatedResponseOrder,
 )
+from crypticorn.trade.client.models.paginated_response_union_futures_trading_action_spot_trading_action import (
+    PaginatedResponseUnionFuturesTradingActionSpotTradingAction,
+)
+from crypticorn.trade.client.models.paginated_response_union_futures_trading_action_spot_trading_action_data_inner import (
+    PaginatedResponseUnionFuturesTradingActionSpotTradingActionDataInner,
+)
 from crypticorn.trade.client.models.pn_l import PnL
 from crypticorn.trade.client.models.post_futures_action import PostFuturesAction
 from crypticorn.trade.client.models.spot_balance import SpotBalance
+from crypticorn.trade.client.models.spot_trading_action import SpotTradingAction
 from crypticorn.trade.client.models.spot_trading_action_create import (
     SpotTradingActionCreate,
 )

crypticorn/trade/client/models/paginated_response_futures_trading_action.py

@@ -0,0 +1,134 @@
+# 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, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional
+from crypticorn.trade.client.models.futures_trading_action import FuturesTradingAction
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class PaginatedResponseFuturesTradingAction(BaseModel):
+    """
+    PaginatedResponseFuturesTradingAction
+    """  # noqa: E501
+
+    data: List[FuturesTradingAction]
+    total: StrictInt = Field(description="The total number of items")
+    page: StrictInt = Field(description="The current page number")
+    page_size: StrictInt = Field(description="The number of items per page")
+    prev: Optional[StrictInt] = None
+    next: Optional[StrictInt] = None
+    last: Optional[StrictInt] = None
+    __properties: ClassVar[List[str]] = [
+        "data",
+        "total",
+        "page",
+        "page_size",
+        "prev",
+        "next",
+        "last",
+    ]
+
+    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 PaginatedResponseFuturesTradingAction 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 data (list)
+        _items = []
+        if self.data:
+            for _item_data in self.data:
+                if _item_data:
+                    _items.append(_item_data.to_dict())
+            _dict["data"] = _items
+        # set to None if prev (nullable) is None
+        # and model_fields_set contains the field
+        if self.prev is None and "prev" in self.model_fields_set:
+            _dict["prev"] = None
+
+        # set to None if next (nullable) is None
+        # and model_fields_set contains the field
+        if self.next is None and "next" in self.model_fields_set:
+            _dict["next"] = None
+
+        # set to None if last (nullable) is None
+        # and model_fields_set contains the field
+        if self.last is None and "last" in self.model_fields_set:
+            _dict["last"] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of PaginatedResponseFuturesTradingAction from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "data": (
+                    [FuturesTradingAction.from_dict(_item) for _item in obj["data"]]
+                    if obj.get("data") is not None
+                    else None
+                ),
+                "total": obj.get("total"),
+                "page": obj.get("page"),
+                "page_size": obj.get("page_size"),
+                "prev": obj.get("prev"),
+                "next": obj.get("next"),
+                "last": obj.get("last"),
+            }
+        )
+        return _obj

crypticorn/trade/client/models/paginated_response_union_futures_trading_action_spot_trading_action.py

@@ -0,0 +1,141 @@
+# 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, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional
+from crypticorn.trade.client.models.paginated_response_union_futures_trading_action_spot_trading_action_data_inner import (
+    PaginatedResponseUnionFuturesTradingActionSpotTradingActionDataInner,
+)
+from typing import Optional, Set
+from typing_extensions import Self
+
+
+class PaginatedResponseUnionFuturesTradingActionSpotTradingAction(BaseModel):
+    """
+    PaginatedResponseUnionFuturesTradingActionSpotTradingAction
+    """  # noqa: E501
+
+    data: List[PaginatedResponseUnionFuturesTradingActionSpotTradingActionDataInner]
+    total: StrictInt = Field(description="The total number of items")
+    page: StrictInt = Field(description="The current page number")
+    page_size: StrictInt = Field(description="The number of items per page")
+    prev: Optional[StrictInt] = None
+    next: Optional[StrictInt] = None
+    last: Optional[StrictInt] = None
+    __properties: ClassVar[List[str]] = [
+        "data",
+        "total",
+        "page",
+        "page_size",
+        "prev",
+        "next",
+        "last",
+    ]
+
+    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 PaginatedResponseUnionFuturesTradingActionSpotTradingAction 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 data (list)
+        _items = []
+        if self.data:
+            for _item_data in self.data:
+                if _item_data:
+                    _items.append(_item_data.to_dict())
+            _dict["data"] = _items
+        # set to None if prev (nullable) is None
+        # and model_fields_set contains the field
+        if self.prev is None and "prev" in self.model_fields_set:
+            _dict["prev"] = None
+
+        # set to None if next (nullable) is None
+        # and model_fields_set contains the field
+        if self.next is None and "next" in self.model_fields_set:
+            _dict["next"] = None
+
+        # set to None if last (nullable) is None
+        # and model_fields_set contains the field
+        if self.last is None and "last" in self.model_fields_set:
+            _dict["last"] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of PaginatedResponseUnionFuturesTradingActionSpotTradingAction from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "data": (
+                    [
+                        PaginatedResponseUnionFuturesTradingActionSpotTradingActionDataInner.from_dict(
+                            _item
+                        )
+                        for _item in obj["data"]
+                    ]
+                    if obj.get("data") is not None
+                    else None
+                ),
+                "total": obj.get("total"),
+                "page": obj.get("page"),
+                "page_size": obj.get("page_size"),
+                "prev": obj.get("prev"),
+                "next": obj.get("next"),
+                "last": obj.get("last"),
+            }
+        )
+        return _obj

crypticorn/trade/client/models/paginated_response_union_futures_trading_action_spot_trading_action_data_inner.py

@@ -0,0 +1,165 @@
+# 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
+from inspect import getfullargspec
+import json
+import pprint
+import re  # noqa: F401
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    StrictStr,
+    ValidationError,
+    field_validator,
+)
+from typing import Optional
+from crypticorn.trade.client.models.futures_trading_action import FuturesTradingAction
+from crypticorn.trade.client.models.spot_trading_action import SpotTradingAction
+from typing import Union, Any, List, Set, TYPE_CHECKING, Optional, Dict
+from typing_extensions import Literal, Self
+from pydantic import Field
+
+PAGINATEDRESPONSEUNIONFUTURESTRADINGACTIONSPOTTRADINGACTIONDATAINNER_ANY_OF_SCHEMAS = [
+    "FuturesTradingAction",
+    "SpotTradingAction",
+]
+
+
+class PaginatedResponseUnionFuturesTradingActionSpotTradingActionDataInner(BaseModel):
+    """
+    PaginatedResponseUnionFuturesTradingActionSpotTradingActionDataInner
+    """
+
+    # data type: FuturesTradingAction
+    anyof_schema_1_validator: Optional[FuturesTradingAction] = None
+    # data type: SpotTradingAction
+    anyof_schema_2_validator: Optional[SpotTradingAction] = None
+    if TYPE_CHECKING:
+        actual_instance: Optional[Union[FuturesTradingAction, SpotTradingAction]] = None
+    else:
+        actual_instance: Any = None
+    any_of_schemas: Set[str] = {"FuturesTradingAction", "SpotTradingAction"}
+
+    model_config = {
+        "validate_assignment": True,
+        "protected_namespaces": (),
+    }
+
+    def __init__(self, *args, **kwargs) -> None:
+        if args:
+            if len(args) > 1:
+                raise ValueError(
+                    "If a position argument is used, only 1 is allowed to set `actual_instance`"
+                )
+            if kwargs:
+                raise ValueError(
+                    "If a position argument is used, keyword arguments cannot be used."
+                )
+            super().__init__(actual_instance=args[0])
+        else:
+            super().__init__(**kwargs)
+
+    @field_validator("actual_instance")
+    def actual_instance_must_validate_anyof(cls, v):
+        instance = (
+            PaginatedResponseUnionFuturesTradingActionSpotTradingActionDataInner.model_construct()
+        )
+        error_messages = []
+        # validate data type: FuturesTradingAction
+        if not isinstance(v, FuturesTradingAction):
+            error_messages.append(
+                f"Error! Input type `{type(v)}` is not `FuturesTradingAction`"
+            )
+        else:
+            return v
+
+        # validate data type: SpotTradingAction
+        if not isinstance(v, SpotTradingAction):
+            error_messages.append(
+                f"Error! Input type `{type(v)}` is not `SpotTradingAction`"
+            )
+        else:
+            return v
+
+        if error_messages:
+            # no match
+            raise ValueError(
+                "No match found when setting the actual_instance in PaginatedResponseUnionFuturesTradingActionSpotTradingActionDataInner with anyOf schemas: FuturesTradingAction, SpotTradingAction. Details: "
+                + ", ".join(error_messages)
+            )
+        else:
+            return v
+
+    @classmethod
+    def from_dict(cls, obj: Dict[str, Any]) -> Self:
+        return cls.from_json(json.dumps(obj))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Returns the object represented by the json string"""
+        instance = cls.model_construct()
+        error_messages = []
+        # anyof_schema_1_validator: Optional[FuturesTradingAction] = None
+        try:
+            instance.actual_instance = FuturesTradingAction.from_json(json_str)
+            return instance
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # anyof_schema_2_validator: Optional[SpotTradingAction] = None
+        try:
+            instance.actual_instance = SpotTradingAction.from_json(json_str)
+            return instance
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+
+        if error_messages:
+            # no match
+            raise ValueError(
+                "No match found when deserializing the JSON string into PaginatedResponseUnionFuturesTradingActionSpotTradingActionDataInner with anyOf schemas: FuturesTradingAction, SpotTradingAction. Details: "
+                + ", ".join(error_messages)
+            )
+        else:
+            return instance
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the actual instance"""
+        if self.actual_instance is None:
+            return "null"
+
+        if hasattr(self.actual_instance, "to_json") and callable(
+            self.actual_instance.to_json
+        ):
+            return self.actual_instance.to_json()
+        else:
+            return json.dumps(self.actual_instance)
+
+    def to_dict(
+        self,
+    ) -> Optional[Union[Dict[str, Any], FuturesTradingAction, SpotTradingAction]]:
+        """Returns the dict representation of the actual instance"""
+        if self.actual_instance is None:
+            return None
+
+        if hasattr(self.actual_instance, "to_dict") and callable(
+            self.actual_instance.to_dict
+        ):
+            return self.actual_instance.to_dict()
+        else:
+            return self.actual_instance
+
+    def to_str(self) -> str:
+        """Returns the string representation of the actual instance"""
+        return pprint.pformat(self.model_dump())

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