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

investing_algorithm_framework/domain/data_provider.py

@@ -1,9 +1,12 @@
-from typing import List
+from typing import List, Any, Union
 from abc import ABC, abstractmethod
 from datetime import datetime
-from investing_algorithm_framework.domain.models.trading_data_types import \
-    TradingDataType
+from investing_algorithm_framework.domain.exceptions import \
+    ImproperlyConfigured
 from investing_algorithm_framework.domain.models.time_frame import TimeFrame
+from investing_algorithm_framework.domain.models.data.data_type import DataType
+from investing_algorithm_framework.domain.models.data.data_source import \
+    DataSource
 
 
 class DataProvider(ABC):
@@ -13,20 +16,16 @@ class DataProvider(ABC):
     algorithms.
 
     Attributes:
-        data_type (str): The type of data to be
+        data_type (DataType): The type of data to be
             fetched (e.g., OHLCV, TICKER, CUSTOM_DATA).
-        symbols (Optional[List[str]]): A list supported symbols that the
+        symbol (Optional[List[str]]): A list supported symbols that the
             data provider can provide data for. The framework will use this
             list when searching for a data provider for a specific symbol.
             Example: ["AAPL/USD", "GOOGL/USD", "MSFT/USD"]
-        markets (Optional[List[str]]): A list supported markets that the
-            data provider can provide data for. The framework will use this
-            list when searching for a data provider for a specific market.
-            Example: ["BINANCE", "COINBASE", "KRAKEN"]
         priority (int): The priority of the data provider. The lower the
             number, the higher the priority. The framework will use this
             priority when searching for a data provider for a specific symbol.
-            Example: 0 is the highest priority, 1 is the second highest
+            Example: 0 is the highest priority, 1 is the second-highest
             priority, etc. This is useful when multiple data providers
             support the same symbol or market. The framework will use the
             data provider with the highest priority.
@@ -40,53 +39,102 @@ class DataProvider(ABC):
             for the data. This is useful for data providers that support
             saving data to a file
     """
+    data_type: DataType = None
+    data_provider_identifier: str = None
 
     def __init__(
         self,
-        data_type: str,
+        data_provider_identifier: str = None,
+        data_type: str = None,
         symbol: str = None,
         market: str = None,
-        markets: list = None,
         priority: int = 0,
         time_frame=None,
         window_size=None,
         storage_path=None,
+        storage_directory=None,
+        config=None,
     ):
         """
-        Initializes the DataProvider with data type, symbols, and markets.
+        Initializes the DataProvider. The data provider should be defined
+        with a data_type and a data_provider_identifier. The data_type
+        should be a valid DataType, and the data_provider_identifier
+        should be a unique identifier for the data provider.
+
+        Args:
+            data_provider_identifier (str): The unique identifier for the
+                data provider. This is used to identify the data provider
+                in the framework. It should be a unique string that identifies
+                the data provider. Example: "binance",
+                "coinbase", "custom_feed_data"
+            data_type (str): The type of data to be fetched
+                (e.g., "OHLCV", "TICKER", "CUSTOM_DATA")
+            symbol (str): The symbol to fetch data for. This is optional and
+                can be set later. Example: "AAPL/USD", "BTC/USD"
+            market (str): The market to fetch data for.
+                This is optional and can be set later.
+                Example: "BINANCE", "COINBASE"
+            priority (int): The priority of the data provider. The lower the
+                number, the higher the priority. This is useful when multiple
+                data providers support the same symbol or market. The framework
+                will use the data provider with the highest priority.
+                Example: 0 is the highest priority, 1 is the second-highest
+                priority, etc.
+            time_frame (str): The time frame for the data. This is optional and
+                can be set later. This is useful for data providers
+                that support multiple time frames.
+                Example: "1m", "5m", "1h", "1d"
+            window_size (int): The window size for the data. This is optional
+                and can be set later. This is useful for data providers that
+                support multiple window sizes. Example: 100, 200, 500
+            storage_path (str): The path to the storage location for the data.
+                This is optional and can be set later. This is useful for data
+                providers that support saving data to a file.
+                Example: "/path/to/data"
         """
         self._data_type = None
         self._time_frame = None
 
         if data_type is not None:
-            self._data_type = TradingDataType.from_value(data_type)
+            self.data_type = DataType.from_value(data_type)
 
         if time_frame is not None:
             self.time_frame = TimeFrame.from_value(time_frame)
 
+        if data_provider_identifier is not None:
+            self.data_provider_identifier = data_provider_identifier
+
         self.symbol = symbol
+
+        if self.symbol is not None:
+            self.symbol = self.symbol.upper()
+
         self.market = market
-        self.markets = markets
+
+        if self.market is not None:
+            self.market = self.market.upper()
+
         self.priority = priority
+        self._config = config
         self.window_size = window_size
         self.storage_path = storage_path
+        self.storage_directory = storage_directory
         self._market_credentials = None
 
-    @property
-    def data_type(self):
-        return self._data_type
+        # Check if the data provider is properly configured
+        if self.data_type is None:
+            raise ImproperlyConfigured(
+                "DataProvider must be initialized "
+                "with a data_type. Either pass it as a parameter in "
+                "the constructor or set it as a class attribute."
+            )
 
-    @data_type.setter
-    def data_type(self, value):
-        self._data_type = TradingDataType.from_value(value)
-
-    @property
-    def time_frame(self):
-        return self._time_frame
-
-    @time_frame.setter
-    def time_frame(self, value):
-        self._time_frame = TimeFrame.from_value(value)
+        if self.data_provider_identifier is None:
+            raise ImproperlyConfigured(
+                "DataProvider must be initialized with a "
+                "data_provider_identifier. Either pass it as a parameter "
+                "in the constructor or set it as a class attribute."
+            )
 
     @property
     def market_credentials(self):
@@ -124,67 +172,163 @@ class DataProvider(ABC):
     @abstractmethod
     def has_data(
         self,
-        data_type: str = None,
-        symbol: str = None,
-        market: str = None,
-        time_frame: str = None,
+        data_source: DataSource,
         start_date: datetime = None,
         end_date: datetime = None,
-        window_size=None,
     ) -> bool:
         """
         Checks if the data provider has data for the given parameters.
+
+        Args:
+            data_source (DataSource): The data source specification that
+                matches a data provider.
+            start_date (datetime): The start date for the data.
+            end_date (datetime): The end date for the data.
+
+        Returns:
+            bool: True if the data provider has data for the given parameters,
         """
         raise NotImplementedError("Subclasses should implement this method.")
 
     @abstractmethod
     def get_data(
         self,
-        data_type: str = None,
         date: datetime = None,
-        symbol: str = None,
-        market: str = None,
-        time_frame: str = None,
         start_date: datetime = None,
         end_date: datetime = None,
-        storage_path=None,
-        window_size=None,
-        pandas=False,
-        save: bool = True,
-    ):
+        save: bool = False,
+    ) -> Any:
         """
         Fetches data for a given symbol and date range.
+
+        Args:
+            start_date (datetime): The start date for the data.
+            end_date (datetime): The end date for the data.
+            date (datetime): The specific date for which to fetch data.
+            save (bool): Whether to save the data to the storage path.
+
+        Returns:
+            Any: The data for the given symbol and date range.
+            This can be a DataFrame, a list, or any other data structure
+            depending on the implementation.
         """
         raise NotImplementedError("Subclasses should implement this method.")
 
     @abstractmethod
-    def pre_pare_backtest_data(
+    def prepare_backtest_data(
         self,
         backtest_start_date,
         backtest_end_date,
-        symbol: str = None,
-        market: str = None,
-        time_frame: str = None,
-        window_size=None,
     ) -> None:
         """
         Prepares backtest data for a given symbol and date range.
+
+        Args:
+            backtest_start_date (datetime): The start date for the
+                backtest data.
+            backtest_end_date (datetime): The end date for the
+                backtest data.
+
+        Returns:
+            None
         """
         raise NotImplementedError("Subclasses should implement this method.")
 
     @abstractmethod
     def get_backtest_data(
         self,
-        date: datetime = None,
-        symbol: str = None,
-        market: str = None,
-        time_frame: str = None,
+        backtest_index_date: datetime,
         backtest_start_date: datetime = None,
         backtest_end_date: datetime = None,
-        window_size=None,
-        pandas=False,
-    ) -> None:
+        data_source: DataSource = None,
+    ) -> Any:
         """
-        Fetches backtest data for a given symbol and date range.
+        Fetches backtest data for a given datasource
+
+        Args:
+            backtest_index_date (datetime): The date for which to fetch
+                backtest data.
+            backtest_start_date (datetime): The start date for the
+                backtest data.
+            backtest_end_date (datetime): The end date for the
+                backtest data.
+            data_source (Optional[DataSource]): The data source
+                specification that is used to fetch the data.
+                This param is optional and can be used to
+                help identify errors in data fetching.
+
+        Returns:
+            Any: The data for the given symbol and date range.
+            This can be a DataFrame, a list, or any other data structure
+            depending on the implementation.
+        """
+        raise NotImplementedError("Subclasses should implement this method.")
+
+    @abstractmethod
+    def copy(self, data_source: DataSource) -> "DataProvider":
+        """
+        Returns a copy of the data provider instance based on a
+        given data source. The data source is previously matched
+        with the 'has_data' method. Then a new instance of the data
+        provider must be registered in the framework so that each
+        data source has its own instance of the data provider.
+
+        Args:
+            data_source (DataSource): The data source specification that
+                matches a data provider.
+
+        Returns:
+            DataProvider: A new instance of the data provider with the same
+                configuration.
+        """
+        raise NotImplementedError("Subclasses should implement this method.")
+
+    @abstractmethod
+    def get_number_of_data_points(
+        self,
+        start_date: datetime,
+        end_date: datetime,
+    ) -> int:
+        """
+        Returns the number of data points available between the
+        given start and end dates.
+
+        Args:
+            start_date (datetime): The start date for the data points.
+            end_date (datetime): The end date for the data points.
+        Returns:
+            int: The number of data points available between the
+                given start and end dates.
+        """
+        raise NotImplementedError("Subclasses should implement this method.")
+
+    @abstractmethod
+    def get_missing_data_dates(
+        self,
+        start_date: datetime,
+        end_date: datetime,
+    ) -> List[datetime]:
+        """
+        Returns a list of dates for which data is missing between the
+        given start and end dates.
+
+        Args:
+            start_date (datetime): The start date for checking missing data.
+            end_date (datetime): The end date for checking missing data.
+
+        Returns:
+            List[datetime]: A list of dates for which data is missing
+                between the given start and end dates.
+        """
+        raise NotImplementedError("Subclasses should implement this method.")
+
+    @abstractmethod
+    def get_data_source_file_path(self) -> Union[str, None]:
+        """
+        Returns the file path for the given data source if applicable.
+
+        Returns:
+            Union[str, None]: The file path for the data source or None
+                if not applicable.
         """
         raise NotImplementedError("Subclasses should implement this method.")

investing_algorithm_framework/domain/exceptions.py

@@ -49,7 +49,14 @@ class ImproperlyConfigured(Exception):
 class OperationalException(Exception):
     """
     Class OperationalException: Exception class indicating a problem occurred
-    during running of the investing_algorithm_framework
+    during running of the investing_algorithm_framework.
+
+    This exception is used to indicate that an error occurred during the
+    operation of the investing_algorithm_framework, such as during a backtest,
+    strategy execution, or any other operational aspect of the framework.
+
+    Attributes:
+        message (str): The error message to be returned in the response.
     """
     def __init__(self, message) -> None:
         super(OperationalException, self).__init__(message)
@@ -77,3 +84,29 @@ class NetworkError(Exception):
             "status": "error",
             "message": self.error_message
         }
+
+
+class DataError(Exception):
+    """
+    Class DataError: Exception class indicating a problem occurred
+    during data retrieval or processing
+    """
+
+    def __init__(
+        self,
+        message,
+        data_source_file_path: str = None,
+        number_of_missing_data_points: int = None,
+        total_number_of_data_points: int = None,
+    ) -> None:
+        super(DataError, self).__init__(message)
+        self.error_message = message
+        self.data_source_file_path = data_source_file_path
+        self.number_of_missing_data_points = number_of_missing_data_points
+        self.total_number_of_data_points = total_number_of_data_points
+
+    def to_response(self):
+        return {
+            "status": "error",
+            "message": self.error_message
+        }

investing_algorithm_framework/domain/models/__init__.py

@@ -1,23 +1,17 @@
 from .app_mode import AppMode
-from .backtesting import BacktestResult, BacktestPosition, \
-    BacktestDateRange
 from .market import MarketCredential
 from .order import OrderStatus, OrderSide, OrderType, Order
 from .portfolio import PortfolioConfiguration, Portfolio, PortfolioSnapshot
-from .position import Position, PositionSnapshot
+from .position import Position, PositionSnapshot, PositionSize
 from .strategy_profile import StrategyProfile
 from .time_frame import TimeFrame
 from .time_interval import TimeInterval
 from .time_unit import TimeUnit
-from .trade import Trade, TradeStatus, TradeStopLoss, TradeTakeProfit, \
-    TradeRiskType
-from .trading_data_types import TradingDataType
-from .trading_time_frame import TradingTimeFrame
-from .date_range import DateRange
-from .market_data_type import MarketDataType
-from .data_source import DataSource
+from .trade import Trade, TradeStatus, TradeStopLoss, TradeTakeProfit
 from .snapshot_interval import SnapshotInterval
 from .event import Event
+from .data import DataSource, DataType
+from .risk_rules import TakeProfitRule, StopLossRule
 
 __all__ = [
     "OrderStatus",
@@ -27,28 +21,25 @@ __all__ = [
     "TimeFrame",
     "TimeInterval",
     "TimeUnit",
-    "TradingTimeFrame",
-    "TradingDataType",
     "PortfolioConfiguration",
     "Position",
     "Portfolio",
-    "BacktestResult",
     "PositionSnapshot",
     "PortfolioSnapshot",
     "StrategyProfile",
-    "BacktestPosition",
     "Trade",
     "MarketCredential",
     "TradeStatus",
-    "BacktestReportsEvaluation",
+    "DataType",
+    "AppMode",
+    "DataSource",
     "AppMode",
-    "BacktestDateRange",
-    "DateRange",
-    "MarketDataType",
     "TradeStopLoss",
     "TradeTakeProfit",
-    "TradeRiskType",
     "DataSource",
     "SnapshotInterval",
     "Event",
+    "PositionSize",
+    "StopLossRule",
+    "TakeProfitRule",
 ]

investing_algorithm_framework/domain/models/base_model.py

@@ -23,9 +23,3 @@ class BaseModel:
 
             if value is not None:
                 setattr(self, attr, value)
-
-    @staticmethod
-    def from_dict(data):
-        instance = BaseModel()
-        instance.update(data)
-        return instance

investing_algorithm_framework/domain/models/data/__init__.py

@@ -0,0 +1,7 @@
+from .data_source import DataSource
+from .data_type import DataType
+
+__all__ = [
+    "DataSource",
+    "DataType",
+]

investing_algorithm_framework/domain/models/data/data_source.py

@@ -0,0 +1,214 @@
+from dataclasses import dataclass
+from datetime import datetime, timezone, timedelta
+from typing import Union
+
+from dateutil import parser
+
+from investing_algorithm_framework.domain.models.time_frame import TimeFrame
+from .data_type import DataType
+
+
+@dataclass(frozen=True)
+class DataSource:
+    """
+    Base class for data sources.
+    """
+    identifier: str = None
+    data_provider_identifier: str = None
+    data_type: Union[DataType, str] = None
+    symbol: str = None
+    window_size: int = None
+    time_frame: Union[TimeFrame, str] = None
+    market: str = None
+    storage_path: str = None
+    pandas: bool = False
+    date: Union[datetime, None] = None
+    start_date: Union[datetime, None] = None
+    end_date: Union[datetime, None] = None
+    save: bool = False
+
+    def __post_init__(self):
+        # Convert data_type and time_frame to their respective enums if needed
+        if isinstance(self.data_type, str):
+            object.__setattr__(self, 'data_type',
+                               DataType.from_string(self.data_type))
+
+        if isinstance(self.time_frame, str):
+            object.__setattr__(self, 'time_frame',
+                               TimeFrame.from_string(self.time_frame))
+
+        start_date = self.start_date
+        end_date = self.end_date
+
+        # Parse the start_date if it is a string and
+        # make sure its set to timezone utc
+        if start_date is None:
+
+            if isinstance(self.start_date, str):
+                start_date = parser.parse(start_date)
+
+            if start_date is not None:
+                object.__setattr__(
+                    self,
+                    'start_date',
+                    start_date.replace(tzinfo=timezone.utc)
+                )
+
+        # Parse the end_date if it is a string and
+        # make sure its set to timezone utc
+        if end_date is None:
+
+            if isinstance(self.end_date, str):
+                end_date = parser.parse(end_date)
+
+            if end_date is not None:
+                object.__setattr__(
+                    self,
+                    'end_date',
+                    end_date.replace(tzinfo=timezone.utc)
+                )
+
+        if self.market is not None:
+            object.__setattr__(self, 'market', self.market.upper())
+
+        if self.symbol is not None:
+            object.__setattr__(self, 'symbol', self.symbol.upper())
+
+    def get_identifier(self):
+        """
+        Returns the identifier or creates a unique identifier for the
+        data source based on its attributes.
+        """
+
+        if self.identifier is not None:
+            return self.identifier
+
+        if DataType.OHLCV.equals(self.data_type):
+            return (f"{self.data_type.value}_{self.market}_"
+                    f"{self.symbol}_{self.time_frame.value}")
+
+        elif DataType.CUSTOM.equals(self.data_type):
+            identifier = "CUSTOM"
+
+            if self.symbol is not None:
+                identifier += f"_{self.symbol}"
+
+            if self.time_frame is not None:
+                identifier += f"_{self.time_frame.value}"
+
+            if self.market is not None:
+                identifier += f"_{self.market}"
+
+            if self.window_size is not None:
+                identifier += f"_{self.window_size}"
+
+            return identifier
+
+    def to_dict(self):
+        """
+        Converts the DataSource instance to a dictionary.
+        """
+        non_null_attributes = {
+            key: value for key, value in self.__dict__.items()
+            if value is not None
+        }
+        # Convert DataType and TimeFrame to their string representations
+        if self.data_type is not None:
+            non_null_attributes['data_type'] = self.data_type.value
+        if self.time_frame is not None:
+            non_null_attributes['time_frame'] = self.time_frame.value
+
+        return non_null_attributes
+
+    def __repr__(self):
+        return (
+            f"DataSource(identifier={self.identifier}, "
+            f"data_provider_identifier={self.data_provider_identifier}, "
+            f"data_type={self.data_type}, symbol={self.symbol}, "
+            f"window_size={self.window_size}, time_frame={self.time_frame}, "
+            f"market={self.market}, storage_path={self.storage_path}, "
+            f"pandas={self.pandas}, date={self.date}, "
+            f"start_date={self.start_date}, end_date={self.end_date}, "
+            f"save={self.save})"
+        )
+
+    def __eq__(self, other):
+        """
+        Compares two DataSource instances for equality.
+
+        OHLCV data sources are considered equal if they have:
+        - The same data_type (OHLCV), symbol, time_frame, and market.
+        - If no market and timeframe is specified, then
+            they are considered equal for the same symbol
+            and data_type.
+        """
+        if DataType.OHLCV.equals(self.data_type):
+
+            if other.time_frame is None and other.window_size is None:
+                return (self.data_type == other.data_type and
+                        self.symbol == other.symbol)
+            elif self.time_frame is None and self.window_size is None:
+                return (self.data_type == other.data_type and
+                        self.symbol == other.symbol)
+
+            return (self.time_frame == other.time_frame and
+                    self.market == other.market and
+                    self.symbol == other.symbol and
+                    self.data_type == other.data_type)
+
+        elif DataType.CUSTOM.equals(self.data_type):
+            return (self.data_type == other.data_type and
+                    self.symbol == other.symbol and
+                    self.window_size == other.window_size and
+                    self.time_frame == other.time_frame and
+                    self.market == other.market)
+
+        elif DataType.TICKER.equals(self.data_type):
+            return (self.data_type == other.data_type and
+                    self.symbol == other.symbol and
+                    self.market == other.market)
+
+        return False
+
+    def create_start_date_data(self, index_date: datetime) -> datetime:
+
+        if self.window_size is None or self.time_frame is None:
+            return index_date
+
+        return index_date - \
+            (self.window_size * timedelta(
+                minutes=self.time_frame.amount_of_minutes
+            ))
+
+    def get_number_of_required_data_points(
+        self, start_date: datetime, end_date: datetime
+    ) -> int:
+        """
+        Returns the number of data points required based on the given
+        attributes of the data source. If the required number of data points
+        can't be determined, it returns None.
+
+        E.g., for OHLCV data source, it
+        calculates the number of data points needed between the
+        start_date and end_date based on the time frame.
+
+        Args:
+            start_date (datetime): The start date for the data points.
+            end_date (datetime): The end date for the data points.
+
+        Returns:
+            int: The number of required data points, or None if it can't
+            be determined.
+        """
+
+        if self.time_frame is None:
+            return None
+
+        delta = end_date - start_date
+        total_minutes = delta.total_seconds() / 60
+        data_points = total_minutes / self.time_frame.amount_of_minutes
+
+        if self.window_size is not None:
+            data_points += self.window_size
+
+        return int(data_points)