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

investing_algorithm_framework/__init__.py

@@ -1,24 +1,56 @@
-from investing_algorithm_framework.app import App, Algorithm, AppHook
-from investing_algorithm_framework.app import TradingStrategy, \
-    StatelessAction, Task
-from investing_algorithm_framework.domain import ApiException, \
-    TradingDataType, TradingTimeFrame, OrderType, OperationalException, \
-    OrderStatus, OrderSide, Config, TimeUnit, TimeInterval, Order, Portfolio, \
-    Position, TimeFrame, BACKTESTING_INDEX_DATETIME, MarketCredential, \
-    PortfolioConfiguration, RESOURCE_DIRECTORY, pretty_print_backtest, \
-    Trade, OHLCVMarketDataSource, OrderBookMarketDataSource, SYMBOLS, \
-    TickerMarketDataSource, MarketService, BacktestReportsEvaluation, \
-    pretty_print_backtest_reports_evaluation, load_backtest_reports, \
-    RESERVED_BALANCES, APP_MODE, AppMode, DATETIME_FORMAT, \
-    load_backtest_report, BacktestDateRange, create_ema_graph, \
-    create_prices_graph, create_rsi_graph, get_price_efficiency_ratio
-from investing_algorithm_framework.infrastructure import \
-    CCXTOrderBookMarketDataSource, CCXTOHLCVMarketDataSource, \
-    CCXTTickerMarketDataSource, CSVOHLCVMarketDataSource, \
-    CSVTickerMarketDataSource
+from .app import App, Algorithm, \
+    TradingStrategy, StatelessAction, Task, AppHook, Context, \
+    add_html_report, BacktestReport, save_backtests_to_directory, \
+    pretty_print_trades, pretty_print_positions, \
+    pretty_print_orders, pretty_print_backtest, select_backtest_date_ranges, \
+    get_equity_curve_with_drawdown_chart, load_backtests_from_directory, \
+    get_rolling_sharpe_ratio_chart, rank_results, \
+    get_monthly_returns_heatmap_chart, create_weights, \
+    get_yearly_returns_bar_chart, get_entry_and_exit_signals, \
+    get_ohlcv_data_completeness_chart, get_equity_curve_chart
+from .domain import ApiException, combine_backtests, PositionSize, \
+    OrderType, OperationalException, OrderStatus, OrderSide, \
+    TimeUnit, TimeInterval, Order, Portfolio, Backtest, DataError, \
+    Position, TimeFrame, INDEX_DATETIME, MarketCredential, TakeProfitRule, \
+    PortfolioConfiguration, RESOURCE_DIRECTORY, AWS_LAMBDA_LOGGING_CONFIG, \
+    Trade, APP_MODE, AppMode, DATETIME_FORMAT, \
+    BacktestDateRange, convert_polars_to_pandas, BacktestRun, \
+    DEFAULT_LOGGING_CONFIG, DataType, DataProvider, StopLossRule, \
+    TradeStatus, generate_backtest_summary_metrics, \
+    APPLICATION_DIRECTORY, DataSource, OrderExecutor, PortfolioProvider, \
+    SnapshotInterval, AWS_S3_STATE_BUCKET_NAME, BacktestEvaluationFocus
+from .infrastructure import AzureBlobStorageStateHandler, \
+    CSVOHLCVDataProvider, CCXTOHLCVDataProvider, PandasOHLCVDataProvider, \
+    AWSS3StorageStateHandler
 from .create_app import create_app
-from investing_algorithm_framework.services import \
-    create_trade_exit_markers_chart, create_trade_entry_markers_chart
+from .download_data import download
+from .services import get_annual_volatility, get_sortino_ratio, \
+    get_drawdown_series, get_max_drawdown, get_equity_curve, \
+    get_price_efficiency_ratio, get_sharpe_ratio, \
+    get_profit_factor, get_cumulative_profit_factor_series, \
+    get_rolling_profit_factor_series, get_cagr, \
+    get_standard_deviation_returns, get_standard_deviation_downside_returns, \
+    get_max_drawdown_absolute, get_total_return, get_exposure_ratio, \
+    get_average_trade_duration, get_win_rate, get_win_loss_ratio, \
+    get_calmar_ratio, get_trade_frequency, get_yearly_returns, \
+    get_monthly_returns, get_best_year, get_best_month, get_worst_year, \
+    get_worst_month, get_best_trade, get_worst_trade, \
+    get_average_yearly_return, get_average_trade_gain, \
+    get_average_trade_loss, get_average_monthly_return, \
+    get_percentage_winning_months, get_max_drawdown_duration, \
+    get_max_daily_drawdown, get_trades_per_day, \
+    get_trades_per_year, get_average_monthly_return_losing_months, \
+    get_average_monthly_return_winning_months, get_percentage_winning_years, \
+    get_rolling_sharpe_ratio, create_backtest_metrics, get_total_growth, \
+    get_total_loss, get_cumulative_exposure, get_median_trade_return, \
+    get_average_trade_return, get_risk_free_rate_us, get_cumulative_return, \
+    get_cumulative_return_series, get_current_average_trade_return, \
+    get_current_average_trade_gain, get_current_average_trade_duration, \
+    get_current_average_trade_loss, get_negative_trades, \
+    get_positive_trades, get_number_of_trades, get_current_win_rate, \
+    get_current_win_loss_ratio, create_backtest_metrics_for_backtest, \
+    TradeTakeProfitService, TradeStopLossService
+
 
 __all__ = [
     "Algorithm",
@@ -27,12 +59,9 @@ __all__ = [
     "AppHook",
     "create_app",
     "ApiException",
-    "TradingDataType",
-    "TradingTimeFrame",
     "OrderType",
     "OrderStatus",
     "OrderSide",
-    "Config",
     "PortfolioConfiguration",
     "TimeUnit",
     "TimeInterval",
@@ -43,34 +72,128 @@ __all__ = [
     "StatelessAction",
     "Task",
     "pretty_print_backtest",
-    "BACKTESTING_INDEX_DATETIME",
+    "INDEX_DATETIME",
     "Trade",
     "TimeFrame",
-    "CCXTOrderBookMarketDataSource",
-    "CCXTTickerMarketDataSource",
-    "CCXTOHLCVMarketDataSource",
-    "OHLCVMarketDataSource",
-    "OrderBookMarketDataSource",
-    "TickerMarketDataSource",
-    "CSVOHLCVMarketDataSource",
-    "CSVTickerMarketDataSource",
     "MarketCredential",
-    "MarketService",
     "OperationalException",
-    "pretty_print_backtest_reports_evaluation",
-    "BacktestReportsEvaluation",
-    "load_backtest_reports",
-    "SYMBOLS",
-    "RESERVED_BALANCES",
     "APP_MODE",
     "AppMode",
     "DATETIME_FORMAT",
-    "load_backtest_report",
+    "Backtest",
     "BacktestDateRange",
-    "create_trade_exit_markers_chart",
-    "create_trade_entry_markers_chart",
-    "create_ema_graph",
-    "create_prices_graph",
-    "create_rsi_graph",
-    "get_price_efficiency_ratio"
+    "convert_polars_to_pandas",
+    "AzureBlobStorageStateHandler",
+    "DEFAULT_LOGGING_CONFIG",
+    "BacktestReport",
+    "TradeStatus",
+    "Context",
+    "APPLICATION_DIRECTORY",
+    "download",
+    "pretty_print_orders",
+    "pretty_print_trades",
+    "pretty_print_positions",
+    "DataSource",
+    "OrderExecutor",
+    "PortfolioProvider",
+    "SnapshotInterval",
+    "add_html_report",
+    "AWSS3StorageStateHandler",
+    "AWS_S3_STATE_BUCKET_NAME",
+    "AWS_LAMBDA_LOGGING_CONFIG",
+    'select_backtest_date_ranges',
+    'DataType',
+    'CSVOHLCVDataProvider',
+    "CCXTOHLCVDataProvider",
+    "DataProvider",
+    "get_annual_volatility",
+    "get_sortino_ratio",
+    "get_drawdown_series",
+    "get_max_drawdown",
+    "get_equity_curve",
+    "get_price_efficiency_ratio",
+    "get_sharpe_ratio",
+    "get_profit_factor",
+    "get_cumulative_profit_factor_series",
+    "get_rolling_profit_factor_series",
+    "get_sharpe_ratio",
+    "get_cagr",
+    "get_standard_deviation_returns",
+    "get_standard_deviation_downside_returns",
+    "get_max_drawdown_absolute",
+    "get_total_return",
+    "get_exposure_ratio",
+    "get_cumulative_exposure",
+    "get_average_trade_duration",
+    "get_win_rate",
+    "get_win_loss_ratio",
+    "get_calmar_ratio",
+    "get_trade_frequency",
+    "get_yearly_returns",
+    "get_monthly_returns",
+    "get_best_year",
+    "get_best_month",
+    "get_worst_year",
+    "get_worst_month",
+    "get_best_trade",
+    "get_worst_trade",
+    "get_average_yearly_return",
+    "get_average_trade_gain",
+    "get_average_trade_loss",
+    "get_average_monthly_return",
+    "get_percentage_winning_months",
+    "get_average_trade_duration",
+    "get_trade_frequency",
+    "get_win_rate",
+    "get_win_loss_ratio",
+    "get_calmar_ratio",
+    "get_max_drawdown_absolute",
+    "get_max_drawdown_duration",
+    "get_max_daily_drawdown",
+    "get_trades_per_day",
+    "get_trades_per_year",
+    "get_average_monthly_return_losing_months",
+    "get_average_monthly_return_winning_months",
+    "get_percentage_winning_years",
+    "get_rolling_sharpe_ratio",
+    "create_backtest_metrics",
+    "PandasOHLCVDataProvider",
+    "get_equity_curve_with_drawdown_chart",
+    "get_rolling_sharpe_ratio_chart",
+    "get_monthly_returns_heatmap_chart",
+    "get_yearly_returns_bar_chart",
+    "get_ohlcv_data_completeness_chart",
+    "rank_results",
+    "create_weights",
+    "get_entry_and_exit_signals",
+    "BacktestEvaluationFocus",
+    "combine_backtests",
+    "PositionSize",
+    "get_median_trade_return",
+    "get_average_trade_return",
+    "get_risk_free_rate_us",
+    "get_cumulative_return",
+    "get_cumulative_return_series",
+    "get_total_loss",
+    "get_total_growth",
+    "generate_backtest_summary_metrics",
+    "get_equity_curve_chart",
+    "get_current_win_rate",
+    "get_current_win_loss_ratio",
+    "get_current_average_trade_loss",
+    "get_current_average_trade_duration",
+    "get_current_average_trade_gain",
+    "get_current_average_trade_return",
+    "get_negative_trades",
+    "get_positive_trades",
+    "get_number_of_trades",
+    "BacktestRun",
+    "load_backtests_from_directory",
+    "save_backtests_to_directory",
+    "DataError",
+    "create_backtest_metrics_for_backtest",
+    "TakeProfitRule",
+    "StopLossRule",
+    "TradeStopLossService",
+    "TradeTakeProfitService"
 ]

investing_algorithm_framework/app/__init__.py

@@ -4,6 +4,18 @@ from investing_algorithm_framework.app.strategy import TradingStrategy
 from investing_algorithm_framework.app.task import Task
 from investing_algorithm_framework.app.web import create_flask_app
 from .algorithm import Algorithm
+from .context import Context
+from .reporting import add_html_report, \
+    BacktestReport, pretty_print_backtest, pretty_print_trades, \
+    pretty_print_positions, pretty_print_orders, \
+    get_equity_curve_with_drawdown_chart, \
+    get_rolling_sharpe_ratio_chart, \
+    get_monthly_returns_heatmap_chart, \
+    get_yearly_returns_bar_chart, get_equity_curve_chart, \
+    get_ohlcv_data_completeness_chart, get_entry_and_exit_signals
+from .analysis import select_backtest_date_ranges, rank_results, \
+    create_weights, load_backtests_from_directory, save_backtests_to_directory
+
 
 __all__ = [
     "Algorithm",
@@ -12,5 +24,24 @@ __all__ = [
     "TradingStrategy",
     "StatelessAction",
     "Task",
-    "AppHook"
+    "AppHook",
+    "Context",
+    "add_html_report",
+    "BacktestReport",
+    "pretty_print_backtest",
+    "pretty_print_trades",
+    "pretty_print_positions",
+    "pretty_print_orders",
+    "select_backtest_date_ranges",
+    "get_equity_curve_with_drawdown_chart",
+    "get_rolling_sharpe_ratio_chart",
+    "get_monthly_returns_heatmap_chart",
+    "get_yearly_returns_bar_chart",
+    "get_ohlcv_data_completeness_chart",
+    "rank_results",
+    "create_weights",
+    "get_entry_and_exit_signals",
+    "get_equity_curve_chart",
+    "load_backtests_from_directory",
+    "save_backtests_to_directory"
 ]

investing_algorithm_framework/app/algorithm/__init__.py

@@ -0,0 +1,7 @@
+from .algorithm_factory import AlgorithmFactory
+from .algorithm import Algorithm
+
+__all__ = [
+    "AlgorithmFactory",
+    "Algorithm"
+]

investing_algorithm_framework/app/algorithm/algorithm.py

@@ -0,0 +1,239 @@
+import inspect
+import logging
+import re
+from typing import List
+
+from investing_algorithm_framework.app.app_hook import AppHook
+from investing_algorithm_framework.app.strategy import TradingStrategy
+from investing_algorithm_framework.domain import OperationalException, \
+    DataSource
+
+logger = logging.getLogger("investing_algorithm_framework")
+
+
+class Algorithm:
+    """
+    Class to represent an algorithm. An algorithm is a collection of
+    strategies that are executed in a specific order.
+
+    Attributes:
+        _name: The name of the algorithm. It should be a string and
+            can only contain letters and numbers.
+        _description: The description of the algorithm. It should be a string.
+        _strategies: A list of strategies that are part of the algorithm.
+        _tasks: A list of tasks that are part of the algorithm.
+        _data_sources: A list of data sources that are part of the algorithm.
+        _on_strategy_run_hooks: A list of hooks that will be called when a
+    """
+    def __init__(
+        self,
+        name: str = None,
+        description: str = None,
+        strategy=None,
+        strategies=None,
+        tasks: List = None,
+        data_sources: List[DataSource] = None,
+        on_strategy_run_hooks=None,
+        metadata=None
+    ):
+        self._name = name
+        self._context = {}
+        self._description = None
+
+        if description is not None:
+            self._description = description
+
+        self._strategies = []
+        self._tasks = []
+        self._data_sources = []
+        self._on_strategy_run_hooks = []
+        self.metadata = metadata
+
+        if data_sources is not None:
+            self._data_sources = data_sources
+
+        if strategies is not None:
+            self.strategies = strategies
+
+        if tasks is not None:
+            self.tasks = tasks
+
+        if strategy is not None:
+            self.add_strategy(strategy, throw_exception=True)
+
+        if on_strategy_run_hooks is not None:
+            for hook in on_strategy_run_hooks:
+                self.add_on_strategy_run_hook(hook)
+
+    @staticmethod
+    def _validate_name(name):
+        """
+        Function to validate the name of the algorithm. This function
+        will check if the name of the algorithm is a string and raise
+        an exception if it is not.
+
+        Name can only contain letters, numbers
+
+        Parameters:
+            name: The name of the algorithm
+
+        Returns:
+            None
+        """
+        if not isinstance(name, str):
+            raise OperationalException(
+                "The name of the algorithm must be a string"
+            )
+
+        pattern = re.compile(r"^[a-zA-Z0-9]*$")
+
+        if not pattern.match(name):
+            raise OperationalException(
+                "The name of the algorithm can only contain" +
+                " letters and numbers"
+            )
+
+        illegal_chars = r"[\/:*?\"<>|]"
+
+        if re.search(illegal_chars, name):
+            raise OperationalException(
+                f"Illegal characters detected in algorithm: {name}. "
+                f"Illegal characters: / \\ : * ? \" < > |"
+            )
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, name):
+        Algorithm._validate_name(name)
+        self._name = name
+
+    @property
+    def data_sources(self):
+        return self._data_sources
+
+    @data_sources.setter
+    def data_sources(self, data_sources):
+        self._data_sources = data_sources
+
+    @property
+    def description(self):
+        """
+        Function to get the description of the algorithm
+        """
+        return self._description
+
+    @property
+    def strategies(self):
+        return self._strategies
+
+    @property
+    def on_strategy_run_hooks(self):
+        return self._on_strategy_run_hooks
+
+    @strategies.setter
+    def strategies(self, strategies):
+
+        for strategy in strategies:
+            self.add_strategy(strategy)
+
+    @property
+    def tasks(self):
+        return self._tasks
+
+    @tasks.setter
+    def tasks(self, tasks):
+
+        for task in tasks:
+            self.add_task(task)
+
+    def get_strategy(self, strategy_id):
+        for strategy in self._strategies:
+            if strategy.worker_id == strategy_id:
+                return strategy
+
+        return None
+
+    def get_strategies(self):
+
+        if self._strategies is None:
+            raise OperationalException(
+                "No strategies have been added to the algorithm"
+            )
+        return self._strategies
+
+    def add_strategy(self, strategy, throw_exception=True) -> None:
+        """
+        Function to add a strategy to the algorithm. The strategy should be an
+        instance of TradingStrategy or a subclass based on the TradingStrategy
+        class.
+
+        Args:
+            strategy: Instance of TradingStrategy
+            throw_exception: Flag to allow for throwing an exception when
+                the provided strategy is not inline with what the application
+                expects.
+
+        Returns:
+            None
+        """
+
+        if inspect.isclass(strategy):
+
+            if not issubclass(strategy, TradingStrategy):
+                raise OperationalException(
+                    "The strategy must be a subclass of TradingStrategy"
+                )
+
+            strategy = strategy()
+
+        if not isinstance(strategy, TradingStrategy):
+
+            if throw_exception:
+                raise OperationalException(
+                    "Strategy should be an instance of TradingStrategy"
+                )
+            else:
+                return
+
+        has_duplicates = False
+
+        for i in range(len(self._strategies)):
+            for j in range(i + 1, len(self._strategies)):
+                if self._strategies[i].worker_id == strategy.worker_id:
+                    has_duplicates = True
+                    break
+
+        if has_duplicates:
+            raise OperationalException(
+                "Can't add strategy, there already exists a strategy "
+                "with the same id in the algorithm"
+            )
+
+        self._strategies.append(strategy)
+
+    def add_task(self, task):
+        if inspect.isclass(task):
+            task = task()
+
+        self._tasks.append(task)
+
+    def add_on_strategy_run_hook(self, app_hook):
+        """
+        Function to add a hook that will be called when a strategy is run.
+
+        Args:
+            app_hook: The hook function to be added.
+        """
+        # Check if the app_hook inherits from AppHook
+        if inspect.isclass(app_hook) and not issubclass(app_hook, AppHook):
+            raise OperationalException(
+                "App hook should be an instance of AppHook"
+            )
+
+        if inspect.isclass(app_hook):
+            app_hook = app_hook()
+
+        self._on_strategy_run_hooks.append(app_hook)

investing_algorithm_framework/app/algorithm/algorithm_factory.py

@@ -0,0 +1,114 @@
+import re
+from .algorithm import Algorithm
+from investing_algorithm_framework.domain import OperationalException
+
+
+def validate_algorithm_name(name, illegal_chars=r"[\/:*?\"<>|]"):
+    """
+    Validate an algorithm name for illegal characters and throw an
+        exception if any are found.
+
+    Args:
+        name (str): The name to validate.
+        illegal_chars (str): A regex pattern for characters considered
+            illegal (default: r"[/:*?\"<>|]").
+
+    Raises:
+        ValueError: If illegal characters are found in the filename.
+    """
+    if re.search(illegal_chars, name):
+        raise OperationalException(
+            f"Illegal characters detected in filename: {name}. "
+            f"Illegal characters: {illegal_chars}"
+        )
+
+
+class AlgorithmFactory:
+    """
+    Factory class for creating an algorithm instance.
+    """
+
+    @staticmethod
+    def create_algorithm_name(algorithm):
+        """
+        Create a name for the algorithm based on its
+        strategies.
+
+        Args:
+            algorithm (Algorithm): Instance of Algorithm.
+
+        Returns:
+            str: Name of the algorithm.
+        """
+        first_strategy = algorithm.strategies[0] \
+            if algorithm.strategies else None
+
+        if first_strategy is not None:
+            return f"{first_strategy.__class__.__name__}"
+
+        return "DefaultAlgorithm"
+
+    @staticmethod
+    def create_algorithm(
+        name=None,
+        algorithm=None,
+        strategy=None,
+        strategies=None,
+        tasks=None,
+        on_strategy_run_hooks=None,
+    ) -> Algorithm:
+        """
+        Create an instance of the specified algorithm type.
+
+        Args:
+            name (str): Name of the algorithm.
+            algorithm (Algorithm): Instance of Algorithm to be used.
+            strategy (TradingStrategy): Single TradingStrategy instance.
+            strategies (list): List of TradingStrategy instances.
+            tasks (list): List of Task instances.
+            on_strategy_run_hooks (list): List of hooks to be called
+                when a strategy is run.
+
+        Returns:
+            Algorithm: Instance of Algorithm.
+        """
+        name = name
+        strategies = strategies or []
+        tasks = tasks or []
+        on_strategy_run_hooks = on_strategy_run_hooks or []
+        data_sources = []
+
+        if algorithm is not None and isinstance(algorithm, Algorithm):
+            if name is None:
+                name = algorithm.name
+
+            strategies.extend(algorithm.strategies)
+            tasks.extend(algorithm.tasks)
+            on_strategy_run_hooks.extend(algorithm.on_strategy_run_hooks)
+
+            if hasattr(algorithm, 'data_sources'):
+                data_sources.extend(algorithm.data_sources)
+
+        if strategy is not None:
+            strategies.append(strategy)
+            data_sources.extend(strategy.data_sources)
+
+        for strategy_entry in strategies:
+            if strategy_entry.data_sources is not None \
+                    and len(strategy_entry.data_sources):
+                data_sources.extend(strategy_entry.data_sources)
+
+        algorithm = Algorithm(
+            name=name,
+            strategies=strategies,
+            tasks=tasks,
+            on_strategy_run_hooks=on_strategy_run_hooks,
+            data_sources=data_sources
+        )
+
+        if algorithm.name is None:
+            algorithm.name = AlgorithmFactory.create_algorithm_name(algorithm)
+
+        # Validate the algorithm name
+        validate_algorithm_name(algorithm.name)
+        return algorithm

investing_algorithm_framework/app/analysis/__init__.py

@@ -0,0 +1,15 @@
+from .backtest_data_ranges import select_backtest_date_ranges
+from .ranking import rank_results, create_weights, combine_backtest_metrics
+from .permutation import create_ohlcv_permutation
+from .backtest_utils import load_backtests_from_directory, \
+    save_backtests_to_directory
+
+__all__ = [
+    "select_backtest_date_ranges",
+    "rank_results",
+    "create_weights",
+    "create_ohlcv_permutation",
+    "combine_backtest_metrics",
+    "load_backtests_from_directory",
+    "save_backtests_to_directory"
+]