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
#include "services/equity/EquitySentimentService.h"
#include "services/equity/EquityResearchService.h"
#include "services/equity/MarketSentimentService.h"
#include "services/news/NewsNlpService.h"
#include <QDateTime>
#include <QHash>
#include <QTimer>
#include <algorithm>
namespace fincept::services::equity {
namespace {
// Blend weights (base, before confidence scaling) and label band. Tunable.
constexpr double kBaseWeightNews = 0.5;
constexpr double kBaseWeightPrice = 0.3;
constexpr double kBaseWeightAdanos = 0.2;
constexpr double kLabelThreshold = 0.15;
// An available source always carries at least this much weight, so an all-NEUTRAL
// reading still counts (→ NEUTRAL) instead of collapsing to "no signal".
constexpr double kConfidenceFloor = 0.15;
constexpr int kTimeoutMs = 15000;
constexpr int kMaxArticles = 40;
QString sentiment_label(double score) {
if (score >= kLabelThreshold)
return QStringLiteral("BULLISH");
if (score <= -kLabelThreshold)
return QStringLiteral("BEARISH");
return QStringLiteral("NEUTRAL");
}
} // namespace
EquitySentimentService& EquitySentimentService::instance() {
static EquitySentimentService service;
return service;
}
EquitySentimentService::EquitySentimentService(QObject* parent) : QObject(parent) {
timeout_timer_ = new QTimer(this);
timeout_timer_->setSingleShot(true);
connect(timeout_timer_, &QTimer::timeout, this, [this]() {
if (finalized_)
return;
// Force completion with whatever legs resolved; unresolved sources stay
// unavailable and simply drop out of the blend.
news_.done = true;
price_.done = true;
adanos_.done = true;
finalize();
});
connect(&EquityResearchService::instance(), &EquityResearchService::news_loaded, this,
[this](const QString& symbol, const QVector<NewsArticle>& articles) { on_news_loaded(symbol, articles); });
connect(&EquityResearchService::instance(), &EquityResearchService::technicals_loaded, this,
[this](const TechnicalsData& data) { on_technicals_loaded(data); });
connect(&MarketSentimentService::instance(), &MarketSentimentService::snapshot_loaded, this,
[this](const QString& symbol, const MarketSentimentSnapshot& snap) { on_adanos_loaded(symbol, snap); });
}
void EquitySentimentService::fetch_sentiment(const QString& symbol) {
const QString sym = symbol.trimmed().toUpper();
if (sym.isEmpty())
return;
// New request: bump the id (drops stale callbacks) and reset all state
// BEFORE firing fetches — the underlying fetchers may emit synchronously on
// a cache hit, re-entering our slots within these calls.
++active_request_id_;
active_symbol_ = sym;
finalized_ = false;
news_consumed_ = false;
tech_consumed_ = false;
adanos_consumed_ = false;
news_ = SourceState{};
price_ = SourceState{};
adanos_ = SourceState{};
bullish_ = 0;
bearish_ = 0;
neutral_ = 0;
engine_.clear();
articles_.clear();
need_adanos_ = MarketSentimentService::instance().is_configured();
adanos_.done = !need_adanos_; // not awaited when no key is configured
timeout_timer_->start(kTimeoutMs);
EquityResearchService::instance().fetch_news(sym);
EquityResearchService::instance().fetch_technicals(sym);
if (need_adanos_)
MarketSentimentService::instance().fetch_snapshot(sym);
}
void EquitySentimentService::on_news_loaded(const QString& symbol, const QVector<NewsArticle>& articles) {
if (symbol != active_symbol_ || news_consumed_)
return;
news_consumed_ = true;
const quint64 rid = active_request_id_;
if (articles.isEmpty()) {
news_.available = false;
news_.done = true;
try_finalize();
return;
}
// news_nlp.py reads headline/summary; equity articles use title/description.
// Map across, tagging a stable id so we can rejoin scores for display.
QVector<fincept::services::NewsArticle> mapped;
mapped.reserve(articles.size());
for (int i = 0; i < articles.size(); ++i) {
fincept::services::NewsArticle n;
n.id = QString::number(i);
n.headline = articles[i].title;
n.summary = articles[i].description;
mapped.append(n);
}
const QVector<NewsArticle> source_articles = articles;
NewsNlpService::instance().analyze_sentiment(
mapped, [this, rid, source_articles](bool ok, const NewsSentimentResult& result) {
if (rid != active_request_id_)
return; // superseded by a newer request
if (!ok) {
news_.available = false;
news_.done = true;
try_finalize();
return;
}
engine_ = result.engine;
bullish_ = result.bullish;
bearish_ = result.bearish;
neutral_ = result.neutral;
QHash<QString, ArticleSentimentResult> by_id;
by_id.reserve(result.per_article.size());
for (const auto& ar : result.per_article)
by_id.insert(ar.id, ar);
articles_.clear();
const int limit = std::min<int>(source_articles.size(), kMaxArticles);
for (int i = 0; i < limit; ++i) {
ArticleSentiment a;
a.title = source_articles[i].title;
a.publisher = source_articles[i].publisher;
a.published_date = source_articles[i].published_date;
a.url = source_articles[i].url;
const auto res = by_id.value(QString::number(i));
a.label = res.label.isEmpty() ? QStringLiteral("NEUTRAL") : res.label;
a.score = res.score;
articles_.append(a);
}
const int scored = result.bullish + result.bearish + result.neutral;
const int non_neutral = result.bullish + result.bearish;
news_.score = result.overall_score;
news_.confidence = scored > 0 ? static_cast<double>(non_neutral) / scored : 0.0;
news_.available = scored > 0;
news_.done = true;
try_finalize();
});
}
void EquitySentimentService::on_technicals_loaded(const TechnicalsData& data) {
if (data.symbol != active_symbol_ || tech_consumed_)
return;
tech_consumed_ = true;
const int total = data.strong_buy + data.buy + data.neutral + data.sell + data.strong_sell;
if (total > 0) {
const double raw =
(data.strong_buy + 0.5 * data.buy - 0.5 * data.sell - data.strong_sell) / static_cast<double>(total);
price_.score = std::clamp(raw, -1.0, 1.0);
const int non_neutral = data.strong_buy + data.buy + data.sell + data.strong_sell;
price_.confidence = static_cast<double>(non_neutral) / total;
price_.available = true;
}
price_.done = true;
try_finalize();
}
void EquitySentimentService::on_adanos_loaded(const QString& symbol, const MarketSentimentSnapshot& snapshot) {
if (!need_adanos_ || symbol != active_symbol_ || adanos_consumed_)
return;
adanos_consumed_ = true;
if (snapshot.configured && snapshot.available && snapshot.coverage > 0) {
adanos_.score = std::clamp((snapshot.average_bullish_pct - 50.0) / 50.0, -1.0, 1.0);
adanos_.confidence = 1.0;
adanos_.available = true;
}
adanos_.done = true;
try_finalize();
}
void EquitySentimentService::try_finalize() {
if (finalized_)
return;
if (!news_.done || !price_.done)
return;
if (need_adanos_ && !adanos_.done)
return;
finalize();
}
void EquitySentimentService::finalize() {
if (finalized_)
return;
finalized_ = true;
timeout_timer_->stop();
EquitySentimentSnapshot snap;
snap.symbol = active_symbol_;
snap.engine = engine_;
snap.bullish = bullish_;
snap.bearish = bearish_;
snap.neutral = neutral_;
snap.article_count = bullish_ + bearish_ + neutral_;
snap.articles = articles_;
snap.fetched_at = QDateTime::currentDateTimeUtc().toString(Qt::ISODate);
struct Contrib {
QString id;
QString label;
const SourceState* state;
double base;
bool include;
};
const Contrib contribs[] = {
{QStringLiteral("news"), QStringLiteral("News Sentiment"), &news_, kBaseWeightNews, true},
{QStringLiteral("price"), QStringLiteral("Price Momentum"), &price_, kBaseWeightPrice, true},
// Adanos row only shown/blended when a key is configured.
{QStringLiteral("adanos"), QStringLiteral("Adanos"), &adanos_, kBaseWeightAdanos, need_adanos_},
};
double weight_sum = 0.0;
for (const auto& c : contribs) {
if (c.include && c.state->available)
weight_sum += c.base * std::max(c.state->confidence, kConfidenceFloor);
}
double blended = 0.0;
double confidence_acc = 0.0;
for (const auto& c : contribs) {
if (!c.include)
continue;
SentimentSource src;
src.id = c.id;
src.label = c.label;
src.available = c.state->available;
src.score = c.state->score;
src.confidence = c.state->confidence;
if (c.state->available && weight_sum > 0.0) {
const double w = (c.base * std::max(c.state->confidence, kConfidenceFloor)) / weight_sum;
src.weight = w;
blended += w * c.state->score;
confidence_acc += w * c.state->confidence;
}
snap.sources.append(src);
}
if (weight_sum > 0.0) {
snap.available = true;
snap.status = QStringLiteral("ok");
snap.overall_score = std::clamp(blended, -1.0, 1.0);
snap.label = sentiment_label(snap.overall_score);
snap.confidence = std::clamp(confidence_acc, 0.0, 1.0);
} else {
snap.available = false;
snap.status = QStringLiteral("unavailable");
snap.label = QStringLiteral("NEUTRAL");
snap.message =
QStringLiteral("No sentiment signal yet — news and price momentum are unavailable for this symbol.");
}
emit sentiment_loaded(active_symbol_, snap);
}
} // namespace fincept::services::equity