investing-algorithm-framework 3.7.0__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

@@ -36,6 +36,15 @@ class TimeFrame(Enum):
                     if value == entry.value.replace("H", "h"):
                         return entry
 
+                # For hour timeframes compare with and without H
+                if "d" in entry.value:
+
+                    if value == entry.value:
+                        return entry
+
+                    if value == entry.value.replace("d", "D"):
+                        return entry
+
                 if value == entry.value:
                     return entry
 
@@ -114,3 +123,31 @@ 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):
+            return self.amount_of_minutes < other.amount_of_minutes
+        raise TypeError(f"Cannot compare TimeFrame with {type(other)}")
+
+    def __le__(self, other):
+        if isinstance(other, TimeFrame):
+            return self.amount_of_minutes <= other.amount_of_minutes
+        raise TypeError(f"Cannot compare TimeFrame with {type(other)}")
+
+    def __gt__(self, other):
+        if isinstance(other, TimeFrame):
+            return self.amount_of_minutes > other.amount_of_minutes
+        raise TypeError(f"Cannot compare TimeFrame with {type(other)}")
+
+    def __ge__(self, other):
+        if isinstance(other, TimeFrame):
+            return self.amount_of_minutes >= other.amount_of_minutes
+        raise TypeError(f"Cannot compare TimeFrame with {type(other)}")

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,10 +26,50 @@ class TimeUnit(Enum):
                 if value.upper() == entry.value:
                     return entry
 
-        raise ValueError(
-            f"Could not convert value {value} to time unit"
+            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):
@@ -83,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

@@ -1,4 +1,11 @@
 from .trade import Trade
 from .trade_status import TradeStatus
+from .trade_stop_loss import TradeStopLoss
+from .trade_take_profit import TradeTakeProfit
 
-__all__ = ["Trade", "TradeStatus"]
+__all__ = [
+    "Trade",
+    "TradeStatus",
+    "TradeStopLoss",
+    "TradeTakeProfit",
+]