investing-algorithm-framework 1.5__py3-none-any.whl → 7.25.6__py3-none-any.whl

investing_algorithm_framework/domain/models/order/order.py

@@ -1,40 +1,47 @@
 import logging
-from datetime import datetime
+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 import OrderStatus, \
-    OrderType, OrderSide
-from investing_algorithm_framework.domain.models.order.order_fee import \
-    OrderFee
+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,
-        status,
         amount,
+        status: OrderStatus | None | str = OrderStatus.CREATED.value,
         target_symbol=None,
         trading_symbol=None,
         price=None,
-        net_gain=0,
         created_at=None,
         updated_at=None,
-        trade_closed_at=None,
-        trade_closed_price=None,
-        trade_closed_amount=None,
         external_id=None,
+        cost=None,
         filled=None,
         remaining=None,
-        cost=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")
@@ -54,6 +61,15 @@ class Order(BaseModel):
         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
@@ -61,16 +77,19 @@ class Order(BaseModel):
         self.status = OrderStatus.from_value(status).value
         self.position_id = position_id
         self.amount = amount
-        self.net_gain = net_gain
-        self.trade_closed_at = trade_closed_at
-        self.trade_closed_price = trade_closed_price
-        self.trade_closed_amount = trade_closed_amount
-        self.created_at = created_at
-        self.updated_at = updated_at
         self.filled = filled
         self.remaining = remaining
-        self.cost = cost
         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
@@ -90,6 +109,24 @@ class Order(BaseModel):
     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
 
@@ -114,30 +151,6 @@ class Order(BaseModel):
     def set_external_id(self, external_id):
         self.external_id = external_id
 
-    def get_net_gain(self):
-        return self.net_gain
-
-    def set_net_gain(self, net_gain):
-        self.net_gain = net_gain
-
-    def get_trade_closed_at(self):
-        return self.trade_closed_at
-
-    def set_trade_closed_at(self, trade_closed_at):
-        self.trade_closed_at = trade_closed_at
-
-    def get_trade_closed_price(self):
-        return self.trade_closed_price
-
-    def set_trade_closed_price(self, trade_closed_price):
-        self.trade_closed_price = trade_closed_price
-
-    def get_trade_closed_amount(self):
-        return self.trade_closed_amount
-
-    def set_trade_closed_amount(self, trade_closed_amount):
-        self.trade_closed_amount = trade_closed_amount
-
     def get_created_at(self):
         return self.created_at
 
@@ -163,27 +176,74 @@ class Order(BaseModel):
     def get_remaining(self):
 
         if self.remaining is None:
-            return '0'
+            return self.get_amount() - self.get_filled()
 
         return self.remaining
 
     def set_remaining(self, remaining):
         self.remaining = remaining
 
-    def get_cost(self):
-        return self.cost
-
-    def set_cost(self, cost):
-        self.cost = cost
-
     def get_fee(self):
         return self.fee
 
     def set_fee(self, order_fee):
         self.fee = order_fee
 
-    def to_dict(self):
+    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,
@@ -192,22 +252,85 @@ class Order(BaseModel):
             "status": self.status,
             "price": self.price,
             "amount": self.amount,
-            "net_gain": self.net_gain,
-            "trade_closed_at": self.trade_closed_at,
-            "trade_closed_price": self.trade_closed_price,
-            "created_at": self.created_at,
-            "updated_at": self.updated_at,
+            "created_at": created_at,
+            "updated_at": updated_at,
+            "cost": self.cost,
             "filled": self.filled,
             "remaining": self.remaining,
-            "cost": self.cost,
-            "fee": self.fee.to_dict() if self.fee is not None else None,
+            "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),
@@ -216,15 +339,15 @@ class Order(BaseModel):
             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),
-            cost=ccxt_order.get("cost", None),
-            fee=OrderFee.from_ccxt_fee(ccxt_order.get("fee", None)),
-            created_at=datetime.strptime(
-                ccxt_order.get("datetime", None), "%Y-%m-%dT%H:%M:%S.%fZ"
-            )
+            order_fee=order_fee,
+            order_fee_currency=order_fee_currency,
+            order_fee_rate=order_fee_rate,
+            created_at=created_at
         )
 
     def __repr__(self):
@@ -238,7 +361,6 @@ class Order(BaseModel):
             id=id_value,
             price=self.get_price(),
             amount=self.get_amount(),
-            net_gain=self.get_net_gain(),
             external_id=self.external_id,
             status=self.status,
             target_symbol=self.target_symbol,
@@ -247,5 +369,16 @@ class Order(BaseModel):
             order_type=self.order_type,
             filled=self.get_filled(),
             remaining=self.get_remaining(),
-            cost=self.get_cost(),
+            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_status.py

@@ -18,7 +18,7 @@ class OrderStatus(Enum):
                 if value.upper() == order_type.value:
                     return order_type
 
-        raise ValueError("Could not convert value to OrderStatus")
+        raise ValueError(f"Could not convert value {value} to OrderStatus")
 
     @staticmethod
     def from_value(value):
@@ -31,7 +31,7 @@ class OrderStatus(Enum):
         elif isinstance(value, str):
             return OrderStatus.from_string(value)
 
-        raise ValueError("Could not convert value to OrderStatus")
+        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

@@ -3,8 +3,6 @@ from enum import Enum
 
 class OrderType(Enum):
     LIMIT = 'LIMIT'
-    MARKET = 'MARKET'
-    STOP_LOSS_LIMIT = "STOP_LOSS_LIMIT"
 
     @staticmethod
     def from_string(value: str):
@@ -15,7 +13,7 @@ class OrderType(Enum):
                 if value.upper() == order_type.value:
                     return order_type
 
-        raise ValueError("Could not convert value to OrderType")
+        raise ValueError(f"Could not convert value: {value} to OrderType")
 
     @staticmethod
     def from_value(value):

investing_algorithm_framework/domain/models/portfolio/__init__.py

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

investing_algorithm_framework/domain/models/portfolio/portfolio.py

@@ -2,6 +2,37 @@ 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,
@@ -9,6 +40,7 @@ class Portfolio(BaseModel):
         trading_symbol,
         net_size,
         unallocated,
+        initial_balance,
         market,
         realized=0,
         total_revenue=0,
@@ -16,21 +48,25 @@ class Portfolio(BaseModel):
         total_net_gain=0,
         total_trade_volume=0,
         created_at=None,
-        updated_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
+        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(
@@ -40,9 +76,14 @@ class Portfolio(BaseModel):
             unallocated=self.unallocated,
             realized=self.realized,
             total_revenue=self.total_revenue,
-            total_cost=self.total_cost
+            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
 
@@ -72,3 +113,57 @@ class Portfolio(BaseModel):
 
     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,
+        }