dienakdz
2584 lines
120 KiB
Python
2584 lines
120 KiB
Python
"""
|
||
Fast Analysis Service 3.0
|
||
Systematic refactoring version - using unified data collector
|
||
|
||
Core improvements:
|
||
1. Unified data sources - use MarketDataCollector, which is completely consistent with the K-line module and watch list
|
||
2. Macroeconomic data - added macroeconomic indicators such as the US dollar index, VIX, and interest rates
|
||
3. Multi-dimensional news - using structured API, no need for in-depth reading
|
||
4. Single LLM call - strong constraint prompt, output structured analysis
|
||
"""
|
||
import json
|
||
import os
|
||
import re
|
||
import time
|
||
from typing import Dict, Any, Optional, List, Tuple
|
||
from decimal import Decimal, ROUND_HALF_UP
|
||
|
||
from app.utils.logger import get_logger
|
||
from app.services.llm import LLMService
|
||
from app.services.market_data_collector import get_market_data_collector
|
||
|
||
logger = get_logger(__name__)
|
||
|
||
|
||
def _safe_float_price(value: Any, default: Optional[float] = None) -> Optional[float]:
|
||
"""Coerce LLM/string prices to float; invalid -> default."""
|
||
if value is None:
|
||
return default
|
||
if isinstance(value, (int, float)):
|
||
if isinstance(value, float) and (value != value): # NaN
|
||
return default
|
||
return float(value)
|
||
try:
|
||
s = str(value).strip().replace(",", "")
|
||
if not s:
|
||
return default
|
||
return float(s)
|
||
except (TypeError, ValueError):
|
||
return default
|
||
|
||
|
||
def _build_trend_outlook_summary(trend_outlook: Dict[str, Any], language: str) -> str:
|
||
"""Human-readable multi-horizon outlook for API / legacy clients."""
|
||
if not trend_outlook:
|
||
return ""
|
||
is_zh = str(language or "").lower().startswith("zh")
|
||
|
||
def _lbl(trend: str) -> str:
|
||
t = str(trend or "HOLD").upper()
|
||
if is_zh:
|
||
return {"BUY": "看多", "SELL": "看空", "HOLD": "震荡/中性"}.get(t, "震荡/中性")
|
||
return {"BUY": "bullish", "SELL": "bearish", "HOLD": "neutral / range"}.get(t, "neutral / range")
|
||
|
||
n24 = trend_outlook.get("next_24h") or {}
|
||
d3 = trend_outlook.get("next_3d") or {}
|
||
w1 = trend_outlook.get("next_1w") or {}
|
||
m1 = trend_outlook.get("next_1m") or {}
|
||
|
||
if is_zh:
|
||
parts = [
|
||
f"约24小时：{_lbl(n24.get('trend'))}（强度 {n24.get('strength', 'neutral')}）",
|
||
f"约3天：{_lbl(d3.get('trend'))}（强度 {d3.get('strength', 'neutral')}）",
|
||
f"约1周：{_lbl(w1.get('trend'))}（强度 {w1.get('strength', 'neutral')}）",
|
||
f"约1月：{_lbl(m1.get('trend'))}（强度 {m1.get('strength', 'neutral')}）",
|
||
]
|
||
return "；".join(parts)
|
||
parts = [
|
||
f"~24h: {_lbl(n24.get('trend'))} ({n24.get('strength', 'neutral')})",
|
||
f"~3d: {_lbl(d3.get('trend'))} ({d3.get('strength', 'neutral')})",
|
||
f"~1w: {_lbl(w1.get('trend'))} ({w1.get('strength', 'neutral')})",
|
||
f"~1m: {_lbl(m1.get('trend'))} ({m1.get('strength', 'neutral')})",
|
||
]
|
||
return " | ".join(parts)
|
||
|
||
|
||
# -----------------------------------------------------------------------------
|
||
# Geopolitical / major-conflict detection (word boundaries + tiers)
|
||
# Avoid false positives: "war" in "toward/award", "tension" in "extension",
|
||
# "us" in "focus/status", bare country names without conflict context, etc.
|
||
# -----------------------------------------------------------------------------
|
||
_GEO_SEVERE_PATTERNS: List[re.Pattern] = [
|
||
re.compile(r"\b(?:war|wars|warfare|wartime)\b", re.I),
|
||
re.compile(r"\b(?:invasion|invaded|invading|invade)\b", re.I),
|
||
re.compile(r"\b(?:airstrike|air\s*strikes?|missile\s+strike|drone\s+strike)\b", re.I),
|
||
re.compile(r"\b(?:military\s+attack|armed\s+attack|troops?\s+(?:fire|attack|invade))\b", re.I),
|
||
re.compile(r"\b(?:declare[sd]?\s+war|state\s+of\s+war|act\s+of\s+war)\b", re.I),
|
||
re.compile(r"\b(?:martial\s+law|military\s+coup|coup\s+d['\u2019]?etat)\b", re.I),
|
||
re.compile(r"\b(?:terror(?:ist)?\s+attack|mass\s+shooting\s+at)\b", re.I),
|
||
]
|
||
_GEO_MODERATE_PATTERNS: List[re.Pattern] = [
|
||
re.compile(r"\bgeopolitical\b", re.I),
|
||
re.compile(r"\b(?:armed|military)\s+conflict\b", re.I),
|
||
re.compile(r"\b(?:international\s+)?sanctions?\s+(?:on|against|targeting|hit)\b", re.I),
|
||
re.compile(r"\b(?:naval\s+blockade|border\s+clash|ceasefire\s+(?:broken|violated))\b", re.I),
|
||
re.compile(r"\b(?:evacuat\w+\s+(?:the\s+)?embassy|embassy\s+evacuation)\b", re.I),
|
||
re.compile(r"\b(?:nuclear\s+(?:threat|strike|weapon)|nuclear\s+war)\b", re.I),
|
||
]
|
||
# "Crisis" / "tension" only in clearly geopolitical phrases (not substring of "extension")
|
||
_GEO_CONTEXT_MODERATE: List[re.Pattern] = [
|
||
re.compile(r"\b(?:geopolitical|diplomatic|border)\s+(?:crisis|tension|standoff)\b", re.I),
|
||
re.compile(r"\b(?:tensions?\s+(?:rise|escalat|flare|mount)\s+(?:with|between))\b", re.I),
|
||
re.compile(r"\b(?:middle\s+east|south\s+china\s+sea|taiwan\s+strait)\s+(?:crisis|tension|conflict)\b", re.I),
|
||
]
|
||
_GEO_ZH_SEVERE = (
|
||
"宣战", "战争爆发", "全面战争", "武装冲突", "军事打击", "军事入侵", "空袭", "导弹袭击",
|
||
"开战", "交火", "战火",
|
||
)
|
||
_GEO_ZH_MODERATE = (
|
||
"地缘政治危机", "国际制裁升级", "断交", "撤侨", "军事对峙", "地区冲突升级",
|
||
)
|
||
|
||
# Optional: country/region + conflict verb (single pattern, avoids "NYSE" noise)
|
||
_GEO_REGION_CONFLICT: List[re.Pattern] = [
|
||
re.compile(
|
||
r"\b(?:russia|ukraine|iran|israel|gaza|hamas|taiwan|north\s+korea|dprk|"
|
||
r"syria|yemen|lebanon|nato)\b.{0,40}\b(?:invade|attack|strike|war|conflict|sanction)\b",
|
||
re.I,
|
||
),
|
||
re.compile(
|
||
r"\b(?:invade|attack|strike|war|conflict|sanction)\b.{0,40}\b(?:russia|ukraine|iran|israel|"
|
||
r"gaza|hamas|taiwan|north\s+korea|dprk|syria|nato)\b",
|
||
re.I,
|
||
),
|
||
]
|
||
|
||
_GEO_MAJOR_NEWS_SEVERE = [
|
||
re.compile(r"\b(?:war|wars|warfare)\b", re.I),
|
||
re.compile(r"\b(?:invasion|invaded|military\s+attack|airstrike)\b", re.I),
|
||
re.compile(r"\b(?:armed\s+conflict|military\s+conflict)\b", re.I),
|
||
]
|
||
|
||
|
||
def _geopolitical_match_level(combined_text: str) -> Tuple[str, Optional[str]]:
|
||
"""
|
||
Returns (level, reason_tag) where level is 'none'|'severe'|'moderate'.
|
||
combined_text: title + summary (original case OK; English patterns use lower via regex I flag).
|
||
"""
|
||
if not combined_text or len(combined_text.strip()) < 4:
|
||
return "none", None
|
||
low = combined_text.lower()
|
||
for pat in _GEO_SEVERE_PATTERNS:
|
||
if pat.search(low):
|
||
return "severe", pat.pattern[:48]
|
||
for z in _GEO_ZH_SEVERE:
|
||
if z in combined_text:
|
||
return "severe", z
|
||
for pat in _GEO_REGION_CONFLICT:
|
||
if pat.search(low):
|
||
return "severe", "region+conflict"
|
||
for pat in _GEO_MODERATE_PATTERNS:
|
||
if pat.search(low):
|
||
return "moderate", pat.pattern[:48]
|
||
for pat in _GEO_CONTEXT_MODERATE:
|
||
if pat.search(low):
|
||
return "moderate", pat.pattern[:48]
|
||
for z in _GEO_ZH_MODERATE:
|
||
if z in combined_text:
|
||
return "moderate", z
|
||
return "none", None
|
||
|
||
|
||
def _geopolitical_sentiment_penalty_delta(level: str) -> int:
|
||
if level == "severe":
|
||
return -42
|
||
if level == "moderate":
|
||
return -18
|
||
return 0
|
||
|
||
|
||
def _is_major_geopolitical_news_text(combined_text: str) -> bool:
|
||
"""Stricter than sentiment: only clear conflict / war signals for _has_major_news."""
|
||
if not combined_text:
|
||
return False
|
||
low = combined_text.lower()
|
||
for pat in _GEO_MAJOR_NEWS_SEVERE:
|
||
if pat.search(low):
|
||
return True
|
||
for z in _GEO_ZH_SEVERE:
|
||
if z in combined_text:
|
||
return True
|
||
if any(p.search(low) for p in _GEO_REGION_CONFLICT):
|
||
return True
|
||
return False
|
||
|
||
|
||
class FastAnalysisService:
|
||
"""
|
||
Rapid Analysis Service 3.0
|
||
|
||
Architecture:
|
||
1. Data collection layer - MarketDataCollector (unified data source)
|
||
2. Analysis layer - single LLM call (strong constraint prompt)
|
||
3. Memory layer - analysis history storage and retrieval
|
||
"""
|
||
|
||
def __init__(self):
|
||
self.llm_service = LLMService()
|
||
self.data_collector = get_market_data_collector()
|
||
self._memory_db = None # Lazy init
|
||
|
||
# ==================== Data Collection Layer ====================
|
||
|
||
def _collect_market_data(
|
||
self,
|
||
market: str,
|
||
symbol: str,
|
||
timeframe: str = "1D",
|
||
*,
|
||
include_macro: bool = True,
|
||
include_news: bool = True,
|
||
include_polymarket: bool = True,
|
||
timeout: int = 45,
|
||
) -> Dict[str, Any]:
|
||
"""
|
||
Collect market data using a unified data collector
|
||
|
||
Data level:
|
||
1. Core data: price, K-line, technical indicators
|
||
2. Fundamentals: Company information, financial data
|
||
3. Macro data: DXY, VIX, TNX, gold, etc.
|
||
4. Sentiment data: news, market sentiment
|
||
5. Prediction market: related prediction market events (new)
|
||
"""
|
||
return self.data_collector.collect_all(
|
||
market=market,
|
||
symbol=symbol,
|
||
timeframe=timeframe,
|
||
include_macro=include_macro,
|
||
include_news=include_news,
|
||
include_polymarket=include_polymarket, # Contains prediction market data
|
||
timeout=timeout, # Increase timeout to ensure data collection is complete
|
||
)
|
||
|
||
def _calculate_indicators(self, kline_data: List[Dict]) -> Dict[str, Any]:
|
||
"""
|
||
Calculate technical indicators using rules (no LLM).
|
||
Returns actionable signals, not raw numbers.
|
||
"""
|
||
if not kline_data or len(kline_data) < 5:
|
||
return {"error": "Insufficient data"}
|
||
|
||
try:
|
||
# Use tools' built-in calculation
|
||
raw_indicators = self.tools.calculate_technical_indicators(kline_data)
|
||
|
||
# Extract key values
|
||
closes = [float(k.get("close", 0)) for k in kline_data if k.get("close")]
|
||
if not closes:
|
||
return {"error": "No close prices"}
|
||
|
||
current_price = closes[-1]
|
||
|
||
# RSI interpretation
|
||
rsi = raw_indicators.get("RSI", 50)
|
||
if rsi < 30:
|
||
rsi_signal = "oversold"
|
||
rsi_action = "potential_buy"
|
||
elif rsi > 70:
|
||
rsi_signal = "overbought"
|
||
rsi_action = "potential_sell"
|
||
else:
|
||
rsi_signal = "neutral"
|
||
rsi_action = "hold"
|
||
|
||
# MACD interpretation
|
||
macd = raw_indicators.get("MACD", 0)
|
||
macd_signal_line = raw_indicators.get("MACD_Signal", 0)
|
||
macd_hist = raw_indicators.get("MACD_Hist", 0)
|
||
|
||
if macd > macd_signal_line and macd_hist > 0:
|
||
macd_signal = "bullish"
|
||
macd_trend = "golden_cross" if macd_hist > 0 and len(kline_data) > 1 else "bullish"
|
||
elif macd < macd_signal_line and macd_hist < 0:
|
||
macd_signal = "bearish"
|
||
macd_trend = "death_cross" if macd_hist < 0 and len(kline_data) > 1 else "bearish"
|
||
else:
|
||
macd_signal = "neutral"
|
||
macd_trend = "consolidating"
|
||
|
||
# Moving averages
|
||
ma5 = sum(closes[-5:]) / 5 if len(closes) >= 5 else current_price
|
||
ma10 = sum(closes[-10:]) / 10 if len(closes) >= 10 else current_price
|
||
ma20 = sum(closes[-20:]) / 20 if len(closes) >= 20 else current_price
|
||
|
||
if current_price > ma5 > ma10 > ma20:
|
||
ma_trend = "strong_uptrend"
|
||
elif current_price > ma20:
|
||
ma_trend = "uptrend"
|
||
elif current_price < ma5 < ma10 < ma20:
|
||
ma_trend = "strong_downtrend"
|
||
elif current_price < ma20:
|
||
ma_trend = "downtrend"
|
||
else:
|
||
ma_trend = "sideways"
|
||
|
||
# Support/Resistance (simple: recent highs/lows)
|
||
recent_highs = [float(k.get("high", 0)) for k in kline_data[-14:] if k.get("high")]
|
||
recent_lows = [float(k.get("low", 0)) for k in kline_data[-14:] if k.get("low")]
|
||
|
||
resistance = max(recent_highs) if recent_highs else current_price * 1.05
|
||
support = min(recent_lows) if recent_lows else current_price * 0.95
|
||
|
||
# Volatility (ATR-like)
|
||
if len(kline_data) >= 14:
|
||
ranges = []
|
||
for k in kline_data[-14:]:
|
||
h = float(k.get("high", 0))
|
||
l = float(k.get("low", 0))
|
||
if h > 0 and l > 0:
|
||
ranges.append(h - l)
|
||
atr = sum(ranges) / len(ranges) if ranges else 0
|
||
volatility_pct = (atr / current_price * 100) if current_price > 0 else 0
|
||
|
||
if volatility_pct > 5:
|
||
volatility = "high"
|
||
elif volatility_pct > 2:
|
||
volatility = "medium"
|
||
else:
|
||
volatility = "low"
|
||
else:
|
||
volatility = "unknown"
|
||
volatility_pct = 0
|
||
|
||
return {
|
||
"current_price": round(current_price, 6),
|
||
"rsi": {
|
||
"value": round(rsi, 2),
|
||
"signal": rsi_signal,
|
||
"action": rsi_action,
|
||
},
|
||
"macd": {
|
||
"value": round(macd, 6),
|
||
"signal_line": round(macd_signal_line, 6),
|
||
"histogram": round(macd_hist, 6),
|
||
"signal": macd_signal,
|
||
"trend": macd_trend,
|
||
},
|
||
"moving_averages": {
|
||
"ma5": round(ma5, 6),
|
||
"ma10": round(ma10, 6),
|
||
"ma20": round(ma20, 6),
|
||
"trend": ma_trend,
|
||
},
|
||
"levels": {
|
||
"support": round(support, 6),
|
||
"resistance": round(resistance, 6),
|
||
},
|
||
"volatility": {
|
||
"level": volatility,
|
||
"pct": round(volatility_pct, 2),
|
||
},
|
||
"raw": raw_indicators,
|
||
}
|
||
except Exception as e:
|
||
logger.error(f"Indicator calculation failed: {e}")
|
||
return {"error": str(e)}
|
||
|
||
def _format_news_summary(self, news_data: List[Dict], max_items: int = 5) -> str:
|
||
"""Format news into a concise summary for the prompt."""
|
||
if not news_data:
|
||
return "No recent news available."
|
||
|
||
summaries = []
|
||
for item in news_data[:max_items]:
|
||
title = item.get("title", item.get("headline", ""))
|
||
sentiment = item.get("sentiment", "neutral")
|
||
date = item.get("date", item.get("datetime", ""))[:10] if item.get("date") or item.get("datetime") else ""
|
||
|
||
if title:
|
||
summaries.append(f"- [{sentiment}] {title} ({date})")
|
||
|
||
return "\n".join(summaries) if summaries else "No recent news available."
|
||
|
||
def _format_polymarket_summary(self, polymarket_events: List[Dict], max_items: int = 3) -> str:
|
||
"""Format prediction market events into a concise summary for the prompt."""
|
||
if not polymarket_events:
|
||
return "No related prediction market events found."
|
||
|
||
summaries = []
|
||
for event in polymarket_events[:max_items]:
|
||
question = event.get('question', '')
|
||
prob = event.get('current_probability', 50.0)
|
||
summaries.append(f"- {question[:80]}: Market probability {prob:.1f}%")
|
||
|
||
return "\n".join(summaries) if summaries else "No related prediction market events found."
|
||
|
||
# ==================== Memory Layer ====================
|
||
|
||
def _get_memory_context(self, market: str, symbol: str, current_indicators: Dict) -> str:
|
||
"""
|
||
Retrieve relevant historical analysis for similar market conditions.
|
||
"""
|
||
try:
|
||
from app.services.analysis_memory import get_analysis_memory
|
||
memory = get_analysis_memory()
|
||
|
||
# Get similar patterns
|
||
patterns = memory.get_similar_patterns(market, symbol, current_indicators, limit=3)
|
||
|
||
if not patterns:
|
||
return "No similar historical patterns found in memory."
|
||
|
||
context_lines = ["Historical patterns with similar conditions:"]
|
||
for p in patterns:
|
||
outcome = ""
|
||
if p.get("was_correct") is not None:
|
||
outcome = f" (Outcome: {'Correct' if p['was_correct'] else 'Incorrect'}"
|
||
if p.get("actual_return_pct"):
|
||
outcome += f", Return: {p['actual_return_pct']:.2f}%"
|
||
outcome += ")"
|
||
|
||
context_lines.append(
|
||
f"- Decision: {p['decision']} at ${p.get('price', 'N/A')}{outcome}"
|
||
)
|
||
|
||
return "\n".join(context_lines)
|
||
|
||
except Exception as e:
|
||
logger.warning(f"Memory retrieval failed: {e}")
|
||
return "Memory retrieval failed."
|
||
|
||
# ==================== Prompt Engineering ====================
|
||
|
||
def _build_analysis_prompt(self, data: Dict[str, Any], language: str) -> tuple:
|
||
"""
|
||
Build the single, comprehensive analysis prompt.
|
||
Key: Strong constraints to prevent absurd recommendations.
|
||
"""
|
||
price_data = data.get("price") or {}
|
||
current_price = price_data.get("price", 0) if price_data else 0
|
||
change_24h = price_data.get("changePercent", 0) if price_data else 0
|
||
|
||
# Ensure all data fields have safe defaults (may be None from failed fetches)
|
||
indicators = data.get("indicators") or {}
|
||
fundamental = data.get("fundamental") or {}
|
||
company = data.get("company") or {}
|
||
news_summary = self._format_news_summary(data.get("news") or [])
|
||
polymarket_events = data.get("polymarket") or []
|
||
|
||
# Language instruction - MUST be enforced strictly
|
||
lang_map = {
|
||
'zh-CN': '⚠️ 重要：你必须用简体中文回答所有内容，包括summary、key_reasons、risks等所有文本字段。不要使用英文。',
|
||
'zh-TW': '⚠️ 重要：你必須用繁體中文回答所有內容，包括summary、key_reasons、risks等所有文本字段。不要使用英文。',
|
||
'en-US': '⚠️ IMPORTANT: You MUST answer ALL content in English, including summary, key_reasons, risks, and all text fields. Do NOT use Chinese.',
|
||
'ja-JP': '⚠️ 重要：すべての内容を日本語で回答してください。summary、key_reasons、risksなど、すべてのテキストフィールドを日本語で記述してください。',
|
||
}
|
||
lang_instruction = lang_map.get(language, '⚠️ IMPORTANT: Answer ALL content in English.')
|
||
|
||
# Get pre-calculated trading levels from technical analysis
|
||
levels = indicators.get("levels", {})
|
||
trading_levels = indicators.get("trading_levels", {})
|
||
volatility = indicators.get("volatility", {})
|
||
|
||
support = levels.get("support", current_price * 0.95)
|
||
resistance = levels.get("resistance", current_price * 1.05)
|
||
pivot = levels.get("pivot", current_price)
|
||
|
||
# Use ATR-based suggestions if available, otherwise use percentage
|
||
atr = volatility.get("atr", current_price * 0.02)
|
||
suggested_stop_loss = trading_levels.get("suggested_stop_loss", current_price - 2 * atr)
|
||
suggested_take_profit = trading_levels.get("suggested_take_profit", current_price + 3 * atr)
|
||
risk_reward_ratio = trading_levels.get("risk_reward_ratio", 1.5)
|
||
|
||
# Price bounds (still enforce max 10% deviation)
|
||
if current_price > 0:
|
||
price_lower_bound = round(max(suggested_stop_loss, current_price * 0.90), 6)
|
||
price_upper_bound = round(min(suggested_take_profit, current_price * 1.10), 6)
|
||
entry_range_low = round(current_price * 0.98, 6)
|
||
entry_range_high = round(current_price * 1.02, 6)
|
||
else:
|
||
price_lower_bound = price_upper_bound = entry_range_low = entry_range_high = 0
|
||
|
||
# Get technical indicator values for decision constraints
|
||
rsi_value = indicators.get("rsi", {}).get("value", 50)
|
||
macd_signal = indicators.get("macd", {}).get("signal", "neutral")
|
||
ma_trend = indicators.get("moving_averages", {}).get("trend", "sideways")
|
||
|
||
# Build decision guidance based on technical indicators
|
||
decision_guidance = self._build_decision_guidance(rsi_value, macd_signal, ma_trend, change_24h)
|
||
|
||
system_prompt = f"""You are QuantDinger's Senior Financial Analyst with 20+ years of experience.
|
||
You are CONSERVATIVE and OBJECTIVE. Your analysis must be based on DATA, not speculation.
|
||
|
||
{lang_instruction}
|
||
|
||
🎯 CRITICAL DECISION RULES (MUST FOLLOW):
|
||
1. **Market Context**: This market supports BOTH long (BUY) and short (SELL) positions. SELL signals are VALID trading opportunities, not just risk warnings.
|
||
2. **Multi-Factor Analysis** (IMPORTANT - Consider ALL factors):
|
||
- **Technical Indicators** (RSI, MACD, MA trends): Provide baseline direction
|
||
- **Macro Environment** (DXY, VIX, interest rates, geopolitical events): Can override technical signals
|
||
- **Breaking News & Events**: Major news can cause sudden reversals - pay attention!
|
||
- **Fundamental Data**: Valuation, growth, financial health matter for medium/long-term
|
||
- **Market Sentiment**: News sentiment, fear/greed index, market mood
|
||
3. **Decision Priority** (When factors conflict):
|
||
- **Major macro events** (war, policy changes, major economic data) > Technical indicators
|
||
- **Breaking news** (regulatory changes, major partnerships, scandals) > Short-term technical
|
||
- **Technical indicators** > General news sentiment (when no major events)
|
||
- **Fundamental data** > Short-term price movements (for long-term decisions)
|
||
4. **Balance Your Decisions** (IMPORTANT - Give SELL signals when appropriate):
|
||
- BUY: When technical indicators show oversold (RSI < 40), bullish MACD, uptrend, OR strong macro/fundamental catalyst
|
||
- SELL: When technical indicators show overbought (RSI > 60), bearish MACD, downtrend, OR major negative macro/news event
|
||
- HOLD: Only when signals are truly mixed or unclear - DO NOT default to HOLD just because you're uncertain
|
||
- **Remember**: SELL is a valid trading signal for short positions, not just a warning to avoid buying
|
||
5. **Confidence Thresholds**:
|
||
- BUY requires confidence >= 60 AND (technical support OR macro/fundamental catalyst)
|
||
- SELL requires confidence >= 60 AND (technical support OR negative event) - SELL signals are encouraged when indicators suggest downside
|
||
- HOLD only when confidence < 60 AND signals are truly unclear
|
||
6. **Identify Trading Opportunities**:
|
||
- When RSI > 60, MACD bearish, downtrend: Consider SELL (short position opportunity)
|
||
- When RSI < 40, MACD bullish, uptrend: Consider BUY (long position opportunity)
|
||
- Do NOT default to HOLD when clear technical signals exist
|
||
7. **Consider Macro Impact**:
|
||
- Strong USD (DXY ↑) usually negative for crypto/commodities → Consider SELL
|
||
- High VIX (>30) indicates fear → Consider SELL or HOLD, avoid BUY
|
||
- Rising interest rates usually negative for growth assets → Consider SELL
|
||
- Geopolitical tensions can cause sudden volatility → Consider SELL if risk-off sentiment
|
||
|
||
{decision_guidance}
|
||
|
||
📐 TECHNICAL LEVELS (Pre-calculated from chart data):
|
||
- Support: ${support} | Resistance: ${resistance} | Pivot: ${pivot}
|
||
- ATR (14-day): ${atr:.4f} ({volatility.get('pct', 0)}% volatility)
|
||
- Suggested Stop Loss: ${suggested_stop_loss:.4f} (based on 2x ATR below support)
|
||
- Suggested Take Profit: ${suggested_take_profit:.4f} (based on 3x ATR above resistance)
|
||
- Risk/Reward Ratio: {risk_reward_ratio}
|
||
|
||
⚠️ CRITICAL PRICE RULES:
|
||
1. Current price: ${current_price}
|
||
2. If decision=BUY: stop_loss should be below current price, take_profit above current price.
|
||
3. If decision=SELL (short): stop_loss MUST be above current price; take_profit MUST be below current price.
|
||
4. BUY stop_loss reference: near ${suggested_stop_loss:.4f} (range: ${price_lower_bound:.4f} ~ ${current_price})
|
||
5. BUY take_profit reference: near ${suggested_take_profit:.4f} (range: ${current_price} ~ ${price_upper_bound:.4f})
|
||
6. Entry price: ${entry_range_low:.4f} ~ ${entry_range_high:.4f}
|
||
7. These levels are based on ATR and support/resistance analysis - use them as reference!
|
||
|
||
📊 YOUR ANALYSIS MUST INCLUDE (ALL factors are important):
|
||
1. **Technical Analysis**: Objectively interpret RSI, MACD, MA, support/resistance. Be honest about conflicting signals.
|
||
2. **Macro Environment Analysis**:
|
||
- Analyze DXY, VIX, interest rates impact on the asset
|
||
- Consider geopolitical events and their potential impact
|
||
- Evaluate how macro trends affect this specific market/symbol
|
||
3. **News & Event Analysis**:
|
||
- **CRITICAL**: Pay special attention to GEOPOLITICAL EVENTS (wars, conflicts, military actions, sanctions)
|
||
- These events can cause sudden and severe market movements, especially for crypto and global markets
|
||
- Identify BREAKING NEWS or major events that could cause sudden moves
|
||
- Assess news sentiment and its credibility
|
||
- Consider regulatory changes, partnerships, scandals, geopolitical tensions, etc.
|
||
- **DO NOT ignore major geopolitical news** (e.g., US-Iran conflict, Russia-Ukraine war) even if technical indicators look good
|
||
- Global events like wars can override all technical analysis - treat them as HIGHEST PRIORITY
|
||
4. **Prediction Market Analysis**:
|
||
- Review related prediction market events and their current probabilities
|
||
- Prediction markets reflect collective market wisdom and can indicate future price movements
|
||
- If prediction markets show high probability for bullish events (e.g., "BTC reaches $100k"), consider this as a positive signal
|
||
- If prediction markets show high probability for bearish events, consider this as a risk factor
|
||
- Use prediction market probabilities as a sentiment indicator alongside technical analysis
|
||
5. **Fundamental Analysis**: Evaluate valuation, growth, competitive position if data available. If data is insufficient, say so.
|
||
6. **Risk Assessment**:
|
||
- Explain why the stop loss level is appropriate
|
||
- List ALL significant risks (technical, macro, news, fundamental)
|
||
- Consider tail risks from unexpected events
|
||
7. **Clear Recommendation**: BUY/SELL/HOLD with entry, stop loss (near suggested), take profit (near suggested)
|
||
- **BUY**: For long positions when indicators suggest upside
|
||
- **SELL**: For short positions when indicators suggest downside - this is a VALID trading opportunity
|
||
- **HOLD**: Only when signals are truly unclear - DO NOT default to HOLD just to be safe
|
||
- Your decision should reflect the WEIGHTED importance of ALL factors
|
||
- If macro/news factors strongly contradict technical, explain why you prioritize one over the other
|
||
8. **Trading Opportunity Recognition**:
|
||
- When you see RSI > 60, bearish MACD, downtrend → Give SELL signal (short opportunity)
|
||
- When you see RSI < 40, bullish MACD, uptrend → Give BUY signal (long opportunity)
|
||
- Only choose HOLD when signals are genuinely mixed or unclear
|
||
|
||
Output ONLY valid JSON (do NOT include word counts or format hints in your actual response):
|
||
{{
|
||
"decision": "BUY" | "SELL" | "HOLD",
|
||
"confidence": 0-100,
|
||
"summary": "Executive summary in 2-3 sentences - be honest about uncertainty if present",
|
||
"analysis": {{
|
||
"technical": "Your detailed technical analysis here - interpret RSI, MACD, MA, support/resistance objectively",
|
||
"fundamental": "Your fundamental assessment here - valuation, growth, competitive position. If data is limited, state that clearly.",
|
||
"sentiment": "Your market sentiment analysis here - news impact, macro factors, mood. Don't overreact."
|
||
}},
|
||
"entry_price": number,
|
||
"stop_loss": number,
|
||
"take_profit": number,
|
||
"position_size_pct": 1-100,
|
||
"timeframe": "short" | "medium" | "long",
|
||
"key_reasons": ["First key reason for this decision", "Second key reason", "Third key reason"],
|
||
"risks": ["Primary risk with potential impact", "Secondary risk"],
|
||
"technical_score": 0-100,
|
||
"fundamental_score": 0-100,
|
||
"sentiment_score": 0-100
|
||
}}
|
||
|
||
⚠️ IMPORTANT:
|
||
- The analysis fields should contain your ACTUAL analysis text, NOT the format description above.
|
||
- Be HONEST and CONSERVATIVE. If you're not confident, choose HOLD with lower confidence.
|
||
- Do NOT make up facts or exaggerate. Base everything on the provided data.
|
||
|
||
📊 OBJECTIVE SCORING SYSTEM (Reference):
|
||
The system will calculate an objective score based on technical indicators, fundamentals, sentiment (including geopolitical events), and macro factors.
|
||
- Score >= +20: Bullish signal → BUY recommended
|
||
- Score <= -20: Bearish signal → SELL recommended
|
||
- Score between -20 and +20: Neutral → HOLD recommended (narrow range)
|
||
- Score >= +70: Strong bullish → Strong BUY signal
|
||
- Score <= -70: Strong bearish → Strong SELL signal
|
||
- Geopolitical events (wars, conflicts) are heavily weighted in sentiment score and can cause severe negative scores
|
||
- Macro factors (VIX, DXY, interest rates) are also heavily weighted
|
||
Your decision should align with this objective score when it's significant (>=20 or <=-20).
|
||
When the score is neutral (-20 to +20), you can use your judgment, but still consider giving BUY/SELL if technical indicators are clear."""
|
||
|
||
# Format indicator data for prompt (ensure safe defaults)
|
||
rsi_data = indicators.get("rsi") or {}
|
||
macd_data = indicators.get("macd") or {}
|
||
ma_data = indicators.get("moving_averages") or {}
|
||
vol_data = indicators.get("volatility") or {}
|
||
levels = indicators.get("levels") or {}
|
||
|
||
# Format macro data
|
||
macro = data.get("macro") or {}
|
||
macro_summary = self._format_macro_summary(macro, data.get("market", ""))
|
||
|
||
user_prompt = f"""Analyze {data['symbol']} in {data['market']} market.
|
||
|
||
📊 REAL-TIME DATA:
|
||
- Current Price: ${current_price}
|
||
- 24h Change: {change_24h}%
|
||
- Support: ${support}
|
||
- Resistance: ${resistance}
|
||
|
||
📈 TECHNICAL INDICATORS:
|
||
- RSI(14): {rsi_data.get('value', 'N/A')} ({rsi_data.get('signal', 'N/A')})
|
||
- MACD: {macd_data.get('signal', 'N/A')} ({macd_data.get('trend', 'N/A')})
|
||
- MA Trend: {ma_data.get('trend', 'N/A')}
|
||
- Volatility: {vol_data.get('level', 'N/A')} ({vol_data.get('pct', 0)}%)
|
||
- Trend: {indicators.get('trend', 'N/A')}
|
||
- Price Position (20d): {indicators.get('price_position', 'N/A')}%
|
||
|
||
🌐 MACRO ENVIRONMENT:
|
||
{macro_summary}
|
||
|
||
📰 MARKET NEWS ({len(data.get('news') or [])} items):
|
||
{news_summary}
|
||
|
||
🎯 PREDICTION MARKETS ({len(polymarket_events)} related events):
|
||
{self._format_polymarket_summary(polymarket_events)}
|
||
|
||
💼 FUNDAMENTALS:
|
||
- Company: {company.get('name', data['symbol'])}
|
||
- Industry: {company.get('industry', 'N/A')}
|
||
- P/E Ratio: {fundamental.get('pe_ratio', 'N/A')}
|
||
- P/B Ratio: {fundamental.get('pb_ratio', 'N/A')}
|
||
- Market Cap: {fundamental.get('market_cap', 'N/A')}
|
||
- 52W High/Low: {fundamental.get('52w_high', 'N/A')} / {fundamental.get('52w_low', 'N/A')}
|
||
- ROE: {fundamental.get('roe', 'N/A')}
|
||
- Revenue Growth: {fundamental.get('revenue_growth', 'N/A')}
|
||
- Profit Margin: {fundamental.get('profit_margin', 'N/A')}
|
||
- Debt to Equity: {fundamental.get('debt_to_equity', 'N/A')}
|
||
- Current Ratio: {fundamental.get('current_ratio', 'N/A')}
|
||
- Free Cash Flow: {fundamental.get('free_cash_flow', 'N/A')}
|
||
|
||
📊 FINANCIAL STATEMENTS (Latest Quarter):
|
||
{self._format_financial_statements(fundamental.get('financial_statements', {}))}
|
||
|
||
📈 EARNINGS DATA:
|
||
{self._format_earnings_data(fundamental.get('earnings', {}))}
|
||
|
||
📚 HISTORICAL PATTERNS (similar conditions in the past):
|
||
{self._get_memory_context(data.get('market', ''), data.get('symbol', ''), indicators)}
|
||
|
||
IMPORTANT:
|
||
1. **CRITICAL**: Check for GEOPOLITICAL EVENTS (wars, conflicts, military actions) in the news section. These events have HIGHEST PRIORITY and can override all technical indicators.
|
||
2. Consider the macro environment (especially DXY, VIX, rates, geopolitical events) when making your recommendation.
|
||
3. Pay attention to BREAKING NEWS and international events that could cause sudden market moves. Geopolitical tensions (e.g., US-Iran conflict) can cause severe market volatility.
|
||
4. For US stocks, analyze financial statements and earnings trends to assess company health.
|
||
5. If you see news about wars, conflicts, or major geopolitical events, you MUST mention them in your analysis and adjust your recommendation accordingly.
|
||
6. Provide your analysis now. Remember: all prices must be within 10% of ${current_price}."""
|
||
|
||
return system_prompt, user_prompt
|
||
|
||
def _format_financial_statements(self, statements: Dict[str, Any]) -> str:
|
||
"""Formatting financial statement data for prompt words"""
|
||
if not statements:
|
||
return "财务报表数据暂不可用"
|
||
|
||
lines = []
|
||
|
||
# balance sheet
|
||
if 'balance_sheet' in statements:
|
||
bs = statements['balance_sheet']
|
||
lines.append("资产负债表 (Balance Sheet):")
|
||
if bs.get('total_assets'):
|
||
lines.append(f" - 总资产: ${bs['total_assets']:,.0f}")
|
||
if bs.get('total_liabilities'):
|
||
lines.append(f" - 总负债: ${bs['total_liabilities']:,.0f}")
|
||
if bs.get('total_equity'):
|
||
lines.append(f" - 股东权益: ${bs['total_equity']:,.0f}")
|
||
if bs.get('cash'):
|
||
lines.append(f" - 现金: ${bs['cash']:,.0f}")
|
||
if bs.get('debt'):
|
||
lines.append(f" - 总债务: ${bs['debt']:,.0f}")
|
||
if bs.get('current_assets') and bs.get('current_liabilities'):
|
||
current_ratio = bs['current_assets'] / bs['current_liabilities'] if bs['current_liabilities'] > 0 else 0
|
||
lines.append(f" - 流动比率: {current_ratio:.2f}")
|
||
|
||
# income statement
|
||
if 'income_statement' in statements:
|
||
is_stmt = statements['income_statement']
|
||
lines.append("利润表 (Income Statement):")
|
||
if is_stmt.get('total_revenue'):
|
||
lines.append(f" - 总收入: ${is_stmt['total_revenue']:,.0f}")
|
||
if is_stmt.get('gross_profit'):
|
||
lines.append(f" - 毛利润: ${is_stmt['gross_profit']:,.0f}")
|
||
if is_stmt.get('operating_income'):
|
||
lines.append(f" - 营业利润: ${is_stmt['operating_income']:,.0f}")
|
||
if is_stmt.get('net_income'):
|
||
lines.append(f" - 净利润: ${is_stmt['net_income']:,.0f}")
|
||
if is_stmt.get('eps'):
|
||
lines.append(f" - 每股收益: ${is_stmt['eps']:.2f}")
|
||
|
||
# cash flow statement
|
||
if 'cash_flow' in statements:
|
||
cf = statements['cash_flow']
|
||
lines.append("现金流量表 (Cash Flow):")
|
||
if cf.get('operating_cash_flow'):
|
||
lines.append(f" - 经营现金流: ${cf['operating_cash_flow']:,.0f}")
|
||
if cf.get('free_cash_flow'):
|
||
lines.append(f" - 自由现金流: ${cf['free_cash_flow']:,.0f}")
|
||
|
||
return "\n".join(lines) if lines else "财务报表数据暂不可用"
|
||
|
||
def _format_earnings_data(self, earnings: Dict[str, Any]) -> str:
|
||
"""Format profit data for prompt words"""
|
||
if not earnings:
|
||
return "盈利数据暂不可用"
|
||
|
||
lines = []
|
||
|
||
# historical profit
|
||
if 'history' in earnings and earnings['history']:
|
||
lines.append("历史盈利 (Earnings History):")
|
||
for i, hist in enumerate(earnings['history'][:4], 1):
|
||
date = hist.get('date', 'N/A')
|
||
eps_actual = hist.get('eps_actual')
|
||
eps_estimate = hist.get('eps_estimate')
|
||
surprise = hist.get('surprise')
|
||
|
||
if eps_actual is not None:
|
||
line = f" {i}. {date}: EPS实际={eps_actual:.2f}"
|
||
if eps_estimate is not None:
|
||
line += f", 预期={eps_estimate:.2f}"
|
||
if surprise is not None:
|
||
surprise_str = f"{surprise:+.1f}%"
|
||
line += f", 超预期={surprise_str}"
|
||
lines.append(line)
|
||
|
||
# future profit
|
||
if 'upcoming' in earnings:
|
||
upcoming = earnings['upcoming']
|
||
if upcoming.get('next_earnings_date'):
|
||
lines.append(f"下次盈利报告: {upcoming['next_earnings_date']}")
|
||
if upcoming.get('eps_estimate'):
|
||
lines.append(f" - EPS预期: ${upcoming['eps_estimate']:.2f}")
|
||
if upcoming.get('revenue_estimate'):
|
||
lines.append(f" - 收入预期: ${upcoming['revenue_estimate']:,.0f}")
|
||
|
||
# quarterly profit
|
||
if 'quarterly' in earnings:
|
||
q = earnings['quarterly']
|
||
if q.get('latest_quarter'):
|
||
lines.append(f"最新季度 ({q['latest_quarter']}):")
|
||
if q.get('revenue'):
|
||
lines.append(f" - 收入: ${q['revenue']:,.0f}")
|
||
if q.get('earnings'):
|
||
lines.append(f" - 盈利: ${q['earnings']:,.0f}")
|
||
|
||
return "\n".join(lines) if lines else "盈利数据暂不可用"
|
||
|
||
def _format_macro_summary(self, macro: Dict[str, Any], market: str) -> str:
|
||
"""Format macro data summaries"""
|
||
if not macro:
|
||
return "宏观数据暂不可用"
|
||
|
||
lines = []
|
||
|
||
# dollar index
|
||
if 'DXY' in macro:
|
||
dxy = macro['DXY']
|
||
direction = "↑" if dxy.get('change', 0) > 0 else "↓"
|
||
lines.append(f"- {dxy.get('name', 'USD Index')}: {dxy.get('price', 'N/A')} ({direction}{abs(dxy.get('changePercent', 0)):.2f}%)")
|
||
# The impact of the strength of the U.S. dollar on different assets
|
||
if market == 'Crypto':
|
||
impact = "利空加密货币" if dxy.get('change', 0) > 0 else "利好加密货币"
|
||
lines.append(f" ⚠️ 美元{direction} {impact}")
|
||
elif market == 'Forex':
|
||
lines.append(f" ⚠️ 美元{direction} 直接影响外汇走势")
|
||
|
||
# VIX panic index
|
||
if 'VIX' in macro:
|
||
vix = macro['VIX']
|
||
vix_value = vix.get('price', 0)
|
||
if vix_value > 30:
|
||
level = "极度恐慌 (>30)"
|
||
elif vix_value > 20:
|
||
level = "较高恐慌 (20-30)"
|
||
elif vix_value > 15:
|
||
level = "正常 (15-20)"
|
||
else:
|
||
level = "低波动 (<15)"
|
||
lines.append(f"- {vix.get('name', 'VIX')}: {vix_value:.2f} - {level}")
|
||
|
||
# U.S. Treasury yields
|
||
if 'TNX' in macro:
|
||
tnx = macro['TNX']
|
||
direction = "↑" if tnx.get('change', 0) > 0 else "↓"
|
||
lines.append(f"- {tnx.get('name', '10Y Treasury')}: {tnx.get('price', 'N/A'):.3f}% ({direction})")
|
||
if tnx.get('price', 0) > 4.5:
|
||
lines.append(" ⚠️ 高利率环境，对估值不利")
|
||
|
||
# gold
|
||
if 'GOLD' in macro:
|
||
gold = macro['GOLD']
|
||
direction = "↑" if gold.get('change', 0) > 0 else "↓"
|
||
lines.append(f"- {gold.get('name', 'Gold')}: ${gold.get('price', 'N/A'):.2f} ({direction}{abs(gold.get('changePercent', 0)):.2f}%)")
|
||
|
||
# S&P 500
|
||
if 'SPY' in macro:
|
||
spy = macro['SPY']
|
||
direction = "↑" if spy.get('change', 0) > 0 else "↓"
|
||
lines.append(f"- {spy.get('name', 'S&P 500')}: ${spy.get('price', 'N/A'):.2f} ({direction}{abs(spy.get('changePercent', 0)):.2f}%)")
|
||
|
||
# Bitcoin (as a risk indicator)
|
||
if 'BTC' in macro and market != 'Crypto':
|
||
btc = macro['BTC']
|
||
direction = "↑" if btc.get('change', 0) > 0 else "↓"
|
||
lines.append(f"- {btc.get('name', 'BTC')}: ${btc.get('price', 'N/A'):,.0f} ({direction}{abs(btc.get('changePercent', 0)):.2f}%) [风险偏好指标]")
|
||
|
||
return "\n".join(lines) if lines else "宏观数据暂不可用"
|
||
|
||
# ==================== Main Analysis ====================
|
||
|
||
def analyze(self, market: str, symbol: str, language: str = 'en-US',
|
||
model: str = None, timeframe: str = "1D", user_id: int = None) -> Dict[str, Any]:
|
||
"""
|
||
Run fast single-call analysis.
|
||
|
||
Args:
|
||
market: Market type (Crypto, USStock, etc.)
|
||
symbol: Trading pair or stock symbol
|
||
language: Response language (zh-CN or en-US)
|
||
model: LLM model to use
|
||
timeframe: Analysis timeframe (1D, 4H, etc.)
|
||
user_id: User ID for storing analysis history
|
||
|
||
Returns:
|
||
Complete analysis result with actionable recommendations.
|
||
"""
|
||
start_time = time.time()
|
||
|
||
# Get default model if not specified
|
||
if not model:
|
||
model = self.llm_service.get_default_model()
|
||
logger.debug(f"Using default model: {model}")
|
||
|
||
result = {
|
||
"market": market,
|
||
"symbol": symbol,
|
||
"language": language,
|
||
"model": model, # Include model in result from the start
|
||
"timeframe": timeframe,
|
||
"analysis_time_ms": 0,
|
||
"error": None,
|
||
}
|
||
|
||
try:
|
||
# Phase 1: Data collection (multi-timeframe for consensus)
|
||
logger.info(f"Fast analysis starting: {market}:{symbol}")
|
||
|
||
# Consensus timeframes:
|
||
# - Default: use the timeframe passed in by the user as the main cycle, and add an upper cycle (1D/4H) to improve stability
|
||
# - Overriding via env (comma separated) is also allowed, e.g. AI_ANALYSIS_CONSENSUS_TIMEFRAMES=1D,4H
|
||
env_tfs = os.getenv("AI_ANALYSIS_CONSENSUS_TIMEFRAMES", "").strip()
|
||
if env_tfs:
|
||
consensus_timeframes = [t.strip() for t in env_tfs.split(",") if t.strip()]
|
||
else:
|
||
# Heuristic defaults
|
||
tf0 = (timeframe or "").strip().upper()
|
||
# Primary first
|
||
consensus_timeframes = [tf0] if tf0 else [timeframe]
|
||
# Add 4H/1D depending on primary
|
||
if tf0 in ("1H", "1HOUR", "60M"):
|
||
consensus_timeframes += ["4H", "1D"]
|
||
elif tf0 in ("4H",):
|
||
consensus_timeframes += ["1D"]
|
||
elif tf0 in ("1D", "1DAY", "D"):
|
||
consensus_timeframes += ["4H"]
|
||
else:
|
||
# Generic fallback
|
||
consensus_timeframes += ["1D", "4H"]
|
||
# Dedup keep order
|
||
seen = set()
|
||
consensus_timeframes = [x for x in consensus_timeframes if not (x in seen or seen.add(x))]
|
||
|
||
primary_tf = (timeframe or "").strip().upper() or "1D"
|
||
# Always include the primary timeframe in consensus,
|
||
# even when env overrides timeframes.
|
||
if primary_tf and primary_tf not in consensus_timeframes:
|
||
consensus_timeframes = [primary_tf] + list(consensus_timeframes)
|
||
# De-dup keep order
|
||
seen = set()
|
||
consensus_timeframes = [x for x in consensus_timeframes if not (x in seen or seen.add(x))]
|
||
# Collect primary data including macro/news/polymarket for prompt quality
|
||
primary_data = self._collect_market_data(
|
||
market,
|
||
symbol,
|
||
primary_tf,
|
||
include_macro=True,
|
||
include_news=True,
|
||
include_polymarket=True,
|
||
)
|
||
|
||
# Collect extra timeframes for objective consensus (technical-only for cost)
|
||
objective_by_tf: Dict[str, Dict[str, Any]] = {}
|
||
decision_votes: Dict[str, int] = {"BUY": 0, "SELL": 0, "HOLD": 0}
|
||
weighted_score_sum = 0.0
|
||
weighted_score_w_sum = 0.0
|
||
|
||
def _extract_current_price(d: Dict[str, Any]) -> Optional[float]:
|
||
if d.get("price") and d["price"].get("price"):
|
||
try:
|
||
return float(d["price"]["price"])
|
||
except Exception:
|
||
return None
|
||
ind = d.get("indicators") or {}
|
||
cp = ind.get("current_price")
|
||
try:
|
||
if cp:
|
||
return float(cp)
|
||
except Exception:
|
||
pass
|
||
# fallback to kline close
|
||
kl = d.get("kline") or []
|
||
if kl:
|
||
try:
|
||
return float(kl[-1].get("close") or 0)
|
||
except Exception:
|
||
return None
|
||
return None
|
||
|
||
logger.info(f"Consensus timeframes: {consensus_timeframes}")
|
||
for tf in consensus_timeframes:
|
||
tf_norm = (tf or "").strip().upper()
|
||
if not tf_norm:
|
||
continue
|
||
|
||
if tf_norm == primary_tf:
|
||
d_tf = primary_data
|
||
else:
|
||
d_tf = self._collect_market_data(
|
||
market,
|
||
symbol,
|
||
tf_norm,
|
||
include_macro=False,
|
||
include_news=False,
|
||
include_polymarket=False,
|
||
timeout=25,
|
||
)
|
||
|
||
current_price_tf = _extract_current_price(d_tf) or 0.0
|
||
objective = self._calculate_objective_score(d_tf, current_price_tf)
|
||
overall_score = float(objective.get("overall_score", 0.0) or 0.0)
|
||
decision = self._score_to_decision(overall_score, market=market)
|
||
abs_score = abs(overall_score)
|
||
|
||
objective_by_tf[tf_norm] = {
|
||
"objective_score": objective,
|
||
"overall_score": overall_score,
|
||
"decision": decision,
|
||
"abs_score": abs_score,
|
||
}
|
||
decision_votes[decision] = decision_votes.get(decision, 0) + 1
|
||
|
||
# Weight by strength so strong cycles dominate
|
||
w = 1.0 + min(1.5, abs_score / 100.0)
|
||
weighted_score_sum += overall_score * w
|
||
weighted_score_w_sum += w
|
||
|
||
# Extra horizon score (not used in consensus override):
|
||
# add 1W objective score for short/medium trend outlook.
|
||
if "1W" not in objective_by_tf:
|
||
try:
|
||
d_1w = self._collect_market_data(
|
||
market,
|
||
symbol,
|
||
"1W",
|
||
include_macro=False,
|
||
include_news=False,
|
||
include_polymarket=False,
|
||
timeout=25,
|
||
)
|
||
cp_1w = _extract_current_price(d_1w) or 0.0
|
||
obj_1w = self._calculate_objective_score(d_1w, cp_1w)
|
||
sc_1w = float(obj_1w.get("overall_score", 0.0) or 0.0)
|
||
objective_by_tf["1W"] = {
|
||
"objective_score": obj_1w,
|
||
"overall_score": sc_1w,
|
||
"decision": self._score_to_decision(sc_1w, market=market),
|
||
"abs_score": abs(sc_1w),
|
||
}
|
||
except Exception as e:
|
||
logger.debug(f"1W outlook score skipped: {e}")
|
||
|
||
# Short-horizon outlook: 1H bar (24h-style), not 1D close
|
||
if "1H" not in objective_by_tf:
|
||
try:
|
||
d_1h = self._collect_market_data(
|
||
market,
|
||
symbol,
|
||
"1H",
|
||
include_macro=False,
|
||
include_news=False,
|
||
include_polymarket=False,
|
||
timeout=18,
|
||
)
|
||
cp_1h = _extract_current_price(d_1h) or 0.0
|
||
obj_1h = self._calculate_objective_score(d_1h, cp_1h)
|
||
sc_1h = float(obj_1h.get("overall_score", 0.0) or 0.0)
|
||
objective_by_tf["1H"] = {
|
||
"objective_score": obj_1h,
|
||
"overall_score": sc_1h,
|
||
"decision": self._score_to_decision(sc_1h, market=market),
|
||
"abs_score": abs(sc_1h),
|
||
}
|
||
except Exception as e:
|
||
logger.debug(f"1H outlook score skipped: {e}")
|
||
|
||
consensus_score = weighted_score_sum / weighted_score_w_sum if weighted_score_w_sum > 0 else 0.0
|
||
consensus_decision = self._score_to_decision(consensus_score, market=market)
|
||
consensus_abs = abs(consensus_score)
|
||
|
||
# Agreement factor: how many timeframes support the consensus decision
|
||
tf_count = max(1, len(objective_by_tf))
|
||
agreement_cnt = sum(1 for x in objective_by_tf.values() if str(x.get("decision") or "").upper() == consensus_decision)
|
||
agreement_ratio = agreement_cnt / tf_count
|
||
|
||
# Data quality degradation: derive from primary_data meta
|
||
meta = primary_data.get("_meta") or {}
|
||
failed_items = set(meta.get("failed_items") or [])
|
||
quality_multiplier = 1.0
|
||
if "macro" in failed_items:
|
||
quality_multiplier *= 0.85
|
||
if "news" in failed_items:
|
||
quality_multiplier *= 0.8
|
||
if "polymarket" in failed_items:
|
||
quality_multiplier *= 0.9
|
||
# If indicators missing key sections, reduce confidence more
|
||
ind = primary_data.get("indicators") or {}
|
||
if not ind or not ind.get("rsi") or not ind.get("moving_averages"):
|
||
quality_multiplier *= 0.65
|
||
|
||
logger.info(
|
||
f"Consensus decision={consensus_decision}, score={consensus_score:.2f}, "
|
||
f"agreement_ratio={agreement_ratio:.2f}, quality_multiplier={quality_multiplier:.2f}"
|
||
)
|
||
|
||
data = primary_data # keep original variable usage for prompt/LLM input
|
||
|
||
# Validate we have essential data - with fallback to indicators
|
||
current_price = None
|
||
|
||
# Get it from price data first
|
||
if data.get("price") and data["price"].get("price"):
|
||
current_price = data["price"]["price"]
|
||
|
||
# Fallback: Get from indicators (if the K-line is calculated successfully)
|
||
if not current_price and data.get("indicators"):
|
||
current_price = data["indicators"].get("current_price")
|
||
if current_price:
|
||
logger.info(f"Using price from indicators: ${current_price}")
|
||
# Build simplified price data
|
||
data["price"] = {
|
||
"price": current_price,
|
||
"change": 0,
|
||
"changePercent": 0,
|
||
"source": "indicators_fallback"
|
||
}
|
||
|
||
# Fallback: Get from the last kline
|
||
if not current_price and data.get("kline"):
|
||
klines = data["kline"]
|
||
if klines and len(klines) > 0:
|
||
current_price = float(klines[-1].get("close", 0))
|
||
if current_price > 0:
|
||
logger.info(f"Using price from kline: ${current_price}")
|
||
prev_close = float(klines[-2].get("close", current_price)) if len(klines) > 1 else current_price
|
||
change = current_price - prev_close
|
||
change_pct = (change / prev_close * 100) if prev_close > 0 else 0
|
||
data["price"] = {
|
||
"price": current_price,
|
||
"change": round(change, 6),
|
||
"changePercent": round(change_pct, 2),
|
||
"source": "kline_fallback"
|
||
}
|
||
|
||
if not current_price or current_price <= 0:
|
||
result["error"] = "Failed to fetch current price from all sources"
|
||
logger.error(f"Price fetch failed for {market}:{symbol}, all sources exhausted")
|
||
return result
|
||
|
||
# Phase 2: Build prompt
|
||
system_prompt, user_prompt = self._build_analysis_prompt(data, language)
|
||
|
||
default_struct = {
|
||
"decision": "HOLD",
|
||
"confidence": 50,
|
||
"summary": "Analysis failed",
|
||
"entry_price": current_price,
|
||
"stop_loss": current_price * 0.95,
|
||
"take_profit": current_price * 1.05,
|
||
"position_size_pct": 10,
|
||
"timeframe": "medium",
|
||
"key_reasons": ["Unable to analyze"],
|
||
"risks": ["Analysis error"],
|
||
"technical_score": 50,
|
||
"fundamental_score": 50,
|
||
"sentiment_score": 50,
|
||
}
|
||
|
||
# Phase 3: LLM call(s) - single or ensemble voting
|
||
logger.info("Calling LLM for analysis...")
|
||
llm_start = time.time()
|
||
ensemble_models = []
|
||
if os.getenv("ENABLE_AI_ENSEMBLE", "false").lower() == "true":
|
||
env_models = (os.getenv("AI_ENSEMBLE_MODELS") or "").strip()
|
||
if env_models:
|
||
ensemble_models = [m.strip() for m in env_models.split(",") if m.strip()]
|
||
|
||
if len(ensemble_models) >= 2:
|
||
analyses_list = []
|
||
for em in ensemble_models[:3]:
|
||
a = self.llm_service.safe_call_llm(
|
||
system_prompt, user_prompt, default_structure=default_struct, model=em
|
||
)
|
||
analyses_list.append(a)
|
||
decisions = [str(a.get("decision", "HOLD") or "HOLD").upper() for a in analyses_list]
|
||
from collections import Counter
|
||
vote = Counter(decisions).most_common(1)[0][0]
|
||
idx = decisions.index(vote)
|
||
analysis = analyses_list[idx].copy()
|
||
analysis["decision"] = vote
|
||
analysis["_ensemble_vote"] = dict(Counter(decisions))
|
||
analysis["_ensemble_models"] = ensemble_models[:3]
|
||
else:
|
||
analysis = self.llm_service.safe_call_llm(
|
||
system_prompt, user_prompt, default_structure=default_struct, model=model
|
||
)
|
||
|
||
llm_time = int((time.time() - llm_start) * 1000)
|
||
logger.info(f"LLM call completed in {llm_time}ms")
|
||
|
||
# Phase 4: Objective score (primary tf) + consensus calibration
|
||
objective_score = self._calculate_objective_score(data, current_price)
|
||
logger.info(
|
||
f"Primary objective score: {objective_score['overall_score']:.1f} "
|
||
f"(Technical: {objective_score['technical_score']:.1f}, Fundamental: {objective_score['fundamental_score']:.1f}, "
|
||
f"Sentiment: {objective_score['sentiment_score']:.1f}, Macro: {objective_score['macro_score']:.1f})"
|
||
)
|
||
|
||
score_based_decision = self._score_to_decision(objective_score["overall_score"], market=market)
|
||
llm_decision = str(analysis.get("decision", "HOLD") or "HOLD").upper()
|
||
|
||
# Horizon trend outlook for users (short/medium/long decision reference)
|
||
score_1d = float((objective_by_tf.get("1D") or {}).get("overall_score", objective_score.get("overall_score", 0.0)) or 0.0)
|
||
score_4h = float((objective_by_tf.get("4H") or {}).get("overall_score", score_1d) or score_1d)
|
||
score_1h = float((objective_by_tf.get("1H") or {}).get("overall_score", score_4h) or score_4h)
|
||
# ~24h: prefer 1H bar objective; fall back 4H -> 1D
|
||
score_24h = float(score_1h)
|
||
score_1w = float((objective_by_tf.get("1W") or {}).get("overall_score", score_1d) or score_1d)
|
||
score_3d = score_1d * 0.7 + score_4h * 0.3
|
||
score_1m = score_1w * 0.55 + float(objective_score.get("fundamental_score", 0.0)) * 0.30 + float(objective_score.get("macro_score", 0.0)) * 0.15
|
||
|
||
def _trend_strength(score_val: float) -> str:
|
||
a = abs(float(score_val))
|
||
if a >= 70:
|
||
return "strong"
|
||
if a >= 40:
|
||
return "moderate"
|
||
if a >= 20:
|
||
return "mild"
|
||
return "neutral"
|
||
|
||
trend_outlook = {
|
||
"next_24h": {
|
||
"score": round(score_24h, 2),
|
||
"trend": self._score_to_decision(score_24h, market=market),
|
||
"strength": _trend_strength(score_24h),
|
||
},
|
||
"next_3d": {
|
||
"score": round(score_3d, 2),
|
||
"trend": self._score_to_decision(score_3d, market=market),
|
||
"strength": _trend_strength(score_3d),
|
||
},
|
||
"next_1w": {
|
||
"score": round(score_1w, 2),
|
||
"trend": self._score_to_decision(score_1w, market=market),
|
||
"strength": _trend_strength(score_1w),
|
||
},
|
||
"next_1m": {
|
||
"score": round(score_1m, 2),
|
||
"trend": self._score_to_decision(score_1m, market=market),
|
||
"strength": _trend_strength(score_1m),
|
||
},
|
||
}
|
||
trend_outlook_summary = _build_trend_outlook_summary(trend_outlook, language)
|
||
|
||
# Consensus confidence:
|
||
consensus_conf = int(max(40, min(98, 50 + consensus_abs * 0.35)))
|
||
# Agreement boosts, disagreement reduces
|
||
consensus_conf = int(max(35, min(98, consensus_conf * (0.85 + 0.3 * agreement_ratio))))
|
||
consensus_conf = int(max(0, min(100, consensus_conf * quality_multiplier)))
|
||
|
||
# Decide whether to enforce consensus over LLM / primary-score decision
|
||
cfg = self._get_ai_calibration(market=market)
|
||
min_abs_override = float(cfg.get("min_consensus_abs_override") or 15.0)
|
||
quality_hold_thr = float(cfg.get("quality_hold_threshold") or 0.7)
|
||
regime = self._detect_market_regime(data.get("indicators") or {})
|
||
if regime == "ranging":
|
||
min_abs_override *= 1.2
|
||
|
||
if consensus_abs >= min_abs_override:
|
||
final_decision = consensus_decision
|
||
if llm_decision != final_decision:
|
||
logger.warning(
|
||
f"Override: llm_decision={llm_decision}, consensus_decision={final_decision}, "
|
||
f"consensus_score={consensus_score:.1f}, consensus_abs={consensus_abs:.1f}"
|
||
)
|
||
analysis["decision"] = final_decision
|
||
analysis["confidence"] = consensus_conf
|
||
original_summary = analysis.get("summary", "")
|
||
is_zh = str(language or "").lower().startswith("zh")
|
||
if is_zh:
|
||
level = "强烈" if consensus_abs >= 70 else "明显" if consensus_abs >= 40 else "轻微"
|
||
bias = "利多" if consensus_score > 0 else "利空"
|
||
consensus_note = (
|
||
f"[多周期客观共识：综合评分{consensus_score:.1f}分（{level}{bias}），建议{final_decision}]"
|
||
)
|
||
else:
|
||
level = "strong" if consensus_abs >= 70 else "moderate" if consensus_abs >= 40 else "mild"
|
||
bias = "bullish" if consensus_score > 0 else "bearish"
|
||
consensus_note = (
|
||
f"[Multi-timeframe objective consensus: score {consensus_score:.1f} "
|
||
f"({level} {bias}), suggested decision {final_decision}]"
|
||
)
|
||
analysis["summary"] = f"{original_summary} {consensus_note}".strip()
|
||
else:
|
||
# Near-neutral: keep LLM but shrink confidence by quality and enforce HOLD if quality is poor
|
||
analysis["confidence"] = int(max(0, min(100, int(analysis.get("confidence", 50) or 50) * quality_multiplier)))
|
||
|
||
if quality_multiplier < quality_hold_thr:
|
||
analysis["decision"] = "HOLD"
|
||
analysis["confidence"] = min(int(analysis.get("confidence", 50) or 50), 55)
|
||
|
||
# Add objective scores and consensus to analysis
|
||
analysis["objective_score"] = objective_score
|
||
analysis["score_based_decision"] = score_based_decision
|
||
analysis["objective_scores_by_timeframe"] = {
|
||
k: {
|
||
"overall_score": v.get("overall_score"),
|
||
"decision": v.get("decision"),
|
||
"abs_score": v.get("abs_score"),
|
||
}
|
||
for k, v in objective_by_tf.items()
|
||
}
|
||
analysis["consensus"] = {
|
||
"consensus_score": consensus_score,
|
||
"consensus_decision": consensus_decision,
|
||
"consensus_abs": consensus_abs,
|
||
"agreement_ratio": agreement_ratio,
|
||
"quality_multiplier": quality_multiplier,
|
||
"market_regime": regime,
|
||
}
|
||
|
||
# Phase 5: Validate and constrain output (pass indicators for decision validation)
|
||
# Check for major news or macro events that could override technical indicators
|
||
news_data = data.get("news") or []
|
||
macro_data = data.get("macro") or {}
|
||
has_major_news = self._has_major_news(news_data)
|
||
has_macro_event = self._has_macro_event(macro_data, data.get("market", ""))
|
||
|
||
analysis = self._validate_and_constrain(
|
||
analysis,
|
||
current_price,
|
||
indicators=data.get("indicators"),
|
||
has_major_news=has_major_news,
|
||
has_macro_event=has_macro_event
|
||
)
|
||
|
||
# Post-validate: adjust position sizing based on quality + agreement
|
||
try:
|
||
ps = analysis.get("position_size_pct", 10)
|
||
ps = int(float(ps or 10))
|
||
# Lower position size if data is incomplete or multi-timeframe disagreement exists
|
||
# agreement_ratio in [0..1]
|
||
agreement_scale = 0.6 + 0.4 * float(agreement_ratio)
|
||
ps_scaled = ps * float(quality_multiplier) * agreement_scale
|
||
if str(analysis.get("decision") or "").upper() == "HOLD":
|
||
ps_scaled *= 0.25
|
||
analysis["position_size_pct"] = max(1, min(100, int(round(ps_scaled))))
|
||
except Exception:
|
||
# Keep model-provided position_size_pct
|
||
pass
|
||
|
||
# Confidence calibration: adjust by historical accuracy in bucket
|
||
if os.getenv("ENABLE_CONFIDENCE_CALIBRATION", "false").lower() == "true":
|
||
try:
|
||
from app.services.analysis_memory import get_analysis_memory
|
||
raw_conf = int(analysis.get("confidence", 50) or 50)
|
||
analysis["confidence"] = get_analysis_memory().get_adjusted_confidence(
|
||
raw_conf, market=market, symbol=symbol
|
||
)
|
||
except Exception as e:
|
||
logger.debug(f"Confidence calibration skipped: {e}")
|
||
|
||
# Build final result
|
||
total_time = int((time.time() - start_time) * 1000)
|
||
|
||
# Extract detailed analysis sections
|
||
detailed_analysis = analysis.get("analysis", {})
|
||
if isinstance(detailed_analysis, str):
|
||
# If AI returned a string instead of dict, use it as technical analysis
|
||
detailed_analysis = {"technical": detailed_analysis, "fundamental": "", "sentiment": ""}
|
||
|
||
result.update({
|
||
"decision": analysis.get("decision", "HOLD"),
|
||
"confidence": analysis.get("confidence", 50),
|
||
"summary": analysis.get("summary", ""),
|
||
"model": model, # Model is already set in result initialization
|
||
"language": language, # Ensure language is included for task record
|
||
"detailed_analysis": {
|
||
"technical": detailed_analysis.get("technical", ""),
|
||
"fundamental": detailed_analysis.get("fundamental", ""),
|
||
"sentiment": detailed_analysis.get("sentiment", ""),
|
||
},
|
||
"trading_plan": {
|
||
"entry_price": analysis.get("entry_price"),
|
||
"stop_loss": analysis.get("stop_loss"),
|
||
"take_profit": analysis.get("take_profit"),
|
||
"position_size_pct": analysis.get("position_size_pct", 10),
|
||
"timeframe": analysis.get("timeframe", "medium"),
|
||
# camelCase + semantic alias: for private front-end/legacy component binding (do not use indicators.trading_levels as a plan)
|
||
"entryPrice": analysis.get("entry_price"),
|
||
"stopLoss": analysis.get("stop_loss"),
|
||
"takeProfit": analysis.get("take_profit"),
|
||
"positionSizePct": analysis.get("position_size_pct", 10),
|
||
"decision": str(analysis.get("decision", "HOLD") or "HOLD").upper(),
|
||
# The same value as stop_loss / take_profit; the naming emphasizes "loss exit / profit target" to avoid confusion with the long order reference line
|
||
"loss_exit_price": analysis.get("stop_loss"),
|
||
"profit_target_price": analysis.get("take_profit"),
|
||
},
|
||
"reasons": analysis.get("key_reasons", []),
|
||
"risks": analysis.get("risks", []),
|
||
"scores": {
|
||
"technical": analysis.get("technical_score", 50),
|
||
"fundamental": analysis.get("fundamental_score", 50),
|
||
"sentiment": analysis.get("sentiment_score", 50),
|
||
"overall": self._calculate_overall_score(analysis),
|
||
},
|
||
"objective_score": analysis.get("objective_score", {}),
|
||
"score_based_decision": analysis.get("score_based_decision", "HOLD"),
|
||
"market_data": {
|
||
"current_price": current_price,
|
||
"change_24h": data["price"].get("changePercent", 0),
|
||
"support": data["indicators"].get("levels", {}).get("support"),
|
||
"resistance": data["indicators"].get("levels", {}).get("resistance"),
|
||
},
|
||
"indicators": data.get("indicators", {}),
|
||
"consensus": analysis.get("consensus", {}),
|
||
"trend_outlook": trend_outlook,
|
||
"trend_outlook_summary": trend_outlook_summary,
|
||
"trendOutlook": trend_outlook,
|
||
"trendOutlookSummary": trend_outlook_summary,
|
||
"analysis_time_ms": total_time,
|
||
"llm_time_ms": llm_time,
|
||
"data_collection_time_ms": data.get("collection_time_ms", 0),
|
||
})
|
||
|
||
# Store in memory for future retrieval and get memory_id for feedback
|
||
memory_id = self._store_analysis_memory(result, user_id=user_id)
|
||
if memory_id:
|
||
result["memory_id"] = memory_id
|
||
|
||
logger.info(f"Fast analysis completed in {total_time}ms: {market}:{symbol} -> {result['decision']} (memory_id={memory_id}, user_id={user_id})")
|
||
|
||
except Exception as e:
|
||
logger.error(f"Fast analysis failed: {e}", exc_info=True)
|
||
result["error"] = str(e)
|
||
|
||
return result
|
||
|
||
def _build_decision_guidance(self, rsi_value: float, macd_signal: str, ma_trend: str, change_24h: float) -> str:
|
||
"""
|
||
Build decision guidance based on technical indicators to help AI make more reasonable decisions.
|
||
Emphasize that the SELL signal is an effective short selling opportunity.
|
||
"""
|
||
guidance_parts = []
|
||
|
||
# RSI Guidance - Identify shorting opportunities more aggressively
|
||
if rsi_value > 70:
|
||
guidance_parts.append("🔴 RSI > 70 (超买): 强烈建议SELL做空，避免BUY")
|
||
elif rsi_value > 60:
|
||
guidance_parts.append("🟠 RSI > 60 (偏超买): 建议SELL做空，谨慎BUY")
|
||
elif rsi_value < 30:
|
||
guidance_parts.append("🟢 RSI < 30 (超卖): 建议BUY做多，避免SELL")
|
||
elif rsi_value < 40:
|
||
guidance_parts.append("🟡 RSI < 40 (偏超卖): 可以考虑BUY做多")
|
||
else:
|
||
guidance_parts.append("⚪ RSI 40-60 (中性): 技术面中性，需要结合其他指标判断")
|
||
|
||
# MACD Guidance - Clear Short Signal
|
||
if macd_signal == "bullish":
|
||
guidance_parts.append("🟢 MACD 看涨: 支持BUY做多")
|
||
elif macd_signal == "bearish":
|
||
guidance_parts.append("🔴 MACD 看跌: 支持SELL做空，这是有效的做空机会")
|
||
else:
|
||
guidance_parts.append("⚪ MACD 中性: 无明显方向")
|
||
|
||
# MA Trend Guidance - Identify Trend Reversal Opportunities
|
||
if "uptrend" in ma_trend.lower() or "strong_uptrend" in ma_trend.lower():
|
||
if rsi_value > 60:
|
||
guidance_parts.append("⚠️ 均线向上但RSI超买: 可能接近顶部，考虑SELL做空")
|
||
else:
|
||
guidance_parts.append("🟢 均线趋势向上: 支持BUY做多")
|
||
elif "downtrend" in ma_trend.lower() or "strong_downtrend" in ma_trend.lower():
|
||
guidance_parts.append("🔴 均线趋势向下: 这是SELL做空的良好机会，避免BUY")
|
||
else:
|
||
guidance_parts.append("⚪ 均线横盘: 趋势不明确")
|
||
|
||
# 24-hour price range guidance - identifying excessive volatility
|
||
if change_24h > 5:
|
||
guidance_parts.append("🔴 24h涨幅 > 5%: 可能已过度上涨，建议SELL做空或获利了结")
|
||
elif change_24h < -5:
|
||
guidance_parts.append("🟢 24h跌幅 > 5%: 可能已过度下跌，可以考虑BUY做多")
|
||
|
||
# Comprehensive suggestions
|
||
sell_signals = sum([
|
||
rsi_value > 60,
|
||
macd_signal == "bearish",
|
||
"downtrend" in ma_trend.lower(),
|
||
change_24h > 5
|
||
])
|
||
buy_signals = sum([
|
||
rsi_value < 40,
|
||
macd_signal == "bullish",
|
||
"uptrend" in ma_trend.lower(),
|
||
change_24h < -5
|
||
])
|
||
|
||
if sell_signals >= 2:
|
||
guidance_parts.append(f"📊 综合判断: {sell_signals}个做空信号，建议考虑SELL")
|
||
elif buy_signals >= 2:
|
||
guidance_parts.append(f"📊 综合判断: {buy_signals}个做多信号，建议考虑BUY")
|
||
else:
|
||
guidance_parts.append("📊 综合判断: 信号混合，需要结合宏观和新闻判断")
|
||
|
||
return "\n".join(guidance_parts) if guidance_parts else "技术指标数据不足，请谨慎判断"
|
||
|
||
def _has_major_news(self, news_data: List[Dict]) -> bool:
|
||
"""
|
||
Check for breaking news events.
|
||
Breaking news includes: regulatory changes, major collaborations, scandals, major policies, geopolitical events, etc.
|
||
The geographical category uses word boundaries and classification to avoid misjudgment of substrings such as toward/extension/us.
|
||
"""
|
||
if not news_data:
|
||
return False
|
||
|
||
# Substring keywords (longer words or Chinese to avoid mismatching of too short English)
|
||
major_keywords = [
|
||
"regulation", "regulatory", "approval", "policy", "government", "central bank",
|
||
"监管", "禁令", "批准", "政策", "政府", "央行",
|
||
"partnership", "merger", "acquisition", "scandal", "lawsuit", "investigation",
|
||
"合作", "合并", "收购", "丑闻", "诉讼", "调查",
|
||
"sanctions", "embargo", "制裁", "中东", "海湾", "北约",
|
||
"united states", "middle east",
|
||
]
|
||
# Use word boundary matching for short English words (without using naked substrings)
|
||
major_short_patterns = [
|
||
re.compile(r"\b(?:ban|banned|banning)\b", re.I),
|
||
re.compile(r"\b(?:crisis|crises)\b", re.I),
|
||
re.compile(r"\b(?:catastrophe|meltdown)\b", re.I),
|
||
]
|
||
|
||
for news in news_data[:10]:
|
||
title = news.get("title") or news.get("headline") or ""
|
||
summary = news.get("summary") or ""
|
||
sentiment = news.get("sentiment", "neutral")
|
||
text_to_check = f"{title} {summary}"
|
||
low = text_to_check.lower()
|
||
|
||
if _is_major_geopolitical_news_text(text_to_check):
|
||
logger.info(f"Detected major geopolitical event in news: {low[:80]}")
|
||
return True
|
||
|
||
if any(kw in low for kw in major_keywords) and sentiment != "neutral":
|
||
logger.info(f"Detected major news event: {low[:80]}")
|
||
return True
|
||
if sentiment != "neutral" and any(p.search(low) for p in major_short_patterns):
|
||
logger.info(f"Detected major news event (pattern): {low[:80]}")
|
||
return True
|
||
|
||
return False
|
||
|
||
def _has_macro_event(self, macro_data: Dict, market: str) -> bool:
|
||
"""
|
||
Check for major macro events.
|
||
Major macro events include: abnormally high VIX, large fluctuations in DXY, changes in interest rate policies, etc.
|
||
"""
|
||
if not macro_data:
|
||
return False
|
||
|
||
# Check the VIX (fear index)
|
||
if "VIX" in macro_data:
|
||
vix = macro_data["VIX"]
|
||
vix_value = vix.get("price", 0)
|
||
if vix_value > 30: # VIX > 30 indicates extreme panic
|
||
return True
|
||
|
||
# Check for large DXY swings (>1%)
|
||
if "DXY" in macro_data:
|
||
dxy = macro_data["DXY"]
|
||
change_pct = abs(dxy.get("changePercent", 0))
|
||
if change_pct > 1.0: # The U.S. dollar index fluctuates more than 1%
|
||
return True
|
||
|
||
# Check for interest rate changes (big impact on stocks and cryptocurrencies)
|
||
if "TNX" in macro_data and market in ["USStock", "Crypto"]:
|
||
tnx = macro_data["TNX"]
|
||
change_pct = abs(tnx.get("changePercent", 0))
|
||
if change_pct > 2.0: # Interest rates change by more than 2%
|
||
return True
|
||
|
||
return False
|
||
|
||
def _finalize_trading_plan_for_decision(
|
||
self, analysis: Dict, current_price: float, indicators: Optional[Dict] = None
|
||
) -> Dict:
|
||
"""
|
||
After decision is final: force correct stop/take-profit geometry and mirror long levels for shorts.
|
||
BUY: stop_loss < current < take_profit
|
||
SELL: take_profit < current < stop_loss (short: stop above, TP below)
|
||
"""
|
||
if not current_price or current_price <= 0:
|
||
return analysis
|
||
indicators = indicators or {}
|
||
decision = str(analysis.get("decision", "HOLD")).upper()
|
||
if decision not in ("BUY", "SELL"):
|
||
return analysis
|
||
|
||
min_price = current_price * 0.90
|
||
max_price = current_price * 1.10
|
||
eps = max(abs(current_price) * 1e-6, 1e-8)
|
||
|
||
tl = indicators.get("trading_levels") or {}
|
||
sl_long = _safe_float_price(tl.get("suggested_stop_loss"))
|
||
tp_long = _safe_float_price(tl.get("suggested_take_profit"))
|
||
long_ok = (
|
||
sl_long is not None
|
||
and tp_long is not None
|
||
and sl_long < current_price - eps
|
||
and tp_long > current_price + eps
|
||
)
|
||
|
||
if decision == "SELL":
|
||
if long_ok:
|
||
mirrored_sl = round(2 * current_price - sl_long, 6)
|
||
mirrored_tp = round(2 * current_price - tp_long, 6)
|
||
mirrored_sl = min(max(mirrored_sl, current_price + eps), max_price)
|
||
mirrored_tp = max(min(mirrored_tp, current_price - eps), min_price)
|
||
if mirrored_sl > current_price and mirrored_tp < current_price:
|
||
analysis["stop_loss"] = mirrored_sl
|
||
analysis["take_profit"] = mirrored_tp
|
||
else:
|
||
analysis["stop_loss"] = round(min(max_price, current_price * 1.05), 6)
|
||
analysis["take_profit"] = round(max(min_price, current_price * 0.95), 6)
|
||
else:
|
||
sl_f = _safe_float_price(analysis.get("stop_loss"))
|
||
tp_f = _safe_float_price(analysis.get("take_profit"))
|
||
if sl_f is not None and tp_f is not None and tp_f < current_price < sl_f:
|
||
analysis["stop_loss"] = round(min(max(sl_f, current_price + eps), max_price), 6)
|
||
analysis["take_profit"] = round(max(min(tp_f, current_price - eps), min_price), 6)
|
||
else:
|
||
analysis["stop_loss"] = round(min(max_price, current_price * 1.05), 6)
|
||
analysis["take_profit"] = round(max(min_price, current_price * 0.95), 6)
|
||
else: # BUY
|
||
if long_ok:
|
||
sl = max(min(sl_long, current_price - eps), min_price)
|
||
tp = min(max(tp_long, current_price + eps), max_price)
|
||
analysis["stop_loss"] = round(sl, 6)
|
||
analysis["take_profit"] = round(tp, 6)
|
||
else:
|
||
sl_f = _safe_float_price(analysis.get("stop_loss"))
|
||
tp_f = _safe_float_price(analysis.get("take_profit"))
|
||
if sl_f is not None and tp_f is not None and sl_f < current_price < tp_f:
|
||
analysis["stop_loss"] = round(max(min(sl_f, current_price - eps), min_price), 6)
|
||
analysis["take_profit"] = round(min(max(tp_f, current_price + eps), max_price), 6)
|
||
else:
|
||
analysis["stop_loss"] = round(max(min_price, current_price * 0.95), 6)
|
||
analysis["take_profit"] = round(min(max_price, current_price * 1.05), 6)
|
||
|
||
# Last-resort: fix inverted or equal levels
|
||
sl_f = _safe_float_price(analysis.get("stop_loss"), current_price)
|
||
tp_f = _safe_float_price(analysis.get("take_profit"), current_price)
|
||
if sl_f is None or tp_f is None:
|
||
return analysis
|
||
if decision == "SELL":
|
||
if not (tp_f < current_price < sl_f):
|
||
analysis["stop_loss"] = round(min(max_price, current_price * 1.05), 6)
|
||
analysis["take_profit"] = round(max(min_price, current_price * 0.95), 6)
|
||
else:
|
||
if not (sl_f < current_price < tp_f):
|
||
analysis["stop_loss"] = round(max(min_price, current_price * 0.95), 6)
|
||
analysis["take_profit"] = round(min(max_price, current_price * 1.05), 6)
|
||
|
||
return analysis
|
||
|
||
def _validate_and_constrain(self, analysis: Dict, current_price: float, indicators: Dict = None,
|
||
has_major_news: bool = False, has_macro_event: bool = False) -> Dict:
|
||
"""
|
||
Validate LLM output and constrain prices to reasonable ranges.
|
||
Also validate decision against technical indicators to prevent absurd recommendations.
|
||
"""
|
||
if not current_price or current_price <= 0:
|
||
return analysis
|
||
|
||
# Price bounds
|
||
min_price = current_price * 0.90
|
||
max_price = current_price * 1.10
|
||
decision = str(analysis.get("decision", "HOLD")).upper()
|
||
|
||
# Constrain entry price
|
||
entry = _safe_float_price(analysis.get("entry_price"), current_price)
|
||
if entry is not None and (entry < min_price or entry > max_price):
|
||
logger.warning(f"Entry price {entry} out of bounds, constraining to current price {current_price}")
|
||
analysis["entry_price"] = round(current_price, 6)
|
||
elif entry is not None:
|
||
analysis["entry_price"] = round(entry, 6)
|
||
|
||
# Constrain stop loss / take profit by direction (numeric-safe).
|
||
# BUY: stop_loss < current < take_profit
|
||
# SELL: take_profit < current < stop_loss
|
||
if decision == "SELL":
|
||
stop_default = round(current_price * 1.05, 6)
|
||
tp_default = round(current_price * 0.95, 6)
|
||
stop_loss = _safe_float_price(analysis.get("stop_loss"), stop_default)
|
||
take_profit = _safe_float_price(analysis.get("take_profit"), tp_default)
|
||
if stop_loss is None or stop_loss <= current_price or stop_loss > max_price:
|
||
analysis["stop_loss"] = stop_default
|
||
else:
|
||
analysis["stop_loss"] = round(stop_loss, 6)
|
||
if take_profit is None or take_profit >= current_price or take_profit < min_price:
|
||
analysis["take_profit"] = tp_default
|
||
else:
|
||
analysis["take_profit"] = round(take_profit, 6)
|
||
else:
|
||
stop_default = round(current_price * 0.95, 6)
|
||
tp_default = round(current_price * 1.05, 6)
|
||
stop_loss = _safe_float_price(analysis.get("stop_loss"), stop_default)
|
||
take_profit = _safe_float_price(analysis.get("take_profit"), tp_default)
|
||
if stop_loss is None or stop_loss < min_price or stop_loss >= current_price:
|
||
analysis["stop_loss"] = stop_default
|
||
else:
|
||
analysis["stop_loss"] = round(stop_loss, 6)
|
||
if take_profit is None or take_profit <= current_price or take_profit > max_price:
|
||
analysis["take_profit"] = tp_default
|
||
else:
|
||
analysis["take_profit"] = round(take_profit, 6)
|
||
|
||
# Constrain confidence
|
||
confidence = analysis.get("confidence", 50)
|
||
analysis["confidence"] = max(0, min(100, int(confidence)))
|
||
|
||
# Constrain scores
|
||
for score_key in ["technical_score", "fundamental_score", "sentiment_score"]:
|
||
score = analysis.get(score_key, 50)
|
||
analysis[score_key] = max(0, min(100, int(score)))
|
||
|
||
# Validate decision
|
||
if decision not in ["BUY", "SELL", "HOLD"]:
|
||
analysis["decision"] = "HOLD"
|
||
else:
|
||
analysis["decision"] = decision
|
||
|
||
# Validate decision-making rationality based on technical indicators (allow macro/news factor coverage)
|
||
if indicators:
|
||
analysis = self._validate_decision_against_indicators(
|
||
analysis, indicators, confidence,
|
||
has_major_news=has_major_news,
|
||
has_macro_event=has_macro_event
|
||
)
|
||
|
||
# Final geometry after any decision change (e.g. forced HOLD skips finalize in caller — still safe)
|
||
analysis = self._finalize_trading_plan_for_decision(analysis, current_price, indicators)
|
||
|
||
return analysis
|
||
|
||
def _validate_decision_against_indicators(self, analysis: Dict, indicators: Dict, confidence: int,
|
||
has_major_news: bool = False, has_macro_event: bool = False) -> Dict:
|
||
"""
|
||
Justify decisions against technical indicators, but allow macro/news factors to override technical indicators.
|
||
|
||
Args:
|
||
analysis: AI analysis results
|
||
indicators: technical indicator data
|
||
confidence: confidence
|
||
has_major_news: Is there a major news event?
|
||
has_macro_event: Is there a major macro event?
|
||
"""
|
||
decision = analysis.get("decision", "HOLD")
|
||
rsi_data = indicators.get("rsi", {})
|
||
macd_data = indicators.get("macd", {})
|
||
ma_data = indicators.get("moving_averages", {})
|
||
|
||
rsi_value = rsi_data.get("value", 50)
|
||
macd_signal = macd_data.get("signal", "neutral")
|
||
ma_trend = ma_data.get("trend", "sideways")
|
||
|
||
# If the confidence level is too low, force it to HOLD
|
||
if confidence < 60:
|
||
if decision != "HOLD":
|
||
logger.warning(f"Decision {decision} with low confidence {confidence}, forcing to HOLD")
|
||
analysis["decision"] = "HOLD"
|
||
analysis["confidence"] = max(confidence, 45) # Reduce confidence
|
||
return analysis
|
||
|
||
# Allows technical indicators to be overridden (but logs warnings) if there is major news or macro events
|
||
allow_override = has_major_news or has_macro_event
|
||
|
||
# Check whether the BUY decision conflicts with technical indicators
|
||
if decision == "BUY":
|
||
conflicts = []
|
||
|
||
# You should not buy when RSI > 70 (unless there is a major upside)
|
||
if rsi_value > 70:
|
||
conflicts.append(f"RSI {rsi_value:.1f} > 70 (超买)")
|
||
|
||
# You should not BUY when MACD is bearish (unless there is a major upside)
|
||
if macd_signal == "bearish":
|
||
conflicts.append("MACD bearish")
|
||
|
||
# You should not buy when the moving average trend is downward (unless there is a major benefit)
|
||
# Only consider a conflict if the trend is very strong (avoid being too sensitive)
|
||
if "strong_downtrend" in ma_trend.lower() or ("downtrend" in ma_trend.lower() and rsi_value > 50):
|
||
conflicts.append(f"MA trend: {ma_trend}")
|
||
|
||
if conflicts:
|
||
if allow_override:
|
||
# Allow override, but lower confidence and add description
|
||
logger.info(f"BUY decision conflicts with indicators but major news/macro event allows override: {', '.join(conflicts)}")
|
||
analysis["confidence"] = max(confidence - 15, 50)
|
||
original_summary = analysis.get("summary", "")
|
||
analysis["summary"] = f"{original_summary} [注意：技术指标显示{', '.join(conflicts)}，但重大事件可能改变趋势]"
|
||
else:
|
||
# If there is no major event, it is forced to be changed to HOLD.
|
||
logger.warning(f"BUY decision conflicts with indicators and no major event: {', '.join(conflicts)}. Forcing to HOLD")
|
||
analysis["decision"] = "HOLD"
|
||
analysis["confidence"] = max(confidence - 20, 40)
|
||
original_summary = analysis.get("summary", "")
|
||
analysis["summary"] = f"{original_summary} [注意：技术指标显示{', '.join(conflicts)}，建议观望]"
|
||
|
||
# Check whether SELL decisions contradict technical indicators (relax restrictions because SELL is a valid short opportunity)
|
||
elif decision == "SELL":
|
||
conflicts = []
|
||
|
||
# Only block SELL (relax conditions) if there is a strong bullish signal
|
||
# It is considered a contradiction when RSI < 30 and MACD is bullish and the moving average is upward.
|
||
if rsi_value < 30 and macd_signal == "bullish" and "uptrend" in ma_trend.lower():
|
||
conflicts.append(f"Strong bullish signals (RSI {rsi_value:.1f} < 30, MACD bullish, uptrend)")
|
||
# Or RSI < 30 and the moving average is strongly upward
|
||
elif rsi_value < 30 and "strong_uptrend" in ma_trend.lower():
|
||
conflicts.append(f"Very strong uptrend with oversold RSI {rsi_value:.1f}")
|
||
|
||
if conflicts:
|
||
if allow_override:
|
||
# Allow override, but lower confidence and add description
|
||
logger.info(f"SELL decision conflicts with strong bullish indicators but major news/macro event allows override: {', '.join(conflicts)}")
|
||
analysis["confidence"] = max(confidence - 15, 50)
|
||
original_summary = analysis.get("summary", "")
|
||
analysis["summary"] = f"{original_summary} [注意：技术指标显示{', '.join(conflicts)}，但重大事件可能改变趋势]"
|
||
else:
|
||
# Only change to HOLD if there is a very strong bullish signal
|
||
logger.warning(f"SELL decision conflicts with very strong bullish indicators: {', '.join(conflicts)}. Forcing to HOLD")
|
||
analysis["decision"] = "HOLD"
|
||
analysis["confidence"] = max(confidence - 20, 40)
|
||
original_summary = analysis.get("summary", "")
|
||
analysis["summary"] = f"{original_summary} [注意：技术指标显示{', '.join(conflicts)}，建议观望]"
|
||
|
||
return analysis
|
||
|
||
def _calculate_objective_score(self, data: Dict[str, Any], current_price: float) -> Dict[str, float]:
|
||
"""
|
||
Calculates a quantitative scoring system based on objective data
|
||
|
||
Return a score between -100 and +100:
|
||
- +100: Strong bullish (strong BUY)
|
||
- +70 to +100: Strong bullish (strong BUY)
|
||
- +40 to +70: BUY
|
||
- -40 to +40: Neutral (HOLD)
|
||
- -70 to -40: SELL
|
||
- -100 to -70: Strongly bearish (strongly SELL)
|
||
- -100: Strongly bearish (strongly SELL)
|
||
"""
|
||
indicators = data.get("indicators") or {}
|
||
fundamental = data.get("fundamental") or {}
|
||
news = data.get("news") or []
|
||
macro = data.get("macro") or {}
|
||
price_data = data.get("price") or {}
|
||
|
||
# 1. Technical indicator score (-100 to +100)
|
||
technical_score = self._calculate_technical_score(indicators, price_data)
|
||
|
||
# 2. Fundamental score (-100 to +100)
|
||
fundamental_score = self._calculate_fundamental_score(fundamental, data.get("market", ""))
|
||
|
||
# 3. News sentiment score (-100 to +100)
|
||
sentiment_score = self._calculate_sentiment_score(news)
|
||
|
||
# 4. Macro environment score (-100 to +100)
|
||
macro_score = self._calculate_macro_score(macro, data.get("market", ""))
|
||
|
||
# 5. Comprehensive rating (weighted average)
|
||
# Optimization weight: Default technical 35%, fundamentals 20%, sentiment 25% (including geopolitics), macro 20% (increase macro weight)
|
||
# But we need to "reweight the available information": when some modules are missing (such as news/macro is not obtained), do not use 0 points to dilute the overall strength.
|
||
# Instead, the weights are renormalized so that technical signals can still play a leading role in their absence.
|
||
market_type = str(data.get("market") or "")
|
||
fundamental_present = (market_type == "USStock") and bool(fundamental)
|
||
sentiment_present = bool(news)
|
||
macro_present = bool(macro)
|
||
# indicators usually exist once they are successfully calculated, but they are also protected here.
|
||
technical_present = bool(indicators)
|
||
|
||
weights = {
|
||
"technical": 0.35,
|
||
"fundamental": 0.20,
|
||
"sentiment": 0.25,
|
||
"macro": 0.20,
|
||
}
|
||
present_flags = {
|
||
"technical": technical_present,
|
||
"fundamental": fundamental_present,
|
||
"sentiment": sentiment_present,
|
||
"macro": macro_present,
|
||
}
|
||
|
||
total_w = sum(w for k, w in weights.items() if present_flags.get(k))
|
||
if total_w <= 0:
|
||
overall_score = technical_score
|
||
else:
|
||
overall_score = (
|
||
(technical_score * weights["technical"] if present_flags.get("technical") else 0.0)
|
||
+ (fundamental_score * weights["fundamental"] if present_flags.get("fundamental") else 0.0)
|
||
+ (sentiment_score * weights["sentiment"] if present_flags.get("sentiment") else 0.0)
|
||
+ (macro_score * weights["macro"] if present_flags.get("macro") else 0.0)
|
||
) / total_w
|
||
|
||
return {
|
||
"technical_score": technical_score,
|
||
"fundamental_score": fundamental_score,
|
||
"sentiment_score": sentiment_score,
|
||
"macro_score": macro_score,
|
||
"overall_score": overall_score
|
||
}
|
||
|
||
def _get_ai_calibration(self, market: str = "Crypto") -> Dict[str, Any]:
|
||
"""
|
||
Load latest offline calibration thresholds for the given market.
|
||
Cached briefly to avoid DB load on every request.
|
||
"""
|
||
# Simple per-process cache
|
||
now = time.time()
|
||
if not hasattr(self, "_calibration_cache"):
|
||
self._calibration_cache = {}
|
||
self._calibration_cache_ts = {}
|
||
ttl = int(os.getenv("AI_CALIBRATION_CACHE_TTL_SEC", "300"))
|
||
key = (market or "").strip() or "Crypto"
|
||
ts = self._calibration_cache_ts.get(key) or 0.0
|
||
if ts and (now - float(ts)) < ttl:
|
||
return self._calibration_cache.get(key) or {}
|
||
|
||
try:
|
||
from app.services.ai_calibration import AICalibrationService
|
||
svc = AICalibrationService()
|
||
cfg = svc.get_latest(key)
|
||
except Exception as e:
|
||
logger.warning(f"_get_ai_calibration failed (fallback): {e}", exc_info=True)
|
||
cfg = {}
|
||
|
||
self._calibration_cache[key] = cfg
|
||
self._calibration_cache_ts[key] = now
|
||
return cfg
|
||
|
||
def _calculate_technical_score(self, indicators: Dict, price_data: Dict) -> float:
|
||
"""Calculate technical indicator score (-100 to +100)"""
|
||
score = 0.0
|
||
weight_sum = 0.0
|
||
|
||
# RSI score (-50 to +50)
|
||
rsi_data = indicators.get("rsi", {})
|
||
rsi_value = rsi_data.get("value", 50)
|
||
if rsi_value > 0:
|
||
if rsi_value > 70:
|
||
rsi_score = -50 # Overbought, strongly bearish
|
||
elif rsi_value > 60:
|
||
rsi_score = -30 # Overbought, negative
|
||
elif rsi_value < 30:
|
||
rsi_score = +50 # Oversold, strongly bullish
|
||
elif rsi_value < 40:
|
||
rsi_score = +30 # Oversold, bullish
|
||
else:
|
||
rsi_score = (50 - rsi_value) * 0.6 # Between 40-60, linear mapping
|
||
score += rsi_score * 0.30
|
||
weight_sum += 0.30
|
||
|
||
# MACD score (-40 to +40)
|
||
macd_data = indicators.get("macd", {})
|
||
macd_signal = macd_data.get("signal", "neutral")
|
||
if macd_signal == "bullish":
|
||
macd_score = +40
|
||
elif macd_signal == "bearish":
|
||
macd_score = -40
|
||
else:
|
||
macd_score = 0
|
||
score += macd_score * 0.25
|
||
weight_sum += 0.25
|
||
|
||
# Moving average trend score (-40 to +40)
|
||
ma_data = indicators.get("moving_averages", {})
|
||
ma_trend = ma_data.get("trend", "sideways")
|
||
if "strong_uptrend" in ma_trend.lower():
|
||
ma_score = +40
|
||
elif "uptrend" in ma_trend.lower():
|
||
ma_score = +25
|
||
elif "strong_downtrend" in ma_trend.lower():
|
||
ma_score = -40
|
||
elif "downtrend" in ma_trend.lower():
|
||
ma_score = -25
|
||
else:
|
||
ma_score = 0
|
||
score += ma_score * 0.25
|
||
weight_sum += 0.25
|
||
|
||
# 24-hour rise and fall score (-20 to +20)
|
||
change_24h = price_data.get("changePercent", 0)
|
||
if change_24h > 10:
|
||
change_score = -20 # Excessive rise is bad
|
||
elif change_24h > 5:
|
||
change_score = -10
|
||
elif change_24h < -10:
|
||
change_score = +20 # Excessive decline, bullish
|
||
elif change_24h < -5:
|
||
change_score = +10
|
||
else:
|
||
change_score = change_24h * 2 # linear mapping
|
||
score += change_score * 0.20
|
||
weight_sum += 0.20
|
||
|
||
# ========== Additional technical features (lightweight enhancement, no change to the main structure) ==========
|
||
# These characteristics come from the output of MarketDataCollector._calculate_indicators:
|
||
# - price_position: range position of the past 20 K-lines 0~100
|
||
# - volume_ratio: latest trading volume / average volume of 20 periods
|
||
# - bollinger: BB_upper/BB_lower/BB_width
|
||
# - volatility: atr, pct
|
||
extra_score = 0.0
|
||
extra_weight = 0.0
|
||
|
||
# 1) Range position: Close to the top of the range is more bearish, and close to the bottom of the range is more bullish.
|
||
try:
|
||
pp = float(indicators.get("price_position", 50.0))
|
||
# 0~100 -> -15~+15 (linear mapping, center 50 is 0)
|
||
pp_score = (50.0 - pp) * 0.3
|
||
# Boost signal in extreme areas
|
||
if pp >= 85:
|
||
pp_score -= 5
|
||
elif pp <= 15:
|
||
pp_score += 5
|
||
extra_score += pp_score
|
||
extra_weight += 0.20
|
||
except Exception:
|
||
pass
|
||
|
||
# 2) The Bollinger Bands are touched: a breakthrough of the upper band is negative, and a fall below the lower band is positive.
|
||
try:
|
||
cur_px = float(indicators.get("current_price") or price_data.get("price") or 0.0)
|
||
bb = indicators.get("bollinger") or {}
|
||
bb_u = float(bb.get("BB_upper") or 0.0)
|
||
bb_l = float(bb.get("BB_lower") or 0.0)
|
||
if cur_px > 0 and bb_u > 0 and bb_l > 0 and bb_u > bb_l:
|
||
if cur_px >= bb_u:
|
||
extra_score += -12
|
||
extra_weight += 0.20
|
||
elif cur_px <= bb_l:
|
||
extra_score += +12
|
||
extra_weight += 0.20
|
||
else:
|
||
# Within bands: small contribution by relative position
|
||
rel = (cur_px - bb_l) / (bb_u - bb_l) # 0..1
|
||
extra_score += (0.5 - float(rel)) * 10
|
||
extra_weight += 0.10
|
||
except Exception:
|
||
pass
|
||
|
||
# 3) Trading volume amplification: plus points in the direction of the trend and minus points against the trend (weak signal)
|
||
try:
|
||
vr = float(indicators.get("volume_ratio") or 1.0)
|
||
trend = str(indicators.get("trend") or indicators.get("moving_averages", {}).get("trend") or "").lower()
|
||
if vr >= 1.8:
|
||
if "uptrend" in trend:
|
||
extra_score += +8
|
||
extra_weight += 0.15
|
||
elif "downtrend" in trend:
|
||
extra_score += -8
|
||
extra_weight += 0.15
|
||
else:
|
||
# Large volume but no trend: more uncertain, slightly lower (considered to be a bearish risk)
|
||
extra_score += -3
|
||
extra_weight += 0.10
|
||
elif vr <= 0.6:
|
||
# Shrinkage: The credibility of the trend signal decreases (slight return to 0)
|
||
extra_score += 0
|
||
extra_weight += 0.05
|
||
except Exception:
|
||
pass
|
||
|
||
# 4) High volatility: reduce strong directional confidence (implemented in the form of "scaling" to avoid hard reversals)
|
||
try:
|
||
vol = indicators.get("volatility") or {}
|
||
vol_pct = float(vol.get("pct") or 0.0)
|
||
if vol_pct >= 6.0:
|
||
# Extremely High Volatility: Discounts extra points and slightly brings the total back to 0
|
||
extra_score *= 0.6
|
||
score *= 0.92
|
||
elif vol_pct >= 3.5:
|
||
extra_score *= 0.8
|
||
score *= 0.96
|
||
except Exception:
|
||
pass
|
||
|
||
# Combine extra into main score (treat as another component)
|
||
if extra_weight > 0:
|
||
# Normalize extra to roughly -100..+100 scale
|
||
extra_norm = max(-100.0, min(100.0, float(extra_score)))
|
||
score += extra_norm * 0.15
|
||
weight_sum += 0.15
|
||
|
||
# Normalized to -100 to +100
|
||
if weight_sum > 0:
|
||
score = score / weight_sum * 100
|
||
|
||
return max(-100, min(100, score))
|
||
|
||
def _calculate_fundamental_score(self, fundamental: Dict, market: str) -> float:
|
||
"""Calculate fundamental score (-100 to +100)"""
|
||
if market != "USStock" or not fundamental:
|
||
return 0.0 # Non-U.S. stocks or no fundamental data, return neutral
|
||
|
||
score = 0.0
|
||
factors = 0
|
||
|
||
# PE Ratio score
|
||
pe_ratio = fundamental.get("pe_ratio")
|
||
if pe_ratio and pe_ratio > 0:
|
||
if pe_ratio < 15:
|
||
pe_score = +20 # Low PE, bullish
|
||
elif pe_ratio < 25:
|
||
pe_score = +10
|
||
elif pe_ratio > 50:
|
||
pe_score = -20 # High PE, negative
|
||
elif pe_ratio > 35:
|
||
pe_score = -10
|
||
else:
|
||
pe_score = 0
|
||
score += pe_score
|
||
factors += 1
|
||
|
||
# ROE score
|
||
roe = fundamental.get("roe")
|
||
if roe:
|
||
if roe > 20:
|
||
roe_score = +20 # High ROE, Rita
|
||
elif roe > 15:
|
||
roe_score = +10
|
||
elif roe < 5:
|
||
roe_score = -20 # Low ROE, bad news
|
||
elif roe < 10:
|
||
roe_score = -10
|
||
else:
|
||
roe_score = 0
|
||
score += roe_score
|
||
factors += 1
|
||
|
||
# revenue growth score
|
||
revenue_growth = fundamental.get("revenue_growth")
|
||
if revenue_growth:
|
||
if revenue_growth > 20:
|
||
growth_score = +20 # High growth, good news
|
||
elif revenue_growth > 10:
|
||
growth_score = +10
|
||
elif revenue_growth < -10:
|
||
growth_score = -20 # negative growth, bad
|
||
elif revenue_growth < 0:
|
||
growth_score = -10
|
||
else:
|
||
growth_score = 0
|
||
score += growth_score
|
||
factors += 1
|
||
|
||
# Profitability score
|
||
profit_margin = fundamental.get("profit_margin")
|
||
if profit_margin:
|
||
if profit_margin > 20:
|
||
margin_score = +15 # High profit margin, profit
|
||
elif profit_margin > 10:
|
||
margin_score = +7
|
||
elif profit_margin < 0:
|
||
margin_score = -15 # loss, bad
|
||
elif profit_margin < 5:
|
||
margin_score = -7
|
||
else:
|
||
margin_score = 0
|
||
score += margin_score
|
||
factors += 1
|
||
|
||
# Debt to Equity Ratio Score
|
||
debt_to_equity = fundamental.get("debt_to_equity")
|
||
if debt_to_equity:
|
||
if debt_to_equity < 0.5:
|
||
debt_score = +10 # Low debt, good profits
|
||
elif debt_to_equity > 2.0:
|
||
debt_score = -10 # High debt, bad
|
||
else:
|
||
debt_score = 0
|
||
score += debt_score
|
||
factors += 1
|
||
|
||
# Normalization (if there are multiple factors)
|
||
if factors > 0:
|
||
score = score / factors * 100 / 4 # The maximum possible score is 20 points for each of the 4 factors = 80, normalized to 100
|
||
|
||
return max(-100, min(100, score))
|
||
|
||
def _calculate_sentiment_score(self, news: List[Dict]) -> float:
|
||
"""
|
||
Calculate news sentiment score (-100 to +100)
|
||
Geographical/conflict category: word boundary + hierarchical punishment, single capping, to avoid superposition of misjudgments such as extension/toward.
|
||
"""
|
||
if not news:
|
||
return 0.0 # No news, neutral
|
||
|
||
positive_count = 0
|
||
negative_count = 0
|
||
neutral_count = 0
|
||
geopolitical_penalty = 0
|
||
max_geo_total = int(os.getenv("SENTIMENT_GEO_PENALTY_CAP", "-55"))
|
||
|
||
for item in news[:15]:
|
||
title = item.get("headline") or item.get("title") or ""
|
||
summary = item.get("summary") or ""
|
||
text = f"{title} {summary}"
|
||
sentiment = item.get("sentiment", "neutral")
|
||
is_global_event = item.get("is_global_event", False)
|
||
|
||
level, tag = _geopolitical_match_level(text)
|
||
if is_global_event and level == "none":
|
||
level, tag = "moderate", "is_global_event"
|
||
|
||
if level != "none":
|
||
delta = _geopolitical_sentiment_penalty_delta(level)
|
||
new_total = geopolitical_penalty + delta
|
||
if new_total < max_geo_total:
|
||
delta = max_geo_total - geopolitical_penalty
|
||
geopolitical_penalty += delta
|
||
preview = (title or summary or "")[:72]
|
||
logger.info(
|
||
f"Geopolitical sentiment ({level}, {tag}): {preview!r}, "
|
||
f"delta={delta}, cumulative={geopolitical_penalty}"
|
||
)
|
||
|
||
if sentiment == "positive":
|
||
positive_count += 1
|
||
elif sentiment == "negative":
|
||
negative_count += 1
|
||
else:
|
||
neutral_count += 1
|
||
|
||
total = positive_count + negative_count + neutral_count
|
||
|
||
if total > 0:
|
||
net_sentiment = (positive_count - negative_count) / total
|
||
base_score = net_sentiment * 60
|
||
else:
|
||
base_score = 0
|
||
|
||
if geopolitical_penalty != 0:
|
||
final_score = base_score + geopolitical_penalty
|
||
logger.info(
|
||
f"Sentiment score: base={base_score:.1f}, "
|
||
f"geopolitical_penalty={geopolitical_penalty}, final={final_score:.1f}"
|
||
)
|
||
else:
|
||
final_score = base_score
|
||
|
||
return max(-100, min(100, final_score))
|
||
|
||
def _calculate_macro_score(self, macro: Dict, market: str) -> float:
|
||
"""
|
||
Calculate macro environment score (-100 to +100)
|
||
Contains macroeconomic indicators such as VIX, DXY, interest rates, etc.
|
||
"""
|
||
if not macro:
|
||
return 0.0 # No macro data, neutral
|
||
|
||
score = 0.0
|
||
factors = 0
|
||
|
||
# VIX score (fear index) - increased weight
|
||
vix = macro.get("VIX", {})
|
||
vix_value = vix.get("price", 0)
|
||
if vix_value > 0:
|
||
if vix_value > 35:
|
||
vix_score = -50 # Extremely high panic (such as during a war), severely negative
|
||
elif vix_value > 30:
|
||
vix_score = -40 # High panic, serious negative news
|
||
elif vix_value > 25:
|
||
vix_score = -30 # Higher panic, bad news
|
||
elif vix_value > 20:
|
||
vix_score = -15 # Moderate panic, slightly negative
|
||
elif vix_value < 12:
|
||
vix_score = +20 # Low panic, bullish
|
||
elif vix_value < 15:
|
||
vix_score = +10 # Lower panic, slightly bullish
|
||
else:
|
||
vix_score = 0
|
||
score += vix_score
|
||
factors += 1
|
||
|
||
# DXY Score (USD Index) - Increased weighting
|
||
dxy = macro.get("DXY", {})
|
||
dxy_value = dxy.get("price", 0)
|
||
dxy_change = dxy.get("changePercent", 0)
|
||
if dxy_value > 0:
|
||
# For Cryptocurrencies and Commodities, A Strong USD Is Typically Bearish
|
||
if market in ["Crypto", "Forex", "Futures"]:
|
||
if dxy_change > 2:
|
||
dxy_score = -30 # The sharp strengthening of the US dollar is seriously negative
|
||
elif dxy_change > 1:
|
||
dxy_score = -20 # A stronger U.S. dollar is a negative
|
||
elif dxy_change < -2:
|
||
dxy_score = +30 # The U.S. dollar weakens sharply, which is bullish
|
||
elif dxy_change < -1:
|
||
dxy_score = +20 # A weaker dollar is bullish
|
||
else:
|
||
dxy_score = 0
|
||
else:
|
||
# It also has an impact on stocks, but it’s smaller
|
||
if dxy_change > 2:
|
||
dxy_score = -10
|
||
elif dxy_change < -2:
|
||
dxy_score = +10
|
||
else:
|
||
dxy_score = 0
|
||
score += dxy_score
|
||
factors += 1
|
||
|
||
# Interest Rate Score (TNX) - Increased weighting
|
||
tnx = macro.get("TNX", {})
|
||
tnx_change = tnx.get("changePercent", 0)
|
||
tnx_value = tnx.get("price", 0)
|
||
if tnx_change != 0 or tnx_value > 0:
|
||
# Rising interest rates are generally negative for growth stocks and cryptocurrencies
|
||
if market in ["Crypto", "USStock"]:
|
||
if tnx_change > 3:
|
||
tnx_score = -30 # Interest rates rise sharply, which is seriously negative
|
||
elif tnx_change > 2:
|
||
tnx_score = -20 # Rising interest rates are bad
|
||
elif tnx_change < -3:
|
||
tnx_score = +30 # A sharp drop in interest rates is bullish
|
||
elif tnx_change < -2:
|
||
tnx_score = +20 # Falling interest rates are bullish
|
||
else:
|
||
tnx_score = 0
|
||
else:
|
||
tnx_score = 0
|
||
score += tnx_score
|
||
factors += 1
|
||
|
||
# Fear and greed index (more suitable for Crypto): extreme greed is negative, extreme fear is bullish (weak signal)
|
||
try:
|
||
fg = macro.get("FEAR_GREED", {}) or {}
|
||
fg_value = float(fg.get("price") or 0.0)
|
||
if fg_value > 0 and market in ["Crypto"]:
|
||
if fg_value >= 80:
|
||
score += -15
|
||
factors += 1
|
||
elif fg_value >= 65:
|
||
score += -8
|
||
factors += 1
|
||
elif fg_value <= 20:
|
||
score += +10
|
||
factors += 1
|
||
elif fg_value <= 35:
|
||
score += +5
|
||
factors += 1
|
||
except Exception:
|
||
pass
|
||
|
||
# Normalization (considering weights)
|
||
if factors > 0:
|
||
# Maximum possible score: VIX(-50~+20), DXY(-30~+30), TNX(-30~+30) = about -110 to +80
|
||
# Normalized to -100 to +100
|
||
# Add the amplitude of Fear&Greed (about 15) and give some buffer
|
||
max_possible = 125 # maximum absolute value
|
||
score = score / max_possible * 100
|
||
|
||
return max(-100, min(100, score))
|
||
|
||
def _detect_market_regime(self, indicators: Dict) -> str:
|
||
"""Detect trending vs ranging from MA trend. trending | ranging"""
|
||
ma = indicators.get("moving_averages") or {}
|
||
trend = str(ma.get("trend", "sideways")).lower()
|
||
if "uptrend" in trend or "downtrend" in trend or "strong" in trend:
|
||
return "trending"
|
||
return "ranging"
|
||
|
||
def _score_to_decision(self, score: float, *, market: str = "Crypto") -> str:
|
||
"""
|
||
Transformed into decisions based on objective scoring
|
||
|
||
Optimized threshold (significantly narrows the HOLD interval to make decisions clearer):
|
||
- score >= +20: BUY (profit)
|
||
- score <= -20: SELL (bad)
|
||
- -20 < score < +20: HOLD (neutral)
|
||
|
||
Hierarchical decision-making (for finer-grained judgment):
|
||
- score >= +70: strong BUY
|
||
- +40 <= score < +70: obvious BUY
|
||
- +20 <= score < +40: BUY
|
||
- +10 < score < +20: Weak profit and long (tend to BUY, but can HOLD)
|
||
- -10 <= score <= +10: Neutral HOLD (true neutral interval)
|
||
- -20 < score < -10: Weakly bearish (inclined to SELL, but can be HOLD)
|
||
- -40 < score <= -20: SELL
|
||
- -70 < score <= -40: obviously SELL
|
||
- score <= -70: Strong SELL
|
||
"""
|
||
cfg = self._get_ai_calibration(market=market)
|
||
buy_thr = float(cfg.get("buy_threshold") or 20.0)
|
||
sell_thr = float(cfg.get("sell_threshold") or -20.0)
|
||
|
||
if score >= buy_thr:
|
||
return "BUY"
|
||
elif score <= sell_thr:
|
||
return "SELL"
|
||
else:
|
||
return "HOLD"
|
||
|
||
def _calculate_overall_score(self, analysis: Dict) -> int:
|
||
"""Calculate weighted overall score (legacy method, now uses objective score if available)."""
|
||
# Prioritize objective scoring
|
||
if "objective_score" in analysis:
|
||
objective = analysis["objective_score"]
|
||
overall = objective.get("overall_score", 50)
|
||
# Convert to 0-100 format (used by the original system)
|
||
return max(0, min(100, int(50 + overall * 0.5)))
|
||
|
||
# Downgraded to LLM rating
|
||
tech = analysis.get("technical_score", 50)
|
||
fund = analysis.get("fundamental_score", 50)
|
||
sent = analysis.get("sentiment_score", 50)
|
||
|
||
# Weights: technical 40%, fundamental 35%, sentiment 25%
|
||
overall = tech * 0.40 + fund * 0.35 + sent * 0.25
|
||
|
||
# Adjust based on decision
|
||
decision = analysis.get("decision", "HOLD")
|
||
confidence = analysis.get("confidence", 50)
|
||
|
||
if decision == "BUY":
|
||
overall = overall * 0.6 + (50 + confidence * 0.5) * 0.4
|
||
elif decision == "SELL":
|
||
overall = overall * 0.6 + (50 - confidence * 0.5) * 0.4
|
||
|
||
return max(0, min(100, int(overall)))
|
||
|
||
def _store_analysis_memory(self, result: Dict, user_id: int = None) -> Optional[int]:
|
||
"""Store analysis result for future learning. Returns memory_id."""
|
||
try:
|
||
from app.services.analysis_memory import get_analysis_memory
|
||
memory = get_analysis_memory()
|
||
memory_id = memory.store(result, user_id=user_id)
|
||
|
||
# Also save to qd_analysis_tasks for admin statistics
|
||
self._save_analysis_task(result, user_id=user_id)
|
||
|
||
return memory_id
|
||
except Exception as e:
|
||
logger.warning(f"Memory storage failed: {e}")
|
||
return None
|
||
|
||
def _save_analysis_task(self, result: Dict, user_id: int = None) -> Optional[int]:
|
||
"""
|
||
Save analysis record to qd_analysis_tasks table for admin statistics.
|
||
|
||
Args:
|
||
result: Analysis result dictionary
|
||
user_id: User ID who created this analysis
|
||
|
||
Returns:
|
||
Task ID or None if failed
|
||
"""
|
||
try:
|
||
from app.utils.db import get_db_connection
|
||
|
||
market = result.get("market", "")
|
||
symbol = result.get("symbol", "")
|
||
model = result.get("model", "")
|
||
# If model is empty, get default model
|
||
if not model:
|
||
from app.services.llm import LLMService
|
||
llm_service = LLMService()
|
||
model = llm_service.get_default_model()
|
||
language = result.get("language", "en-US")
|
||
status = "completed" if not result.get("error") else "failed"
|
||
result_json = json.dumps(result, ensure_ascii=False)
|
||
error_message = result.get("error", "")
|
||
|
||
if not market or not symbol:
|
||
logger.warning(f"Cannot save analysis task: missing market or symbol")
|
||
return None
|
||
|
||
with get_db_connection() as db:
|
||
cur = db.cursor()
|
||
# PostgreSQL: Use RETURNING to get the inserted ID
|
||
cur.execute(
|
||
"""
|
||
INSERT INTO qd_analysis_tasks
|
||
(user_id, market, symbol, model, language, status, result_json, error_message, created_at, completed_at)
|
||
VALUES
|
||
(?, ?, ?, ?, ?, ?, ?, ?, NOW(), NOW())
|
||
RETURNING id
|
||
""",
|
||
(
|
||
int(user_id) if user_id else 1, # Default to user 1 if not provided
|
||
str(market),
|
||
str(symbol),
|
||
str(model) if model else '',
|
||
str(language),
|
||
str(status),
|
||
str(result_json),
|
||
str(error_message) if error_message else ''
|
||
)
|
||
)
|
||
row = cur.fetchone()
|
||
task_id = row['id'] if row else None
|
||
db.commit()
|
||
cur.close()
|
||
|
||
if task_id:
|
||
logger.debug(f"Saved analysis task {task_id} for user {user_id}: {market}:{symbol}")
|
||
return task_id
|
||
|
||
except Exception as e:
|
||
logger.warning(f"Failed to save analysis task: {e}")
|
||
return None
|
||
|
||
# ==================== Backward Compatibility ====================
|
||
|
||
def analyze_legacy_format(self, market: str, symbol: str, language: str = 'en-US',
|
||
model: str = None, timeframe: str = "1D") -> Dict[str, Any]:
|
||
"""
|
||
Returns analysis in legacy multi-agent format for backward compatibility.
|
||
"""
|
||
fast_result = self.analyze(market, symbol, language, model, timeframe)
|
||
|
||
if fast_result.get("error"):
|
||
return {
|
||
"overview": {"report": f"Analysis failed: {fast_result['error']}"},
|
||
"fundamental": {"report": "N/A"},
|
||
"technical": {"report": "N/A"},
|
||
"news": {"report": "N/A"},
|
||
"sentiment": {"report": "N/A"},
|
||
"risk": {"report": "N/A"},
|
||
"error": fast_result["error"],
|
||
}
|
||
|
||
# Convert to legacy format
|
||
decision = fast_result.get("decision", "HOLD")
|
||
confidence = fast_result.get("confidence", 50)
|
||
scores = fast_result.get("scores", {})
|
||
to_sum = (fast_result.get("trend_outlook_summary") or "").strip()
|
||
overview_report = fast_result.get("summary", "") or ""
|
||
if to_sum:
|
||
overview_report = f"{overview_report}\n\n【周期预判】{to_sum}" if overview_report.strip() else f"【周期预判】{to_sum}"
|
||
|
||
return {
|
||
"overview": {
|
||
"overallScore": scores.get("overall", 50),
|
||
"recommendation": decision,
|
||
"confidence": confidence,
|
||
"dimensionScores": {
|
||
"fundamental": scores.get("fundamental", 50),
|
||
"technical": scores.get("technical", 50),
|
||
"news": scores.get("sentiment", 50),
|
||
"sentiment": scores.get("sentiment", 50),
|
||
"risk": 100 - confidence, # Inverse of confidence
|
||
},
|
||
"report": overview_report,
|
||
},
|
||
"fundamental": {
|
||
"score": scores.get("fundamental", 50),
|
||
"report": f"Fundamental score: {scores.get('fundamental', 50)}/100",
|
||
},
|
||
"technical": {
|
||
"score": scores.get("technical", 50),
|
||
"report": f"Technical score: {scores.get('technical', 50)}/100",
|
||
"indicators": fast_result.get("indicators", {}),
|
||
},
|
||
"news": {
|
||
"score": scores.get("sentiment", 50),
|
||
"report": "See sentiment analysis",
|
||
},
|
||
"sentiment": {
|
||
"score": scores.get("sentiment", 50),
|
||
"report": f"Sentiment score: {scores.get('sentiment', 50)}/100",
|
||
},
|
||
"risk": {
|
||
"score": 100 - confidence,
|
||
"report": "\n".join(fast_result.get("risks", [])),
|
||
},
|
||
"debate": {
|
||
"bull": {"confidence": confidence if decision == "BUY" else 50},
|
||
"bear": {"confidence": confidence if decision == "SELL" else 50},
|
||
"research_decision": fast_result.get("summary", ""),
|
||
},
|
||
"trader_decision": {
|
||
"decision": decision,
|
||
"confidence": confidence,
|
||
"reasoning": fast_result.get("summary", ""),
|
||
"trading_plan": fast_result.get("trading_plan", {}),
|
||
"report": "\n".join(fast_result.get("reasons", [])),
|
||
},
|
||
"risk_debate": {
|
||
"risky": {"recommendation": ""},
|
||
"neutral": {"recommendation": fast_result.get("summary", "")},
|
||
"safe": {"recommendation": ""},
|
||
},
|
||
"final_decision": {
|
||
"decision": decision,
|
||
"confidence": confidence,
|
||
"reasoning": fast_result.get("summary", ""),
|
||
"risk_summary": {
|
||
"risks": fast_result.get("risks", []),
|
||
},
|
||
"recommendation": "\n".join(fast_result.get("reasons", [])),
|
||
},
|
||
"fast_analysis": fast_result, # Include new format for gradual migration
|
||
"trend_outlook": fast_result.get("trend_outlook"),
|
||
"trend_outlook_summary": fast_result.get("trend_outlook_summary"),
|
||
"error": None,
|
||
}
|
||
|
||
|
||
# Singleton instance
|
||
_fast_analysis_service = None
|
||
|
||
def get_fast_analysis_service() -> FastAnalysisService:
|
||
"""Get singleton FastAnalysisService instance."""
|
||
global _fast_analysis_service
|
||
if _fast_analysis_service is None:
|
||
_fast_analysis_service = FastAnalysisService()
|
||
return _fast_analysis_service
|
||
|
||
|
||
def fast_analyze(market: str, symbol: str, language: str = 'en-US',
|
||
model: str = None, timeframe: str = "1D") -> Dict[str, Any]:
|
||
"""Convenience function for fast analysis."""
|
||
service = get_fast_analysis_service()
|
||
return service.analyze(market, symbol, language, model, timeframe)
|