investing-algorithm-framework 7.19.14__py3-none-any.whl

investing_algorithm_framework/domain/models/order/order.py

@@ -0,0 +1,384 @@
+import logging
+from datetime import datetime, timezone
+
+from dateutil.parser import parse
+
+from investing_algorithm_framework.domain.exceptions import \
+    OperationalException
+from investing_algorithm_framework.domain.models.base_model import BaseModel
+from investing_algorithm_framework.domain.models.order.order_side import \
+    OrderSide
+from investing_algorithm_framework.domain.models.order.order_status import \
+    OrderStatus
+from investing_algorithm_framework.domain.models.order.order_type import \
+    OrderType
+
+logger = logging.getLogger("investing_algorithm_framework")
+
+
+class Order(BaseModel):
+    """
+    Order model class to represent an order of the trading bot
+    """
+    def __init__(
+        self,
+        order_type,
+        order_side,
+        amount,
+        status: OrderStatus | None | str = OrderStatus.CREATED.value,
+        target_symbol=None,
+        trading_symbol=None,
+        price=None,
+        created_at=None,
+        updated_at=None,
+        external_id=None,
+        cost=None,
+        filled=None,
+        remaining=None,
+        fee=None,
+        position_id=None,
+        order_fee=None,
+        order_fee_currency=None,
+        order_fee_rate=None,
+        id=None,
+        metadata=None,
+    ):
+        if target_symbol is None:
+            raise OperationalException("Target symbol is not specified")
+
+        if trading_symbol is None:
+            raise OperationalException("Trading symbol is not specified")
+
+        self.target_symbol = target_symbol.upper()
+        self.trading_symbol = trading_symbol.upper()
+
+        if order_side is None:
+            raise OperationalException("Order side is not set")
+
+        if order_type is None:
+            raise OperationalException("Order type is not set")
+
+        if status is None:
+            raise OperationalException("Status is not set")
+
+        self.created_at = created_at
+        self.updated_at = updated_at
+
+        if self.created_at is None:
+            self.created_at = datetime.now(tz=timezone.utc)
+
+        if self.updated_at is None:
+            self.updated_at = datetime.now(tz=timezone.utc)
+
+        self.external_id = external_id
+        self.price = price
+        self.order_side = OrderSide.from_value(order_side).value
+        self.order_type = OrderType.from_value(order_type).value
+        self.status = OrderStatus.from_value(status).value
+        self.position_id = position_id
+        self.amount = amount
+        self.filled = filled
+        self.remaining = remaining
+        self.fee = fee
+        self._available_amount = self.filled
+        self.order_fee = order_fee
+        self.order_fee_currency = order_fee_currency
+        self.order_fee_rate = order_fee_rate
+        self.id = id
+        self.cost = cost
+        self.metadata = metadata if metadata is not None else {}
+
+    def get_id(self):
+        return self.id
+
+    def get_external_id(self):
+        return self.external_id
+
+    def get_target_symbol(self):
+        return self.target_symbol
+
+    def get_trading_symbol(self):
+        return self.trading_symbol
+
+    def get_price(self):
+        if self.price is not None:
+            return self.price
+
+        return 0
+
+    def set_price(self, price):
+        self.price = price
+
+    def get_order_fee_currency(self):
+        return self.order_fee_currency
+
+    def set_order_fee_currency(self, order_fee_currency):
+        self.order_fee_currency = order_fee_currency
+
+    def get_order_fee_rate(self):
+        return self.order_fee_rate
+
+    def set_order_fee_rate(self, order_fee_rate):
+        self.order_fee_rate = order_fee_rate
+
+    def get_order_fee(self):
+        return self.order_fee
+
+    def set_order_fee(self, order_fee):
+        self.order_fee = order_fee
+
+    def get_order_size(self):
+        return self.order_side
+
+    def get_status(self) -> OrderStatus:
+        return self.status
+
+    def set_status(self, status):
+        self.status = OrderStatus.from_value(status).value
+
+    def get_order_type(self):
+        return self.order_type
+
+    def get_order_side(self):
+        return self.order_side
+
+    def get_amount(self):
+        return self.amount
+
+    def set_amount(self, amount):
+        self.amount = amount
+
+    def set_external_id(self, external_id):
+        self.external_id = external_id
+
+    def get_created_at(self):
+        return self.created_at
+
+    def set_created_at(self, created_at):
+        self.created_at = created_at
+
+    def get_updated_at(self):
+        return self.updated_at
+
+    def set_updated_at(self, updated_at):
+        self.updated_at = updated_at
+
+    def get_filled(self):
+
+        if self.filled is None:
+            return 0
+
+        return self.filled
+
+    def set_filled(self, filled):
+        self.filled = filled
+
+    def get_remaining(self):
+
+        if self.remaining is None:
+            return self.get_amount() - self.get_filled()
+
+        return self.remaining
+
+    def set_remaining(self, remaining):
+        self.remaining = remaining
+
+    def get_fee(self):
+        return self.fee
+
+    def set_fee(self, order_fee):
+        self.fee = order_fee
+
+    def get_symbol(self):
+        return (self.get_target_symbol().upper() + "/"
+                + self.get_trading_symbol().upper())
+
+    @property
+    def symbol(self):
+        return (self.get_target_symbol().upper() + "/"
+                + self.get_trading_symbol().upper())
+
+    def get_available_amount(self):
+
+        if self._available_amount is None:
+            return self.get_filled()
+
+        return self._available_amount
+
+    @property
+    def available_amount(self):
+        return self.get_available_amount()
+
+    def set_available_amount(self, available_amount):
+        self._available_amount = available_amount
+
+    @available_amount.setter
+    def available_amount(self, available_amount):
+        self.set_available_amount(available_amount)
+
+    def to_dict(self, datetime_format=None):
+        """
+        Convert the Order object to a dictionary
+
+        Args:
+            datetime_format (str): The format to use for the datetime fields.
+                If None, the datetime fields will be returned as is.
+                Defaults to None.
+
+        Returns:
+            dict: A dictionary representation of the Order object.
+        """
+
+        def ensure_iso(value):
+            if hasattr(value, "isoformat"):
+                if value.tzinfo is None:
+                    value = value.replace(tzinfo=timezone.utc)
+                return value.isoformat()
+            return value
+
+        created_at = ensure_iso(self.created_at) if self.created_at else None
+        updated_at = ensure_iso(self.updated_at) if self.updated_at else None
+
+        # Ensure status is a string
+        self.status = OrderStatus.from_value(self.status).value
+
+        return {
+            "id": self.id,
+            "external_id": self.external_id,
+            "target_symbol": self.target_symbol,
+            "trading_symbol": self.trading_symbol,
+            "order_side": self.order_side,
+            "order_type": self.order_type,
+            "status": self.status,
+            "price": self.price,
+            "amount": self.amount,
+            "created_at": created_at,
+            "updated_at": updated_at,
+            "cost": self.cost,
+            "filled": self.filled,
+            "remaining": self.remaining,
+            "order_fee_currency": self.order_fee_currency,
+            "order_fee_rate": self.order_fee_rate,
+            "order_fee": self.order_fee,
+            "metadata": self.metadata if hasattr(self, 'metadata') else {},
+        }
+
+    @staticmethod
+    def from_dict(data: dict):
+        created_at = data.get("created_at", None)
+        updated_at = data.get("updated_at", None)
+        symbol = data.get("symbol", None)
+
+        if symbol is not None:
+            target_symbol = symbol.split("/")[0]
+            trading_symbol = symbol.split("/")[1]
+        else:
+            target_symbol = data.get("target_symbol", None)
+            trading_symbol = data.get("trading_symbol", None)
+
+        if created_at is not None:
+            created_at = parse(created_at)
+
+        if updated_at is not None:
+            updated_at = parse(updated_at)
+
+        order = Order(
+            id=data.get("id", None),
+            external_id=data.get("external_id", None),
+            target_symbol=target_symbol,
+            trading_symbol=trading_symbol,
+            price=data.get("price", None),
+            amount=data.get("amount", None),
+            status=data.get("status", None),
+            order_type=data.get("order_type", None),
+            order_side=data.get("order_side", None),
+            filled=data.get("filled", None),
+            remaining=data.get("remaining", None),
+            fee=data.get("fee", None),
+            cost=data.get("cost", None),
+            created_at=created_at,
+            updated_at=updated_at,
+            order_fee=data.get("order_fee", None),
+            order_fee_currency=data.get("order_fee_currency", None),
+            order_fee_rate=data.get("order_fee_rate", None),
+            metadata=data.get("metadata", {}),
+        )
+        return order
+
+    @staticmethod
+    def from_ccxt_order(ccxt_order):
+        """
+        Create an Order object from a ccxt order object
+        :param ccxt_order: ccxt order object
+        :return: Order object
+        """
+        status = OrderStatus.from_value(ccxt_order["status"])
+        target_symbol = ccxt_order.get("symbol").split("/")[0]
+        trading_symbol = ccxt_order.get("symbol").split("/")[1]
+        ccxt_fee = ccxt_order.get("fee", None)
+        order_fee = None
+        order_fee_currency = None
+        order_fee_rate = None
+
+        if ccxt_fee is not None:
+            order_fee = ccxt_fee.get("cost", None)
+            order_fee_currency = ccxt_fee.get("currency", None)
+            order_fee_rate = ccxt_fee.get("rate", None)
+
+        created_at = ccxt_order.get("datetime", None)
+        created_at = parse(created_at) if created_at else None
+
+        # Make sure that the created_at is a utc datetime object
+        if created_at and created_at.tzinfo is None:
+            created_at = created_at.replace(tzinfo=timezone.utc)
+
+        return Order(
+            external_id=ccxt_order.get("id", None),
+            target_symbol=target_symbol,
+            trading_symbol=trading_symbol,
+            price=ccxt_order.get("price", None),
+            amount=ccxt_order.get("amount", None),
+            status=status,
+            cost=ccxt_order.get("cost", None),
+            order_type=ccxt_order.get("type", None),
+            order_side=ccxt_order.get("side", None),
+            filled=ccxt_order.get("filled", None),
+            remaining=ccxt_order.get("remaining", None),
+            order_fee=order_fee,
+            order_fee_currency=order_fee_currency,
+            order_fee_rate=order_fee_rate,
+            created_at=created_at
+        )
+
+    def __repr__(self):
+
+        if not hasattr(self, "id"):
+            id_value = "ccxt external order"
+        else:
+            id_value = self.id
+
+        return self.repr(
+            id=id_value,
+            price=self.get_price(),
+            amount=self.get_amount(),
+            external_id=self.external_id,
+            status=self.status,
+            target_symbol=self.target_symbol,
+            trading_symbol=self.trading_symbol,
+            order_side=self.order_side,
+            order_type=self.order_type,
+            filled=self.get_filled(),
+            remaining=self.get_remaining(),
+            created_at=self.get_created_at(),
+            updated_at=self.get_updated_at(),
+        )
+
+    def get_size(self):
+        """
+        Get the size of the order
+
+        Returns:
+            float: The size of the order
+        """
+        return self.get_amount() * self.get_price() \
+            if self.get_price() is not None else 0

investing_algorithm_framework/domain/models/order/order_side.py

@@ -0,0 +1,36 @@
+from enum import Enum
+
+
+class OrderSide(Enum):
+    SELL = 'SELL'
+    BUY = 'BUY'
+
+    @staticmethod
+    def from_string(value: str):
+
+        if isinstance(value, str):
+            for order_type in OrderSide:
+
+                if value.upper() == order_type.value:
+                    return order_type
+
+        raise ValueError(f"Could not convert value {value} to OrderSide")
+
+    @staticmethod
+    def from_value(value):
+
+        if isinstance(value, OrderSide):
+            for order_side in OrderSide:
+
+                if value == order_side:
+                    return order_side
+
+        return OrderSide.from_string(value)
+
+    def equals(self, other):
+
+        if isinstance(other, Enum):
+            return self.value == other.value
+
+        else:
+            return OrderSide.from_string(other) == self

investing_algorithm_framework/domain/models/order/order_status.py

@@ -0,0 +1,37 @@
+from enum import Enum
+
+
+class OrderStatus(Enum):
+    CREATED = 'CREATED'
+    OPEN = "OPEN"
+    CLOSED = "CLOSED"
+    CANCELED = "CANCELED"
+    EXPIRED = "EXPIRED"
+    REJECTED = "REJECTED"
+
+    @staticmethod
+    def from_string(value: str):
+
+        if isinstance(value, str):
+            for order_type in OrderStatus:
+
+                if value.upper() == order_type.value:
+                    return order_type
+
+        raise ValueError(f"Could not convert value {value} to OrderStatus")
+
+    @staticmethod
+    def from_value(value):
+
+        if isinstance(value, OrderStatus):
+            for order_status in OrderStatus:
+
+                if value == order_status:
+                    return order_status
+        elif isinstance(value, str):
+            return OrderStatus.from_string(value)
+
+        raise ValueError(f"Could not convert value: {value} to OrderStatus")
+
+    def equals(self, other):
+        return OrderStatus.from_value(other) == self

investing_algorithm_framework/domain/models/order/order_type.py

@@ -0,0 +1,30 @@
+from enum import Enum
+
+
+class OrderType(Enum):
+    LIMIT = 'LIMIT'
+
+    @staticmethod
+    def from_string(value: str):
+
+        if isinstance(value, str):
+            for order_type in OrderType:
+
+                if value.upper() == order_type.value:
+                    return order_type
+
+        raise ValueError(f"Could not convert value: {value} to OrderType")
+
+    @staticmethod
+    def from_value(value):
+
+        if isinstance(value, OrderType):
+            for order_type in OrderType:
+
+                if value == order_type:
+                    return order_type
+
+        return OrderType.from_string(value)
+
+    def equals(self, other):
+        return OrderType.from_value(other) == self

investing_algorithm_framework/domain/models/portfolio/__init__.py

@@ -0,0 +1,9 @@
+from .portfolio import Portfolio
+from .portfolio_configuration import PortfolioConfiguration
+from .portfolio_snapshot import PortfolioSnapshot
+
+__all__ = [
+    "PortfolioConfiguration",
+    "Portfolio",
+    "PortfolioSnapshot",
+]

investing_algorithm_framework/domain/models/portfolio/portfolio.py

@@ -0,0 +1,169 @@
+from investing_algorithm_framework.domain.models.base_model import BaseModel
+
+
+class Portfolio(BaseModel):
+    """
+    Portfolio base class.
+
+    A portfolio is a collection of positions that are managed by an algorithm.
+
+    Attributes:
+    * identifier: str, unique identifier of the portfolio
+    * trading_symbol: str, trading symbol of the portfolio
+    * unallocated: float, the size of the trading symbol that is not
+      allocated. For example, if the trading symbol is USDT and the unallocated
+      is 1000, it means that the portfolio has 1000 USDT that is not
+        allocated to any position.
+    * net_size: float, net size of the portfolio is the initial balance of the
+        portfolio plus the all the net gains of the trades. The
+    * realized: float, the realized gain of the portfolio is the sum of all the
+        realized gains of the trades.
+    * total_revenue: float, the total revenue of the portfolio is the sum
+        of all the orders (price * size)
+    * total_cost: float, the total cost of the portfolio is the sum of all the
+        costs of the trades (price * size (for buy orders)
+        or -price * size (for sell orders))
+    * total_net_gain: float, the total net gain of the portfolio is the sum of
+        all the net gains of the trades
+    * total_trade_volume: float, the total trade volume of the
+        portfolio is the sum of all the sizes of the trades
+    * market: str, the market of the portfolio (e.g. BITVAVO, BINANCE)
+    * created_at: datetime, the datetime when the portfolio was created
+    * updated_at: datetime, the datetime when the portfolio was last updated
+    * initialized: bool, whether the portfolio is initialized or not
+    * initial_balance: float, the initial balance of the portfolio
+    """
+
+    def __init__(
+        self,
+        identifier,
+        trading_symbol,
+        net_size,
+        unallocated,
+        initial_balance,
+        market,
+        realized=0,
+        total_revenue=0,
+        total_cost=0,
+        total_net_gain=0,
+        total_trade_volume=0,
+        created_at=None,
+        updated_at=None,
+        initialized=False,
+    ):
+        self.identifier = identifier
+        self.updated_at = None
+        self.trading_symbol = trading_symbol.upper()
+        self.net_size = net_size
+        self.unallocated = unallocated
+        self.initial_balance = initial_balance
+        self.realized = realized
+        self.total_revenue = total_revenue
+        self.total_cost = total_cost
+        self.total_net_gain = total_net_gain
+        self.total_trade_volume = total_trade_volume
+        self.market = market.upper()
+        self.created_at = created_at
+        self.updated_at = updated_at
+        self.initialized = initialized
+        self._allocated = None
+
+    def __repr__(self):
+        return self.repr(
+            identifier=self.identifier,
+            trading_symbol=self.trading_symbol,
+            net_size=self.net_size,
+            unallocated=self.unallocated,
+            realized=self.realized,
+            total_revenue=self.total_revenue,
+            total_cost=self.total_cost,
+            market=self.market,
+            initial_balance=self.initial_balance
+        )
+
+    def get_identifier(self):
+        return self.identifier
+
+    def get_unallocated(self):
+        return self.unallocated
+
+    def get_net_size(self):
+        return self.net_size
+
+    def get_realized(self):
+        return self.realized
+
+    def get_total_revenue(self):
+        return self.total_revenue
+
+    def get_total_cost(self):
+        return self.total_cost
+
+    def get_total_net_gain(self):
+        return self.total_net_gain
+
+    def get_total_trade_volume(self):
+        return self.total_trade_volume
+
+    def get_created_at(self):
+        return self.created_at
+
+    def get_updated_at(self):
+        return self.updated_at
+
+    def get_trading_symbol(self):
+        return self.trading_symbol
+
+    def get_market(self):
+        return self.market
+
+    def get_initial_balance(self):
+        return self.initial_balance
+
+    @property
+    def allocated(self):
+
+        if self._allocated is None:
+            return 0.0
+
+        return self._allocated
+
+    @allocated.setter
+    def allocated(self, value):
+        self._allocated = value
+
+    @staticmethod
+    def from_portfolio_configuration(portfolio_configuration):
+        """
+        Function to create a portfolio from a portfolio configuration
+
+        We assume that a portfolio that is created from a configuration
+        is always un initialized.
+
+        Args:
+            portfolio_configuration: PortfolioConfiguration
+
+        Returns:
+            Portfolio
+        """
+        return Portfolio(
+            identifier=portfolio_configuration.identifier,
+            trading_symbol=portfolio_configuration.trading_symbol,
+            unallocated=portfolio_configuration.initial_balance,
+            net_size=portfolio_configuration.initial_balance,
+            market=portfolio_configuration.market,
+            initial_balance=portfolio_configuration.initial_balance,
+            initialized=False
+        )
+
+    def to_dict(self):
+        return {
+            "trading_symbol": self.trading_symbol,
+            "market": self.market,
+            "unallocated": self.unallocated,
+            "identifier": self.identifier,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            "initialized": self.initialized,
+            "initial_balance": self.initial_balance,
+        }