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

investing_algorithm_framework/domain/models/strategy_profile.py

@@ -1,141 +1,25 @@
-from .base_model import BaseModel
-from .time_unit import TimeUnit
-
-
-class StrategyProfile(BaseModel):
-
-    def __init__(
-        self,
-        strategy_id=None,
-        interval=None,
-        time_unit=None,
-        trading_time_frame=None,
-        trading_time_frame_start_date=None,
-        symbols=None,
-        market=None,
-        backtest_start_date_data=None,
-        backtest_data_index_date=None,
-        trading_data_type=None,
-        trading_data_types=None,
-        market_data_sources=None,
-    ):
-        self._strategy_id = strategy_id
-        self._interval = interval
-        self._time_unit = time_unit
-        self._number_of_runs = 0
-        self._trading_time_frame = trading_time_frame
-        self._trading_time_frame_start_date = trading_time_frame_start_date
-        self._backtest_start_date_data = backtest_start_date_data
-        self._backtest_data_index_date = backtest_data_index_date
-        self._symbols = symbols
-        self._market = market
-        self._trading_data_type = trading_data_type
-        self._trading_data_types = trading_data_types
-        self._market_data_sources = market_data_sources
-
-    @property
-    def strategy_id(self):
-        return self._strategy_id
-
-    @strategy_id.setter
-    def strategy_id(self, strategy_id):
-        self._strategy_id = strategy_id
-
-    @property
-    def interval(self):
-        return self._interval
-
-    @interval.setter
-    def interval(self, value):
-        self._interval = value
-
-    @property
-    def time_unit(self):
-        return self._time_unit
-
-    @time_unit.setter
-    def time_unit(self, value):
-        self._time_unit = value
-
-    @property
-    def symbols(self):
-        return self._symbols
-
-    @property
-    def trading_time_frame(self):
-        return self._trading_time_frame
-
-    @property
-    def trading_time_frame_start_date(self):
-        return self._trading_time_frame_start_date
-
-    @property
-    def number_of_runs(self):
-        return self._number_of_runs
-
-    @property
-    def market(self):
-        return self._market
+from dataclasses import dataclass
 
-    @symbols.setter
-    def symbols(self, value):
-        self._symbols = value
-
-    @market.setter
-    def market(self, value):
-        self._market = value
-
-    @number_of_runs.setter
-    def number_of_runs(self, value):
-        self._number_of_runs = value
-
-    @trading_time_frame.setter
-    def trading_time_frame(self, value):
-        self._trading_time_frame = value
-
-    @property
-    def backtest_start_date_data(self):
-        return self._backtest_start_date_data
-
-    @backtest_start_date_data.setter
-    def backtest_start_date_data(self, value):
-        self._backtest_start_date_data = value
-
-    @property
-    def backtest_data_index_date(self):
-        return self._backtest_data_index_date
-
-    @backtest_data_index_date.setter
-    def backtest_data_index_date(self, value):
-        self._backtest_data_index_date = value
-
-    @property
-    def trading_data_type(self):
-        return self._trading_data_type
-
-    @trading_data_type.setter
-    def trading_data_type(self, value):
-        self._trading_data_type = value
-
-    @property
-    def trading_data_types(self):
-
-        if self.trading_data_type is not None:
-            return [self.trading_data_type]
-
-        return self._trading_data_types
-
-    @trading_data_types.setter
-    def trading_data_types(self, value):
-        self._trading_data_types = value
+from .time_unit import TimeUnit
 
-    @property
-    def market_data_sources(self):
-        return self._market_data_sources
 
-    @market_data_sources.setter
-    def market_data_sources(self, value):
-        self._market_data_sources = value
+@dataclass(frozen=True)
+class StrategyProfile:
+    """
+    StrategyProfile class that represents the profile of a trading strategy.
+    """
+    strategy_id: str = None
+    interval: int = None
+    time_unit: TimeUnit = None
+    trading_time_frame: str = None
+    trading_time_frame_start_date: str = None
+    backtest_start_date_data: str = None
+    backtest_data_index_date: str = None
+    symbols: list = None
+    market: str = None
+    trading_data_type: str = None
+    trading_data_types: list = None
+    data_sources: list = None
 
     def get_runs_per_day(self):
 
@@ -147,19 +31,3 @@ class StrategyProfile(BaseModel):
             return 1440 / self.interval
         else:
             return 24 / self.interval
-
-    def __repr__(self):
-        return self.repr(
-            strategy_id=self._strategy_id,
-            number_of_runs=self._number_of_runs,
-            trading_time_frame=self._trading_time_frame,
-            trading_time_frame_start_date=self._trading_time_frame_start_date,
-            symbols=self._symbols,
-            time_unit=self.time_unit,
-            interval=self.interval,
-            market=self._market,
-            backtest_start_date_data=self._backtest_start_date_data,
-            backtest_data_index_date=self._backtest_data_index_date,
-            trading_data_type=self._trading_data_type,
-            trading_data_types=self._trading_data_types,
-        )

investing_algorithm_framework/domain/models/time_frame.py

@@ -124,6 +124,13 @@ class TimeFrame(Enum):
         if self.equals(TimeFrame.ONE_MONTH):
             return 40320
 
+        if self.equals(TimeFrame.ONE_YEAR):
+            return 525600
+
+        raise ValueError(
+            f"Could not determine amount of minutes for {self.value}"
+        )
+
     # Add comparison methods for ordering
     def __lt__(self, other):
         if isinstance(other, TimeFrame):

investing_algorithm_framework/domain/models/time_interval.py

@@ -25,6 +25,39 @@ class TimeInterval(Enum):
                 f"Could not convert {value} to TimeInterval"
             )
 
+    @staticmethod
+    def from_ohlcv_data_file(file_path: str):
+        """
+        Extracts the time interval from the file name of an OHLCV data file.
+        The file name should contain the time interval in the format
+        'symbol_timeinterval.csv'.
+
+        Args:
+            file_path (str): The file path of the OHLCV data file.
+
+        Returns:
+            TimeInterval: The extracted time interval.
+        """
+        if not isinstance(file_path, str):
+            raise ValueError("File path must be a string.")
+
+        parts = file_path.split('_')
+        if len(parts) < 2:
+            raise ValueError(
+                "File name does not contain a valid time interval."
+            )
+
+        time_interval_str = parts[-1].split('.')[0].upper()
+        try:
+            return TimeInterval.from_string(time_interval_str)
+        except ValueError:
+            raise ValueError(
+                "Could not extract time interval from "
+                f"file name: {file_path}. "
+                "Expected format 'symbol_timeinterval.csv', "
+                f"got '{time_interval_str}'."
+            )
+
     def equals(self, other):
 
         if isinstance(other, Enum):

investing_algorithm_framework/domain/models/time_unit.py

@@ -1,8 +1,16 @@
 from datetime import timedelta
 from enum import Enum
+from investing_algorithm_framework.domain.exceptions import \
+    OperationalException
 
 
 class TimeUnit(Enum):
+    """
+    Enum class the represents a time unit such as
+    second, minute, hour or day. This can class
+    can be used to specify time specification within
+    the framework.
+    """
     SECOND = "SECOND"
     MINUTE = "MINUTE"
     HOUR = "HOUR"
@@ -18,12 +26,50 @@ class TimeUnit(Enum):
                 if value.upper() == entry.value:
                     return entry
 
-        raise ValueError(
+            raise OperationalException(
+                f"Could not convert string {value} to time unit"
+            )
+
+        raise OperationalException(
             f"Could not convert value {value} to time unit," +
             " please make sure that the value is either of type string or" +
             f"TimeUnit. Its current type is {type(value)}"
         )
 
+    @staticmethod
+    def from_ohlcv_data_file(file_path: str):
+        """
+        Extracts the time unit from the file name of an OHLCV data file.
+        The file name should contain the time unit in the
+        format 'symbol_timeunit.csv'.
+
+        Args:
+            file_path (str): The file path of the OHLCV data file.
+
+        Returns:
+            TimeUnit: The extracted time unit.
+        """
+        if not isinstance(file_path, str):
+            raise OperationalException(
+                "File path must be a string."
+            )
+
+        parts = file_path.split('_')
+        if len(parts) < 2:
+            raise OperationalException(
+                "File name does not contain a valid time unit."
+            )
+
+        time_unit_str = parts[-1].split('.')[0].upper()
+        try:
+            return TimeUnit.from_string(time_unit_str)
+        except ValueError:
+            raise OperationalException(
+                f"Could not extract time unit from file name: {file_path}. "
+                "Expected format 'symbol_timeunit.csv', "
+                f"got '{time_unit_str}'."
+            )
+
     def equals(self, other):
 
         if isinstance(other, Enum):
@@ -85,3 +131,19 @@ class TimeUnit(Enum):
 
         if TimeUnit.DAY.equals(self.value):
             return "days"
+
+    @property
+    def amount_of_minutes(self):
+        if TimeUnit.SECOND.equals(self):
+            return 1 / 60
+
+        if TimeUnit.MINUTE.equals(self):
+            return 1
+
+        if TimeUnit.HOUR.equals(self):
+            return 60
+
+        if TimeUnit.DAY.equals(self):
+            return 60 * 24
+
+        raise ValueError(f"Unsupported time unit: {self}")

investing_algorithm_framework/domain/models/trade/__init__.py

@@ -2,12 +2,10 @@ from .trade import Trade
 from .trade_status import TradeStatus
 from .trade_stop_loss import TradeStopLoss
 from .trade_take_profit import TradeTakeProfit
-from .trade_risk_type import TradeRiskType
 
 __all__ = [
     "Trade",
     "TradeStatus",
     "TradeStopLoss",
     "TradeTakeProfit",
-    "TradeRiskType",
 ]

investing_algorithm_framework/domain/models/trade/trade.py

@@ -1,4 +1,5 @@
 from dateutil.parser import parse
+from datetime import timezone
 
 from investing_algorithm_framework.domain.models.base_model import BaseModel
 from investing_algorithm_framework.domain.models.order import OrderSide, Order
@@ -40,9 +41,10 @@ class Trade(BaseModel):
         last_reported_price: float, the last reported price of the trade
         last_reported_price_datetime: datetime, the datetime when the last
             reported price was reported
-        created_at: datetime, the datetime when the trade was created
         updated_at: datetime, the datetime when the trade was last updated
         status: str, the status of the trade
+        metadata: dict, the metadata of the trade, this can be used to store
+            additional information about the trade.
     """
 
     def __init__(
@@ -68,6 +70,7 @@ class Trade(BaseModel):
         updated_at=None,
         stop_losses=None,
         take_profits=None,
+        metadata=None,
     ):
         self.id = id
         self.orders = orders
@@ -86,15 +89,16 @@ class Trade(BaseModel):
         self.last_reported_price_datetime = last_reported_price_datetime
         self.high_water_mark = high_water_mark
         self.high_water_mark_datetime = high_water_mark_datetime
-        self.status = status
+        self.status = TradeStatus.from_value(status).value
         self.updated_at = updated_at
         self.stop_losses = stop_losses
         self.take_profits = take_profits
+        self.metadata = metadata if metadata is not None else {}
 
     def update(self, data):
 
         if "status" in data:
-            self.status = TradeStatus.from_value(data["status"])
+            self.status = TradeStatus.from_value(data["status"]).value
 
             if TradeStatus.CLOSED.equals(self.status):
 
@@ -174,16 +178,25 @@ class Trade(BaseModel):
 
     @property
     def change(self):
+        """
+        Property to calculate the change in value of the trade.
+
+        This is the difference between the current value of the trade
+        and the cost of the trade.
+        """
         if TradeStatus.CLOSED.equals(self.status):
-            cost = self.amount * self.open_price
-            return self.net_gain - cost
+            return self.net_gain
 
         if self.last_reported_price is None:
             return 0
 
-        cost = self.remaining * self.open_price
-        gain = (self.remaining * self.last_reported_price) - cost
-        gain += self.net_gain
+        if self.remaining is None or self.remaining == 0:
+            amount = self.amount
+        else:
+            amount = self.amount - self.remaining
+
+        cost = amount * self.open_price
+        gain = (amount * self.last_reported_price) - cost
         return gain
 
     @property
@@ -196,7 +209,7 @@ class Trade(BaseModel):
 
             if self.last_reported_price is not None:
                 gain = (
-                    self.remaining *
+                    self.available_amount *
                     (self.last_reported_price - self.open_price)
                 )
 
@@ -216,7 +229,7 @@ class Trade(BaseModel):
 
             if self.last_reported_price is not None:
                 gain = (
-                    self.remaining *
+                    self.available_amount *
                     (self.last_reported_price - self.open_price)
                 )
 
@@ -231,31 +244,36 @@ class Trade(BaseModel):
     def percentage_change(self):
 
         if TradeStatus.CLOSED.equals(self.status):
-            cost = self.amount * self.open_price
-            gain = self.net_gain - cost
-            return (gain / cost) * 100
+
+            if self.cost != 0:
+                return (self.net_gain / self.cost) * 100
 
         if self.last_reported_price is None:
             return 0
 
-        cost = self.remaining * self.open_price
-        gain = (self.remaining * self.last_reported_price) - cost
+        cost = self.available_amount * self.open_price
+        gain = (self.available_amount * self.last_reported_price) - cost
         gain += self.net_gain
-        return (gain / cost) * 100
+
+        if cost != 0:
+            return (gain / cost) * 100
+
+        return 0
 
     def to_dict(self, datetime_format=None):
+        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:
-            opened_at = self.opened_at.strftime(datetime_format) \
-                if self.opened_at else None
-            closed_at = self.closed_at.strftime(datetime_format) \
-                if self.closed_at else None
-            updated_at = self.updated_at.strftime(datetime_format) \
-                if self.updated_at else None
-        else:
-            opened_at = self.opened_at
-            closed_at = self.closed_at
-            updated_at = self.updated_at
+        opened_at = ensure_iso(self.opened_at) if self.opened_at else None
+        closed_at = ensure_iso(self.closed_at) if self.closed_at else None
+        updated_at = ensure_iso(self.updated_at) if self.updated_at else None
+
+        # Ensure status is a string
+        self.status = TradeStatus.from_value(self.status).value
 
         return {
             "id": self.id,
@@ -267,14 +285,14 @@ class Trade(BaseModel):
             "trading_symbol": self.trading_symbol,
             "status": self.status,
             "amount": self.amount,
-            "remaining": self.remaining,
+            "remaining": self.remaining if self.remaining is not None else 0,
             "open_price": self.open_price,
             "last_reported_price": self.last_reported_price,
             "opened_at": opened_at,
             "closed_at": closed_at,
             "updated_at": updated_at,
-            "net_gain": self.net_gain,
-            "cost": self.cost,
+            "net_gain": self.net_gain if self.net_gain is not None else 0,
+            "cost": self.cost if self.cost is not None else 0,
             "stop_losses": [
                 stop_loss.to_dict(datetime_format=datetime_format)
                 for stop_loss in self.stop_losses
@@ -283,6 +301,9 @@ class Trade(BaseModel):
                 take_profit.to_dict(datetime_format=datetime_format)
                 for take_profit in self.take_profits
             ] if self.take_profits else None,
+            "filled_amount": self.filled_amount,
+            "available_amount": self.available_amount,
+            "metadata": self.metadata if self.metadata else {},
         }
 
     @staticmethod
@@ -320,7 +341,6 @@ class Trade(BaseModel):
                 Order.from_dict(order)
                 for order in data["orders"]
             ]
-
         return Trade(
             id=data.get("id", None),
             orders=orders,
@@ -335,16 +355,18 @@ class Trade(BaseModel):
             remaining=data.get("remaining", 0),
             net_gain=data.get("net_gain", 0),
             last_reported_price=data.get("last_reported_price"),
-            status=data["status"],
+            status=TradeStatus.from_value(data["status"]).value,
             cost=data.get("cost", 0),
             updated_at=updated_at,
             stop_losses=stop_losses,
             take_profits=take_profits,
+            metadata=data.get("metadata", {}),
         )
 
     def __repr__(self):
         return self.repr(
             id=self.id,
+            symbol=self.symbol,
             target_symbol=self.target_symbol,
             trading_symbol=self.trading_symbol,
             status=self.status,
@@ -357,6 +379,8 @@ class Trade(BaseModel):
             closed_at=self.closed_at,
             net_gain=self.net_gain,
             last_reported_price=self.last_reported_price,
+            updated_at=self.updated_at,
+            metadata=self.metadata,
         )
 
     def __lt__(self, other):

investing_algorithm_framework/domain/models/trade/trade_status.py

@@ -1,4 +1,6 @@
 from enum import Enum
+from investing_algorithm_framework.domain.exceptions import \
+    OperationalException
 
 
 class TradeStatus(Enum):
@@ -15,7 +17,9 @@ class TradeStatus(Enum):
                 if value.upper() == status.value:
                     return status
 
-        raise ValueError("Could not convert value to TradeStatus")
+        raise OperationalException(
+            f"Could not convert value: '{value}' to TradeStatus"
+        )
 
     @staticmethod
     def from_value(value):
@@ -28,7 +32,9 @@ class TradeStatus(Enum):
         elif isinstance(value, str):
             return TradeStatus.from_string(value)
 
-        raise ValueError("Could not convert value to TradeStatus")
+        raise OperationalException(
+            f"Could not convert value: {value} to TradeStatus"
+        )
 
     def equals(self, other):
         return TradeStatus.from_value(other) == self