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/ai_quant_lab/QuantModulePanel_Results.cpp
//
// Result rendering — the generic display_result() and the big on_result()
// dispatcher (rl_trading / online_learning / meta_learning / factor_discovery
// / model_library / live_signals / cfa_quant / gs_quant / functime / statsmodels
// / fortitudo / quant_reporting / gluonts / advanced_* / langgraph / rd_agent
// / backtesting / hft / rolling_retraining).
//
// Part of the partial-class split of QuantModulePanel.cpp.
#include "core/logging/Logger.h"
#include "screens/ai_quant_lab/QuantModulePanel.h"
#include "screens/ai_quant_lab/QuantModulePanel_Common.h"
#include "screens/ai_quant_lab/QuantModulePanel_GsHelpers.h"
#include "screens/ai_quant_lab/QuantModulePanel_Styles.h"
#include "services/ai_quant_lab/AIQuantLabService.h"
#include "services/file_manager/FileManagerService.h"
#include "storage/repositories/LlmProfileRepository.h"
#include "ui/theme/Theme.h"
#include "ui/theme/ThemeManager.h"
#include <QAreaSeries>
#include <QChart>
#include <QChartView>
#include <QDateTime>
#include <QDateTimeAxis>
#include <QDesktopServices>
#include <QFile>
#include <QFileInfo>
#include <QFrame>
#include <QGridLayout>
#include <QHBoxLayout>
#include <QHeaderView>
#include <QJsonArray>
#include <QJsonDocument>
#include <QLineSeries>
#include <QPlainTextEdit>
#include <QProgressBar>
#include <QRegularExpression>
#include <QScopeGuard>
#include <QScrollArea>
#include <QStackedWidget>
#include <QTabWidget>
#include <QTableWidget>
#include <QTableWidgetItem>
#include <QTimer>
#include <QUrl>
#include <QValueAxis>
#include <cmath>
namespace fincept::screens {
using namespace fincept::services::quant;
using namespace fincept::screens::quant_styles;
using namespace fincept::screens::quant_common;
using namespace fincept::screens::quant_gs_helpers;
void QuantModulePanel::display_result(const QJsonObject& payload) {
clear_results();
auto* header = new QLabel(tr("RESULTS"));
header->setStyleSheet(QString("color:%1; font-weight:700; font-family:%2; letter-spacing:1px;")
.arg(module_.color.name())
.arg(ui::fonts::DATA_FAMILY));
results_layout_->addWidget(header);
// Fallback renderer for commands without a dedicated display. It used to
// show only the top-level scalars plus the whole payload as a JSON text
// dump, so any list result (models, factors, windows, trades) was readable
// only as raw JSON. Now: scalars → key/value table, arrays of objects →
// column tables, scalar arrays → a summary row, nested objects → their own
// key/value section. Raw JSON stays available behind a toggle.
// Tables take their look from the panel stylesheet (refresh_theme →
// table_ss), so nothing here calls setStyleSheet per table.
constexpr int kMaxRows = 200;
constexpr int kMaxCols = 12;
auto pretty_key = [](QString k) {
k.replace('_', ' ');
return k.toUpper();
};
auto cell_text = [](const QJsonValue& v) -> QString {
if (v.isObject() || v.isArray()) {
const QJsonDocument doc = v.isObject() ? QJsonDocument(v.toObject()) : QJsonDocument(v.toArray());
return QString::fromUtf8(doc.toJson(QJsonDocument::Compact)).left(120);
}
if (v.isNull() || v.isUndefined())
return QString::fromUtf8("—");
return format_val(v);
};
auto make_table = [this](int rows, const QStringList& headers) {
auto* t = new QTableWidget(rows, headers.size(), this);
t->setHorizontalHeaderLabels(headers);
t->setEditTriggers(QAbstractItemView::NoEditTriggers);
t->setAlternatingRowColors(true);
t->setSortingEnabled(false);
t->horizontalHeader()->setStretchLastSection(true);
t->verticalHeader()->setVisible(false);
t->setMaximumHeight(qMin(rows * 26 + 32, 420));
return t;
};
auto add_kv_table = [&](const QJsonObject& obj) {
QStringList keys;
for (auto it = obj.begin(); it != obj.end(); ++it)
if (!it.value().isObject() && !it.value().isArray())
keys.append(it.key());
if (keys.isEmpty())
return;
auto* table = make_table(keys.size(), {tr("Metric"), tr("Value")});
for (int r = 0; r < keys.size(); ++r) {
table->setItem(r, 0, new QTableWidgetItem(pretty_key(keys[r])));
auto* vi = new QTableWidgetItem(cell_text(obj.value(keys[r])));
vi->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
table->setItem(r, 1, vi);
}
table->resizeColumnsToContents();
results_layout_->addWidget(table);
};
add_kv_table(payload);
for (auto it = payload.begin(); it != payload.end(); ++it) {
const QString title = pretty_key(it.key());
if (it.value().isObject()) {
const QJsonObject obj = it.value().toObject();
if (obj.isEmpty())
continue;
results_layout_->addWidget(gs_section_header(title, module_.color.name()));
add_kv_table(obj);
QStringList nested;
for (auto n = obj.begin(); n != obj.end(); ++n)
if (n.value().isObject() || n.value().isArray())
nested << pretty_key(n.key());
if (!nested.isEmpty()) {
auto* note = new QLabel(tr("Nested fields (see raw JSON): %1").arg(nested.join(QStringLiteral(", "))));
note->setWordWrap(true);
results_layout_->addWidget(note);
}
continue;
}
if (!it.value().isArray())
continue;
const QJsonArray arr = it.value().toArray();
if (arr.isEmpty()) {
results_layout_->addWidget(gs_section_header(tr("%1 | empty").arg(title), module_.color.name()));
continue;
}
if (arr.first().isObject()) {
// Column set = union of keys over the shown rows, in first-seen order.
QStringList cols;
const int shown = qMin(static_cast<int>(arr.size()), kMaxRows);
for (int r = 0; r < shown && cols.size() < kMaxCols; ++r) {
const QJsonObject row = arr.at(r).toObject();
for (auto c = row.begin(); c != row.end() && cols.size() < kMaxCols; ++c)
if (!cols.contains(c.key()))
cols << c.key();
}
const QString count = shown < arr.size() ? tr("first %1 of %2 rows").arg(shown).arg(arr.size())
: tr("%n row(s)", "", static_cast<int>(arr.size()));
results_layout_->addWidget(
gs_section_header(QStringLiteral("%1 | %2").arg(title, count), module_.color.name()));
QStringList headers;
for (const auto& c : cols)
headers << pretty_key(c);
auto* table = make_table(shown, headers);
for (int r = 0; r < shown; ++r) {
const QJsonObject row = arr.at(r).toObject();
for (int c = 0; c < cols.size(); ++c) {
const QJsonValue v = row.value(cols[c]);
auto* item = new QTableWidgetItem(cell_text(v));
if (v.isDouble())
item->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
table->setItem(r, c, item);
}
}
table->resizeColumnsToContents();
results_layout_->addWidget(table);
continue;
}
// Scalar array: numeric → summary statistics; otherwise a joined list.
bool numeric = true;
double mn = 0.0, mx = 0.0, sum = 0.0;
int n_num = 0;
for (const auto& v : arr) {
if (!v.isDouble()) {
numeric = false;
break;
}
const double x = v.toDouble();
mn = n_num == 0 ? x : qMin(mn, x);
mx = n_num == 0 ? x : qMax(mx, x);
sum += x;
++n_num;
}
if (numeric && n_num > 0) {
results_layout_->addWidget(gs_section_header(
tr("%1 | series of %2 values").arg(title).arg(n_num), module_.color.name()));
auto* table = make_table(1, {tr("Count"), tr("First"), tr("Last"), tr("Min"), tr("Max"), tr("Mean")});
const QStringList cells = {QString::number(n_num), format_val(arr.first()), format_val(arr.last()),
format_val(QJsonValue(mn)), format_val(QJsonValue(mx)),
format_val(QJsonValue(sum / n_num))};
for (int c = 0; c < cells.size(); ++c) {
auto* item = new QTableWidgetItem(cells[c]);
item->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
table->setItem(0, c, item);
}
results_layout_->addWidget(table);
} else {
QStringList parts;
for (int i = 0; i < arr.size() && i < kMaxRows; ++i)
parts << cell_text(arr.at(i));
results_layout_->addWidget(
gs_section_header(tr("%1 | %n item(s)", "", static_cast<int>(arr.size())).arg(title),
module_.color.name()));
auto* list = new QLabel(parts.join(QStringLiteral(", ")) +
(arr.size() > kMaxRows ? tr(" … (+%1 more)").arg(arr.size() - kMaxRows) : QString()));
list->setWordWrap(true);
list->setTextInteractionFlags(Qt::TextSelectableByMouse);
results_layout_->addWidget(list);
}
}
// Raw JSON — collapsed by default; for checking exact values / bug reports.
auto* raw = new QTextEdit;
raw->setReadOnly(true);
raw->setMaximumHeight(240);
raw->setPlainText(QJsonDocument(payload).toJson(QJsonDocument::Indented));
raw->setStyleSheet(output_ss());
raw->hide();
auto* raw_toggle = new QPushButton(tr("SHOW RAW JSON"));
raw_toggle->setCursor(Qt::PointingHandCursor);
raw_toggle->setFixedHeight(24);
raw_toggle->setObjectName(QStringLiteral("quantQuietButton")); // styled by refresh_theme()
connect(raw_toggle, &QPushButton::clicked, this, [raw, raw_toggle]() {
raw->setVisible(!raw->isVisible());
raw_toggle->setText(raw->isVisible() ? QuantModulePanel::tr("HIDE RAW JSON")
: QuantModulePanel::tr("SHOW RAW JSON"));
});
results_layout_->addWidget(raw_toggle);
results_layout_->addWidget(raw);
// Export button — saves raw JSON to File Manager
auto* export_btn = new QPushButton(tr("EXPORT RESULTS"));
export_btn->setCursor(Qt::PointingHandCursor);
export_btn->setFixedHeight(28);
export_btn->setStyleSheet(QString("QPushButton { background:transparent; color:%1; border:1px solid %2; "
"font-size:%3px; font-family:%4; padding:0 12px; }"
"QPushButton:hover { color:%1; background:rgba(255,255,255,0.05); }")
.arg(module_.color.name(), ui::colors::BORDER_DIM())
.arg(ui::fonts::SMALL)
.arg(ui::fonts::DATA_FAMILY));
QString json_str = QJsonDocument(payload).toJson(QJsonDocument::Indented);
connect(export_btn, &QPushButton::clicked, this, [this, json_str]() {
QString safe_name = module_.label;
safe_name.replace(QRegularExpression("[^a-zA-Z0-9_\\-]"), "_");
QString stored_name = safe_name + "_" + QString::number(QDateTime::currentMSecsSinceEpoch()) + ".json";
QString dest = services::FileManagerService::instance().storage_dir() + "/" + stored_name;
QFile f(dest);
if (f.open(QIODevice::WriteOnly | QIODevice::Text)) {
f.write(json_str.toUtf8());
f.close();
services::FileManagerService::instance().register_file(stored_name, module_.label + "_result.json",
QFileInfo(dest).size(), "application/json",
"ai_quant_lab");
LOG_INFO("AIQuantLab", "Exported result: " + stored_name);
if (status_label_)
status_label_->setText(tr("Exported to File Manager: %1").arg(stored_name));
} else {
// A failed export used to do nothing at all.
LOG_WARN("AIQuantLab", "Export failed: " + f.errorString());
if (status_label_)
status_label_->setText(tr("Export failed: %1").arg(f.errorString()));
}
});
results_layout_->addWidget(export_btn);
status_label_->setText(tr("Done"));
}
// ── Signal handlers ──────────────────────────────────────────────────────────
void QuantModulePanel::on_result(const QString& module_id, const QString& command, const QJsonObject& payload) {
if (module_id != module_.id)
return;
// A result that carries a "warning" (trained on synthetic data, a benchmark that failed to
// resolve, an ensemble that is only a definition) has to say so where the user reads it --
// the card renderers below never looked at the key. Runs after whichever renderer handles
// the payload, and puts the banner above the cards. get_data renders its own warning card.
const auto warning_banner = qScopeGuard([this, &payload, &command]() {
const bool sample = sample_input_pending_;
sample_input_pending_ = false;
if (!results_layout_)
return;
const QString warning = payload.value("warning").toString().trimmed();
if (!warning.isEmpty() && command != "get_data") {
auto* banner = gs_section_header(QString::fromUtf8("⚠ ") + warning, ui::colors::WARNING());
banner->setWordWrap(true);
results_layout_->insertWidget(0, banner);
}
// Results computed on LOAD SYNTHETIC SAMPLE data look exactly like real
// ones; say so above them, every time.
if (sample) {
auto* banner = gs_section_header(tr("SAMPLE INPUT — computed on generated (synthetic) data from LOAD "
"SYNTHETIC SAMPLE, not on market data. Replace the inputs with "
"your own series for a real analysis."),
ui::colors::WARNING());
banner->setWordWrap(true);
results_layout_->insertWidget(0, banner);
}
});
// RL Trading: training finished → re-enable button, keep progress/logs visible so
// the user can inspect the run. The card-based renderer below paints into
// the bottom results pane (in addition to the bespoke log/progress widgets).
if (module_id == "rl_trading" && command == "train" && rl_train_button_) {
rl_train_button_->setEnabled(true);
if (rl_progress_bar_)
rl_progress_bar_->setValue(100);
}
if (module_id == "rl_trading") {
display_rl_trading_result(command, payload);
return;
}
if (module_id == "online_learning") {
display_online_learning_result(command, payload);
return;
}
if (module_id == "meta_learning") {
display_meta_learning_result(command, payload);
return;
}
// CORE-category renderers (backtesting handled later via display_backtest_result)
if (module_id == "factor_discovery") {
display_factor_discovery_result(command, payload);
return;
}
if (module_id == "model_library") {
display_model_library_result(command, payload);
return;
}
if (module_id == "live_signals") {
display_live_signals_result(command, payload);
return;
}
// ── CFA Quant: uniform result shape across all analyses ──────────────────
if (module_id == "cfa_quant") {
display_cfa_result(command, payload);
return;
}
// ── GS Quant: rich card-based display per sub-tab ────────────────────────
if (module_id == "gs_quant") {
display_gs_result(command, payload);
return;
}
// ── Functime: rich card-based display per sub-tab ────────────────────────
if (module_id == "functime") {
display_functime_result(command, payload);
return;
}
// ── Statsmodels: rich card-based display per sub-tab ─────────────────────
if (module_id == "statsmodels") {
display_statsmodels_result(command, payload);
return;
}
// ── Fortitudo: rich card-based display per sub-tab ───────────────────────
if (module_id == "fortitudo") {
display_fortitudo_result(command, payload);
return;
}
// ── Quant Reporting: rich card-based display per sub-tab ─────────────────
if (module_id == "quant_reporting") {
display_quant_reporting_result(command, payload);
return;
}
// ── GluonTS: rich card-based display per sub-tab ─────────────────────────
if (module_id == "gluonts") {
display_gluonts_result(command, payload);
return;
}
// ── ADVANCED-category panels: card-based displays ────────────────────────
// hft and rolling_retraining are intentionally NOT dispatched here — they
// have bespoke per-tab UI (in-tab card grid + order-book tables for HFT;
// progress bar + schedule cards for Rolling Retraining) handled later in
// this function. Re-routing them to the generic results pane would create
// a duplicate, disconnected display.
if (module_id == "advanced_models") {
display_advanced_models_result(command, payload);
return;
}
if (module_id == "feature_engineering") {
display_feature_engineering_result(command, payload);
return;
}
if (module_id == "portfolio_opt") {
display_portfolio_opt_result(command, payload);
return;
}
if (module_id == "factor_evaluation") {
display_factor_evaluation_result(command, payload);
return;
}
if (module_id == "strategy_builder") {
display_strategy_builder_result(command, payload);
return;
}
if (module_id == "data_processors") {
display_data_processors_result(command, payload);
return;
}
// ── LangGraph deep analysis result ───────────────────────────────────────
if (command == "execute_task") {
for (auto* b : findChildren<QPushButton*>(QStringLiteral("quantRunButton")))
if (b->property("deepRun").toBool())
b->setEnabled(true);
if (!payload["success"].toBool()) {
const QString err = payload["error"].toString(tr("Unknown error"));
// agent_output_ still says "Running multi-agent analysis..." — replace
// it, or the failure (painted in the pane below) reads as in-progress.
if (agent_output_)
agent_output_->setPlainText(tr("Deep analysis failed:\n\n%1").arg(err));
display_error(err);
return;
}
auto text = payload["result"].toString();
if (text.isEmpty())
text = QJsonDocument(payload).toJson(QJsonDocument::Indented);
if (agent_output_)
agent_output_->setPlainText(text);
auto tid = payload["thread_id"].toString();
status_label_->setText(tid.isEmpty() ? tr("Done") : tr("Done — thread: %1").arg(tid));
return;
}
// RD-Agent branches. The RD-Agent tab has its own status strip ("Checking...", "Refreshing
// task list...") that the buttons set when they fire a request; nothing ever cleared it, so
// it read "Checking..." forever. And display_error() paints into the Deep Analysis tab's
// results pane, which is on the other page of the outer QTabWidget -- a failed RD-Agent call
// showed the user nothing. Route both to this tab.
auto rd_status = [this](const QString& text) {
status_label_->setText(text);
if (auto* lbl = findChild<QLabel*>(QStringLiteral("rdStatusTxt")))
lbl->setText(text);
};
auto rd_fail = [this, &rd_status](const QString& text) {
rd_status(text);
if (rd_agent_output_)
rd_agent_output_->setPlainText(text);
};
// ── RD-Agent: check_status ────────────────────────────────────────────────
if (command == "check_status") {
auto ver = payload["rdagent_version"].toString("?");
auto avail = payload["availability"].toObject();
QStringList flags;
for (auto it = avail.begin(); it != avail.end(); ++it)
if (it.value().toBool())
flags << it.key();
rd_status(tr("rdagent %1 — %2").arg(ver, flags.join(", ")));
return;
}
// ── RD-Agent: task started (factor_mining / model_optimization / quant_research) ──
if (command == "start_factor_mining" || command == "start_model_optimization" ||
command == "start_quant_research") {
if (!payload["success"].toBool()) {
rd_fail(payload["error"].toString(tr("Unknown error")));
return;
}
auto task_id = payload["task_id"].toString();
auto est = payload["estimated_time"].toString();
rd_status(tr("Task %1 started").arg(task_id));
// Populate the monitor right away (in-memory listing); its result arms
// the auto-refresh while the task runs.
AIQuantLabService::instance().rd_agent_list_tasks({});
if (rd_agent_output_)
rd_agent_output_->setPlainText(
tr("Task started: %1\nEstimated time: %2\n\nUse Task Monitor → REFRESH to track progress.")
.arg(task_id, est));
return;
}
// ── RD-Agent: list_tasks ──────────────────────────────────────────────────
if (command == "list_tasks" && rd_task_table_) {
auto tasks = payload["tasks"].toArray();
// Keep the user's selection across the rebuild — the monitor now
// auto-refreshes every 5 s while a task runs.
QString selected_id;
if (const int cur = rd_task_table_->currentRow(); cur >= 0 && rd_task_table_->item(cur, 0))
selected_id = rd_task_table_->item(cur, 0)->text();
bool any_running = false;
rd_task_table_->setRowCount(0);
for (const auto& t : tasks) {
auto obj = t.toObject();
int row = rd_task_table_->rowCount();
rd_task_table_->insertRow(row);
rd_task_table_->setItem(row, 0, new QTableWidgetItem(obj["task_id"].toString()));
rd_task_table_->setItem(row, 1, new QTableWidgetItem(obj["type"].toString()));
auto status_str = obj["status"].toString();
any_running = any_running || status_str == QLatin1String("running");
auto* status_item = new QTableWidgetItem(status_str);
if (status_str == "running")
status_item->setForeground(QColor("" + QString(ui::colors::WARNING()) + ""));
else if (status_str == "completed")
status_item->setForeground(QColor("" + QString(ui::colors::POSITIVE()) + ""));
else if (status_str == "failed" || status_str == "stopped")
status_item->setForeground(QColor("" + QString(ui::colors::NEGATIVE()) + ""));
rd_task_table_->setItem(row, 2, status_item);
rd_task_table_->setItem(
row, 3, new QTableWidgetItem(QString::number(obj["progress"].toDouble() * 100, 'f', 0) + "%"));
auto ic = obj["best_ic"];
rd_task_table_->setItem(row, 4,
new QTableWidgetItem(ic.isNull() ? "-" : QString::number(ic.toDouble(), 'f', 4)));
rd_task_table_->setItem(row, 5, new QTableWidgetItem(obj["elapsed_time"].toString("-")));
if (!selected_id.isEmpty() && obj["task_id"].toString() == selected_id)
rd_task_table_->setCurrentCell(row, 0);
}
if (auto* poll = findChild<QTimer*>(QStringLiteral("rdTaskPollTimer"))) {
poll->setProperty("rdActive", any_running);
if (any_running && rd_task_table_->isVisible()) {
if (!poll->isActive())
poll->start();
} else {
poll->stop();
}
}
rd_status(any_running ? tr("%1 task(s) · auto-refreshing every 5 s").arg(tasks.size())
: tr("%1 task(s)").arg(tasks.size()));
return;
}
// ── RD-Agent: get_task_status ─────────────────────────────────────────────
if (command == "get_task_status") {
if (!payload["success"].toBool()) {
rd_fail(payload["error"].toString(tr("Unknown error")));
return;
}
auto task_id = payload["task_id"].toString();
auto progress = payload["progress"].toDouble() * 100;
auto step = payload["current_step"].toString();
auto ic = payload["best_ic"];
rd_status(tr("Task %1 — %2% — %3").arg(task_id).arg(progress, 0, 'f', 0).arg(step));
if (rd_agent_output_) {
rd_agent_output_->setPlainText(
tr("Task ID: %1\nStatus: %2\nProgress: %3%\nStep: %4\nBest IC: %5\nElapsed: %6")
.arg(task_id, payload["status"].toString())
.arg(progress, 0, 'f', 0)
.arg(step)
.arg(ic.isNull() ? tr("N/A") : QString::number(ic.toDouble(), 'f', 4))
.arg(payload["elapsed_time"].toString("-")));
}
return;
}
// ── RD-Agent: get_discovered_factors ──────────────────────────────────────
if (command == "get_discovered_factors" && rd_agent_output_) {
if (!payload["success"].toBool()) {
rd_fail(payload["error"].toString(tr("Unknown error")));
return;
}
auto factors = payload["factors"].toArray();
auto best_ic = payload["best_ic"];
QString out = tr("Discovered Factors: %1 | Best IC: %2\n\n")
.arg(factors.size())
.arg(best_ic.isNull() ? tr("N/A") : QString::number(best_ic.toDouble(), 'f', 4));
int idx = 1;
for (const auto& f : factors) {
auto obj = f.toObject();
out += tr("[%1] %2\n IC: %3 Sharpe: %4\n %5\n\n")
.arg(idx++)
.arg(obj["name"].toString(tr("Factor")))
.arg(obj["ic"].isNull() ? tr("N/A") : QString::number(obj["ic"].toDouble(), 'f', 4))
.arg(obj["sharpe"].isNull() ? tr("N/A") : QString::number(obj["sharpe"].toDouble(), 'f', 3))
.arg(obj["description"].toString());
}
rd_agent_output_->setPlainText(out);
rd_status(tr("Found %1 factor(s)").arg(factors.size()));
return;
}
// ── RD-Agent: get_optimized_model ─────────────────────────────────────────
if (command == "get_optimized_model" && rd_agent_output_) {
if (!payload["success"].toBool()) {
rd_fail(payload["error"].toString(tr("Unknown error")));
return;
}
auto models = payload["models"].toArray();
QString out = tr("Optimized Models: %1\n\n").arg(models.size());
int idx = 1;
for (const auto& m : models) {
auto obj = m.toObject();
out += tr("[%1] %2\n Sharpe: %3 IC: %4\n")
.arg(idx++)
.arg(obj["model_id"].toString(tr("Model")))
.arg(obj["sharpe"].isNull() ? tr("N/A") : QString::number(obj["sharpe"].toDouble(), 'f', 3))
.arg(obj["ic"].isNull() ? tr("N/A") : QString::number(obj["ic"].toDouble(), 'f', 4));
}
rd_agent_output_->setPlainText(out);
rd_status(tr("%1 optimized model(s)").arg(models.size()));
return;
}
// ── RD-Agent: stop_task / resume_task ────────────────────────────────────
if (command == "stop_task" || command == "resume_task") {
// A refused stop / resume ("Task not found", "No checkpoint found") comes back as
// success:false with the reason in "error", not in "message".
if (!payload["success"].toBool(true)) {
rd_fail(payload["error"].toString(tr("Unknown error")));
return;
}
rd_status(payload["message"].toString(command));
if (rd_agent_output_)
rd_agent_output_->setPlainText(payload["message"].toString());
return;
}
// ── RD-Agent: start_ui ───────────────────────────────────────────────────
if (command == "start_ui") {
auto url = payload["url"].toString();
if (!url.isEmpty()) {
rd_status(tr("Log viewer: %1").arg(url));
QDesktopServices::openUrl(QUrl(url));
} else {
rd_fail(payload["error"].toString(tr("The log viewer did not report a URL.")));
}
return;
}
// ── RD-Agent: start_mcp_server ────────────────────────────────────────────
if (command == "start_mcp_server") {
if (!payload["success"].toBool()) {
rd_status(tr("MCP server failed"));
if (rd_agent_output_)
rd_agent_output_->setPlainText(
tr("MCP server failed to start:\n%1\n\nInstall: %2")
.arg(payload["error"].toString())
.arg(payload["install"].toString("pip install 'mcp[cli]' 'pydantic-ai[mcp]' yfinance")));
return;
}
auto url = payload["url"].toString();
auto port = payload["port"].toInt();
auto tools = payload["tools"].toArray();
QStringList tool_names;
for (const auto& t : tools)
tool_names << t.toString();
rd_status(tr("MCP ready on port %1").arg(port));
if (rd_agent_output_)
rd_agent_output_->setPlainText(tr("MCP tool server running at %1\n\nAvailable tools:\n %2\n\n"
"Enable 'enable_mcp: true' in factor/model/quant research params\n"
"to give RD-Agent loops access to these tools.")
.arg(url, tool_names.join("\n ")));
return;
}
// ── RD-Agent: mcp_status ─────────────────────────────────────────────────
if (command == "mcp_status") {
auto avail = payload["mcp_server_available"].toBool();
auto pai_mcp = payload["pydantic_ai_mcp"].toBool();
auto ports = payload["running_ports"].toArray();
QString info = tr("MCP server available: %1\npydantic-ai MCP: %2\nRunning ports: %3")
.arg(avail ? tr("yes") : tr("no"))
.arg(pai_mcp ? tr("yes") : tr("no"))
.arg(ports.isEmpty() ? tr("none") : [&]() {
QStringList ps;
for (const auto& p : ports)
ps << QString::number(p.toInt());
return ps.join(", ");
}());
rd_status(avail ? tr("MCP available") : tr("MCP not installed"));
if (rd_agent_output_)
rd_agent_output_->setPlainText(info);
return;
}
// ── Backtesting ───────────────────────────────────────────────────────────
if (module_id == "backtesting") {
if (!payload["success"].toBool()) {
display_error(payload["error"].toString(tr("Unknown error")));
return;
}
if (command == "run_backtest") {
display_backtest_result(payload);
return;
}
display_result(payload);
return;
}
// factor_discovery, model_library, live_signals are now rendered by the
// card-based dispatch at the top of this function (display_*_result in
// QuantModulePanel_CoreDisplays.cpp).
//
// online_learning and meta_learning are also rendered by card-based
// dispatches at the top (display_*_result in
// QuantModulePanel_AIMLDisplays.cpp).
// ── HFT ──────────────────────────────────────────────────────────────────
if (module_id == "hft") {
if (!payload["success"].toBool()) {
display_error(payload["error"].toString());
return;
}
// HFT paints into fixed in-tab cards rather than the results pane, so
// nothing else clears a previously shown error banner — do it here or a
// stale red box sits under a successful run forever.
clear_results();
// Helper: find a named child label in this panel and set its text
auto set_card = [this](const QString& name, const QString& text, const QString& color = {}) {
auto* lbl = this->findChild<QLabel*>(name);
if (!lbl)
return;
lbl->setText(text);
if (!color.isEmpty())
lbl->setStyleSheet(
QString(
"color:%1; font-size:13px; font-weight:700; font-family:'Courier New'; background:transparent;")
.arg(color));
};
// Helper: populate a bid or ask QTableWidget from a JSON array [[price,size],...]
auto fill_book_table = [this](const QString& name, const QJsonArray& levels, bool is_bid) {
auto* tbl = this->findChild<QTableWidget*>(name);
if (!tbl)
return;
const int n = qMin(levels.size(), 10);
tbl->setRowCount(n);
double cumulative = 0.0;
const QString price_col = is_bid ? QString(ui::colors::POSITIVE()) : QString(ui::colors::NEGATIVE());
for (int i = 0; i < n; ++i) {
const auto row = levels[i].toArray();
const double price = row.size() > 0 ? row[0].toDouble() : 0.0;
const double size = row.size() > 1 ? row[1].toDouble() : 0.0;
cumulative += size;
auto* pi = new QTableWidgetItem(QString::number(price, 'f', 4));
pi->setForeground(QColor(price_col));
auto* si = new QTableWidgetItem(QString::number(size, 'g', 5));
si->setForeground(QColor(QString(ui::colors::TEXT_PRIMARY())));
auto* ci = new QTableWidgetItem(QString::number(cumulative, 'g', 6));
ci->setForeground(QColor(QString(ui::colors::TEXT_TERTIARY())));
tbl->setItem(i, 0, pi);
tbl->setItem(i, 1, si);
tbl->setItem(i, 2, ci);
tbl->setRowHeight(i, 22);
}
};
// ── fetch_orderbook ────────────────────────────────────────────────
if (command == "fetch_orderbook") {
const auto bids = payload["bids"].toArray();
const auto asks = payload["asks"].toArray();
const double mid = payload["mid_price"].toDouble();
const double spread_bps = payload["spread_bps"].toDouble();
const double obi = payload["obi"].toDouble();
const QString pres = payload["pressure"].toString();
const double wmid = payload["weighted_mid"].toDouble();
const double lat = payload["latency_ms"].toDouble();
// Update latency badge
if (auto* lbl = this->findChild<QLabel*>("hftLatency"))
lbl->setText(tr("LATENCY %1 ms").arg(lat, 0, 'f', 1));
// Metric cards
set_card("hft_mid_val", QString::number(mid, 'f', 4));
set_card("hft_spread_val", QString::number(spread_bps, 'f', 3) + tr(" bps"));
const QString obi_color = obi > 0.1 ? QString(ui::colors::POSITIVE())
: obi < -0.1 ? QString(ui::colors::NEGATIVE())
: QString(ui::colors::TEXT_PRIMARY());
set_card("hft_obi_val", QString::number(obi, 'f', 4), obi_color);
const QString pres_color = pres == "BUY" ? QString(ui::colors::POSITIVE())
: pres == "SELL" ? QString(ui::colors::NEGATIVE())
: QString(ui::colors::TEXT_PRIMARY());
set_card("hft_pressure_val", pres, pres_color);
set_card("hft_wmid_val", QString::number(wmid, 'f', 4));
fill_book_table("hft_bid_table", bids, true);
fill_book_table("hft_ask_table", asks, false);
status_label_->setText(tr("%1 mid: %2 spread: %3 bps OBI: %4")
.arg(payload["symbol"].toString())
.arg(mid, 0, 'f', 4)
.arg(spread_bps, 0, 'f', 3)
.arg(obi, 0, 'f', 4));
return;
}
// ── market_making ─────────────────────────────────────────────────
if (command == "market_making") {
const auto mm = payload["market_making"].toObject();
// Also update book metrics if present
if (payload.contains("book_metrics")) {
const auto bm = payload["book_metrics"].toObject();
set_card("hft_mid_val", QString::number(bm["mid_price"].toDouble(), 'f', 4));
set_card("hft_spread_val", QString::number(bm["spread_bps"].toDouble(), 'f', 3) + tr(" bps"));
}
set_card("hft_mm_bid", QString::number(mm["bid_price"].toDouble(), 'f', 4),
QString(ui::colors::POSITIVE()));
set_card("hft_mm_ask", QString::number(mm["ask_price"].toDouble(), 'f', 4),
QString(ui::colors::NEGATIVE()));
set_card("hft_mm_qspread", QString::number(mm["quoted_spread_bps"].toDouble(), 'f', 3) + tr(" bps"));
set_card("hft_mm_edge", QString::number(mm["edge_per_side_bps"].toDouble(), 'f', 3) + tr(" bps"));
const QString rec = mm["recommendation"].toString();
const QString r_col = rec == "WIDEN" ? QString(ui::colors::WARNING())
: rec == "TIGHTEN" ? QString(ui::colors::POSITIVE())
: QString(ui::colors::TEXT_PRIMARY());
set_card("hft_mm_rec", rec, r_col);
status_label_->setText(tr("Bid: %1 Ask: %2 Edge: %3 bps/side")
.arg(mm["bid_price"].toDouble(), 0, 'f', 4)
.arg(mm["ask_price"].toDouble(), 0, 'f', 4)
.arg(mm["edge_per_side_bps"].toDouble(), 0, 'f', 3));
return;
}
// ── toxic_flow ────────────────────────────────────────────────────
if (command == "toxic_flow") {
const auto tf = payload["toxic_flow"].toObject();
const bool is_toxic = tf["is_toxic"].toBool();
const double score = tf["toxicity_score"].toDouble();
const QString cls = tf["classification"].toString();
const QString action = tf["action"].toString();
const QString score_col = score > 60 ? QString(ui::colors::NEGATIVE())
: score > 30 ? QString(ui::colors::WARNING())
: QString(ui::colors::POSITIVE());
set_card("hft_tox_pin", QString::number(score, 'f', 1), score_col);
set_card("hft_tox_vol", QString::number(tf["vol_imbalance"].toDouble(), 'f', 4));
set_card("hft_tox_impact", QString::number(tf["price_impact_bps"].toDouble(), 'f', 2) + tr(" bps"));
const QString cls_col = cls == "HIGH_RISK" ? QString(ui::colors::NEGATIVE())
: cls == "ELEVATED" ? QString(ui::colors::WARNING())
: QString(ui::colors::POSITIVE());
set_card("hft_tox_class", cls, cls_col);
const QString act_col = action == "WIDEN_SPREADS" || action == "STEP_BACK"
? QString(ui::colors::WARNING())
: QString(ui::colors::POSITIVE());
set_card("hft_tox_action", QString(action).replace('_', ' '), act_col);
status_label_->setText(is_toxic ? tr("TOXIC FLOW DETECTED — score: %1 — %2").arg(score, 0, 'f', 1).arg(cls)
: tr("Flow clean — score: %1 — %2").arg(score, 0, 'f', 1).arg(cls));
return;
}
// ── slippage ──────────────────────────────────────────────────────
if (command == "slippage") {
const auto sl = payload; // flat: average_price, slippage_bps, fills, etc at top level
const double avg_p = sl["average_price"].toDouble();
const double sl_bps = sl["slippage_bps"].toDouble();
const double cost = sl["total_cost"].toDouble();
const int n_fills = sl["fill_count"].toInt();
const bool viable = sl["viable"].toBool();
set_card("hft_slip_avgp", QString::number(avg_p, 'f', 4));
const QString bps_col = sl_bps < 5 ? QString(ui::colors::POSITIVE())
: sl_bps < 20 ? QString(ui::colors::WARNING())
: QString(ui::colors::NEGATIVE());
set_card("hft_slip_bps", QString::number(sl_bps, 'f', 4) + tr(" bps"), bps_col);
set_card("hft_slip_cost", QString::number(cost, 'f', 4));
set_card("hft_slip_fills", QString::number(n_fills));
set_card("hft_slip_viable", viable ? tr("VIABLE") : tr("HIGH SLIP"),
viable ? QString(ui::colors::POSITIVE()) : QString(ui::colors::NEGATIVE()));
// Populate fills table
if (auto* tbl = this->findChild<QTableWidget*>("hft_slip_table")) {
const auto fills = sl["fills"].toArray();
tbl->setRowCount(fills.size());
for (int i = 0; i < fills.size(); ++i) {
const auto f = fills[i].toObject();
tbl->setItem(i, 0, new QTableWidgetItem(QString::number(f["price"].toDouble(), 'f', 4)));
tbl->setItem(i, 1, new QTableWidgetItem(QString::number(f["quantity"].toDouble(), 'g', 6)));
tbl->setItem(i, 2, new QTableWidgetItem(QString::number(f["cost"].toDouble(), 'f', 4)));
tbl->setRowHeight(i, 20);
}
}
status_label_->setText(tr("Avg fill: %1 | Slippage: %2 bps | %3")
.arg(avg_p, 0, 'f', 4)
.arg(sl_bps, 0, 'f', 4)
.arg(viable ? tr("VIABLE") : tr("HIGH SLIPPAGE")));
return;
}
// ── analyze (full analysis) ───────────────────────────────────────
if (command == "analyze") {
// Sub-analyses report their own failure as {"error": "..."} (too few trades,
// zero spread, thin book). Their cards used to render as 0.0000 and the toxic-flow
// card as a CLEAN reading; collect the messages and show them instead.
QStringList partial_errors;
auto sub_error = [&partial_errors, &set_card](const QJsonObject& sub, const QString& what,
const QStringList& cards) {
const QString err = sub.value("error").toString();
if (err.isEmpty())
return false;
partial_errors << QString("%1: %2").arg(what, err);
for (const auto& card : cards) // do not leave the previous run's values on screen
set_card(card, QStringLiteral("—"));
return true;
};
// Dispatch sub-results to each section
if (payload.contains("bids")) {
const auto bids = payload["bids"].toArray();
const auto asks = payload["asks"].toArray();
fill_book_table("hft_bid_table", bids, true);
fill_book_table("hft_ask_table", asks, false);
}
if (payload.contains("book_metrics")) {
const auto bm = payload["book_metrics"].toObject();
set_card("hft_mid_val", QString::number(bm["mid_price"].toDouble(), 'f', 4));
set_card("hft_spread_val", QString::number(bm["spread_bps"].toDouble(), 'f', 3) + tr(" bps"));
const double obi = bm["obi"].toDouble();
const QString obi_col = obi > 0.1 ? QString(ui::colors::POSITIVE())
: obi < -0.1 ? QString(ui::colors::NEGATIVE())
: QString(ui::colors::TEXT_PRIMARY());
set_card("hft_obi_val", QString::number(obi, 'f', 4), obi_col);
const QString pres = bm["pressure"].toString();
const QString p_col = pres == "BUY" ? QString(ui::colors::POSITIVE())
: pres == "SELL" ? QString(ui::colors::NEGATIVE())
: QString(ui::colors::TEXT_PRIMARY());
set_card("hft_pressure_val", pres, p_col);
set_card("hft_wmid_val", QString::number(bm["weighted_mid"].toDouble(), 'f', 4));
}
if (payload.contains("market_making") && !sub_error(payload["market_making"].toObject(), tr("Quotes"),
{"hft_mm_bid", "hft_mm_ask", "hft_mm_qspread",
"hft_mm_edge", "hft_mm_rec"})) {
const auto mm = payload["market_making"].toObject();
set_card("hft_mm_bid", QString::number(mm["bid_price"].toDouble(), 'f', 4),
QString(ui::colors::POSITIVE()));
set_card("hft_mm_ask", QString::number(mm["ask_price"].toDouble(), 'f', 4),
QString(ui::colors::NEGATIVE()));
set_card("hft_mm_qspread", QString::number(mm["quoted_spread_bps"].toDouble(), 'f', 3) + tr(" bps"));
set_card("hft_mm_edge", QString::number(mm["edge_per_side_bps"].toDouble(), 'f', 3) + tr(" bps"));
set_card("hft_mm_rec", mm["recommendation"].toString());
}
if (payload.contains("toxic_flow") && !sub_error(payload["toxic_flow"].toObject(), tr("Toxic flow"),
{"hft_tox_pin", "hft_tox_vol", "hft_tox_impact",
"hft_tox_class", "hft_tox_action"})) {
const auto tf = payload["toxic_flow"].toObject();
const double sc = tf["toxicity_score"].toDouble();
const QString col = sc > 60 ? QString(ui::colors::NEGATIVE())
: sc > 30 ? QString(ui::colors::WARNING())
: QString(ui::colors::POSITIVE());
set_card("hft_tox_pin", QString::number(sc, 'f', 1), col);
set_card("hft_tox_vol", QString::number(tf["vol_imbalance"].toDouble(), 'f', 4));
set_card("hft_tox_impact", QString::number(tf["price_impact_bps"].toDouble(), 'f', 2) + tr(" bps"));
set_card("hft_tox_class", tf["classification"].toString());
set_card("hft_tox_action", QString(tf["action"].toString()).replace('_', ' '));
}
if (payload.contains("slippage") && !sub_error(payload["slippage"].toObject(), tr("Slippage"),
{"hft_slip_avgp", "hft_slip_bps", "hft_slip_cost",
"hft_slip_fills", "hft_slip_viable"})) {
const auto sl = payload["slippage"].toObject();
set_card("hft_slip_avgp", QString::number(sl["average_price"].toDouble(), 'f', 4));
set_card("hft_slip_bps", QString::number(sl["slippage_bps"].toDouble(), 'f', 4) + tr(" bps"));
set_card("hft_slip_cost", QString::number(sl["total_cost"].toDouble(), 'f', 4));
set_card("hft_slip_fills", QString::number(sl["fill_count"].toInt()));
const bool v = sl["viable"].toBool();
set_card("hft_slip_viable", v ? tr("VIABLE") : tr("HIGH SLIP"),
v ? QString(ui::colors::POSITIVE()) : QString(ui::colors::NEGATIVE()));
}
if (auto* lat_lbl = this->findChild<QLabel*>("hftLatency"))
lat_lbl->setText(tr("LATENCY %1 ms").arg(payload["latency_ms"].toDouble(), 0, 'f', 1));
status_label_->setText(
partial_errors.isEmpty()
? tr("Full analysis complete — %1 @ %2")
.arg(payload["symbol"].toString(), payload["timestamp"].toString().left(19))
: tr("Analysis incomplete — %1").arg(partial_errors.join(" | ")));
return;
}
display_result(payload);
return;
}
// ── Rolling Retraining ───────────────────────────────────────────────────
if (module_id == "rolling_retraining") {
// ── Streaming events from retrain command ────────────────────────────
const QString event = payload["event"].toString();
if (!event.isEmpty()) {
auto* pb = this->findChild<QProgressBar*>("rr_progress");
auto* log = this->findChild<QTextEdit*>("rr_log");
if (event == "start") {
const int total = payload["total_windows"].toInt();
if (pb) {
pb->setRange(0, total);
pb->setValue(0);
pb->setFormat(tr("0 / %v windows"));
}
if (log)
log->append(
tr("Starting retrain: %1 | %2 windows").arg(payload["model_id"].toString()).arg(total));
status_label_->setText(
tr("Retraining %1 — 0/%2 windows").arg(payload["model_id"].toString()).arg(total));
} else if (event == "window") {
const int idx = payload["index"].toInt();
const int total = payload["total"].toInt();
if (pb) {
pb->setValue(idx);
pb->setFormat(tr("%1 / %2 windows").arg(idx).arg(total));
}
if (log)
log->append(tr(" Window %1/%2 train→%3 test %4→%5")
.arg(idx)
.arg(total)
.arg(payload["train_end"].toString().left(10))
.arg(payload["test_start"].toString().left(10))
.arg(payload["test_end"].toString().left(10)));
status_label_->setText(tr("Window %1/%2").arg(idx).arg(total));
} else if (event == "ensemble") {
if (log)
log->append(QString(" %1").arg(payload["message"].toString()));
status_label_->setText(tr("Combining rolling results..."));
} else if (event == "done") {
const int total = payload["windows_trained"].toInt();
if (pb) {
pb->setValue(total);
pb->setFormat(tr("Complete"));
}
if (log)
log->append(tr("\nDone — %1 windows in %2s | Experiment: %3")
.arg(total)
.arg(payload["elapsed_sec"].toDouble(), 0, 'f', 1)
.arg(payload["exp_name"].toString()));
status_label_->setText(tr("Retrain complete — %1 windows in %2s")
.arg(total)
.arg(payload["elapsed_sec"].toDouble(), 0, 'f', 1));
set_retrain_busy(this, false);
} else if (event == "error") {
set_retrain_busy(this, false);
if (pb) {
pb->setFormat(tr("Failed"));
}
if (log)
log->append(tr("\nError: %1").arg(payload["error"].toString()));
display_error(payload["error"].toString());
}
return;
}
// ── Non-streaming responses ──────────────────────────────────────────
if (!payload["success"].toBool()) {
display_error(payload["error"].toString());
return;
}
clear_results();
if (command == "list") {
auto schedules = payload["schedules"].toObject();
// Find the cards container and repopulate it
auto* cards_w = this->findChild<QWidget*>("rr_cards_container");
if (cards_w) {
auto* cards_vl = qobject_cast<QVBoxLayout*>(cards_w->layout());
// Remove old cards (keep the trailing stretch)
while (cards_vl->count() > 1)
delete cards_vl->takeAt(0)->widget();
if (schedules.isEmpty()) {
auto* empty = new QLabel(
tr("No schedules configured yet.\nUse the Create Schedule tab to add one."), cards_w);
empty->setAlignment(Qt::AlignCenter);
empty->setStyleSheet(
QString("color:%1; font-size:12px; padding:24px;").arg(ui::colors::TEXT_SECONDARY()));
cards_vl->insertWidget(0, empty);
} else {
int i = 0;
for (auto it = schedules.begin(); it != schedules.end(); ++it, ++i) {
const QString mid = it.key();
auto obj = it.value().toObject();
// Card frame
auto* card = new QWidget(cards_w);
card->setStyleSheet(
QString("QWidget{background:%1;border:1px solid %2;border-radius:6px;}"
"QWidget:hover{border-color:%3;}")
.arg(ui::colors::BG_RAISED(), ui::colors::BORDER_MED(), module_.color.name()));
auto* cvl = new QVBoxLayout(card);
cvl->setContentsMargins(12, 10, 12, 10);
cvl->setSpacing(4);
// Top row: model ID + status badge
auto* top = new QWidget(card);
top->setStyleSheet("QWidget{background:transparent;border:none;}");
auto* thl = new QHBoxLayout(top);
thl->setContentsMargins(0, 0, 0, 0);
auto* id_lbl = new QLabel(mid, top);
id_lbl->setStyleSheet(QString("color:%1;font-weight:700;font-size:13px;"
"background:transparent;border:none;")
.arg(ui::colors::TEXT_PRIMARY()));
thl->addWidget(id_lbl);
thl->addStretch();
const QString status = obj["last_status"].toString(tr("pending"));
const QString badge_color = (status == "completed") ? "#22c55e"
: (status == "failed") ? "#ef4444"
: "#f59e0b";
auto* badge = new QLabel(status.toUpper(), top);
badge->setStyleSheet(QString("color:%1;background:transparent;border:none;"
"font-size:10px;font-weight:700;")
.arg(badge_color));
thl->addWidget(badge);
cvl->addWidget(top);
// Details row
const QString freq = obj["frequency"].toString(obj["freq"].toString());
const QString window = QString::number(obj["window"].toInt());
const QString next = obj["next_run"].toString("-").left(16).replace("T", " ");
const QString last = obj["last_run"].isNull()
? tr("Never")
: obj["last_run"].toString().left(16).replace("T", " ");
auto* detail = new QLabel(
tr("Freq: %1 | Window: %2 days | Next: %3 | Last: %4").arg(freq, window, next, last),
card);
detail->setStyleSheet(QString("color:%1;font-size:11px;"
"background:transparent;border:none;")
.arg(ui::colors::TEXT_SECONDARY()));
cvl->addWidget(detail);
// Action buttons row
auto* acts = new QWidget(card);
acts->setStyleSheet("QWidget{background:transparent;border:none;}");
auto* ahl = new QHBoxLayout(acts);
ahl->setContentsMargins(0, 4, 0, 0);
ahl->setSpacing(6);
auto* run_btn = new QPushButton(tr("Run Now"), acts);
run_btn->setProperty("rrRetrain", true);
run_btn->setEnabled(!this->property("rrBusy").toBool());
run_btn->setStyleSheet(
QString("QPushButton{background:%1;color:%2;border:1px solid %1;"
"border-radius:3px;font-size:10px;font-weight:700;padding:3px 10px;}"
"QPushButton:hover{background:%3;}")
.arg(module_.color.name(), "#000000", module_.color.lighter(115).name()));
connect(run_btn, &QPushButton::clicked, this, [this, mid]() {
if (auto* pb = this->findChild<QProgressBar*>("rr_progress")) {
pb->setValue(0);
pb->setFormat(tr("Starting..."));
}
if (auto* log = this->findChild<QTextEdit*>("rr_log"))
log->clear();
status_label_->setText(tr("Retraining %1...").arg(mid));
set_retrain_busy(this, true); // re-enabled by the run's done / error event
QJsonObject p;
p["model_id"] = mid;
AIQuantLabService::instance().rolling_execute_retrain(p);
});
ahl->addWidget(run_btn);
auto* del_btn = new QPushButton(tr("Delete"), acts);
del_btn->setStyleSheet(
QString("QPushButton{background:transparent;color:#ef4444;border:1px solid #ef4444;"
"border-radius:3px;font-size:10px;font-weight:700;padding:3px 10px;}"
"QPushButton:hover{background:#7f1d1d;}"));
connect(del_btn, &QPushButton::clicked, this, [this, mid]() {
status_label_->setText(tr("Deleting %1...").arg(mid));
QJsonObject p;
p["model_id"] = mid;
AIQuantLabService::instance().rolling_delete_schedule(p);
});
ahl->addWidget(del_btn);
ahl->addStretch();
cvl->addWidget(acts);
cards_vl->insertWidget(i, card);
}
}
}
status_label_->setText(tr("%1 schedule(s)").arg(schedules.size()));
return;
}
if (command == "create") {
auto sched = payload["schedule"].toObject();
const QString tmpl =
payload["template_generated"].toBool()
? tr("\nBuilt-in LightGBM+Alpha158 template generated at:\n%1").arg(payload["conf_path"].toString())
: "";
clear_results();
auto* lbl = new QLabel(tr("Schedule created: %1\nFreq: %2 | Window: %3 days | Next: %4%5")
.arg(payload["model_id"].toString(), sched["frequency"].toString(),
QString::number(sched["window"].toInt()),
sched["next_run"].toString().left(16).replace("T", " "), tmpl),
this);
lbl->setWordWrap(true);
lbl->setStyleSheet(QString("color:%1;").arg(ui::colors::TEXT_PRIMARY()));
results_layout_->addWidget(lbl);
status_label_->setText(tr("Schedule created — switch to Schedules tab to view"));
return;
}
if (command == "preview") {
clear_results();
const int total = payload["total_windows"].toInt();
auto windows = payload["windows"].toArray();
auto* hdr = new QLabel(tr("Preview: %1 rolling windows (step=%2, horizon=%3)")
.arg(total)
.arg(payload["step"].toInt())
.arg(payload["horizon"].toInt()),
this);
hdr->setStyleSheet(QString("color:%1;font-weight:700;font-size:13px;").arg(ui::colors::TEXT_PRIMARY()));
results_layout_->addWidget(hdr);
// Table of windows. Sized from the returned array, not from
// total_windows — the Python side caps the preview list, so a larger
// `total` produced silently blank trailing rows (and a smaller one
// dropped windows because setItem() past rowCount is a no-op).
auto* tbl = new QTableWidget(int(windows.size()), 4, this);
tbl->setStyleSheet(table_ss());
tbl->setHorizontalHeaderLabels({"#", tr("Train Start"), tr("Train End"), tr("Test Period")});
tbl->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
tbl->verticalHeader()->setVisible(false);
tbl->setEditTriggers(QAbstractItemView::NoEditTriggers);
tbl->setSelectionBehavior(QAbstractItemView::SelectRows);
tbl->setAlternatingRowColors(true);
int row = 0;
for (const auto& v : windows) {
auto obj = v.toObject();
auto item = [&](const QString& s) {
auto* it = new QTableWidgetItem(s.left(10));
it->setTextAlignment(Qt::AlignCenter);
return it;
};
tbl->setItem(row, 0, item(QString::number(row + 1)));
tbl->setItem(row, 1, item(obj["train_start"].toString()));
tbl->setItem(row, 2, item(obj["train_end"].toString()));
tbl->setItem(row, 3,
item(QString("%1 → %2").arg(obj["test_start"].toString().left(10),
obj["test_end"].toString().left(10))));
++row;
}
tbl->setMaximumHeight(220);
results_layout_->addWidget(tbl);
status_label_->setText(tr("Preview: %1 windows").arg(total));
return;
}
if (command == "delete") {
status_label_->setText(tr("Deleted: %1").arg(payload["model_id"].toString()));
// Auto-refresh the schedule list
AIQuantLabService::instance().rolling_list_schedules();
return;
}
display_result(payload);
return;
}
display_result(payload);
}
} // namespace fincept::screens