OctoBot script strategies

On OctoBot script, similarly to TradingView Pine Script, a trading strategy is a python async function that will be called at new price data.

async def strategy(ctx):
    # your strategy content

In most cases, a strategy will:

1. Read price data
2. Use technical evaluators or statistics
3. Decide to take (or not take) action depending on its configuration
4. Create / cancel or edit orders (see Creating orders)

As OctoBot script strategies are meant for backtesting, it is possible to create a strategy in 2 ways:

Pre-computed strategies

Pre-computed are only possible in backtesting: since the data is already known, when dealing with technical evaluator based strategies, it is possible to compute the values of the evaluators for the whole backtest at once. This approach is faster than iterative strategies as evaluators call only called once.

Warning: when writing a pre-computed strategy, always make sure to associate the evaluator values to the right time otherwise you might be reading data from the past of the future when running the strategy.

config = {
    "period": 10,
    "rsi_value_buy_threshold": 28,
}
run_data = {
    "entries": None,
}
async def strategy(ctx):
    if run_data["entries"] is None:
        # 1. Read price data
        closes = await obs.Close(ctx, max_history=True)
        times = await obs.Time(ctx, max_history=True, use_close_time=True)
        # 2. Use technical evaluators or statistics 
        rsi_v = tulipy.rsi(closes, period=ctx.tentacle.trading_config["period"])
        delta = len(closes) - len(rsi_v)
        # 3. Decide to take (or not take) action depending on its configuration 
        run_data["entries"] = {
            times[index + delta]
            for index, rsi_val in enumerate(rsi_v)
            if rsi_val < ctx.tentacle.trading_config["rsi_value_buy_threshold"]
        }
        await obs.plot_indicator(ctx, "RSI", times[delta:], rsi_v, run_data["entries"])
    if obs.current_live_time(ctx) in run_data["entries"]:
        # 4. Create / cancel or edit orders
        await obs.market(ctx, "buy", amount="10%", stop_loss_offset="-15%", take_profit_offset="25%")

This pre-computed strategy computes entries using the RSI: times of favorable entries are stored into run_data["entries"] which is defined outside on the strategy function in order to keep its values throughout iterations.

Please note the max_history=True in obs.Close and obs.Time keywords. This is allowing to select data using the whole run available data and only call tulipy.rsi once and populate run_data["entries"] only once.

In each subsequent call, run_data["entries"] is None will be True and only the last 2 lines of the strategy will be executed.

Iterative strategies

config = {
    "period": 10,
    "rsi_value_buy_threshold": 28,
}
async def strategy(ctx):
    # 1. Read price data
    close = await obs.Close(ctx)
    if len(close) <= ctx.tentacle.trading_config["period"]:
        # not enough data to compute RSI
        return
    # 2. Use technical evaluators or statistics 
    rsi_v = tulipy.rsi(close, period=ctx.tentacle.trading_config["period"])
    # 3. Decide to take (or not take) action depending on its configuration 
    if rsi_v[-1] < ctx.tentacle.trading_config["rsi_value_buy_threshold"]:
        # 4. Create / cancel or edit orders
        await obs.market(ctx, "buy", amount="10%", stop_loss_offset="-15%", take_profit_offset="25%")

This iterative strategy is similar to the above pre-computed strategy except that it is evaluating the RSI at each candle to know if an entry should be created.

This type of strategy is simpler to create than a pre-computed strategy and can be used in OctoBot live trading.

Running a strategy

When running a backtest, a strategy should be referenced alongside:

• The data it should be run on using obs.run:
• Its configuration (a dict in above examples, it could be anything)

res = await obs.run(data, strategy, config)

Have a look at the demo script for a full example of how to run a strategy within a python script.