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

investing_algorithm_framework/cli/templates/readme.md.template

@@ -0,0 +1,135 @@
+# README created by investing_algorithm_framework
+
+You can find the documentation for the investing_algorithm_framework
+[here](https://coding-kitties.github.io/investing-algorithm-framework).
+
+
+## Getting Started
+
+This project was created using the investing_algorithm_framework CLI. It provides a template for building a trading algorithm using the investing_algorithm_framework.
+
+This repository contains a simple trading algorithm that uses the
+`investing_algorithm_framework` to fetch data from [bitvavo](https://www.bitvavo.com/en/) and execute trades on the [bitvavo exchange](https://www.bitvavo.com/en/).
+
+The trading strategy is a simple moving average crossover strategy that uses the 50 and 100 day moving averages and the 200 day moving average as a trend filter. The strategy is implemented in the `strategy.py` file. The data provider is implemented in the `data_providers.py` file.
+
+All indicators are implemented with the [pyindicators](https://github.com/coding-kitties/PyIndicators) library.
+
+
+#### 1. Install the requirements
+
+You can install the requirements using the following command:
+```bash
+pip install -r requirements.txt
+```
+
+This will install the `investing_algorithm_framework`, `pyindicators`, and
+`python-dotenv` libraries. If you use the azure functions type option, it will also install the `azure-functions` library.
+
+
+#### 2. Create a `.env` file
+You need to create a `.env` file in the root of the project. You can use the `.env.example` file as a template. The `.env` file should contain the following environment variables:
+
+```bash
+BITVAVO_API_KEY=your_api_key
+BITVAVO_API_SECRET=your_api_secret
+```
+
+##### 2.1 Changing the exchange
+You can change the exchange in the `app.py` file. The default is set to `bitvavo`, but you can change it to any exchange you want. You can find the list of supported exchanges [here](https://investing-algorithm-framework.com/Getting%20Started/markets).
+
+##### 2.2 Azure Functions `.env` file
+If you are using the azure functions type option, you also need to add the following environment variables:
+
+```
+AZURE_STORAGE_CONNECTION_STRING=your_azure_storage_connection_string
+AZURE_STORAGE_CONTAINER_NAME=your_azure_storage_container_name
+```
+
+If you would like to have guidance on how to create the azure storage connection string, you can find it [here](https://learn.microsoft.com/en-us/azure/storage/common/storage-account-create?tabs=azure-portal).
+
+#### 3. Run the app (Skip this step if you have not backtested your strategy)
+> This will run the app as if it was run in production. It will execute live
+> trades on your connected exchange. Please only run this if you are
+> comfortable with this and have backtested your strategy.
+
+You can run the app using the following command:
+```bash
+python app.py
+```
+
+This will start the app and run the trading algorithm. The app will fetch data from the bitvavo exchange and execute trades based on the trading strategy.
+
+#### 3.1 Run the app with azure functions locally
+> Make sure to have the azure functions core tools installed. You can find the
+> installation instructions [here](https://learn.microsoft.com/en-us/azure/azure-functions/functions-run-local).
+
+If you are using the azure functions type option, you can run the app locally using the following command:
+```bash
+func start
+```
+
+#### 4. Run the backtest
+You can run the backtest using the following command:
+
+```bash
+python run_backtest.py
+```
+
+#### 5. Deployment
+You can deploy your trading bot in varous ways.
+
+##### 5.1 Azure Functions
+You can deploy your trading bot to azure functions using the following command:
+
+```bash
+investing-algorithm-framework deploy --type function --cloud azure
+```
+This will deploy your trading bot to azure functions. You can find the deployment instructions [here](https://investing-algorithm-framework.com/Getting%20Started/deployment).
+
+## Project Structure
+
+> We highly recommend to keep the file structure as is, as it is
+> designed to work with the investing_algorithm_framework CLI.
+> You can add your own files and folders as needed, however, we
+> recommend to keep the `strategies` folder for your strategies
+> and the `app.py` file for your app entry point.
+
+```yaml
+.
+├── app.py
+├── requirements.txt
+├── strategies
+│   ├── data_providers.py
+│   └── strategy.py
+├── .gitignore
+├── .env.example
+└── README.md
+```
+
+If you're using the azure functions type option, you will also have an `function_app.py`, `local.settings.json`, and `function.json` file. The `function_app.py` file is the entry point for the azure function, and the `local.settings.json` file is used to configure the local environment for the azure function. The `function.json` file is used to configure the function itself.
+
+> You can change the time trigger in the `function_app.py` when
+> using the azure functions type option. The default is set to
+> every 30 seconds. You can change it to any time you want,
+> but make sure to use the correct format for the time trigger.
+
+## Requirements
+
+The project requires Python 3.10 or higher. You can create a virtual environment and install the requirements using the following commands:
+
+```bash
+virtualenv venv
+source venv/bin/activate  # On Windows use `venv\Scripts\activate`
+pip install -r requirements.txt
+```
+
+By default pyindicators is installed as its specified in the requirements.txt file. This is a requirement for the example strategy in the `strategy.py` file. You can always remove it from the requirements.txt file if you don't need it.
+
+## Deployment
+
+You can deploy your trading bot to azure functions using the following cli command:
+
+```bash
+investing-algorithm-framework deploy --type function --cloud azure
+```

investing_algorithm_framework/cli/templates/requirements.txt.template

@@ -0,0 +1,2 @@
+investing-algorithm-framework>=6.8.2
+pyindicators>=0.5.4

investing_algorithm_framework/cli/templates/run_backtest.py.template

@@ -0,0 +1,20 @@
+from datetime import datetime
+
+from investing_algorithm_framework import BacktestDateRange
+from investing_algorithm_framework import create_app
+from strategies.strategy import MyTradingStrategy
+
+app = create_app()
+app.add_strategy(MyTradingStrategy)
+app.add_market(market="BITVAVO", trading_symbol="EUR")
+
+
+if __name__ == "__main__":
+    backtest_date_range = BacktestDateRange(
+        start_date=datetime(2023, 1, 1),
+        end_date=datetime(2023, 12, 31),
+    )
+    report = app.run_backtest(
+        backtest_date_range=backtest_date_range, initial_amount=1000
+    )
+    report.show()

investing_algorithm_framework/cli/templates/strategy.py.template

@@ -0,0 +1,124 @@
+from investing_algorithm_framework import TimeUnit, TradingStrategy, Context, \
+    OrderSide
+from .data_providers import btc_eur_ohlcv_2h, btc_eur_ticker
+from pyindicators import ema, is_crossover, is_above, is_below, is_crossunder
+
+
+class MyTradingStrategy(TradingStrategy):
+    """
+    A simple trading strategy that uses EMA crossovers to generate buy and
+    sell signals. The strategy uses a 50-period EMA and a 100-period EMA
+    to detect golden and death crosses. It also uses a 200-period EMA to
+    determine the overall trend direction. The strategy trades BTC/EUR
+    on a 2-hour timeframe. The strategy is designed to be used with the
+    Investing Algorithm Framework and uses the PyIndicators library
+    to calculate the EMAs and crossover signals.
+
+    The strategy uses a trailing stop loss and take profit to manage
+    risk. The stop loss is set to 5% below the entry price and the
+    take profit is set to 10% above the entry price. The stop loss and
+    take profit are both trailing, meaning that they will move up
+    with the price when the price goes up.
+    """
+    time_unit = TimeUnit.HOUR
+    interval = 2
+    symbol_pairs = ["BTC/EUR"]
+    market_data_sources = [btc_eur_ohlcv_2h, btc_eur_ticker]
+    fast = 50
+    slow = 100
+    trend = 200
+    stop_loss_percentage = 2
+    stop_loss_sell_size = 50
+    take_profit_percentage = 8
+    take_profit_sell_size = 50
+
+    def apply_strategy(self, context: Context, market_data):
+
+        for pair in self.symbol_pairs:
+            symbol = pair.split('/')[0]
+
+            # Don't trade if there are open orders for the symbol
+            # This is important to avoid placing new orders while there are
+            # existing orders that are not yet filled
+            if context.has_open_orders(symbol):
+                continue
+
+            ohlvc_data = market_data[f"{pair}-ohlcv-2h"]
+            # ticker_data = market_data[f"{symbol}-ticker"]
+            # Add fast, slow, and trend EMAs to the data
+            ohlvc_data = ema(
+                ohlvc_data,
+                source_column="Close",
+                period=self.fast,
+                result_column=f"ema_{self.fast}"
+            )
+            ohlvc_data = ema(
+                ohlvc_data,
+                source_column="Close",
+                period=self.slow,
+                result_column=f"ema_{self.slow}"
+            )
+            ohlvc_data = ema(
+                ohlvc_data,
+                source_column="Close",
+                period=self.trend,
+                result_column=f"ema_{self.trend}"
+            )
+
+            price = ohlvc_data["Close"][-1]
+
+            if not context.has_position(symbol) \
+                    and self._is_buy_signal(ohlvc_data):
+                order = context.create_limit_order(
+                    target_symbol=symbol,
+                    order_side=OrderSide.BUY,
+                    price=price,
+                    percentage_of_portfolio=25,
+                    precision=4,
+                )
+                trade = context.get_trade(order_id=order.id)
+                context.add_stop_loss(
+                    trade=trade,
+                    trade_risk_type="trailing",
+                    percentage=self.stop_loss_percentage,
+                    sell_percentage=self.stop_loss_sell_size
+                )
+                context.add_take_profit(
+                    trade=trade,
+                    percentage=self.take_profit_percentage,
+                    trade_risk_type="trailing",
+                    sell_percentage=self.take_profit_sell_size
+                )
+
+            if context.has_position(symbol) \
+                    and self._is_sell_signal(ohlvc_data):
+                open_trades = context.get_open_trades(
+                    target_symbol=symbol
+                )
+
+                for trade in open_trades:
+                    context.close_trade(trade)
+
+    def _is_sell_signal(self, data):
+        return is_crossunder(
+            data,
+            first_column=f"ema_{self.fast}",
+            second_column=f"ema_{self.slow}",
+            number_of_data_points=2
+        ) and is_below(
+            data,
+            first_column=f"ema_{self.fast}",
+            second_column=f"ema_{self.trend}",
+        )
+
+    def _is_buy_signal(self, data):
+        return is_crossover(
+            data=data,
+            first_column=f"ema_{self.fast}",
+            second_column=f"ema_{self.slow}",
+            number_of_data_points=2
+        ) and is_above(
+            data=data,
+            first_column=f"ema_{self.fast}",
+            second_column=f"ema_{self.trend}",
+        )

investing_algorithm_framework/create_app.py

@@ -1,20 +1,54 @@
+import os
 import logging
+import inspect
+from dotenv import load_dotenv
 
 from .app import App
 from .dependency_container import setup_dependency_container
+from .domain import AppMode, APPLICATION_DIRECTORY, APP_MODE
 
 logger = logging.getLogger("investing_algorithm_framework")
 
 
-def create_app(config=None, stateless=False, web=False) -> App:
-    app = App(web=web, stateless=stateless)
+def create_app(
+    config: dict = None,
+    state_handler=None,
+    web: bool = False,
+    name=None
+) -> App:
+    """
+    Factory method to create an app instance.
+
+    Args:
+        config (dict): Configuration dictionary
+        web (bool): Whether to create a web app
+        state_handler (StateHandler): State handler for the app
+        name (str): Name of the app
+
+    Returns:
+        App: App instance
+    """
+    # Load the environment variables
+    load_dotenv()
+
+    app = App(state_handler=state_handler)
     app = setup_dependency_container(
         app,
         ["investing_algorithm_framework"],
         ["investing_algorithm_framework"]
     )
-    # After the container is setup, initialize the services
-    app.initialize_services()
-    app.set_config(config)
-    logger.info("Investing algoritm framework app created")
+    app.name = name
+
+    if config is not None:
+        app.set_config_with_dict(config)
+
+    if web:
+        app.set_config(APP_MODE, AppMode.WEB.value)
+
+    # Add the application directory to the config
+    caller_frame = inspect.stack()[1]
+    caller_path = os.path.abspath(caller_frame.filename)
+    app.set_config(APPLICATION_DIRECTORY, caller_path)
+
+    logger.info("Investing algorithm framework app created")
     return app

investing_algorithm_framework/dependency_container.py

@@ -1,16 +1,18 @@
 from dependency_injector import containers, providers
 
-from investing_algorithm_framework.app.algorithm import Algorithm
+from investing_algorithm_framework.app.algorithm import AlgorithmFactory
+from investing_algorithm_framework.app.context import Context
 from investing_algorithm_framework.infrastructure import SQLOrderRepository, \
     SQLPositionRepository, SQLPortfolioRepository, \
-    SQLPortfolioSnapshotRepository, \
-    SQLPositionSnapshotRepository, PerformanceService, CCXTMarketService
+    SQLPortfolioSnapshotRepository, SQLTradeRepository, \
+    SQLPositionSnapshotRepository, SQLTradeStopLossRepository, \
+    SQLTradeTakeProfitRepository, SQLOrderMetadataRepository
 from investing_algorithm_framework.services import OrderService, \
-    PositionService, PortfolioService, StrategyOrchestratorService, \
-    PortfolioConfigurationService, MarketDataSourceService, BacktestService, \
-    ConfigurationService, PortfolioSnapshotService, PositionSnapshotService, \
-    MarketCredentialService, TradeService, BacktestReportWriterService, \
-    PortfolioSyncService
+    PositionService, PortfolioService, PortfolioConfigurationService, \
+    BacktestService, ConfigurationService, PortfolioSnapshotService, \
+    PositionSnapshotService, MarketCredentialService, TradeService, \
+    PortfolioSyncService, OrderExecutorLookup, PortfolioProviderLookup, \
+    DataProviderService, TradeTakeProfitService, TradeStopLossService
 
 
 def setup_dependency_container(app, modules=None, packages=None):
@@ -33,7 +35,14 @@ class DependencyContainer(containers.DeclarativeContainer):
         MarketCredentialService
     )
     order_repository = providers.Factory(SQLOrderRepository)
+    order_executor_lookup = providers.ThreadSafeSingleton(
+        OrderExecutorLookup
+    )
+    order_metadata_repository = providers.Factory(SQLOrderMetadataRepository)
     position_repository = providers.Factory(SQLPositionRepository)
+    portfolio_provider_lookup = providers.ThreadSafeSingleton(
+        PortfolioProviderLookup,
+    )
     portfolio_repository = providers.Factory(SQLPortfolioRepository)
     position_snapshot_repository = providers.Factory(
         SQLPositionSnapshotRepository
@@ -41,14 +50,14 @@ class DependencyContainer(containers.DeclarativeContainer):
     portfolio_snapshot_repository = providers.Factory(
         SQLPortfolioSnapshotRepository
     )
-    market_service = providers.Factory(
-        CCXTMarketService,
-        market_credential_service=market_credential_service,
-    )
-    market_data_source_service = providers.Factory(
-        MarketDataSourceService,
-        market_service=market_service,
-        market_credential_service=market_credential_service,
+    trade_repository = providers.Factory(SQLTradeRepository)
+    trade_take_profit_repository = providers\
+        .Factory(SQLTradeTakeProfitRepository)
+    trade_stop_loss_repository = providers.Factory(SQLTradeStopLossRepository)
+    data_provider_service = providers.ThreadSafeSingleton(
+        DataProviderService,
+        configuration_service=configuration_service,
+        market_credential_service=market_credential_service
     )
     position_snapshot_service = providers.Factory(
         PositionSnapshotService,
@@ -56,94 +65,101 @@ class DependencyContainer(containers.DeclarativeContainer):
     )
     portfolio_snapshot_service = providers.Factory(
         PortfolioSnapshotService,
+        order_repository=order_repository,
         repository=portfolio_snapshot_repository,
+        portfolio_repository=portfolio_repository,
         position_snapshot_service=position_snapshot_service,
         position_repository=position_repository,
+        data_provider_service=data_provider_service,
     )
     portfolio_configuration_service = providers.ThreadSafeSingleton(
         PortfolioConfigurationService,
         portfolio_repository=portfolio_repository,
         position_repository=position_repository,
     )
-    order_service = providers.Factory(
-        OrderService,
-        configuration_service=configuration_service,
+    trade_service = providers.Factory(
+        TradeService,
         order_repository=order_repository,
+        trade_take_profit_repository=trade_take_profit_repository,
+        trade_stop_loss_repository=trade_stop_loss_repository,
+        configuration_service=configuration_service,
+        trade_repository=trade_repository,
         portfolio_repository=portfolio_repository,
         position_repository=position_repository,
-        market_service=market_service,
-        market_credential_service=market_credential_service,
-        portfolio_configuration_service=portfolio_configuration_service,
-        portfolio_snapshot_service=portfolio_snapshot_service
+        order_metadata_repository=order_metadata_repository,
+    )
+    trade_take_profit_service = providers.Factory(
+        TradeTakeProfitService,
+        repository=trade_take_profit_repository,
+    )
+    trade_stop_loss_service = providers.Factory(
+        TradeStopLossService,
+        repository=trade_stop_loss_repository,
     )
     position_service = providers.Factory(
         PositionService,
+        portfolio_repository=portfolio_repository,
         repository=position_repository,
-        market_service=market_service,
-        market_credential_service=market_credential_service,
+    )
+    order_service = providers.Factory(
+        OrderService,
+        configuration_service=configuration_service,
         order_repository=order_repository,
+        portfolio_repository=portfolio_repository,
+        position_service=position_service,
+        market_credential_service=market_credential_service,
+        portfolio_configuration_service=portfolio_configuration_service,
+        portfolio_snapshot_service=portfolio_snapshot_service,
+        trade_service=trade_service,
+        order_executor_lookup=order_executor_lookup,
+        portfolio_provider_lookup=portfolio_provider_lookup
     )
     portfolio_service = providers.Factory(
         PortfolioService,
         configuration_service=configuration_service,
         market_credential_service=market_credential_service,
-        market_service=market_service,
         order_service=order_service,
         position_service=position_service,
         portfolio_repository=portfolio_repository,
         portfolio_configuration_service=portfolio_configuration_service,
         portfolio_snapshot_service=portfolio_snapshot_service,
-    )
-    trade_service = providers.Factory(
-        TradeService,
-        portfolio_repository=portfolio_repository,
-        order_service=order_service,
-        market_data_source_service=market_data_source_service,
-        position_service=position_service,
+        portfolio_provider_lookup=portfolio_provider_lookup
     )
     portfolio_sync_service = providers.Factory(
         PortfolioSyncService,
         trade_service=trade_service,
         configuration_service=configuration_service,
-        order_repository=order_repository,
+        order_service=order_service,
         position_repository=position_repository,
         portfolio_repository=portfolio_repository,
         portfolio_configuration_service=portfolio_configuration_service,
         market_credential_service=market_credential_service,
-        market_service=market_service,
-    )
-    strategy_orchestrator_service = providers.Factory(
-        StrategyOrchestratorService,
-        market_data_source_service=market_data_source_service
-    )
-    performance_service = providers.Factory(
-        PerformanceService,
-        order_repository=order_repository,
-        position_repository=position_repository,
-        portfolio_repository=portfolio_repository
+        portfolio_provider_lookup=portfolio_provider_lookup,
     )
     backtest_service = providers.Factory(
         BacktestService,
         configuration_service=configuration_service,
         order_service=order_service,
-        portfolio_repository=portfolio_repository,
-        performance_service=performance_service,
+        trade_service=trade_service,
+        portfolio_service=portfolio_service,
         position_repository=position_repository,
-        market_data_source_service=market_data_source_service,
-    )
-    backtest_report_writer_service = providers.Factory(
-        BacktestReportWriterService,
+        portfolio_configuration_service=portfolio_configuration_service,
+        portfolio_snapshot_service=portfolio_snapshot_service,
+        data_provider_service=data_provider_service,
     )
-    algorithm = providers.Factory(
-        Algorithm,
+    context = providers.Factory(
+        Context,
         configuration_service=configuration_service,
         portfolio_configuration_service=portfolio_configuration_service,
         portfolio_service=portfolio_service,
         position_service=position_service,
         order_service=order_service,
-        strategy_orchestrator_service=strategy_orchestrator_service,
         market_credential_service=market_credential_service,
-        market_data_source_service=market_data_source_service,
-        market_service=market_service,
         trade_service=trade_service,
+        data_provider_service=data_provider_service,
+        trade_stop_loss_service=trade_stop_loss_service,
+        trade_take_profit_service=trade_take_profit_service,
+    )
+    algorithm_factory = providers.Factory(
+        AlgorithmFactory,
     )