Refactor to persistent trade service

Author: MDUYN

.github/workflows/test.yml

@@ -40,7 +40,7 @@ jobs:
     strategy:
       fail-fast: true
       matrix:
-        os: [ "ubuntu-latest", "macos-latest" ]
+        os: [ "ubuntu-latest", "macos-latest", "windows-latest" ]
         python-version: [ "3.8", "3.9", "3.10", "3.11" ]
     runs-on: ${{ matrix.os }}
     steps:

README.md

@@ -37,7 +37,6 @@ Features:
 The following algorithm connects to binance and buys BTC every 5 seconds. It also exposes an REST API that allows you to interact with the algorithm.
 
 ```python
-import logging
 import logging.config
 
 from investing_algorithm_framework import create_app, PortfolioConfiguration, \
@@ -90,24 +89,21 @@ def perform_strategy(algorithm: Algorithm, market_data: dict):
     closed_trades = algorithm.get_closed_trades()
 
     # Create a buy oder
-    trade = algorithm.create_limit_order(
+    order = algorithm.create_limit_order(
         target_symbol="BTC/EUR",
         order_side="buy",
         amount=0.01,
         price=ticker_data["ask"],
     )
-
-    # Add a stop loss percentage of 5%
-    algorithm.add_stop_loss(trade.id, percentage=5)
-
-    # Add a take profit percentage of 10%
-    algorithm.add_take_profit(trade.id, percentage=5)
+    trade = algorithm.get_trade(order_id=order.id)
+    algorithm.add_trailing_stop_loss(trade=trade, percentage=5)
 
     # Close a trade
-    algorithm.close_trade(trades[0].id)
+    algorithm.close_trade(trade=trade)
 
     # Close a position
-    algorithm.close_position(positions[0].get_symbol())
+    position = algorithm.get_position(symbol="BTC/EUR")
+    algorithm.close_position(position)
 
 if __name__ == "__main__":
     app.run()
@@ -119,7 +115,14 @@ if __name__ == "__main__":
 
 The framework also supports backtesting and performing backtest experiments. After a backtest, you can print a report that shows the performance of your trading bot.
 
-To run a single backtest you can use the example code that can be found [here](./examples/backtest).
+To run a single backtest you can use the example code that can be found [here](./examples/backtest_example). Simply run:
+
+> Its assumed here that you have cloned the repository, installed the framework and
+> are in the root of the project.
+
+```bash
+python examples/backtest_example/run_backtest.py
+```
 
 ### Backtesting report
 

examples/backtest_example/__init__.py

@@ -1,19 +1,150 @@
+import logging.config
 from datetime import datetime, timedelta
 
-from algorithm.algorithm import algorithm
-from algorithm.data_sources import bitvavo_btc_eur_ohlcv_2h, \
-    bitvavo_dot_eur_ohlcv_2h, bitvavo_dot_eur_ticker, bitvavo_btc_eur_ticker
-from app import app
-from investing_algorithm_framework import PortfolioConfiguration, \
-    pretty_print_backtest, BacktestDateRange
 
+from investing_algorithm_framework import CCXTOHLCVMarketDataSource, \
+    CCXTTickerMarketDataSource, Algorithm, PortfolioConfiguration, \
+    create_app, pretty_print_backtest, BacktestDateRange, TimeUnit, \
+    TradingStrategy, OrderSide, DEFAULT_LOGGING_CONFIG
+
+import tulipy as ti
+
+logging.config.dictConfig(DEFAULT_LOGGING_CONFIG)
+
+
+"""
+This strategy is based on the golden cross strategy. It will buy when the
+fast moving average crosses the slow moving average from below. It will sell
+when the fast moving average crosses the slow moving average from above.
+The strategy will also check if the fast moving average is above the trend
+moving average. If it is not above the trend moving average it will not buy.
+
+It uses tulipy indicators to calculate the metrics. You need to
+install this library in your environment to run this strategy.
+You can find instructions on how to install tulipy here:
+https://tulipindicators.org/ or go directly to the pypi page:
+https://pypi.org/project/tulipy/
+"""
+
+bitvavo_btc_eur_ohlcv_2h = CCXTOHLCVMarketDataSource(
+    identifier="BTC/EUR-ohlcv",
+    market="BINANCE",
+    symbol="BTC/EUR",
+    time_frame="2h",
+    window_size=200
+)
+bitvavo_dot_eur_ohlcv_2h = CCXTOHLCVMarketDataSource(
+    identifier="DOT/EUR-ohlcv",
+    market="BINANCE",
+    symbol="DOT/EUR",
+    time_frame="2h",
+    window_size=200
+)
+bitvavo_dot_eur_ticker = CCXTTickerMarketDataSource(
+    identifier="DOT/EUR-ticker",
+    market="BINANCE",
+    symbol="DOT/EUR",
+    backtest_time_frame="2h",
+)
+bitvavo_btc_eur_ticker = CCXTTickerMarketDataSource(
+    identifier="BTC/EUR-ticker",
+    market="BINANCE",
+    symbol="BTC/EUR",
+    backtest_time_frame="2h",
+)
+
+
+def is_below_trend(fast_series, slow_series):
+    return fast_series[-1] < slow_series[-1]
+
+
+def is_above_trend(fast_series, slow_series):
+    return fast_series[-1] > slow_series[-1]
+
+
+def is_crossover(fast, slow):
+    """
+    Expect df to have columns: Date, ma_<period_one>, ma_<period_two>.
+    With the given date time it will check if the ma_<period_one> is a
+    crossover with the ma_<period_two>
+    """
+    return fast[-2] <= slow[-2] and fast[-1] > slow[-1]
+
+
+def is_crossunder(fast, slow):
+    """
+    Expect df to have columns: Date, ma_<period_one>, ma_<period_two>.
+    With the given date time it will check if the ma_<period_one> is a
+    crossover with the ma_<period_two>
+    """
+    return fast[-2] >= slow[-2] and fast[-1] < slow[-1]
+
+
+class CrossOverStrategy(TradingStrategy):
+    time_unit = TimeUnit.HOUR
+    interval = 2
+    market_data_sources = [
+        bitvavo_dot_eur_ticker,
+        bitvavo_btc_eur_ticker,
+        bitvavo_dot_eur_ohlcv_2h,
+        bitvavo_btc_eur_ohlcv_2h
+    ]
+    symbols = ["BTC/EUR", "DOT/EUR"]
+    fast = 21
+    slow = 75
+    trend = 150
+    stop_loss_percentage = 7
+
+    def apply_strategy(self, algorithm: Algorithm, market_data):
+
+        for symbol in self.symbols:
+            target_symbol = symbol.split('/')[0]
+
+            if algorithm.has_open_orders(target_symbol):
+                continue
+
+            df = market_data[f"{symbol}-ohlcv"]
+            ticker_data = market_data[f"{symbol}-ticker"]
+            fast = ti.sma(df['Close'].to_numpy(), self.fast)
+            slow = ti.sma(df['Close'].to_numpy(), self.slow)
+            trend = ti.sma(df['Close'].to_numpy(), self.trend)
+            price = ticker_data["bid"]
+
+            if not algorithm.has_position(target_symbol) \
+                    and is_crossover(fast, slow) \
+                    and is_above_trend(fast, trend):
+                order = algorithm.create_limit_order(
+                    target_symbol=target_symbol,
+                    order_side=OrderSide.BUY,
+                    price=price,
+                    percentage_of_portfolio=25,
+                    precision=4,
+                )
+                trade = algorithm.get_trade(order_id=order.id)
+                algorithm.add_trailing_stop_loss(
+                    trade=trade, percentage=5
+                )
+
+
+            if algorithm.has_position(target_symbol) \
+                    and is_below_trend(fast, slow):
+                open_trades = algorithm.get_open_trades(
+                    target_symbol=target_symbol
+                )
+
+                for trade in open_trades:
+                    algorithm.close_trade(trade)
+
+
+app = create_app()
+algorithm = Algorithm("GoldenCrossStrategy")
+algorithm.add_strategy(CrossOverStrategy)
 app.add_algorithm(algorithm)
 app.add_market_data_source(bitvavo_btc_eur_ohlcv_2h)
 app.add_market_data_source(bitvavo_dot_eur_ohlcv_2h)
 app.add_market_data_source(bitvavo_btc_eur_ticker)
 app.add_market_data_source(bitvavo_dot_eur_ticker)
 
-
 # Add a portfolio configuration of 400 euro initial balance
 app.add_portfolio_configuration(
     PortfolioConfiguration(