here is the backtest sample

To resolve the issues in the code, you should make the following changes:

1. Import the api module: Ensure that the api module is imported or defined. If it's a custom object, make sure it's initialized properly.

2. Import timedelta from the datetime module: Add the import statement for timedelta to handle date and time calculations.

3. Import the math module: Add the import statement for the math module to use its functions.

4. Type Conversion: Ensure that the types match or perform necessary type conversions where a float is being assigned to an integer variable.

Here's how you can modify the code:

from datetime import timedelta
import math
import random
import matplotlib.pyplot as plt
# Assuming `api` is a custom object or module, ensure it's imported or defined
# import api
project_id = "18019435"
backtest_id = "24220b8a2f86be86feac5171295e7db3"
backtest = api.read_backtest(project_id, backtest_id)
orders = api.read_backtest_orders(project_id, backtest_id)
closed_trades = backtest.total_performance.closed_trades
start_equity = backtest.total_performance.portfolio_statistics.start_equity
from bisect import bisect_right
strategy_days_duration = 365
exit_time_list = [t.exit_time for t in closed_trades]
sorted_exit_time_list = sorted(exit_time_list)
trade_number_list = []
for i, exit_time in enumerate(sorted_exit_time_list):
    pos = bisect_right(
        sorted_exit_time_list, 
        exit_time + timedelta(days=strategy_days_duration), 
        i,
        len(sorted_exit_time_list))
    if pos == len(sorted_exit_time_list):
        break
    trade_number_list.append(pos - i)
def monte_carlo_in_sample_consider_duration(start_equity, closed_trades, trade_number_list):
    trades = closed_trades.copy()
    trade_number = random.choice(trade_number_list)
    trades = random.choices(trades, k=trade_number)
    profit_loss_relative_list = []
    equity_relative_list = []
    current_equity = start_equity
    for i, trade in enumerate(trades):
        profit_loss_ratio = (trade.profit_loss - trade.total_fees) / current_equity
        current_equity += current_equity * profit_loss_ratio
        profit_loss_relative_list.append(profit_loss_ratio)
        equity_relative_list.append(current_equity)
    return trades, profit_loss_relative_list, equity_relative_list
plt.figure(figsize=(16, 6))
plt.grid(True)
resample_num = 1000
for i in range(resample_num):
    trades, profit_loss_relative_list, equity_relative_list = monte_carlo_in_sample_consider_duration(start_equity, closed_trades, trade_number_list)
    plt.plot(list(range(len(profit_loss_relative_list))), equity_relative_list, linewidth=0.2)
plt.show()
def max_drawdown(equity_curve):
    drawdown_start_equity = None
    mdd = 0
    for i, equity in enumerate(equity_curve):
        if i == 0:
            drawdown_start_equity = equity_curve[i]
            continue
        if equity <= drawdown_start_equity:
            mdd = max(mdd, (drawdown_start_equity - equity) / drawdown_start_equity)
        else:
            drawdown_start_equity = equity
    return mdd
def monte_carlo_statistics(equity_curve_list):
    max_drawdown_list = []
    net_profit_list = []
    profit_ratio_list = []
    return_max_dd_ratio_list = []
    win_rate_list = []
    for equity_curve in equity_curve_list:
        max_drawdown_list.append(max_drawdown(equity_curve))
        net_profit_list.append(equity_curve[-1])
        profit_ratio_list.append(equity_curve[-1] / start_equity)
        return_max_dd_ratio_list.append(equity_curve[-1] / (max(equity_curve) - min(equity_curve)))
        win_rate_list.append(float(equity_curve[-1] > 0))
    max_drawdown_list.sort()
    net_profit_list.sort()
    profit_ratio_list.sort()
    return_max_dd_ratio_list.sort()
    win_rate_list.sort()
    print(f"probability return > 0: {sum(win_rate_list) / len(win_rate_list)}")
    for i in range(0, 100 + 1, 5):
        max_drawdown_index = max(0, min(len(max_drawdown_list) - 1, int(len(max_drawdown_list) * i / 100.0)))
        net_profit_index = max(0, min(len(net_profit_list) - 1, int(len(net_profit_list) * i / 100.0)))
        profit_ratio_index = max(0, min(len(profit_ratio_list) - 1, int(len(profit_ratio_list) * i / 100.0)))
        return_max_dd_ratio_index = max(0, min(len(return_max_dd_ratio_list) - 1, int(len(return_max_dd_ratio_list) * i / 100.0)))
        print(f"{i:>3}th percentile: MDD:{max_drawdown_list[max_drawdown_index]:.2f}, net profit: {net_profit_list[net_profit_index]:.2f}, return: {profit_ratio_list[profit_ratio_index]:.2f}, return/MDD: {return_max_dd_ratio_list[return_max_dd_ratio_index]:.2f}")
resample_num = 30000
equity_curve_list = []
for i in range(resample_num):
    trades, profit_loss_relative_list, equity_relative_list = monte_carlo_in_sample_consider_duration(start_equity, closed_trades, trade_number_list)
    equity_curve_list.append(equity_relative_list)
monte_carlo_statistics(equity_curve_list)
+ Expand
- Collapse

Ensure that the api object is correctly initialized or imported based on your specific setup.

Hi 李元骏,

Thank you for your patience.
When we place orders at 4 PM, the brokerage receives them when the market is closed. Unfortunately, some brokerages don't accept market-on-open orders during the first few minutes or hours after closing the market.

The easiest way to address this issue is to set daily_precise_end_time to False in live mode:

self.settings.daily_precise_end_time = not self.live_mode

or set it to False regardless:

self.settings.daily_precise_end_time = False

Best regards,
Alex

Thank you, I'll try it and observe continuously for a week, grateful for your reponse