investing-algorithm-framework 6.9.1__py3-none-any.whl → 7.19.15__py3-none-any.whl

investing_algorithm_framework/domain/models/{market_data_type.py → data/data_type.py}

@@ -1,7 +1,7 @@
 from enum import Enum
 
 
-class MarketDataType(Enum):
+class DataType(Enum):
     OHLCV = "OHLCV"
     TICKER = "TICKER"
     ORDER_BOOK = "ORDER_BOOK"
@@ -12,24 +12,24 @@ class MarketDataType(Enum):
 
         if isinstance(value, str):
 
-            for entry in MarketDataType:
+            for entry in DataType:
 
                 if value.upper() == entry.value:
                     return entry
 
             raise ValueError(
-                f"Could not convert {value} to MarketDataType"
+                f"Could not convert {value} to DataType"
             )
 
     @staticmethod
     def from_value(value):
 
         if isinstance(value, str):
-            return MarketDataType.from_string(value)
+            return DataType.from_string(value)
 
-        if isinstance(value, MarketDataType):
+        if isinstance(value, DataType):
 
-            for entry in MarketDataType:
+            for entry in DataType:
 
                 if value == entry:
                     return entry
@@ -43,4 +43,4 @@ class MarketDataType(Enum):
         if isinstance(other, Enum):
             return self.value == other.value
         else:
-            return MarketDataType.from_string(other) == self
+            return DataType.from_string(other) == self

investing_algorithm_framework/domain/models/market/market_credential.py

@@ -52,6 +52,12 @@ class MarketCredential:
             environment_variable = f"{self.market.upper()}_SECRET_KEY"
             self._secret_key = os.getenv(environment_variable)
 
+        if self.api_key is not None:
+            self._api_key = self.api_key.strip()
+
+        if self.secret_key is not None:
+            self._secret_key = self.secret_key.strip()
+
     def get_api_key(self):
         return self.api_key
 

investing_algorithm_framework/domain/models/order/order.py

@@ -25,7 +25,7 @@ class Order(BaseModel):
         order_type,
         order_side,
         amount,
-        status=OrderStatus.CREATED.value,
+        status: OrderStatus | None | str = OrderStatus.CREATED.value,
         target_symbol=None,
         trading_symbol=None,
         price=None,
@@ -40,7 +40,8 @@ class Order(BaseModel):
         order_fee=None,
         order_fee_currency=None,
         order_fee_rate=None,
-        id=None
+        id=None,
+        metadata=None,
     ):
         if target_symbol is None:
             raise OperationalException("Target symbol is not specified")
@@ -85,6 +86,7 @@ class Order(BaseModel):
         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
@@ -191,6 +193,11 @@ class Order(BaseModel):
         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:
@@ -222,14 +229,18 @@ class Order(BaseModel):
             dict: A dictionary representation of the Order object.
         """
 
-        if datetime_format is not None:
-            created_at = self.created_at.strftime(datetime_format) \
-                if self.created_at else None
-            updated_at = self.updated_at.strftime(datetime_format) \
-                if self.updated_at else None
-        else:
-            created_at = self.created_at
-            updated_at = self.updated_at
+        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,
@@ -249,6 +260,7 @@ class Order(BaseModel):
             "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
@@ -271,7 +283,8 @@ class Order(BaseModel):
             updated_at = parse(updated_at)
 
         order = Order(
-            external_id=data.get("id", None),
+            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),
@@ -282,12 +295,13 @@ class Order(BaseModel):
             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),
-            id=data.get("id", None)
+            metadata=data.get("metadata", {}),
         )
         return order
 
@@ -311,6 +325,13 @@ class Order(BaseModel):
             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,
@@ -326,7 +347,7 @@ class Order(BaseModel):
             order_fee=order_fee,
             order_fee_currency=order_fee_currency,
             order_fee_rate=order_fee_rate,
-            created_at=parse(ccxt_order.get("datetime", None))
+            created_at=created_at
         )
 
     def __repr__(self):

investing_algorithm_framework/domain/models/order/order_status.py

@@ -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

@@ -13,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/portfolio.py

@@ -40,6 +40,7 @@ class Portfolio(BaseModel):
         trading_symbol,
         net_size,
         unallocated,
+        initial_balance,
         market,
         realized=0,
         total_revenue=0,
@@ -49,7 +50,6 @@ class Portfolio(BaseModel):
         created_at=None,
         updated_at=None,
         initialized=False,
-        initial_balance=None
     ):
         self.identifier = identifier
         self.updated_at = None
@@ -66,6 +66,7 @@ class Portfolio(BaseModel):
         self.created_at = created_at
         self.updated_at = updated_at
         self.initialized = initialized
+        self._allocated = None
 
     def __repr__(self):
         return self.repr(
@@ -119,6 +120,18 @@ class Portfolio(BaseModel):
     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):
         """

investing_algorithm_framework/domain/models/portfolio/portfolio_configuration.py

@@ -10,7 +10,7 @@ class PortfolioConfiguration(BaseModel):
     This class represents a portfolio configuration. It is used to
     configure the portfolio that the user wants to create.
 
-    The portfolio configuration will have the following attributes:
+    Attributes:
     - market: The market where the portfolio will be created
     - trading_symbol: The trading symbol of the portfolio
     - track_from: The date from which the portfolio will be tracked
@@ -33,6 +33,10 @@ class PortfolioConfiguration(BaseModel):
         initial_balance=None,
     ):
         self._market = market
+
+        if self._market is not None:
+            self._market = self._market.upper()
+
         self._track_from = None
         self._trading_symbol = trading_symbol.upper()
         self._identifier = identifier

investing_algorithm_framework/domain/models/portfolio/portfolio_snapshot.py

@@ -1,4 +1,7 @@
+from datetime import timezone
+
 from dateutil import parser
+
 from investing_algorithm_framework.domain.models.base_model import BaseModel
 
 
@@ -17,7 +20,8 @@ class PortfolioSnapshot(BaseModel):
         total_value=None,
         cash_flow=None,
         created_at=None,
-        position_snapshots=None
+        position_snapshots=None,
+        metadata=None,
     ):
         self.portfolio_id = portfolio_id
         self.trading_symbol = trading_symbol
@@ -29,7 +33,15 @@ class PortfolioSnapshot(BaseModel):
         self.net_size = net_size
         self.total_cost = total_cost
         self.cash_flow = cash_flow
-        self.created_at = created_at
+        self.metadata = metadata if metadata is not None else {}
+
+        if created_at is not None and isinstance(created_at, str):
+            self.created_at = parser.parse(created_at)
+        else:
+            self.created_at = created_at
+
+        # Make sure that created_at is a timezone aware datetime object
+        self.created_at = self.created_at.replace(tzinfo=timezone.utc)
 
         if position_snapshots is None:
             position_snapshots = []
@@ -120,6 +132,7 @@ class PortfolioSnapshot(BaseModel):
             total_revenue=self.total_revenue,
             total_cost=self.total_cost,
             cash_flow=self.cash_flow,
+            metadata=self.metadata,
         )
 
     def to_dict(self, datetime_format=None):
@@ -134,18 +147,30 @@ class PortfolioSnapshot(BaseModel):
         Returns:
             dict: A dictionary representation of the portfolio snapshot 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
 
-        if datetime_format is not None:
-            created_at = self.created_at.strftime(datetime_format) \
-                if self.created_at else None
-
-        else:
-            created_at = self.created_at
+        created_at = ensure_iso(self.created_at) if self.created_at else None
 
         return {
-            "net_size": self.net_size,
-            "created_at": created_at,
-            "total_value": self.total_value,
+            "metadata": self.metadata if self.metadata else {},
+            "portfolio_id": self.portfolio_id if self.portfolio_id else "",
+            "trading_symbol": self.trading_symbol
+            if self.trading_symbol else "",
+            "pending_value": self.pending_value if self.pending_value else 0.0,
+            "unallocated": self.unallocated if self.unallocated else 0.0,
+            "total_net_gain": self.total_net_gain
+            if self.total_net_gain else 0.0,
+            "total_revenue": self.total_revenue if self.total_revenue else 0.0,
+            "total_cost": self.total_cost if self.total_cost else 0.0,
+            "cash_flow": self.cash_flow if self.cash_flow else 0.0,
+            "net_size": self.net_size if self.net_size else 0.0,
+            "created_at": created_at if created_at else "",
+            "total_value": self.total_value if self.total_value else 0.0,
         }
 
     @staticmethod
@@ -161,8 +186,23 @@ class PortfolioSnapshot(BaseModel):
         """
         created_at_str = data.get("created_at")
         created_at = parser.parse(created_at_str)
+
+        # Ensure created_at is timezone aware
+        created_at = created_at.replace(tzinfo=timezone.utc)
+
         return PortfolioSnapshot(
             net_size=data.get("net_size", 0.0),
             created_at=created_at,
             total_value=data.get("total_value", 0.0),
+            trading_symbol=data.get(
+                "trading_symbol", None
+            ),
+            portfolio_id=data.get("portfolio_id", None),
+            pending_value=data.get("pending_value", 0.0),
+            unallocated=data.get("unallocated", 0.0),
+            total_net_gain=data.get("total_net_gain", 0.0),
+            total_revenue=data.get("total_revenue", 0.0),
+            total_cost=data.get("total_cost", 0.0),
+            cash_flow=data.get("cash_flow", 0.0),
+            metadata=data.get("metadata", {})
         )

investing_algorithm_framework/domain/models/position/__init__.py

@@ -1,4 +1,5 @@
 from .position import Position
 from .position_snapshot import PositionSnapshot
+from .position_size import PositionSize
 
-__all__ = ["Position", "PositionSnapshot"]
+__all__ = ["Position", "PositionSnapshot", "PositionSize"]

investing_algorithm_framework/domain/models/position/position.py

@@ -50,6 +50,15 @@ class Position(BaseModel):
             "portfolio_id": self.portfolio_id,
         }
 
+    @staticmethod
+    def from_dict(data: dict):
+        return Position(
+            symbol=data.get("symbol"),
+            amount=data.get("amount", 0),
+            cost=data.get("cost", 0),
+            portfolio_id=data.get("portfolio_id"),
+        )
+
     def __repr__(self):
         return self.repr(
             symbol=self.symbol,

investing_algorithm_framework/domain/models/position/position_size.py

@@ -0,0 +1,41 @@
+from typing import Optional
+from investing_algorithm_framework.domain.exceptions import \
+    OperationalException
+
+
+class PositionSize:
+    """
+    Defines how much capital to allocate to a specific symbol.
+    """
+
+    def __init__(
+        self,
+        symbol: str,
+        percentage_of_portfolio: Optional[float] = None,
+        fixed_amount: Optional[float] = None
+    ):
+        self.symbol = symbol
+        self.percentage_of_portfolio = percentage_of_portfolio
+        self.fixed_amount = fixed_amount
+
+    def get_size(self, portfolio, asset_price) -> float:
+        """
+        Calculate size in currency/units.
+        """
+        if self.fixed_amount is not None:
+            return self.fixed_amount
+        elif self.percentage_of_portfolio is not None:
+            total_value = portfolio.get_unallocated() + portfolio.allocated
+            return total_value * (self.percentage_of_portfolio / 100)
+        else:
+            raise OperationalException(
+                "A position size object must have either a fixed amount or a "
+                "percentage of the portfolio defined."
+            )
+
+    def __repr__(self) -> str:
+        return (
+            f"PositionSize(symbol={self.symbol}, "
+            f"percentage_of_portfolio={self.percentage_of_portfolio}, "
+            f"fixed_amount={self.fixed_amount})"
+        )

investing_algorithm_framework/domain/models/risk_rules/__init__.py

@@ -0,0 +1,7 @@
+from .stop_loss_rule import StopLossRule
+from .take_profit_rule import TakeProfitRule
+
+__all__ = [
+    "StopLossRule",
+    "TakeProfitRule",
+]

investing_algorithm_framework/domain/models/risk_rules/stop_loss_rule.py

@@ -0,0 +1,51 @@
+class StopLossRule:
+    """
+    A rule that defines when to trigger a stop loss based
+    on a specified threshold such as a percentage drop in price or
+    a fixed amount.
+
+    if trade_risk_type is fixed, the stop loss price is calculated as follows:
+        You buy an asset at $100.
+        You set a 5% stop loss, meaning you will sell if
+            the price drops to $95.
+        If the price rises to $120, the stop loss is not triggered.
+        But if the price keeps falling to $95, the stop loss triggers,
+            and you exit with a $5 loss.
+
+    if trade_risk_type is trailing, the stop loss price is
+    calculated as follows:
+        You buy an asset at $100.
+        You set a 5% trailing stop loss, meaning you will sell if
+            the price drops 5% from its peak at $96
+        If the price rises to $120, the stop loss adjusts
+            to $114 (5% below $120).
+        If the price falls to $114, the position is
+            closed, securing a $14 profit.
+        But if the price keeps rising to $150, the stop
+            loss moves up to $142.50.
+        If the price drops from $150 to $142.50, the stop
+            loss triggers, and you exit with a $42.50 profit.
+
+    Attributes:
+        - percentage_threshold (float): The percentage drop in price
+            that triggers the stop loss.
+        - trailing (bool): Indicates whether the stop loss is trailing
+            or fixed.
+        - sell_percentage (float): The percentage of the position to sell
+            when the stop loss is triggered.
+        - symbol (str): The symbol of the asset the stop loss rule
+            applies to. Symbol is defined as the target symbol
+            (the asset being traded) combined with the trading symbol
+            (the asset used to trade the target symbol), e.g., 'BTC-EUR'.
+    """
+    def __init__(
+        self,
+        percentage_threshold: float,
+        sell_percentage: float,
+        symbol: str,
+        trailing: bool = False,
+    ):
+        self.percentage_threshold = percentage_threshold
+        self.trailing = trailing
+        self.sell_percentage = sell_percentage
+        self.symbol = symbol

investing_algorithm_framework/domain/models/risk_rules/take_profit_rule.py

@@ -0,0 +1,55 @@
+class TakeProfitRule:
+    """
+    A rule that defines when to trigger a take profit based
+    on a specified threshold such as a percentage gain in price or
+    a fixed amount.
+
+    if trailing is set to true, the take profit price is
+    calculated as follows:
+        You buy an asset at $100.
+        You set a 5% take profit, meaning you will sell if the price
+            rises to $105.
+        If the price rises to $120, the take profit triggers,
+            and you exit with a $20 profit.
+        But if the price keeps falling below $105, the take profit is not
+            triggered.
+
+    if trailing is set to true, the take profit price is
+    calculated as follows:
+        You buy an asset at $100.
+        You set a 5% trailing take profit, the moment the price rises
+            5% the initial take profit mark will be set. This means you
+            will set the take_profit_price initially at none and
+            only if the price hits $105, you will set the
+            take_profit_price to $105.
+        if the price drops below $105, the take profit is triggered.
+        If the price rises to $120, the take profit adjusts to
+        $114 (5% below $120).
+        If the price falls to $114, the position is closed,
+        securing a $14 profit.
+        But if the price keeps rising to $150, the take profit
+        moves up to $142.50.
+
+
+    Attributes:
+        - percentage_threshold (float): The percentage gain in price
+            that triggers the stop loss.
+        - trailing (bool): Indicates whether the take profit is trailing
+            or fixed.
+        - sell_percentage (float): The percentage of the position to sell
+            when the take profit is triggered.
+        - symbol (str): The symbol of the asset the take profit rule
+            applies to. Symbol is defined as only the target symbol.
+            So for example, 'BTC' in 'BTC-EUR' or 'META' in 'META-USD'.
+    """
+    def __init__(
+        self,
+        percentage_threshold: float,
+        sell_percentage: float,
+        symbol: str,
+        trailing: bool = False,
+    ):
+        self.percentage_threshold = percentage_threshold
+        self.trailing = trailing
+        self.sell_percentage = sell_percentage
+        self.symbol = symbol

investing_algorithm_framework/domain/models/snapshot_interval.py

@@ -2,7 +2,6 @@ from enum import Enum
 
 
 class SnapshotInterval(Enum):
-    TRADE_CLOSE = "TRADE_CLOSE"
     STRATEGY_ITERATION = "STRATEGY_ITERATION"
     DAILY = "DAILY"