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

investing_algorithm_framework/__init__.py

@@ -1,29 +1,56 @@
-from investing_algorithm_framework.app import App, Algorithm, \
+from .app import App, Algorithm, \
     TradingStrategy, StatelessAction, Task, AppHook, Context, \
-    add_html_report, add_metrics, BacktestReport, \
-    BacktestReportsEvaluation, pretty_print_trades, pretty_print_positions, \
-    pretty_print_orders, pretty_print_backtest
-from investing_algorithm_framework.domain import ApiException, \
-    TradingDataType, TradingTimeFrame, OrderType, OperationalException, \
-    OrderStatus, OrderSide, TimeUnit, TimeInterval, Order, Portfolio, \
-    Position, TimeFrame, BACKTESTING_INDEX_DATETIME, MarketCredential, \
-    PortfolioConfiguration, RESOURCE_DIRECTORY, \
-    Trade, OHLCVMarketDataSource, OrderBookMarketDataSource, SYMBOLS, \
-    TickerMarketDataSource, MarketService, \
-    RESERVED_BALANCES, APP_MODE, AppMode, DATETIME_FORMAT, \
-    BacktestDateRange, convert_polars_to_pandas, \
-    DateRange, DEFAULT_LOGGING_CONFIG, \
-    BacktestResult, TradeStatus, MarketDataType, TradeRiskType, \
+    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
-from investing_algorithm_framework.infrastructure import \
-    CCXTOrderBookMarketDataSource, CCXTOHLCVMarketDataSource, \
-    CCXTTickerMarketDataSource, CSVOHLCVMarketDataSource, \
-    CSVTickerMarketDataSource, AzureBlobStorageStateHandler, \
-    PandasOHLCVBacktestMarketDataSource, PandasOHLCVMarketDataSource, \
+    SnapshotInterval, AWS_S3_STATE_BUCKET_NAME, BacktestEvaluationFocus
+from .infrastructure import AzureBlobStorageStateHandler, \
+    CSVOHLCVDataProvider, CCXTOHLCVDataProvider, PandasOHLCVDataProvider, \
     AWSS3StorageStateHandler
 from .create_app import create_app
 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",
@@ -32,8 +59,6 @@ __all__ = [
     "AppHook",
     "create_app",
     "ApiException",
-    "TradingDataType",
-    "TradingTimeFrame",
     "OrderType",
     "OrderStatus",
     "OrderSide",
@@ -47,36 +72,21 @@ __all__ = [
     "StatelessAction",
     "Task",
     "pretty_print_backtest",
-    "BACKTESTING_INDEX_DATETIME",
+    "INDEX_DATETIME",
     "Trade",
     "TimeFrame",
-    "CCXTOrderBookMarketDataSource",
-    "CCXTTickerMarketDataSource",
-    "CCXTOHLCVMarketDataSource",
-    "OHLCVMarketDataSource",
-    "OrderBookMarketDataSource",
-    "TickerMarketDataSource",
-    "CSVOHLCVMarketDataSource",
-    "CSVTickerMarketDataSource",
     "MarketCredential",
-    "MarketService",
     "OperationalException",
-    "BacktestReportsEvaluation",
-    "SYMBOLS",
-    "RESERVED_BALANCES",
     "APP_MODE",
     "AppMode",
     "DATETIME_FORMAT",
-    "BacktestResult",
+    "Backtest",
     "BacktestDateRange",
     "convert_polars_to_pandas",
-    "DateRange",
     "AzureBlobStorageStateHandler",
     "DEFAULT_LOGGING_CONFIG",
     "BacktestReport",
     "TradeStatus",
-    "MarketDataType",
-    "TradeRiskType",
     "Context",
     "APPLICATION_DIRECTORY",
     "download",
@@ -86,11 +96,104 @@ __all__ = [
     "DataSource",
     "OrderExecutor",
     "PortfolioProvider",
-    "PandasOHLCVBacktestMarketDataSource",
-    "PandasOHLCVMarketDataSource",
     "SnapshotInterval",
-    "add_metrics",
     "add_html_report",
     "AWSS3StorageStateHandler",
-    "AWS_S3_STATE_BUCKET_NAME"
+    "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

@@ -5,9 +5,16 @@ 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, add_metrics, \
-    BacktestReport, pretty_print_backtest, BacktestReportsEvaluation, \
-    pretty_print_trades, pretty_print_positions, pretty_print_orders
+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__ = [
@@ -20,11 +27,21 @@ __all__ = [
     "AppHook",
     "Context",
     "add_html_report",
-    "add_metrics",
     "BacktestReport",
     "pretty_print_backtest",
-    "BacktestReportsEvaluation",
     "pretty_print_trades",
     "pretty_print_positions",
-    "pretty_print_orders"
+    "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/algorithm.py

@@ -6,7 +6,7 @@ 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, \
-    MarketDataSource
+    DataSource
 
 logger = logging.getLogger("investing_algorithm_framework")
 
@@ -32,8 +32,9 @@ class Algorithm:
         strategy=None,
         strategies=None,
         tasks: List = None,
-        data_sources: List[MarketDataSource] = None,
-        on_strategy_run_hooks=None
+        data_sources: List[DataSource] = None,
+        on_strategy_run_hooks=None,
+        metadata=None
     ):
         self._name = name
         self._context = {}
@@ -46,6 +47,7 @@ class Algorithm:
         self._tasks = []
         self._data_sources = []
         self._on_strategy_run_hooks = []
+        self.metadata = metadata
 
         if data_sources is not None:
             self._data_sources = data_sources
@@ -210,9 +212,6 @@ class Algorithm:
                 "with the same id in the algorithm"
             )
 
-        if strategy.market_data_sources is not None:
-            self.add_data_sources(strategy.market_data_sources)
-
         self._strategies.append(strategy)
 
     def add_task(self, task):
@@ -221,41 +220,6 @@ class Algorithm:
 
         self._tasks.append(task)
 
-    def add_data_source(self, data_source) -> None:
-        """
-        Function to add a data source to the app. The data source should
-        be an instance of DataSource.
-
-        Args:
-            data_source: Instance of DataSource
-
-        Returns:
-            None
-        """
-        if inspect.isclass(data_source):
-            if not issubclass(data_source, MarketDataSource):
-                raise OperationalException(
-                    "Data source should be an instance of MarketDataSource"
-                )
-
-            data_source = data_source()
-
-        self.data_sources.append(data_source)
-
-    def add_data_sources(self, data_sources) -> None:
-        """
-        Function to add a list of data sources to the app. The data sources
-        should be instances of DataSource.
-
-        Args:
-            data_sources: List of DataSource
-
-        Returns:
-            None
-        """
-        for data_source in data_sources:
-            self.add_data_source(data_source)
-
     def add_on_strategy_run_hook(self, app_hook):
         """
         Function to add a hook that will be called when a strategy is run.

investing_algorithm_framework/app/algorithm/algorithm_factory.py

@@ -56,7 +56,6 @@ class AlgorithmFactory:
         strategies=None,
         tasks=None,
         on_strategy_run_hooks=None,
-        data_sources=None
     ) -> Algorithm:
         """
         Create an instance of the specified algorithm type.
@@ -69,7 +68,6 @@ class AlgorithmFactory:
             tasks (list): List of Task instances.
             on_strategy_run_hooks (list): List of hooks to be called
                 when a strategy is run.
-            data_sources (list): List of MarketDataSource instances.
 
         Returns:
             Algorithm: Instance of Algorithm.
@@ -78,21 +76,30 @@ class AlgorithmFactory:
         strategies = strategies or []
         tasks = tasks or []
         on_strategy_run_hooks = on_strategy_run_hooks or []
-        data_sources = data_sources or []
+        data_sources = []
 
-        if algorithm is not None:
+        if algorithm is not None and isinstance(algorithm, Algorithm):
+            if name is None:
+                name = algorithm.name
 
-            for task in tasks:
-                algorithm.add_task(task)
+            strategies.extend(algorithm.strategies)
+            tasks.extend(algorithm.tasks)
+            on_strategy_run_hooks.extend(algorithm.on_strategy_run_hooks)
 
-            for app_hook in on_strategy_run_hooks:
-                algorithm.add_on_strategy_run_hook(app_hook)
+            if hasattr(algorithm, 'data_sources'):
+                data_sources.extend(algorithm.data_sources)
 
-            return algorithm
+        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,
-            strategy=strategy,
             strategies=strategies,
             tasks=tasks,
             on_strategy_run_hooks=on_strategy_run_hooks,

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

investing_algorithm_framework/app/analysis/backtest_data_ranges.py

@@ -0,0 +1,121 @@
+import pandas as pd
+from typing import List, Union
+
+from datetime import timezone
+from investing_algorithm_framework.domain import BacktestDateRange, \
+    OperationalException
+
+
+def select_backtest_date_ranges(
+    df: pd.DataFrame, window: Union[str, int] = '365D'
+) -> List[BacktestDateRange]:
+    """
+    Identifies the best upturn, worst downturn, and sideways periods
+    for the given window duration. This allows you to quickly select
+    interesting periods for backtesting.
+
+    Args:
+        df (pd.DataFrame): DataFrame with a DateTime index
+            and 'Close' column.
+        window (Union[str, int]): Duration of the window
+            to analyze. Can be a string like '365D' or an
+            integer representing days.
+
+    Returns:
+        List[BacktestDateRange]: List of BacktestDateRange
+            objects representing the best upturn, worst
+            downturn, and most sideways periods.
+    """
+    df = df.copy()
+    df = df.sort_index()
+
+    if isinstance(window, int):
+        window = pd.Timedelta(days=window)
+    elif isinstance(window, str):
+        window = pd.to_timedelta(window)
+    else:
+        raise OperationalException("window must be a string or integer")
+
+    # Check if the window is larger than the DataFrame
+    if len(df) == 0:
+        raise OperationalException("DataFrame is empty")
+
+    if df.index[-1] - df.index[0] < window:
+        raise OperationalException(
+            "Window duration is larger than the data duration"
+        )
+
+    if len(df) < 2 or df.index[-1] - df.index[0] < window:
+        raise OperationalException(
+            "DataFrame must contain at least two rows and span "
+            "the full window duration"
+        )
+
+    best_upturn = {
+        "name": "UpTurn", "return": float('-inf'), "start": None, "end": None
+    }
+    worst_downturn = {
+        "name": "DownTurn", "return": float('inf'), "start": None, "end": None
+    }
+    most_sideways = {
+        "name": "SideWays",
+        "volatility": float('inf'),
+        "return": None,
+        "start": None,
+        "end": None
+    }
+
+    for i in range(len(df)):
+        start_time = df.index[i]
+        end_time = start_time + window
+        window_df = df[(df.index >= start_time) & (df.index <= end_time)]
+
+        if len(window_df) < 2 or (window_df.index[-1] - start_time) < window:
+            continue
+
+        start_price = window_df['Close'].iloc[0]
+        end_price = window_df['Close'].iloc[-1]
+        ret = (end_price / start_price) - 1  # relative return
+        volatility = window_df['Close'].std()
+
+        # Ensure datetime for BacktestDateRange and with timezone utc
+        start_time = pd.Timestamp(start_time).to_pydatetime()
+        start_time = start_time.replace(tzinfo=timezone.utc)
+        end_time = pd.Timestamp(window_df.index[-1]).to_pydatetime()
+        end_time = end_time.replace(tzinfo=timezone.utc)
+
+        if ret > best_upturn["return"]:
+            best_upturn.update(
+                {"return": ret, "start": start_time, "end": end_time}
+            )
+
+        if ret < worst_downturn["return"]:
+            worst_downturn.update(
+                {"return": ret, "start": start_time, "end": end_time}
+            )
+
+        if volatility < most_sideways["volatility"]:
+            most_sideways.update({
+                "return": ret,
+                "volatility": volatility,
+                "start": start_time,
+                "end": end_time
+            })
+
+    return [
+        BacktestDateRange(
+            start_date=best_upturn['start'],
+            end_date=best_upturn['end'],
+            name=best_upturn['name']
+        ),
+        BacktestDateRange(
+            start_date=worst_downturn['start'],
+            end_date=worst_downturn['end'],
+            name=worst_downturn['name']
+        ),
+        BacktestDateRange(
+            start_date=most_sideways['start'],
+            end_date=most_sideways['end'],
+            name=most_sideways['name']
+        )
+    ]

investing_algorithm_framework/app/analysis/backtest_utils.py

@@ -0,0 +1,107 @@
+import os
+from pathlib import Path
+from typing import List, Union, Callable
+from logging import getLogger
+from random import Random
+
+from investing_algorithm_framework.domain import Backtest
+
+
+logger = getLogger("investing_algorithm_framework")
+
+
+def save_backtests_to_directory(
+    backtests: List[Backtest],
+    directory_path: Union[str, Path],
+    dir_name_generation_function: Callable[[Backtest], str] = None,
+    filter_function: Callable[[Backtest], bool] = None
+) -> None:
+    """
+    Saves a list of Backtest objects to the specified directory.
+
+    Args:
+        backtests (List[Backtest]): List of Backtest objects to save.
+        directory_path (str): Path to the directory where backtests
+            will be saved.
+        dir_name_generation_function (Callable[[Backtest], str], optional):
+            A function that takes a Backtest object as input and returns
+            a string to be used as the directory name for that backtest.
+            If not provided, the backtest's metadata 'id' will be used.
+            Defaults to None.
+        filter_function (Callable[[Backtest], bool], optional): A function
+            that takes a Backtest object as input and returns True if the
+            backtest should be saved. Defaults to None.
+
+    Returns:
+        None
+    """
+
+    if not os.path.exists(directory_path):
+        os.makedirs(directory_path)
+
+    for backtest in backtests:
+
+        if filter_function is not None:
+            if not filter_function(backtest):
+                continue
+
+        if dir_name_generation_function is not None:
+            dir_name = dir_name_generation_function(backtest)
+        else:
+            # Check if there is an ID in the backtest metadata
+            dir_name = backtest.metadata.get('id', None)
+
+        if dir_name is None:
+            logger.warning(
+                "Backtest metadata does not contain an 'id' field. "
+                "Generating a random directory name."
+            )
+            dir_name = str(Random().randint(100000, 999999))
+
+        backtest.save(os.path.join(directory_path, dir_name))
+
+
+def load_backtests_from_directory(
+    directory_path: Union[str, Path],
+    filter_function: Callable[[Backtest], bool] = None
+) -> List[Backtest]:
+    """
+    Loads Backtest objects from the specified directory.
+
+    Args:
+        directory_path (str): Path to the directory from which backtests
+            will be loaded.
+        filter_function (Callable[[Backtest], bool], optional): A function
+            that takes a Backtest object as input and returns True if the
+            backtest should be included in the result. Defaults to None.
+
+    Returns:
+        List[Backtest]: List of loaded Backtest objects.
+    """
+
+    backtests = []
+
+    if not os.path.exists(directory_path):
+        logger.warning(
+            f"Directory {directory_path} does not exist. "
+            "No backtests loaded."
+        )
+        return backtests
+
+    for file_name in os.listdir(directory_path):
+        file_path = os.path.join(directory_path, file_name)
+
+        try:
+            backtest = Backtest.open(file_path)
+
+            if filter_function is not None:
+                if not filter_function(backtest):
+                    continue
+
+            backtests.append(backtest)
+        except Exception as e:
+            logger.error(
+                f"Failed to load backtest from {file_path}: {e}"
+            )
+
+    return backtests