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

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,10 +1,20 @@
+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"
+    DAY = "DAY"
 
     @staticmethod
     def from_string(value: str):
@@ -16,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):
@@ -38,3 +88,62 @@ class TimeUnit(Enum):
                     return entry
 
         return TimeUnit.from_string(value)
+
+    def create_date(self, start_date, interval):
+
+        if TimeUnit.SECOND.equals(self):
+            return timedelta(minutes=interval)
+        elif TimeUnit.MINUTE.equals(self):
+            return timedelta(minutes=interval)
+        elif TimeUnit.HOUR.equals(self):
+            return timedelta(hours=interval)
+        elif TimeUnit.DAY.equals(self):
+            return timedelta(days=interval)
+
+        raise ValueError(f"Unsupported time unit: {self}")
+
+    @property
+    def single_name(self):
+
+        if TimeUnit.SECOND.equals(self.value):
+            return "second"
+
+        if TimeUnit.MINUTE.equals(self.value):
+            return "minute"
+
+        if TimeUnit.HOUR.equals(self.value):
+            return "hour"
+
+        if TimeUnit.DAY.equals(self.value):
+            return "day"
+
+    @property
+    def plural_name(self):
+
+        if TimeUnit.SECOND.equals(self.value):
+            return "seconds"
+
+        if TimeUnit.MINUTE.equals(self.value):
+            return "minutes"
+
+        if TimeUnit.HOUR.equals(self.value):
+            return "hours"
+
+        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",
+]