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

investing_algorithm_framework/domain/constants.py

@@ -1,5 +1,4 @@
 # Framework constants
-FRAMEWORK_NAME = 'FRAMEWORK_NAME'
 ENVIRONMENT = "ENVIRONMENT"
 STATELESS = "STATELESS"
 
@@ -8,70 +7,46 @@ DATABASE_CONFIG = 'DATABASE_CONFIG'
 DATABASE_NAME = 'DATABASE_NAME'
 DATABASE_TYPE = 'DATABASE_TYPE'
 DATABASE_DIRECTORY_PATH = 'DATABASE_DIRECTORY_PATH'
+DATABASE_DIRECTORY_NAME = 'DATABASE_DIRECTORY_NAME'
 DATABASE_URL = 'DATABASE_URL'
 DEFAULT_DATABASE_NAME = "database"
 
-SYMBOLS = "SYMBOLS"
+APPLICATION_DIRECTORY = "APP_DIR"
 RESOURCE_DIRECTORY = "RESOURCE_DIRECTORY"
 BACKTEST_DATA_DIRECTORY_NAME = "BACKTEST_DATA_DIRECTORY_NAME"
+DATA_DIRECTORY = "DATA_DIRECTORY"
 LOG_LEVEL = 'LOG_LEVEL'
 BASE_DIR = 'BASE_DIR'
 SQLALCHEMY_DATABASE_URI = 'SQLALCHEMY_DATABASE_URI'
-SQLITE_INITIALIZED = "SQLITE_INITIALIZED"
 SQLALCHEMY_INITIALIZED = "SQLALCHEMY_INITIALIZED"
-RESERVED_BALANCES = "RESERVED_BALANCES"
 APP_MODE = "APP_MODE"
-BINANCE = "BINANCE"
 
-IDENTIFIER_QUERY_PARAM = "identifier"
-TARGET_SYMBOL_QUERY_PARAM = "target_symbol"
-TRADING_SYMBOL_QUERY_PARAM = "trading_symbol"
-ORDER_SIDE_QUERY_PARAM = "order_size"
-STATUS_QUERY_PARAM = "status"
-POSITION_SYMBOL_QUERY_PARAM = "position"
-SYMBOL_QUERY_PARAM = "symbol"
-TIME_FRAME_QUERY_PARAM = "time_frame"
-
-RESERVED_IDENTIFIERS = [
-    BINANCE
-]
-
-BINANCE_API_KEY = "binance_api_key"
-BINANCE_SECRET_KEY = "binance_secret_key"
 
 CHECK_PENDING_ORDERS = "CHECK_PENDING_ORDERS"
 RUN_STRATEGY = "RUN_STRATEGY"
 
 # Configuration
-TRADING_SYMBOL = "TRADING_SYMBOL"
-CCXT_ENABLED = "CCXT_ENABLED"
-API_KEY = "API_KEY"
-SECRET_KEY = "SECRET_KEY"
-MARKET = "MARKET"
-TRACK_PORTFOLIO_FROM = "TRACK_PORTFOLIO_FROM"
-SQLITE_ENABLED = "SQLITE_ENABLED"
-PORTFOLIOS = "PORTFOLIOS"
-STRATEGIES = "STRATEGIES"
-APPLICATION_CONFIGURED = "APPLICATION_CONFIGURED"
-ACTION = "ACTION"
-
 DEFAULT_PER_PAGE_VALUE = 10
 DEFAULT_PAGE_VALUE = 1
 ITEMIZE = 'itemize'
 ITEMIZED = 'itemized'
 PAGE = 'page'
 PER_PAGE = 'per_page'
-
-DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S"
-DATETIME_FORMAT_BACKTESTING = "%Y-%m-%d:%H:%M"
+DATETIME_FORMAT_BACKTESTING = "%Y-%m-%d-%H-%M"
 CCXT_DATETIME_FORMAT_WITH_TIMEZONE = "%Y-%m-%dT%H:%M:%S.%fZ"
 CCXT_DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S.%f"
+DEFAULT_DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S"
 BACKTESTING_FLAG = "BACKTESTING"
-BACKTESTING_INDEX_DATETIME = "BACKTESTING_INDEX_DATETIME"
+INDEX_DATETIME = "INDEX_DATETIME"
+LAST_SNAPSHOT_DATETIME = "LAST_SNAPSHOT_DATETIME"
 BACKTESTING_START_DATE = "BACKTESTING_START_DATE"
 BACKTESTING_END_DATE = "BACKTESTING_END_DATE"
-BACKTESTING_PENDING_ORDER_CHECK_INTERVAL \
-    = "BACKTESTING_PENDING_ORDER_CHECK_INTERVAL"
+BACKTESTING_INITIAL_AMOUNT = "BACKTESTING_INITIAL_AMOUNT"
 TICKER_DATA_TYPE = "TICKER"
 OHLCV_DATA_TYPE = "OHLCV"
 CURRENT_UTC_DATETIME = "CURRENT_UTC_DATETIME"
+SNAPSHOT_INTERVAL = "SNAPSHOT_INTERVAL"
+DATETIME_FORMAT = "DATETIME_FORMAT"
+DATETIME_FORMAT_FILE_NAME = "DATETIME_FORMAT_FILE_NAME"
+# Deployment
+AWS_S3_STATE_BUCKET_NAME = "AWS_S3_STATE_BUCKET_NAME"

investing_algorithm_framework/domain/data_provider.py

@@ -0,0 +1,334 @@
+from typing import List, Any, Union
+from abc import ABC, abstractmethod
+from datetime import datetime
+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):
+    """
+    Abstract base class for data providers. The DataProvider class
+    is responsible for fetching and preparing data for trading
+    algorithms.
+
+    Attributes:
+        data_type (DataType): The type of data to be
+            fetched (e.g., OHLCV, TICKER, CUSTOM_DATA).
+        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"]
+        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
+            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.
+        time_frame (Optional[str]): The time frame for the data. This is
+            useful for data providers that support multiple time frames.
+            Example: "1m", "5m", "1h", "1d"
+        window_size (Optional[int]): The window size for the data. This is
+            useful for data providers that support multiple window sizes.
+            Example: 100, 200, 500
+        storage_path (Optional[str]): The path to the storage location
+            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_provider_identifier: str = None,
+        data_type: str = None,
+        symbol: str = None,
+        market: str = None,
+        priority: int = 0,
+        time_frame=None,
+        window_size=None,
+        storage_path=None,
+        storage_directory=None,
+        config=None,
+    ):
+        """
+        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 = 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
+
+        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
+
+        # 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."
+            )
+
+        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):
+        """
+        Returns the market credentials for the data provider.
+        """
+        return self._market_credentials
+
+    @market_credentials.setter
+    def market_credentials(self, value: List):
+        """
+        Sets the market credentials for the data provider.
+        """
+        self._market_credentials = value
+
+    def get_credential(self, market: str):
+        """
+        Returns the credentials for the given market.
+        """
+        if self.market_credentials is None:
+            return None
+        for credential in self.market_credentials:
+            if credential.market == market:
+                return credential
+        return None
+
+    @property
+    def config(self):
+        return self._config
+
+    @config.setter
+    def config(self, value):
+        self._config = value
+
+    @abstractmethod
+    def has_data(
+        self,
+        data_source: DataSource,
+        start_date: datetime = None,
+        end_date: datetime = 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,
+        date: datetime = None,
+        start_date: datetime = None,
+        end_date: datetime = None,
+        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 prepare_backtest_data(
+        self,
+        backtest_start_date,
+        backtest_end_date,
+    ) -> 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,
+        backtest_index_date: datetime,
+        backtest_start_date: datetime = None,
+        backtest_end_date: datetime = None,
+        data_source: DataSource = None,
+    ) -> Any:
+        """
+        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/data_structures.py

@@ -1,6 +1,6 @@
 class PeekableQueue:
-    def __init__(self):
-        self.queue = []
+    def __init__(self, items=[]):
+        self.queue = items
         self.index = 0
 
     def enqueue(self, item):
@@ -24,6 +24,7 @@ class PeekableQueue:
     def __len__(self):
         return len(self.queue)
 
+    @property
     def size(self):
         return len(self.queue)
 

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)
@@ -60,3 +67,46 @@ class OperationalException(Exception):
             "status": "error",
             "message": self.error_message
         }
+
+
+class NetworkError(Exception):
+    """
+    Class NetworkError: Exception class indicating a problem occurred
+    during making a netwok request
+    """
+
+    def __init__(self, message) -> None:
+        super(NetworkError, self).__init__(message)
+        self.error_message = message
+
+    def to_response(self):
+        return {
+            "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,17 +1,17 @@
 from .app_mode import AppMode
-from .backtesting import BacktestReport, BacktestPosition, \
-    BacktestReportsEvaluation, 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
-from .trading_data_types import TradingDataType
-from .trading_time_frame import TradingTimeFrame
+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",
@@ -21,20 +21,25 @@ __all__ = [
     "TimeFrame",
     "TimeInterval",
     "TimeUnit",
-    "TradingTimeFrame",
-    "TradingDataType",
     "PortfolioConfiguration",
     "Position",
     "Portfolio",
-    "BacktestReport",
     "PositionSnapshot",
     "PortfolioSnapshot",
     "StrategyProfile",
-    "BacktestPosition",
     "Trade",
     "MarketCredential",
     "TradeStatus",
-    "BacktestReportsEvaluation",
+    "DataType",
     "AppMode",
-    "BacktestDateRange"
+    "DataSource",
+    "AppMode",
+    "TradeStopLoss",
+    "TradeTakeProfit",
+    "DataSource",
+    "SnapshotInterval",
+    "Event",
+    "PositionSize",
+    "StopLossRule",
+    "TakeProfitRule",
 ]

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",
+]