FinceptTerminal is a modern finance application offering advanced market analytics, investment research, and economic data tools, designed for interactive exploration and data-driven decision-making in a user-friendly environment.
C++ ai-agentsalgorithmic-tradingbloomberg-terminalcppfinancefinancial-marketsfintechgood-first-issueinvestmentinvestment-researchmachine-learningopensourcepythonqtquantitative-financestock-markettrading
// src/screens/backtesting/BacktestingScreen_Commands.cpp
//
// Provider / command selection state, run dispatch, and arg gathering.
// Owns the UI-state transitions when the user picks a different provider
// or command (re-skinning pills, toggling section visibility, etc.) and
// translates the right-panel config widgets into a JSON args bundle for
// BacktestingService.
//
// Part of the partial-class split of BacktestingScreen.cpp; helpers shared
// across split files live in BacktestingScreen_internal.h.
#include "core/logging/Logger.h"
#include "core/session/ScreenStateManager.h"
#include "screens/backtesting/BacktestingScreen.h"
#include "screens/backtesting/BacktestingScreen_internal.h"
#include "services/backtesting/BacktestingService.h"
#include "ui/theme/Theme.h"
#include <QJsonArray>
#include <QJsonObject>
namespace fincept::screens {
using namespace fincept::services::backtest;
// ── Provider/Command/Strategy selection ──────────────────────────────────────
void BacktestingScreen::on_provider_changed(int index) {
if (index < 0 || index >= providers_.size())
return;
active_provider_ = index;
update_provider_buttons();
update_command_buttons();
// Clear stale strategies and show loading state
strategies_.clear();
strategy_category_combo_->clear();
strategy_category_combo_->addItem(tr("Loading..."));
strategy_combo_->clear();
const auto& slug = providers_[index].slug;
auto& svc = BacktestingService::instance();
svc.load_strategies(slug);
svc.load_command_options(slug);
svc.execute(slug, "get_indicators", {});
ScreenStateManager::instance().notify_changed(this);
}
void BacktestingScreen::update_provider_buttons() {
// Colours come from per-slug rules in refresh_theme(); only the "active"
// property changes here (no stylesheet reparse per click).
for (int i = 0; i < provider_buttons_.size(); ++i)
backtesting_internal::set_style_prop(provider_buttons_[i], "active", i == active_provider_);
}
void BacktestingScreen::on_command_changed(int index) {
const auto& cmds = commands_;
if (index < 0 || index >= cmds.size())
return;
active_command_ = index;
update_command_buttons();
// Map command index to config stack page. The page order in
// build_left_panel must match the command order in
// BacktestingTypes::all_commands() — adding a new command requires
// appending a matching cmd_config_stack_ page in the same position.
// commands: backtest(0), optimize(1), walk_forward(2), indicator(3),
// indicator_signals(4), labels(5), splits(6), returns(7),
// signals(8), labels_to_signals(9), indicator_sweep(10)
cmd_config_stack_->setCurrentIndex(index);
update_section_visibility();
}
void BacktestingScreen::update_section_visibility() {
// Show/hide whole right + left panel sections based on the active command.
//
// Sections map to the args each command actually consumes (see gather_args):
// - backtest/optimize/walk_forward : execution, advanced, benchmark, strategy
// - returns : benchmark (only — for benchmark-relative analysis)
// - everything else (labels, splits, : MARKET DATA + per-command page only
// signals, labels_to_signals,
// indicator, indicator_signals,
// indicator_sweep)
//
// MARKET DATA is always visible — every command reads symbols + dates.
if (active_command_ < 0 || active_command_ >= commands_.size())
return;
const QString cmd = commands_[active_command_].id;
const bool is_backtest_family = (cmd == "backtest" || cmd == "optimize" || cmd == "walk_forward");
const bool needs_benchmark = is_backtest_family || cmd == "returns";
if (execution_section_)
execution_section_->setVisible(is_backtest_family);
if (advanced_section_)
advanced_section_->setVisible(is_backtest_family);
if (benchmark_section_)
benchmark_section_->setVisible(needs_benchmark);
if (strategy_section_)
strategy_section_->setVisible(is_backtest_family);
// Show explicit MIN/MAX/STEP rows under each strategy param only for `optimize`.
const bool is_optimize = (cmd == "optimize");
for (auto* row : param_range_rows_)
if (row)
row->setVisible(is_optimize);
}
void BacktestingScreen::update_command_buttons() {
const auto& cmds = commands_;
const auto& supported = providers_[active_provider_].commands;
for (int i = 0; i < command_buttons_.size() && i < cmds.size(); ++i) {
command_buttons_[i]->setEnabled(supported.contains(cmds[i].id));
backtesting_internal::set_style_prop(command_buttons_[i], "active", i == active_command_);
}
}
// ── Gather args ──────────────────────────────────────────────────────────────
QJsonObject BacktestingScreen::gather_strategy_params() {
// Custom combo: build comboConfig JSON instead of flat params
auto strategy_id = strategy_combo_->currentData().toString();
if (strategy_id == "custom_combo" && combo_rows_[0].type && combo_rows_[1].type) {
QJsonObject params;
QJsonArray indicators;
int n_indicators = (combo_ind3_enabled_ && combo_ind3_enabled_->isChecked()) ? 3 : 2;
for (int i = 0; i < n_indicators; ++i) {
const auto& r = combo_rows_[i];
if (!r.type)
continue;
QJsonObject ind;
ind["type"] = r.type->currentText();
ind["period"] = r.period ? r.period->value() : 14;
ind["condition"] = r.cond->currentText();
ind["threshold"] = r.val->value();
const QString cond = r.cond->currentText();
ind["exitCondition"] = (cond == "below" || cond == "cross_up") ? QString("above") : QString("below");
ind["exitThreshold"] = (r.type->currentText() == "rsi") ? 70.0 : r.val->value();
indicators.append(ind);
}
QJsonObject combo_config;
combo_config["indicators"] = indicators;
combo_config["logic"] = combo_logic_ ? combo_logic_->currentText() : QString("and");
params["comboConfig"] = combo_config;
return params;
}
QJsonObject params;
for (auto* spin : param_spinboxes_) {
auto name = spin->property("param_name").toString();
if (!name.isEmpty())
params[name] = spin->value();
}
return params;
}
QJsonObject BacktestingScreen::gather_args() {
const auto& cmds = commands_;
auto cmd_id = cmds[active_command_].id;
// Common fields
auto sym_text = symbols_edit_->text().trimmed();
QJsonArray symbols;
for (const auto& s : sym_text.split(',', Qt::SkipEmptyParts))
symbols.append(s.trimmed());
auto start = start_date_->date().toString("yyyy-MM-dd");
auto end = end_date_->date().toString("yyyy-MM-dd");
QJsonObject args;
args["symbols"] = symbols;
args["startDate"] = start;
args["endDate"] = end;
if (interval_combo_)
args["interval"] = interval_combo_->currentText();
if (!pending_weights_.isEmpty() && pending_weights_.size() == symbols.size())
args["weights"] = pending_weights_;
// Providers refuse to run on synthetic prices unless this is explicitly ticked.
args["allowSyntheticData"] = allow_synthetic_check_ && allow_synthetic_check_->isChecked();
// ── Command-specific args ──
if (cmd_id == "backtest" || cmd_id == "optimize" || cmd_id == "walk_forward") {
args["initialCapital"] = capital_spin_->value();
args["commission"] = commission_spin_->value() / 100.0;
args["slippage"] = slippage_spin_->value() / 100.0;
args["leverage"] = leverage_spin_->value();
args["positionSizing"] = pos_sizing_combo_->currentText();
if (pos_sizing_value_spin_)
args["positionSizeValue"] = pos_sizing_value_spin_->value();
args["allowShort"] = allow_short_check_->isChecked();
args["benchmarkSymbol"] = benchmark_edit_->text().trimmed();
if (risk_free_spin_)
args["riskFreeRate"] = risk_free_spin_->value() / 100.0;
if (stop_loss_spin_->value() > 0)
args["stopLoss"] = stop_loss_spin_->value() / 100.0;
if (take_profit_spin_->value() > 0)
args["takeProfit"] = take_profit_spin_->value() / 100.0;
// Strategy — type = ID (used by Python), name = display name
QJsonObject strategy;
strategy["type"] = strategy_combo_->currentData().toString(); // strategy ID
strategy["name"] = strategy_combo_->currentText(); // display name
strategy["category"] = strategy_category_combo_->currentText();
strategy["params"] = gather_strategy_params();
args["strategy"] = strategy;
}
if (cmd_id == "optimize") {
args["optimizeObjective"] = opt_objective_combo_->currentText();
args["optimizeMethod"] = opt_method_combo_->currentText();
args["maxIterations"] = opt_iterations_spin_->value();
// Build paramRanges from the explicit per-param MIN/MAX/STEP editor.
// rebuild_strategy_params keeps param_spinboxes_ and the three range
// vectors index-aligned, so we can zip them.
QJsonObject ranges;
for (int i = 0; i < param_spinboxes_.size(); ++i) {
auto name = param_spinboxes_[i]->property("param_name").toString();
if (name.isEmpty())
continue;
if (i >= param_min_spinboxes_.size() || i >= param_max_spinboxes_.size() ||
i >= param_step_spinboxes_.size())
continue;
double mn = param_min_spinboxes_[i]->value();
double mx = param_max_spinboxes_[i]->value();
double st = qMax(0.0001, param_step_spinboxes_[i]->value());
if (mx < mn)
std::swap(mn, mx);
QJsonObject range;
range["min"] = mn;
range["max"] = mx;
range["step"] = st;
ranges[name] = range;
}
args["paramRanges"] = ranges;
}
if (cmd_id == "walk_forward") {
args["wfSplits"] = wf_splits_spin_->value();
args["wfTrainRatio"] = wf_train_ratio_spin_->value();
}
if (cmd_id == "indicator") {
args["indicator"] = indicator_combo_->currentData().toString();
QJsonObject p;
p["period"] = indicator_period_spin_->value();
args["params"] = p;
}
if (cmd_id == "indicator_signals") {
args["indicator"] = ind_signal_indicator_combo_->currentData().toString();
const QString m = ind_signal_mode_combo_->currentText();
args["mode"] = m;
QJsonObject params;
// vectorbt uses long mode names ('crossover_signals'); zipline uses both
// long and short forms. The params keys are the same across providers.
if (m == "crossover_signals" || m == "crossover") {
params["fast_period"] = is_fast_period_spin_->value();
params["slow_period"] = is_slow_period_spin_->value();
params["fastPeriod"] = is_fast_period_spin_->value(); // zipline alias
params["slowPeriod"] = is_slow_period_spin_->value();
params["ma_type"] = is_ma_type_combo_->currentText();
params["maType"] = is_ma_type_combo_->currentText();
params["fast_indicator"] = is_ma_type_combo_->currentText(); // vectorbt key
params["slow_indicator"] = is_ma_type_combo_->currentText();
} else if (m == "threshold_signals" || m == "threshold") {
params["period"] = is_period_spin_->value();
params["lower"] = is_lower_spin_->value();
params["upper"] = is_upper_spin_->value();
} else if (m == "breakout_signals" || m == "breakout") {
params["period"] = is_period_spin_->value();
params["channel"] = is_channel_combo_->currentText();
} else if (m == "mean_reversion_signals" || m == "mean_reversion") {
params["period"] = is_period_spin_->value();
params["z_entry"] = is_z_entry_spin_->value();
params["z_exit"] = is_z_exit_spin_->value();
} else if (m == "signal_filter" || m == "filter") {
params["base_indicator"] = ind_signal_indicator_combo_->currentData().toString();
params["base_period"] = is_period_spin_->value();
params["filter_indicator"] = is_filter_indicator_combo_->currentText();
params["filter_period"] = is_filter_period_spin_->value();
params["filter_threshold"] = is_filter_threshold_spin_->value();
params["filter_type"] = is_filter_type_combo_->currentText();
}
args["params"] = params;
}
if (cmd_id == "labels") {
const QString lt = labels_type_combo_->currentText();
args["labelType"] = lt;
QJsonObject params;
// Send only the params the chosen generator consumes so the JSON stays
// unambiguous; Python providers use defaults for anything missing.
if (lt == "FIXLB") {
params["horizon"] = labels_horizon_spin_->value();
params["threshold"] = labels_threshold_spin_->value();
} else if (lt == "MEANLB" || lt == "TRENDLB") {
params["window"] = labels_window_spin_->value();
params["threshold"] = labels_threshold_spin_->value();
} else if (lt == "LEXLB") {
params["window"] = labels_window_spin_->value();
} else if (lt == "BOLB") {
params["window"] = labels_window_spin_->value();
params["alpha"] = labels_alpha_spin_->value();
}
args["params"] = params;
}
if (cmd_id == "splits") {
const QString st = splitter_type_combo_->currentText();
args["splitterType"] = st;
QJsonObject params;
// vectorbt reads snake_case (window_len/test_len/min_len/n_splits/purge_len/embargo_len);
// zipline reads camelCase (windowLen/testLen/minLen/nSplits/purgeLen/embargoLen).
// Sending both keeps the JSON contract provider-agnostic.
if (st == "RollingSplitter") {
params["window_len"] = splitter_window_spin_->value();
params["windowLen"] = splitter_window_spin_->value();
params["test_len"] = splitter_test_spin_->value();
params["testLen"] = splitter_test_spin_->value();
params["step"] = splitter_step_spin_->value();
} else if (st == "ExpandingSplitter") {
params["min_len"] = splitter_min_spin_->value();
params["minLen"] = splitter_min_spin_->value();
params["test_len"] = splitter_test_spin_->value();
params["testLen"] = splitter_test_spin_->value();
params["step"] = splitter_step_spin_->value();
} else if (st == "PurgedKFoldSplitter" || st == "PurgedKFold") {
params["n_splits"] = splitter_n_splits_spin_->value();
params["nSplits"] = splitter_n_splits_spin_->value();
params["purge_len"] = splitter_purge_spin_->value();
params["purgeLen"] = splitter_purge_spin_->value();
params["embargo_len"] = splitter_embargo_spin_->value();
params["embargoLen"] = splitter_embargo_spin_->value();
}
args["params"] = params;
}
if (cmd_id == "returns") {
const QString at = returns_type_combo_->currentText();
args["analysisType"] = at;
if (!benchmark_edit_->text().trimmed().isEmpty())
args["benchmarkSymbol"] = benchmark_edit_->text().trimmed();
if (risk_free_spin_)
args["riskFreeRate"] = risk_free_spin_->value() / 100.0;
QJsonObject params;
if (at == "rolling") {
params["window"] = returns_window_spin_->value();
// vectorbt reads `metric` (singular string); zipline reads
// `metrics` (list, used as a set-membership check). Send both.
const QString m = returns_metric_combo_->currentText();
params["metric"] = m;
QJsonArray ml;
ml.append(m);
params["metrics"] = ml;
} else if (at == "ranges") {
params["threshold"] = returns_threshold_spin_->value();
}
if (!params.isEmpty())
args["params"] = params;
}
if (cmd_id == "signals") {
const QString g = signal_gen_combo_->currentText();
args["generatorType"] = g;
// vectorbt reads snake_case (n / entry_prob / exit_prob / min_hold / max_hold);
// zipline reads camelCase (n / entryProb / exitProb / minHold / maxHold).
// Send both so every provider gets what it needs.
QJsonObject params;
if (g == "RAND" || g == "RANDX" || g == "RANDNX") {
params["n"] = signal_count_spin_->value();
}
if (g == "RANDNX") {
params["min_hold"] = signal_min_hold_spin_->value();
params["max_hold"] = signal_max_hold_spin_->value();
params["minHold"] = signal_min_hold_spin_->value();
params["maxHold"] = signal_max_hold_spin_->value();
}
if (g == "RPROB" || g == "RPROBX") {
params["entry_prob"] = signal_entry_prob_spin_->value();
params["entryProb"] = signal_entry_prob_spin_->value();
}
if (g == "RPROBX") {
params["exit_prob"] = signal_exit_prob_spin_->value();
params["exitProb"] = signal_exit_prob_spin_->value();
}
args["params"] = params;
}
if (cmd_id == "labels_to_signals") {
// Shares the labels page's widgets (the labels_to_signals page only
// re-picks the generator). Apply the same type→params mapping so we
// don't send irrelevant params and so non-FIXLB types still get window.
const QString lt = l2s_label_type_combo_->currentText();
args["labelType"] = lt;
args["entryLabel"] = l2s_entry_label_spin_->value();
args["exitLabel"] = l2s_exit_label_spin_->value();
QJsonObject params;
if (lt == "FIXLB") {
params["horizon"] = labels_horizon_spin_->value();
params["threshold"] = labels_threshold_spin_->value();
} else if (lt == "MEANLB" || lt == "TRENDLB") {
params["window"] = labels_window_spin_->value();
params["threshold"] = labels_threshold_spin_->value();
} else if (lt == "LEXLB") {
params["window"] = labels_window_spin_->value();
} else if (lt == "BOLB") {
params["window"] = labels_window_spin_->value();
params["alpha"] = labels_alpha_spin_->value();
}
args["params"] = params;
}
if (cmd_id == "indicator_sweep") {
args["indicator"] = sweep_indicator_combo_->currentData().toString();
QJsonObject range;
range["min"] = sweep_min_spin_->value();
range["max"] = sweep_max_spin_->value();
range["step"] = sweep_step_spin_->value();
args["paramRange"] = range;
}
return args;
}
// ── Run ──────────────────────────────────────────────────────────────────────
void BacktestingScreen::on_run() {
if (is_running_)
return;
if (active_provider_ < 0 || active_provider_ >= providers_.size())
return;
if (active_command_ < 0 || active_command_ >= commands_.size())
return;
const auto& provider_info = providers_[active_provider_];
const auto& command_id = commands_[active_command_].id;
// Validate command is supported by current provider
if (!provider_info.commands.contains(command_id)) {
display_error(tr("Command '%1' is not supported by provider '%2'").arg(command_id, provider_info.display_name));
return;
}
// Validate symbols not empty
if (symbols_edit_->text().trimmed().isEmpty()) {
display_error(tr("Please enter at least one symbol (e.g. SPY, AAPL)"));
return;
}
// Date sanity: an inverted range reaches the Python provider as an empty download and
// comes back as a generic "no data" failure minutes later.
if (start_date_->date() >= end_date_->date()) {
display_error(tr("Start date must be before the end date."));
return;
}
is_running_ = true;
running_provider_ = provider_info.slug;
running_command_ = command_id;
run_button_->setEnabled(false);
cancel_button_->setVisible(true);
set_status_state(tr("EXECUTING… 0s"), QStringLiteral("running"));
start_run_ticker();
const auto args = gather_args();
// What was asked for, frozen at RUN time (the inputs may change before an export).
last_run_meta_ = QJsonObject{
{"provider", provider_info.display_name},
{"command", command_id},
{"symbols", args.value("symbols")},
{"startDate", args.value("startDate")},
{"endDate", args.value("endDate")},
{"interval", args.value("interval")},
{"strategy", args.value("strategy").toObject().value("name")},
{"initialCapital", args.value("initialCapital")},
{"commission", args.value("commission")},
{"slippage", args.value("slippage")},
};
LOG_INFO("Backtesting", QString("Executing %1/%2").arg(provider_info.slug, command_id));
current_run_id_ = BacktestingService::instance().execute(provider_info.slug, command_id, args);
}
void BacktestingScreen::on_cancel() {
if (!is_running_ || current_run_id_ == 0)
return;
// run_cancelled (emitted synchronously) resets the UI - see on_run_cancelled.
if (!BacktestingService::instance().cancel(current_run_id_))
end_run(); // run already gone (raced with its result): just leave the running state
}
void BacktestingScreen::end_run() {
is_running_ = false;
current_run_id_ = 0;
stop_run_ticker();
run_button_->setEnabled(true);
cancel_button_->setVisible(false);
}
} // namespace fincept::screens