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

investing_algorithm_framework/domain/models/strategy_profile.py

@@ -1,131 +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,
-    ):
-        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
-
-    @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
+from dataclasses import dataclass
 
-    @property
-    def market(self):
-        return self._market
-
-    @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]
+from .time_unit import TimeUnit
 
-        return self._trading_data_types
 
-    @trading_data_types.setter
-    def trading_data_types(self, value):
-        self._trading_data_types = 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):
 
@@ -137,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

@@ -1,16 +1,24 @@
-from datetime import datetime, timedelta
 from enum import Enum
 
-from dateutil import relativedelta
-
 
 class TimeFrame(Enum):
     CURRENT = "CURRENT"
-    ONE_HOUR = "ONE_HOUR"
-    ONE_DAY = "ONE_DAY"
-    ONE_WEEK = "ONE_WEEK"
-    ONE_MONTH = "ONE_MONTH"
-    ONE_YEAR = "ONE_YEAR"
+    ONE_MINUTE = "1m"
+    TWO_MINUTE = "2m"
+    THREE_MINUTE = "3m"
+    FOUR_MINUTE = "4m"
+    FIVE_MINUTE = "5m"
+    TEN_MINUTE = "10m"
+    FIFTEEN_MINUTE = "15m"
+    THIRTY_MINUTE = "30m"
+    ONE_HOUR = "1h"
+    TWO_HOUR = "2h"
+    FOUR_HOUR = "4h"
+    TWELVE_HOUR = "12h"
+    ONE_DAY = "1d"
+    ONE_WEEK = "1W"
+    ONE_MONTH = "1M"
+    ONE_YEAR = "1Y"
 
     @staticmethod
     def from_string(value: str):
@@ -19,7 +27,25 @@ class TimeFrame(Enum):
 
             for entry in TimeFrame:
 
-                if value.upper() == entry.value:
+                # For hour timeframes compare with and without H
+                if "H" in entry.value:
+
+                    if value == entry.value:
+                        return entry
+
+                    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
 
             raise ValueError(
@@ -50,108 +76,78 @@ class TimeFrame(Enum):
         else:
             return TimeFrame.from_string(other) == self
 
-    def create_time_frame(self, end_datetime=None):
-
-        if end_datetime is None:
-            end_datetime = datetime.utcnow()
-
-        if TimeFrame.ONE_HOUR.equals(self):
-            start_datetime = end_datetime - \
-                             relativedelta.relativedelta(hours=1)
-        elif TimeFrame.ONE_DAY.equals(self):
-            start_datetime = end_datetime - \
-                             relativedelta.relativedelta(hours=24)
-        elif TimeFrame.ONE_WEEK.equals(self):
-            start_datetime = end_datetime - \
-                             relativedelta.relativedelta(days=7)
-        elif TimeFrame.ONE_MONTH.equals(self):
-            start_datetime = \
-                end_datetime - relativedelta.relativedelta(days=28)
-        elif TimeFrame.ONE_YEAR.equals(self):
-            start_datetime = \
-                end_datetime - relativedelta.relativedelta(days=365)
-        else:
-            raise NotImplementedError(
-                f"Timeframe {self.value} not implemented"
-            )
+    @property
+    def amount_of_minutes(self):
 
-        return start_datetime, end_datetime
-
-    def duration(self):
-        if TimeFrame.ONE_HOUR.equals(self):
-            return relativedelta.relativedelta(hours=1)
-        elif TimeFrame.ONE_DAY.equals(self):
-            return relativedelta.relativedelta(hours=24)
-        elif TimeFrame.ONE_WEEK.equals(self):
-            return relativedelta.relativedelta(days=7)
-        elif TimeFrame.ONE_MONTH.equals(self):
-            return relativedelta.relativedelta(days=28)
-        elif TimeFrame.ONE_YEAR.equals(self):
-            return relativedelta.relativedelta(days=365)
-        else:
-            raise NotImplementedError(
-                f"Timeframe {self.value} not implemented"
-            )
+        if self.equals(TimeFrame.ONE_MINUTE):
+            return 1
 
-    @property
-    def time_interval(self):
-        from investing_algorithm_framework.core.models import TimeInterval
-
-        if TimeFrame.CURRENT.equals(self):
-            return TimeInterval.CURRENT
-        elif TimeFrame.ONE_HOUR.equals(self):
-            return TimeInterval.MINUTES_ONE
-        elif TimeFrame.ONE_DAY.equals(self):
-            return TimeInterval.MINUTES_FIFTEEN
-        elif TimeFrame.ONE_WEEK.equals(self):
-            return TimeInterval.HOURS_ONE
-        elif TimeFrame.ONE_MONTH.equals(self):
-            return TimeInterval.HOURS_FOUR
-        elif TimeFrame.ONE_YEAR.equals(self):
-            return TimeInterval.DAYS_ONE
-        else:
-            raise NotImplementedError(
-                f"Timeframe {self.value} not implemented"
-            )
+        if self.equals(TimeFrame.TWO_MINUTE):
+            return 2
 
-    @property
-    def intervals(self):
-        intervals = []
-        start_datetime, end_datetime = self.create_time_frame()
-        delta = end_datetime - start_datetime
+        if self.equals(TimeFrame.THREE_MINUTE):
+            return 3
 
-        intervals.append(end_datetime)
+        if self.equals(TimeFrame.FOUR_MINUTE):
+            return 4
 
-        if TimeFrame.ONE_HOUR.equals(self):
+        if self.equals(TimeFrame.FIVE_MINUTE):
+            return 5
 
-            for i in range(1, int(delta.total_seconds() / 60)):
-                intervals.append(end_datetime - timedelta(minutes=i))
+        if self.equals(TimeFrame.TEN_MINUTE):
+            return 10
 
-        elif TimeFrame.ONE_DAY.equals(self):
+        if self.equals(TimeFrame.FIFTEEN_MINUTE):
+            return 15
 
-            for i in range(1, int((delta.total_seconds() / 60) / 15)):
-                intervals.append(end_datetime - timedelta(minutes=i * 15))
+        if self.equals(TimeFrame.THIRTY_MINUTE):
+            return 30
 
-        elif TimeFrame.ONE_WEEK.equals(self):
+        if self.equals(TimeFrame.ONE_HOUR):
+            return 60
 
-            for i in range(1, int((delta.total_seconds() / 60) / 60)):
-                intervals.append(end_datetime - timedelta(hours=i))
+        if self.equals(TimeFrame.TWO_HOUR):
+            return 120
 
-        elif TimeFrame.ONE_MONTH.equals(self):
+        if self.equals(TimeFrame.FOUR_HOUR):
+            return 240
 
-            for i in range(1, int(((delta.total_seconds() / 60) / 60) / 4)):
-                intervals.append(end_datetime - timedelta(hours=i * 4))
+        if self.equals(TimeFrame.TWELVE_HOUR):
+            return 720
 
-        elif TimeFrame.ONE_YEAR.equals(self):
+        if self.equals(TimeFrame.ONE_DAY):
+            return 1440
 
-            for i in range(1, int(delta.days)):
-                intervals.append(
-                    end_datetime - relativedelta.relativedelta(days=i)
-                )
+        if self.equals(TimeFrame.ONE_WEEK):
+            return 10080
 
-        else:
-            raise NotImplementedError(
-                f"Timeframe {self.value} not implemented"
-            )
+        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}"
+        )
 
-        return intervals
+    # 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/tracing/trace.py

@@ -0,0 +1,23 @@
+class Trace:
+    """
+    Represents a trace of a trading strategy. A trace contains
+    data that has been generated by a trading strategy during its
+    execution.
+
+    The data can be used to analyze the performance of the trading after
+    it has been executed. Usually, the data contains metrics that
+    have been generated by the trading strategy during its execution,
+    and the signals that have been generated.
+    """
+
+    def __init__(
+        self,
+        strategy_id: str,
+        symbol: str,
+        data,
+        drop_duplicates=True
+    ):
+        self.strategy_id = strategy_id
+        self.symbol = symbol
+        self.data = data
+        self.drop_duplicates = drop_duplicates

investing_algorithm_framework/domain/models/trade/__init__.py

@@ -0,0 +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",
+    "TradeStopLoss",
+    "TradeTakeProfit",
+]