investing-algorithm-framework 6.9.6__tar.gz → 6.9.7__tar.gz

{investing_algorithm_framework-6.9.6 → investing_algorithm_framework-6.9.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: investing-algorithm-framework
-Version: 6.9.6
+Version: 6.9.7
 Summary: A framework for creating trading bots
 Author: MDUYN
 Requires-Python: >=3.10
@@ -126,7 +126,7 @@ from pyindicators import ema, rsi
 
 from investing_algorithm_framework import create_app, TimeUnit, Context, BacktestDateRange, \
     CCXTOHLCVMarketDataSource, CCXTTickerMarketDataSource, DEFAULT_LOGGING_CONFIG, \
-    TradingStrategy, SnapshotInterval, convert_polars_to_pandas
+    TradingStrategy, SnapshotInterval, convert_polars_to_pandas, BacktestReport
 
 load_dotenv()
 logging.config.dictConfig(DEFAULT_LOGGING_CONFIG)
@@ -205,9 +205,10 @@ app.add_strategy(MyStrategy)
 
 if __name__ == "__main__":
     # Run the backtest with a daily snapshot interval for end-of-day granular reporting
-    backtest_report = app.run_backtest(
+    backtest = app.run_backtest(
         backtest_date_range=date_range, initial_amount=100, snapshot_interval=SnapshotInterval.STRATEGY_ITERATION
     )
+    backtest_report = BacktestReport(backtests=[backtest])
     backtest_report.show()
 ```
 

{investing_algorithm_framework-6.9.6 → investing_algorithm_framework-6.9.7}/README.md

@@ -90,7 +90,7 @@ from pyindicators import ema, rsi
 
 from investing_algorithm_framework import create_app, TimeUnit, Context, BacktestDateRange, \
     CCXTOHLCVMarketDataSource, CCXTTickerMarketDataSource, DEFAULT_LOGGING_CONFIG, \
-    TradingStrategy, SnapshotInterval, convert_polars_to_pandas
+    TradingStrategy, SnapshotInterval, convert_polars_to_pandas, BacktestReport
 
 load_dotenv()
 logging.config.dictConfig(DEFAULT_LOGGING_CONFIG)
@@ -169,9 +169,10 @@ app.add_strategy(MyStrategy)
 
 if __name__ == "__main__":
     # Run the backtest with a daily snapshot interval for end-of-day granular reporting
-    backtest_report = app.run_backtest(
+    backtest = app.run_backtest(
         backtest_date_range=date_range, initial_amount=100, snapshot_interval=SnapshotInterval.STRATEGY_ITERATION
     )
+    backtest_report = BacktestReport(backtests=[backtest])
     backtest_report.show()
 ```
 

{investing_algorithm_framework-6.9.6 → investing_algorithm_framework-6.9.7}/investing_algorithm_framework/__init__.py

@@ -1,8 +1,8 @@
 from investing_algorithm_framework.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
+    add_html_report, BacktestReport, \
+    pretty_print_trades, pretty_print_positions, \
+    pretty_print_orders, pretty_print_backtest, select_backtest_date_ranges
 from investing_algorithm_framework.domain import ApiException, \
     TradingDataType, TradingTimeFrame, OrderType, OperationalException, \
     OrderStatus, OrderSide, TimeUnit, TimeInterval, Order, Portfolio, \
@@ -12,7 +12,7 @@ from investing_algorithm_framework.domain import ApiException, \
     TickerMarketDataSource, MarketService, \
     RESERVED_BALANCES, APP_MODE, AppMode, DATETIME_FORMAT, \
     BacktestDateRange, convert_polars_to_pandas, \
-    DateRange, DEFAULT_LOGGING_CONFIG, \
+    DEFAULT_LOGGING_CONFIG, \
     BacktestResult, TradeStatus, MarketDataType, TradeRiskType, \
     APPLICATION_DIRECTORY, DataSource, OrderExecutor, PortfolioProvider, \
     SnapshotInterval, AWS_S3_STATE_BUCKET_NAME
@@ -61,7 +61,6 @@ __all__ = [
     "MarketCredential",
     "MarketService",
     "OperationalException",
-    "BacktestReportsEvaluation",
     "SYMBOLS",
     "RESERVED_BALANCES",
     "APP_MODE",
@@ -70,7 +69,6 @@ __all__ = [
     "BacktestResult",
     "BacktestDateRange",
     "convert_polars_to_pandas",
-    "DateRange",
     "AzureBlobStorageStateHandler",
     "DEFAULT_LOGGING_CONFIG",
     "BacktestReport",
@@ -89,9 +87,9 @@ __all__ = [
     "PandasOHLCVBacktestMarketDataSource",
     "PandasOHLCVMarketDataSource",
     "SnapshotInterval",
-    "add_metrics",
     "add_html_report",
     "AWSS3StorageStateHandler",
     "AWS_S3_STATE_BUCKET_NAME",
-    "AWS_LAMBDA_LOGGING_CONFIG"
+    "AWS_LAMBDA_LOGGING_CONFIG",
+    'select_backtest_date_ranges'
 ]

{investing_algorithm_framework-6.9.6 → investing_algorithm_framework-6.9.7}/investing_algorithm_framework/app/__init__.py

@@ -5,9 +5,10 @@ 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
+from .analysis import select_backtest_date_ranges
 
 
 __all__ = [
@@ -20,11 +21,10 @@ __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"
 ]

investing_algorithm_framework-6.9.7/investing_algorithm_framework/app/analysis/__init__.py

@@ -0,0 +1,5 @@
+from .backtest_data_ranges import select_backtest_date_ranges
+
+__all__ = [
+    "select_backtest_date_ranges"
+]

investing_algorithm_framework-6.9.7/investing_algorithm_framework/app/analysis/backtest_data_ranges.py

@@ -0,0 +1,96 @@
+import pandas as pd
+from investing_algorithm_framework.domain import BacktestDateRange, \
+    OperationalException
+from typing import List, Union
+
+
+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.
+    """
+    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")
+
+    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
+        start_time = pd.Timestamp(start_time).to_pydatetime()
+        end_time = pd.Timestamp(window_df.index[-1]).to_pydatetime()
+
+        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-6.9.6 → investing_algorithm_framework-6.9.7}/investing_algorithm_framework/app/app.py

@@ -18,7 +18,7 @@ from investing_algorithm_framework.domain import DATABASE_NAME, TimeUnit, \
     SQLALCHEMY_DATABASE_URI, OperationalException, StateHandler, \
     BACKTESTING_START_DATE, BACKTESTING_END_DATE, APP_MODE, MarketCredential, \
     AppMode, BacktestDateRange, DATABASE_DIRECTORY_NAME, \
-    BACKTESTING_INITIAL_AMOUNT, SNAPSHOT_INTERVAL, \
+    BACKTESTING_INITIAL_AMOUNT, SNAPSHOT_INTERVAL, Backtest, \
     MarketDataSource, PortfolioConfiguration, SnapshotInterval, \
     PortfolioProvider, OrderExecutor, ImproperlyConfigured
 from investing_algorithm_framework.infrastructure import setup_sqlalchemy, \
@@ -42,7 +42,9 @@ class App:
 
     Attributes:
         container: The dependency container for the app. This is used
-            to store all the services and repositories for the app
+            to store all the services and repositories for the app.
+        algorithm: The algorithm to run. This is used to run the
+            trading bot.
         _flask_app: The flask app instance. This is used to run the
             web app.
         _state_handler: The state handler for the app. This is used
@@ -503,6 +505,7 @@ class App:
             try:
                 while strategy_orchestrator_service.running:
                     if number_of_iterations_since_last_orders_check == 30:
+                        logger.info("Checking pending orders")
                         number_of_iterations_since_last_orders_check = 1
 
                     strategy_orchestrator_service.run_pending_jobs()
@@ -514,8 +517,7 @@ class App:
             logger.error(e)
             raise e
         finally:
-            if strategy_orchestrator_service is not None:
-                self._run_history = strategy_orchestrator_service.history
+            self._run_history = strategy_orchestrator_service.history
 
             try:
                 strategy_orchestrator_service.stop()
@@ -628,9 +630,11 @@ class App:
     def _create_resources_if_not_exists(self):
         """
         Function to create the resources required by the app if they
-          do not exist. This function will check if the resource directory
-          exists and check if the database directory exists. If they do
-          not exist, it will create them.
+        do not exist. This function will check if the resource directory
+        exists and check if the database directory exists. If they do
+        not exist, it will create them. Also it will make sure that
+        the resource directory is read and write accessible by the
+        application.
 
         Returns:
             None
@@ -650,6 +654,9 @@ class App:
         if not os.path.isdir(resource_dir):
             try:
                 os.makedirs(resource_dir)
+
+                # Make sure the resource directory is readable and writable
+                os.chmod(resource_dir, 0o755)
             except OSError as e:
                 logger.error(e)
                 raise OperationalException(
@@ -712,11 +719,12 @@ class App:
         algorithm=None,
         strategy=None,
         strategies: List = None,
-        save_strategy=True,
+        save=True,
         snapshot_interval: SnapshotInterval = SnapshotInterval.TRADE_CLOSE,
         strategy_directory_path: Optional[str] = None,
-        report_name: Optional[str] = None
-    ) -> BacktestReport:
+        backtest_directory_name: Optional[str] = None,
+        risk_free_rate: Optional[float] = None
+    ) -> Backtest:
         """
         Run a backtest for an algorithm.
 
@@ -730,14 +738,13 @@ class App:
                 portfolio will start with.
             strategy (TradingStrategy) (Optional): The strategy object
                 that needs to be backtested.
-            strategies (List[TradingStrategy) (Optional): List of strategy
+            strategies (List[TradingStrategy]) (Optional): List of strategy
                 objects that need to be backtested
-            algorithm:
-            output_directory: str - The directory to
-              write the backtest report to
-            save_strategy: bool - Whether to save the strategy
-                as part of the backtest report. You can only save in-memory
-                strategies when running multiple backtests. This is because
+            algorithm (Algorithm) (Optional): The algorithm object that needs
+                to be backtested. If this is provided, then the strategies
+                and tasks of the algorithm will be used for the backtest.
+            output_directory (str) (Optional): The directory to write
+                the backtest report to
             snapshot_interval (SnapshotInterval): The snapshot
                 interval to use for the backtest. This is used to determine
                 how often the portfolio snapshot should be taken during the
@@ -748,7 +755,7 @@ class App:
                 strategy if save_strategy is True. If not provided,
                 the framework tries to determine the path via the
                 algorithm or strategy object.
-            report_name (Optional[str]): The name of the report. If not
+            backtest_directory_name (Optional[str]): If not
                 provided, the framework will generate a name based on the
                 algorithm name and the backtest date range and the current
                 date and time.
@@ -765,7 +772,9 @@ class App:
             DATABASE_NAME: "backtest-database.sqlite3",
             DATABASE_DIRECTORY_NAME: "backtest_databases",
             BACKTESTING_INITIAL_AMOUNT: initial_amount,
-            SNAPSHOT_INTERVAL: snapshot_interval.value,
+            SNAPSHOT_INTERVAL: SnapshotInterval.from_value(
+                snapshot_interval
+            ).value,
         })
 
         self.initialize_config()
@@ -811,41 +820,33 @@ class App:
         portfolio_service = self.container.portfolio_service()
         portfolio_service.clear_observers()
         portfolio_service.add_observer(portfolio_snapshot_service)
-
-        # Run the backtest with the backtest_service and collect and
-        # save the report
-        results = backtest_service.run_backtest(
+        backtest = backtest_service.run_backtest(
             algorithm=algorithm,
             context=context,
             strategy_orchestrator_service=strategy_orchestrator_service,
             initial_amount=initial_amount,
-            backtest_date_range=backtest_date_range
+            backtest_date_range=backtest_date_range,
+            risk_free_rate=risk_free_rate,
+            strategy_directory_path=strategy_directory_path
         )
-        report = BacktestReport(results=results)
 
         if output_directory is None:
             output_directory = os.path.join(
                 config[RESOURCE_DIRECTORY], "backtest_reports"
             )
 
-        if report_name is None:
-            report_name = BacktestService.create_report_directory_name(report)
+        if backtest_directory_name is None:
+            backtest_directory_name = BacktestService\
+                .create_report_directory_name(backtest)
 
-        output_directory = os.path.join(output_directory, report_name)
-        report.save(
-            path=output_directory,
-            algorithm=algorithm,
-            strategy_directory_path=strategy_directory_path,
-            save_strategy=save_strategy
+        output_directory = os.path.join(
+            output_directory, backtest_directory_name
         )
-        # print(report.html_report)
-        # backtest_service.save_report(
-        #     report=report,
-        #     algorithm=algorithm,
-        #     output_directory=output_directory,
-        #     save_strategy=save_strategy,
-        # )
-        return report
+
+        if save:
+            backtest.save(directory_path=output_directory)
+
+        return backtest
 
     def run_backtests(
         self,
@@ -956,7 +957,6 @@ class App:
                     initial_amount=initial_amount,
                     output_directory=output_directory,
                     algorithm=algorithm,
-                    save_strategy=save_strategy
                 )
                 reports.append(report)
 

{investing_algorithm_framework-6.9.6 → investing_algorithm_framework-6.9.7}/investing_algorithm_framework/app/context.py

@@ -828,7 +828,12 @@ class Context:
         return (position.cost / net_size) * 100
 
     def close_position(
-        self, position=None, symbol=None, portfolio=None, precision=None
+        self,
+        position=None,
+        symbol=None,
+        portfolio=None,
+        precision=None,
+        price=None
     ) -> Order:
         """
         Function to close a position. This function will close a position
@@ -841,6 +846,8 @@ class Context:
             symbol (Optional): The symbol of the asset
             portfolio (Optional): The portfolio where the position is located
             precision (Optional): The precision of the amount
+            price (Optional[Float]): The price with which the position needs
+                to be closed.
 
         Returns:
             Order: The order created to close the position
@@ -887,19 +894,23 @@ class Context:
 
         target_symbol = position.get_symbol()
         symbol = f"{target_symbol.upper()}/{portfolio.trading_symbol.upper()}"
-        ticker = self.market_data_source_service.get_ticker(
-            symbol=symbol, market=portfolio.market
-        )
+
+        if price is None:
+            ticker = self.market_data_source_service.get_ticker(
+                symbol=symbol, market=portfolio.market
+            )
+            price = ticker["bid"]
+
         logger.info(
             f"Closing position {position.symbol} "
             f"with amount {position.get_amount()} "
-            f"at price {ticker['bid']}"
+            f"at price {price}"
         )
         return self.create_limit_order(
             target_symbol=position.symbol,
             amount=position.get_amount(),
             order_side=OrderSide.SELL.value,
-            price=ticker["bid"],
+            price=price,
             precision=precision,
         )
 

{investing_algorithm_framework-6.9.6 → investing_algorithm_framework-6.9.7}/investing_algorithm_framework/app/reporting/__init__.py

@@ -1,15 +1,12 @@
-from .generate import add_html_report, add_metrics
+from .generate import add_html_report
 from .backtest_report import BacktestReport
 from .ascii import pretty_print_backtest, pretty_print_positions, \
     pretty_print_trades, pretty_print_orders
-from .evaluation import BacktestReportsEvaluation
 
 __all__ = [
     "add_html_report",
-    "add_metrics",
     "BacktestReport",
     "pretty_print_backtest",
-    "BacktestReportsEvaluation",
     "pretty_print_positions",
     "pretty_print_trades",
     "pretty_print_orders"