9a6b6f70b1
Backend: - iv_engine.py: ATM IV, term structure (30/60/90/180j), put/call skew, options flow (P/C OI ratio, unusual strikes, gamma bias), proxy map for futures→ETFs - database.py: iv_history table + save_iv_snapshot, get_iv_rank_percentile, get_iv_history - routers/options_vol.py: /api/options-vol/ endpoints (snapshot, batch, watchlist, history) - auto_cycle.py: inject IV context string into scoring prompt (step 3.5) - ai_analyzer.py: score_patterns_with_context accepts iv_context param - main.py: register options_vol router Frontend: - pages/OptionsLab.tsx: full IV dashboard (watchlist by IVR, term structure, skew, flow, sparkline) - pages/JournalDeBord.tsx: IvRankCell component + IV Rank column per trade - hooks/useApi.ts: useIvSnapshot, useIvWatchlist, useIvBatch, useIvHistory, useIvForTrade Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
952 lines
44 KiB
Python
952 lines
44 KiB
Python
"""
|
||
AI analysis engine using OpenAI GPT-4o.
|
||
Tasks: news scoring, speech analysis, pattern evaluation, trade idea ranking.
|
||
"""
|
||
from openai import OpenAI
|
||
from typing import Optional, List, Dict, Any
|
||
import json
|
||
import os
|
||
|
||
_client: Optional[OpenAI] = None
|
||
|
||
|
||
def get_client() -> Optional[OpenAI]:
|
||
global _client
|
||
key = os.environ.get("OPENAI_API_KEY", "")
|
||
if not key:
|
||
return None
|
||
if _client is None or _client.api_key != key:
|
||
_client = OpenAI(api_key=key)
|
||
return _client
|
||
|
||
|
||
def _chat(system: str, user: str, model: str = "gpt-4o-mini", json_mode: bool = True, max_tokens: int = 1500) -> Optional[Dict]:
|
||
client = get_client()
|
||
if not client:
|
||
return None
|
||
kwargs: Dict[str, Any] = {
|
||
"model": model,
|
||
"messages": [{"role": "system", "content": system}, {"role": "user", "content": user}],
|
||
"temperature": 0.2,
|
||
"max_tokens": max_tokens,
|
||
}
|
||
if json_mode:
|
||
kwargs["response_format"] = {"type": "json_object"}
|
||
resp = client.chat.completions.create(**kwargs)
|
||
content = resp.choices[0].message.content
|
||
if json_mode:
|
||
return json.loads(content)
|
||
return {"text": content}
|
||
|
||
|
||
# ── News / Article Analysis ───────────────────────────────────────────────────
|
||
|
||
SYSTEM_NEWS = """Tu es un analyste financier géopolitique senior spécialisé en options.
|
||
Tu analyses des actualités et identifies leur impact potentiel sur les marchés financiers.
|
||
Réponds UNIQUEMENT en JSON selon le schéma demandé. Sois précis et concis."""
|
||
|
||
def analyze_news_item(title: str, summary: str) -> Dict[str, Any]:
|
||
"""Classify and score a single news item with GPT."""
|
||
user = f"""Analyse cet article géopolitique/économique:
|
||
Titre: {title}
|
||
Résumé: {summary}
|
||
|
||
Retourne ce JSON:
|
||
{{
|
||
"category": "military|sanctions|elections|natural_disaster|health_crisis|resource_scarcity|trade_war|energy|political_speech|financial_crisis|general",
|
||
"impact_score": <float 0.0-1.0>,
|
||
"direction": "bullish|bearish|neutral|volatile",
|
||
"affected_assets": {{
|
||
"energy": <float -1.0 à 1.0 ou null>,
|
||
"metals": <float -1.0 à 1.0 ou null>,
|
||
"agriculture": <float -1.0 à 1.0 ou null>,
|
||
"indices": <float -1.0 à 1.0 ou null>,
|
||
"forex": <float -1.0 à 1.0 ou null>
|
||
}},
|
||
"key_entities": [<max 5 entités clés: pays, personnes, organisations>],
|
||
"horizon": "immediate|days|weeks|months",
|
||
"reasoning": "<1 phrase expliquant l'impact>"
|
||
}}"""
|
||
result = _chat(SYSTEM_NEWS, user)
|
||
if not result:
|
||
return {"category": "general", "impact_score": 0.1, "direction": "neutral",
|
||
"affected_assets": {}, "key_entities": [], "horizon": "days", "reasoning": "AI non disponible"}
|
||
return result
|
||
|
||
|
||
# ── Speech / Text Analysis (Trump, Powell, etc.) ─────────────────────────────
|
||
|
||
SYSTEM_SPEECH = """Tu es un analyste quantitatif géopolitique. Tu décodes les discours et déclarations
|
||
de personnalités politiques/économiques pour identifier des opportunités de trading en options.
|
||
Tu te spécialises dans: discours Trump (tarifs, énergie, dollar), Powell/Fed (taux),
|
||
leaders géopolitiques (sanctions, guerres, ressources). Réponds en JSON uniquement."""
|
||
|
||
def analyze_speech(text: str, speaker: str = "") -> Dict[str, Any]:
|
||
"""Deep analysis of a speech/statement for trading signals."""
|
||
user = f"""Analyse cette déclaration{'de ' + speaker if speaker else ''} pour des signaux de trading:
|
||
|
||
---
|
||
{text[:3000]}
|
||
---
|
||
|
||
Retourne ce JSON:
|
||
{{
|
||
"speaker_identified": "<nom si détecté>",
|
||
"tone": "hawkish|dovish|aggressive|conciliatory|ambiguous",
|
||
"key_statements": [<liste des 3-5 phrases/points les plus impactants>],
|
||
"market_signals": [
|
||
{{
|
||
"asset": "<symbole ou classe>",
|
||
"direction": "up|down|volatile",
|
||
"magnitude": "low|medium|high|extreme",
|
||
"reasoning": "<pourquoi>",
|
||
"timeframe": "<immédiat|1 semaine|1 mois|3 mois>"
|
||
}}
|
||
],
|
||
"options_opportunities": [
|
||
{{
|
||
"underlying": "<symbole ETF ou futur>",
|
||
"strategy": "Long Call|Long Put|Bull Call Spread|Bear Put Spread|Long Straddle",
|
||
"strike_guidance": "<ATM|5% OTM|10% OTM>",
|
||
"expiry_guidance": "<30j|60j|90j>",
|
||
"rationale": "<pourquoi cette stratégie>",
|
||
"confidence": <int 0-100>,
|
||
"capital_1000eur": "<comment allouer 1000€>"
|
||
}}
|
||
],
|
||
"risk_level": "low|medium|high|extreme",
|
||
"geo_pattern_triggered": "<nom du pattern si applicable ou null>",
|
||
"summary": "<2-3 phrases de synthèse pour un trader>"
|
||
}}"""
|
||
result = _chat(SYSTEM_SPEECH, user, model="gpt-4o")
|
||
if not result:
|
||
return {"error": "OpenAI non disponible — vérifier la clé API"}
|
||
return result
|
||
|
||
|
||
# ── Pattern Evaluation & Creation ────────────────────────────────────────────
|
||
|
||
SYSTEM_PATTERN = """Tu es un expert en analyse géopolitique quantitative et en trading d'options.
|
||
Tu évalues et améliores des patterns géopolitiques pour un système de trading algorithmique.
|
||
Tes évaluations se basent sur des faits historiques vérifiables. Réponds en JSON."""
|
||
|
||
def evaluate_pattern(pattern: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""AI evaluation of a user-defined pattern."""
|
||
user = f"""Évalue ce pattern géopolitique de trading:
|
||
|
||
{json.dumps(pattern, ensure_ascii=False, indent=2)}
|
||
|
||
Retourne ce JSON:
|
||
{{
|
||
"quality_score": <int 0-100>,
|
||
"validity": "excellent|good|fair|poor",
|
||
"strengths": [<liste des points forts>],
|
||
"weaknesses": [<liste des faiblesses ou lacunes>],
|
||
"suggested_improvements": {{
|
||
"additional_keywords": [<mots-clés manquants pertinents>],
|
||
"additional_triggers": [<catégories manquantes>],
|
||
"probability_estimate": <float 0.0-1.0, ton estimation>,
|
||
"expected_move_revision": <float % ou null si ok>,
|
||
"horizon_revision": <int jours ou null si ok>
|
||
}},
|
||
"historical_validation": [
|
||
{{
|
||
"date": "<YYYY-MM-DD>",
|
||
"event": "<événement réel qui confirme le pattern>",
|
||
"outcome": "<ce qui s'est passé sur les marchés>"
|
||
}}
|
||
],
|
||
"counter_scenarios": [<2-3 scénarios qui invalideraient ce pattern>],
|
||
"overall_recommendation": "<conseil général en 2-3 phrases>",
|
||
"risk_warnings": [<risques spécifiques à ce pattern>]
|
||
}}"""
|
||
result = _chat(SYSTEM_PATTERN, user, model="gpt-4o")
|
||
if not result:
|
||
return {"error": "OpenAI non disponible", "quality_score": 0}
|
||
return result
|
||
|
||
|
||
def suggest_pattern_from_context(context: str) -> Dict[str, Any]:
|
||
"""AI creates a pattern structure from a free-text context description."""
|
||
user = f"""Un trader décrit ce contexte géopolitique et veut créer un pattern de trading:
|
||
|
||
"{context}"
|
||
|
||
Génère un pattern complet en JSON:
|
||
{{
|
||
"id": "P_USER_<3 lettres aléatoires>",
|
||
"name": "<nom concis du pattern>",
|
||
"description": "<description précise du mécanisme>",
|
||
"triggers": [<catégories parmi: military, sanctions, elections, natural_disaster, health_crisis, resource_scarcity, trade_war, energy, political_speech, financial_crisis>],
|
||
"keywords": [<10-15 mots-clés anglais pour détecter ce pattern dans les news>],
|
||
"historical_instances": [
|
||
{{"date": "<YYYY-MM-DD>", "event": "<événement réel>", "outcome": "<mouvement de marché observé>"}}
|
||
],
|
||
"suggested_trades": [
|
||
{{"strategy": "<stratégie>", "underlying": "<symbole>", "rationale": "<pourquoi>"}}
|
||
],
|
||
"asset_class": "<classe principale>",
|
||
"expected_move_pct": <float>,
|
||
"probability": <float 0.0-1.0>,
|
||
"horizon_days": <int>,
|
||
"confidence_in_pattern": <int 0-100>,
|
||
"caveats": [<mises en garde importantes>]
|
||
}}"""
|
||
result = _chat(SYSTEM_PATTERN, user, model="gpt-4o")
|
||
if not result:
|
||
return {"error": "OpenAI non disponible"}
|
||
return result
|
||
|
||
|
||
# ── Top 10 Trade Ideas Ranking ────────────────────────────────────────────────
|
||
|
||
SYSTEM_RANKING = """Tu es un gestionnaire de portefeuille spécialisé en options.
|
||
Tu dois sélectionner et classer les 10 meilleures opportunités de trading options
|
||
pour un capital de ~1000€ avec horizon 3 mois, en intégrant le contexte géopolitique actuel.
|
||
Privilégie: risque/rendement optimal, liquidité des options, clarté du catalyseur. Réponds en JSON."""
|
||
|
||
def rank_trade_ideas(
|
||
pattern_matches: List[Dict],
|
||
geo_score: Dict,
|
||
recent_news: List[Dict],
|
||
market_quotes: Dict,
|
||
) -> List[Dict[str, Any]]:
|
||
"""Generate and rank top 10 trade ideas using GPT-4o."""
|
||
|
||
context = {
|
||
"geo_risk_score": geo_score.get("score", 50),
|
||
"geo_risk_level": geo_score.get("level", "medium"),
|
||
"top_risks": geo_score.get("top_risks", []),
|
||
"active_patterns": [
|
||
{"name": p["name"], "similarity": p["similarity"],
|
||
"asset_class": p["asset_class"], "expected_move": p["expected_move_pct"]}
|
||
for p in pattern_matches[:5]
|
||
],
|
||
"top_news": [
|
||
{"title": n["title"], "category": n["category"], "impact": n["impact_score"]}
|
||
for n in recent_news[:10]
|
||
],
|
||
}
|
||
|
||
user = f"""Contexte géopolitique et marché actuel:
|
||
{json.dumps(context, ensure_ascii=False, indent=2)}
|
||
|
||
Génère les 10 meilleures idées de trades en options pour 1000€ / horizon 3 mois.
|
||
Diversifie les classes d'actifs. Inclus au moins: 2 énergie, 1 métal, 1 agri, 2 indices/actions, 1 forex.
|
||
|
||
Retourne ce JSON:
|
||
{{
|
||
"ideas": [
|
||
{{
|
||
"rank": <1-10>,
|
||
"title": "<titre court>",
|
||
"underlying": "<symbole ETF/futur liquide>",
|
||
"strategy": "Long Call|Long Put|Bull Call Spread|Bear Put Spread|Long Straddle|Long Strangle",
|
||
"asset_class": "<classe>",
|
||
"rationale": "<raisonnement géopolitique en 2 phrases>",
|
||
"geo_trigger": "<pattern ou événement déclencheur>",
|
||
"strike_guidance": "<ATM|5% OTM|10% OTM>",
|
||
"expiry_days": <int>,
|
||
"expected_move_pct": <float>,
|
||
"max_loss_eur": <float, max 1000>,
|
||
"target_gain_eur": <float>,
|
||
"confidence": <int 0-100>,
|
||
"risk_level": "low|medium|high|extreme",
|
||
"timing": "<entrer maintenant|attendre catalyseur|après date X>",
|
||
"invalidation": "<condition qui invalide le trade>"
|
||
}}
|
||
],
|
||
"portfolio_note": "<note générale sur l'allocation des 1000€ entre ces idées>",
|
||
"current_bias": "bullish|bearish|neutral|volatile",
|
||
"key_risk": "<risque principal à surveiller>"
|
||
}}"""
|
||
|
||
result = _chat(SYSTEM_RANKING, user, model="gpt-4o")
|
||
if not result:
|
||
return []
|
||
return result.get("ideas", [])
|
||
|
||
|
||
# ── Pattern Scoring with Rich Context ────────────────────────────────────────
|
||
|
||
DEFAULT_ANALYSIS_TEMPLATE = """Pour chaque pattern, note chaque sous-pilier ET fournis un commentaire 1-2 phrases en français.
|
||
Score total = somme exacte des 4 piliers (0-100).
|
||
|
||
PILIER 1 — ACTUALITÉS & GÉO-CONTEXTE (30 pts max)
|
||
1a. News géopolitiques (0-12): pertinence des événements récents vs keywords/triggers du pattern
|
||
1b. News macro/économiques (0-10): données macro, publications éco, politiques monétaires/fiscales
|
||
1c. Volume & récence signal (0-8) : nb de sources indépendantes, fraîcheur (<48h = max), cohérence
|
||
|
||
PILIER 2 — CALENDRIER ÉCONOMIQUE (20 pts max)
|
||
2a. Banques centrales (0-10): décisions FOMC/BCE/BoJ/BoE à venir, minutes, discours membres
|
||
2b. Publications macro (0-10): CPI, NFP, PIB, PMI, rapport OPEC — alignement avec le pattern
|
||
|
||
PILIER 3 — SIGNAUX DE PRIX (35 pts max)
|
||
3a. Taux & Obligations (0-7): mouvements yields, courbe de taux, spreads crédit
|
||
3b. Énergie & Matières prem. (0-7): or, pétrole, gaz, cuivre, blé — direction et momentum
|
||
3c. Forex (0-7): USD index, EUR/USD, paires émergentes — cohérence avec pattern
|
||
3d. Actions & Indices (0-7): SPX, NDX, rotation sectorielle, breadth, sentiment
|
||
3e. Volatilité (VIX/IV) (0-7): régime de vol, coût options, skew — favorable à la stratégie ?
|
||
|
||
PILIER 4 — RISQUE / RÉCOMPENSE (15 pts max)
|
||
4a. Asymétrie R/R (0-10): ratio gain potentiel / prime payée / perte max pour ~1000€
|
||
4b. Timing d'entrée (0-5) : qualité du point d'entrée vs analogues historiques du pattern
|
||
|
||
Règles: score total = 1a+1b+1c+2a+2b+3a+3b+3c+3d+3e+4a+4b; ne pas dépasser les max; commenter chaque sous-pilier.
|
||
|
||
⚠️ RÈGLE ANTI-BIAIS DIRECTIONNELLE (IMPÉRATIVE):
|
||
- "expected_direction" indique si le pattern attend une hausse ou une baisse.
|
||
- "contra_signals" liste les news AI-scorées qui CONTREDISENT cette direction.
|
||
- "has_strong_contra": true = le contexte actuel ANNULE ou INVERSE la thèse du pattern.
|
||
→ Si has_strong_contra=true: score total ≤ 40/100 ; sous-pilier 1a geo ≤ 3/12.
|
||
→ Si resolution=true dans contra_signals (accord/cessez-le-feu résolvant le conflit trigger): 1a geo = 0-2/12.
|
||
→ Indique toujours dans "summary" si le signal est [SUPPORTING], [NEUTRAL] ou [CONTRA]."""
|
||
|
||
SYSTEM_SCORER = """Tu es un gestionnaire de portefeuille senior spécialisé en options géopolitiques.
|
||
Tu analyses des patterns géopolitiques avec leur contexte marché enrichi (news, prix, IV) pour identifier
|
||
les meilleures opportunités de trading options (~1000€, horizon 3 mois).
|
||
Tu es rigoureux, quantitatif et pragmatique. Réponds UNIQUEMENT en JSON valide.
|
||
|
||
RÈGLE DE DISTRIBUTION DES SCORES (IMPÉRATIVE):
|
||
- Les scores doivent refléter une vraie distribution : certains patterns sont forts (70+), d'autres faibles (30-)
|
||
- Il est INTERDIT de noter tous les patterns au même score ou proche de 50
|
||
- Base tes scores sur : relevant_news_count (catalyseurs actifs), macro_regime.asset_class_bias, has_strong_contra, horizon vs catalyseurs imminents
|
||
- Un pattern sans aucune news récente pertinente (relevant_news_count=0) ne peut pas dépasser 35/100
|
||
- Un pattern avec has_strong_contra=true ne dépasse pas 40/100
|
||
- Un pattern avec 3+ news pertinentes ET macro favorable peut atteindre 70-85/100"""
|
||
|
||
|
||
def score_patterns_with_context(
|
||
patterns: List[Dict],
|
||
recent_news: List[Dict],
|
||
quotes_by_class: Dict,
|
||
geo_score: Dict,
|
||
template: str = None,
|
||
top_n: int = 10,
|
||
category_filter: str = None,
|
||
macro_regime: Optional[Dict] = None,
|
||
portfolio_lessons: Optional[Dict] = None,
|
||
iv_context: str = "",
|
||
) -> List[Dict[str, Any]]:
|
||
"""Score all patterns with rich context (news, prices, IV) using GPT-4o."""
|
||
if not get_client():
|
||
return []
|
||
|
||
scoring_template = template or DEFAULT_ANALYSIS_TEMPLATE
|
||
|
||
# Flatten quotes to symbol -> data dict for fast lookup
|
||
quotes_flat: Dict[str, Dict] = {}
|
||
for cls_quotes in quotes_by_class.values():
|
||
for q in cls_quotes:
|
||
quotes_flat[q.get("symbol", "")] = q
|
||
|
||
# Build per-pattern context blocks
|
||
pattern_blocks = []
|
||
for pat in patterns:
|
||
if category_filter and category_filter != "all":
|
||
if pat.get("asset_class") != category_filter:
|
||
# also check suggested trades
|
||
trade_classes = [t.get("asset_class", "") for t in pat.get("suggested_trades", [])]
|
||
if category_filter not in trade_classes:
|
||
continue
|
||
|
||
# Filter news relevant to this pattern
|
||
keywords = [kw.lower() for kw in pat.get("keywords", [])]
|
||
relevant_news = []
|
||
for n in recent_news[:50]:
|
||
text = (n.get("title", "") + " " + n.get("summary", "")).lower()
|
||
if any(kw in text for kw in keywords):
|
||
relevant_news.append({
|
||
"title": n.get("title", ""),
|
||
"date": n.get("published", "")[:10],
|
||
"source": n.get("source", ""),
|
||
"impact": n.get("impact_score", 0),
|
||
})
|
||
if len(relevant_news) >= 4:
|
||
break
|
||
|
||
# Market data for each suggested underlying
|
||
market_data = {}
|
||
for trade in pat.get("suggested_trades", []):
|
||
sym = trade.get("underlying", "")
|
||
if sym and sym in quotes_flat:
|
||
q = quotes_flat[sym]
|
||
from services.data_fetcher import compute_historical_iv
|
||
try:
|
||
iv = compute_historical_iv(sym)
|
||
except Exception:
|
||
iv = None
|
||
market_data[sym] = {
|
||
"price": q.get("price"),
|
||
"change_1d_pct": q.get("change_pct"),
|
||
"iv_pct": round(iv * 100, 1) if iv else None,
|
||
"name": q.get("name", sym),
|
||
}
|
||
|
||
# Detect contra-signals: AI-scored news that contradicts this pattern's direction
|
||
expected_up = pat.get("expected_move_pct", 0) > 0
|
||
asset_cls = pat.get("asset_class", "")
|
||
_dir_field = {"energy": "ai_dir_energy", "metals": "ai_dir_metals"}.get(asset_cls, "ai_dir_indices")
|
||
|
||
contra_signals = []
|
||
for n in recent_news[:25]:
|
||
if not n.get("ai_scored"):
|
||
continue
|
||
ai_dir = n.get(_dir_field, "neutral")
|
||
impact = float(n.get("impact_score") or 0)
|
||
is_contra = (expected_up and ai_dir == "bearish") or (not expected_up and ai_dir == "bullish")
|
||
if is_contra and impact >= 0.35:
|
||
contra_signals.append({
|
||
"title": (n.get("title") or "")[:100],
|
||
"impact": round(impact, 2),
|
||
"direction": ai_dir,
|
||
"resolution": n.get("ai_resolution", False),
|
||
"insight": n.get("ai_insight", ""),
|
||
})
|
||
has_strong_contra = any(c["impact"] >= 0.55 or c.get("resolution") for c in contra_signals)
|
||
|
||
# Macro regime context for this pattern
|
||
macro_ctx = None
|
||
if macro_regime:
|
||
scenarios = macro_regime.get("scenarios", {})
|
||
gauges = macro_regime.get("gauges", {})
|
||
dominant = scenarios.get("dominant", "incertain")
|
||
asset_bias = scenarios.get("asset_bias", {})
|
||
pat_cls = pat.get("asset_class", "")
|
||
bias_for_class = asset_bias.get(dominant, {}).get(pat_cls, "neutral") if dominant != "incertain" else "neutral"
|
||
macro_ctx = {
|
||
"dominant_scenario": dominant,
|
||
"scenario_scores": scenarios.get("scores", {}),
|
||
"asset_class_bias": bias_for_class,
|
||
"vix": gauges.get("vix", {}).get("value"),
|
||
"yield_slope_pct": gauges.get("slope_10y3m", {}).get("value"),
|
||
"gold_copper_ratio": gauges.get("gold_copper_ratio", {}).get("value"),
|
||
"brent_1d_pct": gauges.get("brent", {}).get("change_pct"),
|
||
"spx_vs_200d_pct": gauges.get("spx_vs_200d", {}).get("value"),
|
||
}
|
||
|
||
pattern_blocks.append({
|
||
"id": pat.get("id", pat.get("pattern_id", "")),
|
||
"name": pat.get("name", ""),
|
||
"description": pat.get("description", ""),
|
||
"asset_class": pat.get("asset_class", ""),
|
||
"triggers": pat.get("triggers", []),
|
||
"historical_instances": pat.get("historical_instances", [])[:2],
|
||
"suggested_trades": pat.get("suggested_trades", []),
|
||
"expected_move_pct": pat.get("expected_move_pct", 0),
|
||
"expected_direction": "hausse" if expected_up else "baisse",
|
||
"horizon_days": pat.get("horizon_days", 90),
|
||
"relevant_news_count": len(relevant_news),
|
||
"relevant_news": relevant_news,
|
||
"market_data": market_data,
|
||
"contra_signals": contra_signals[:3],
|
||
"has_strong_contra": has_strong_contra,
|
||
"macro_regime": macro_ctx,
|
||
})
|
||
|
||
if not pattern_blocks:
|
||
return []
|
||
|
||
macro_section = ""
|
||
if macro_regime:
|
||
sc = macro_regime.get("scenarios", {})
|
||
dom = sc.get("dominant", "incertain")
|
||
sc_scores = sc.get("scores", {})
|
||
macro_section = f"""
|
||
RÉGIME MACRO ACTUEL (30 compteurs agrégés):
|
||
- Scénario dominant: {dom.upper()} | Scores: {json.dumps(sc_scores, ensure_ascii=False)}
|
||
- Instruction: Intègre ce régime dans les piliers prix (3a taux, 3b énergie, 3d indices, 3e VIX).
|
||
Chaque pattern reçoit un champ "macro_regime.asset_class_bias" indiquant la compatibilité
|
||
(bullish+/bullish/neutral/bearish/bearish+/defensive) de sa classe d'actif avec le scénario dominant.
|
||
→ "bullish+" = conditions très favorables pour ce pattern → majore 3b ou 3d selon la classe
|
||
→ "bearish" ou "bearish+" = conditions défavorables → minore 3b ou 3d
|
||
Indique dans "summary": [GOLDILOCKS|STAGFLATION|RÉCESSION|DÉSINFLATION|CRISE] + [SUPPORTING|NEUTRAL|CONTRA]
|
||
"""
|
||
|
||
user = f"""CONTEXTE GLOBAL:
|
||
- Score risque géopolitique: {geo_score.get('score', 50)}/100 ({geo_score.get('level', 'medium')})
|
||
- Top risques: {geo_score.get('top_risks', [])}
|
||
{macro_section}
|
||
TEMPLATE DE NOTATION:
|
||
{scoring_template}
|
||
|
||
PATTERNS À SCORER ({len(pattern_blocks)} patterns):
|
||
{json.dumps(pattern_blocks, ensure_ascii=False, indent=2)}
|
||
|
||
Pour chacun des {len(pattern_blocks)} patterns, score chaque sous-pilier + commente en français.
|
||
Le champ "score" = somme exacte de tous les sous-piliers.
|
||
|
||
⚠️ TRADE RANKINGS (OBLIGATOIRE): Un pattern peut avoir plusieurs suggested_trades (ex: Long Call WTI + Bull Spread XLE).
|
||
Ces trades ne méritent PAS tous le même score. Pour chaque pattern, remplis "trade_rankings" en:
|
||
- classant les trades du meilleur (rank 1) au moins bon
|
||
- assignant un "score_delta" entre -20 et +20 (ex: +10 pour le meilleur, 0 pour la moyenne, -8 pour le moins bon)
|
||
- expliquant en 1 phrase pourquoi chaque trade est au-dessus/en-dessous de la moyenne du pattern
|
||
- la somme des score_delta doit être ≈ 0 (les trades se compensent par rapport au score pattern)
|
||
|
||
Retourne UNIQUEMENT ce JSON valide:
|
||
{{
|
||
"scored_patterns": [
|
||
{{
|
||
"pattern_id": "<id>",
|
||
"score": <int 0-100, somme exacte des 4 piliers>,
|
||
"confidence": <int 0-100>,
|
||
"buckets": [
|
||
{{
|
||
"id": "actualites",
|
||
"label": "Actualités & Géo-contexte",
|
||
"score": <0-30>,
|
||
"max": 30,
|
||
"comment": "<synthèse 1-2 phrases>",
|
||
"subs": [
|
||
{{"id": "geo", "label": "News géopolitiques", "score": <0-12>, "max": 12, "comment": "<1-2 phrases>"}},
|
||
{{"id": "eco", "label": "News macro/éco", "score": <0-10>, "max": 10, "comment": "<1-2 phrases>"}},
|
||
{{"id": "flux", "label": "Volume & récence", "score": <0-8>, "max": 8, "comment": "<1-2 phrases>"}}
|
||
]
|
||
}},
|
||
{{
|
||
"id": "calendrier",
|
||
"label": "Calendrier économique",
|
||
"score": <0-20>,
|
||
"max": 20,
|
||
"comment": "<synthèse>",
|
||
"subs": [
|
||
{{"id": "banques", "label": "Banques centrales", "score": <0-10>, "max": 10, "comment": "<1-2 phrases>"}},
|
||
{{"id": "macro_cal", "label": "Publications macro", "score": <0-10>, "max": 10, "comment": "<1-2 phrases>"}}
|
||
]
|
||
}},
|
||
{{
|
||
"id": "prix",
|
||
"label": "Signaux de prix",
|
||
"score": <0-35>,
|
||
"max": 35,
|
||
"comment": "<synthèse>",
|
||
"subs": [
|
||
{{"id": "taux", "label": "Taux & Obligations", "score": <0-7>, "max": 7, "comment": "<1-2 phrases>"}},
|
||
{{"id": "energie", "label": "Énergie & Matières", "score": <0-7>, "max": 7, "comment": "<1-2 phrases>"}},
|
||
{{"id": "forex_sig", "label": "Forex", "score": <0-7>, "max": 7, "comment": "<1-2 phrases>"}},
|
||
{{"id": "actions", "label": "Actions & Indices", "score": <0-7>, "max": 7, "comment": "<1-2 phrases>"}},
|
||
{{"id": "vix", "label": "Volatilité (VIX/IV)", "score": <0-7>, "max": 7, "comment": "<1-2 phrases>"}}
|
||
]
|
||
}},
|
||
{{
|
||
"id": "rr",
|
||
"label": "Risque / Récompense",
|
||
"score": <0-15>,
|
||
"max": 15,
|
||
"comment": "<synthèse>",
|
||
"subs": [
|
||
{{"id": "asymetrie", "label": "Asymétrie R/R", "score": <0-10>, "max": 10, "comment": "<1-2 phrases>"}},
|
||
{{"id": "timing_rr", "label": "Timing d'entrée", "score": <0-5>, "max": 5, "comment": "<1-2 phrases>"}}
|
||
]
|
||
}}
|
||
],
|
||
"key_catalyst": "<catalyseur principal en 1 phrase>",
|
||
"recommended_trade": {{
|
||
"underlying": "<symbole>",
|
||
"strategy": "<Long Call|Long Put|Bull Call Spread|Bear Put Spread|Long Straddle>",
|
||
"strike_guidance": "<ATM|5% OTM|...>",
|
||
"expiry_days": <int>,
|
||
"rationale": "<pourquoi ce trade maintenant, 2 phrases max>",
|
||
"target_gain_eur": <float>,
|
||
"max_loss_eur": <float max 1000>,
|
||
"timing_note": "<entrer maintenant|attendre X|surveiller Y>",
|
||
"invalidation": "<condition qui invalide>"
|
||
}},
|
||
"asset_class": "<classe>",
|
||
"geo_trigger": "<pattern name>",
|
||
"summary": "<synthèse 1 phrase>",
|
||
"trade_rankings": [
|
||
{{
|
||
"underlying": "<ticker>",
|
||
"strategy": "<stratégie>",
|
||
"rank": <1-N>,
|
||
"score_delta": <int -20 à +20, positif si ce trade est supérieur à la moyenne du pattern>,
|
||
"rationale": "<1 phrase: pourquoi ce trade mérite plus/moins que les autres du même pattern>",
|
||
"expected_move_pct": <float, RENDEMENT OPTION ATTENDU en % si thèse confirmée, levier inclus. Long Call ATM: 80-200%, Spread: 40-120%, Straddle: 60-180%. Réévalue par rapport au contexte actuel.>
|
||
}}
|
||
]
|
||
}}
|
||
],
|
||
"analysis_meta": {{
|
||
"patterns_analyzed": <int>,
|
||
"top_bias": "bullish|bearish|neutral|volatile",
|
||
"key_risk": "<risque principal>"
|
||
}}
|
||
}}"""
|
||
|
||
# Extract the return-schema portion from `user` so batches use the identical full schema
|
||
# (includes bucket id/label/max definitions that GPT-4o needs to populate correctly)
|
||
_return_schema = user.split("Retourne UNIQUEMENT ce JSON valide:\n", 1)[1]
|
||
|
||
# Build lessons feedback block for the scorer
|
||
lessons_header = ""
|
||
if portfolio_lessons:
|
||
lessons = portfolio_lessons.get("key_lessons") or []
|
||
super_ctx = portfolio_lessons.get("super_context", "")
|
||
priorities = portfolio_lessons.get("strategic_priorities", [])
|
||
mistakes = portfolio_lessons.get("recurring_mistakes", [])
|
||
super_scoring_block = ""
|
||
if super_ctx:
|
||
super_scoring_block = f"""
|
||
🧠 SUPER CONTEXTE (base de raisonnement accumulée) :
|
||
{super_ctx[:400]}
|
||
Priorités: {' | '.join(str(p) for p in priorities[:2])}
|
||
Erreurs à éviter: {' | '.join(str(m) for m in mistakes[:2])}
|
||
"""
|
||
lessons_header = f"""
|
||
{super_scoring_block}
|
||
RETOUR DE PERFORMANCE (rapport du {portfolio_lessons.get('created_at','?')[:10]}) :
|
||
Bilan global : {portfolio_lessons.get('headline', '')[:150]}
|
||
Angles morts détectés : {portfolio_lessons.get('blind_spots', '')[:150]}
|
||
Priorités : {portfolio_lessons.get('next_cycle_priorities', '')[:150]}
|
||
Leçons : {' | '.join(str(l)[:80] for l in lessons[:3])}
|
||
⚠️ Tiens compte du Super Contexte et de ces leçons pour ajuster les scores et les commentaires par pilier.
|
||
|
||
"""
|
||
|
||
# Build the per-batch prompt template (static parts)
|
||
prompt_header = f"""CONTEXTE GLOBAL:
|
||
- Score risque géopolitique: {geo_score.get('score', 50)}/100 ({geo_score.get('level', 'medium')})
|
||
- Top risques: {geo_score.get('top_risks', [])}
|
||
{macro_section}{lessons_header}{iv_context}
|
||
TEMPLATE DE NOTATION:
|
||
{scoring_template}
|
||
|
||
"""
|
||
|
||
import logging as _logging
|
||
_scorer_log = _logging.getLogger(__name__)
|
||
|
||
def _score_batch(batch: list) -> list:
|
||
ids = [p.get("id", "?") for p in batch]
|
||
_scorer_log.info(f"[Scorer] Batch of {len(batch)} patterns: {ids}")
|
||
batch_user = (
|
||
prompt_header
|
||
+ f"PATTERNS À SCORER ({len(batch)} patterns):\n"
|
||
+ json.dumps(batch, ensure_ascii=False, indent=2)
|
||
+ f"\n\n⚠️ OBLIGATOIRE: Tu dois retourner EXACTEMENT {len(batch)} objets dans scored_patterns — un pour CHAQUE pattern de la liste, SANS EXCEPTION. Même si un pattern a score=0 (non pertinent actuellement), il doit figurer dans la liste.\n\n"
|
||
+ f"Pour chacun des {len(batch)} patterns, score chaque sous-pilier + commente en français.\n"
|
||
+ "Le champ \"score\" = somme exacte de tous les sous-piliers.\n\n"
|
||
+ "🎯 CALIBRATION OBLIGATOIRE — Les scores DOIVENT être différenciés, jamais tous identiques:\n"
|
||
+ " score 75-100 = catalyseur actif fort, signal clair, timing excellent\n"
|
||
+ " score 55-74 = signal modéré, contexte favorable mais incertain\n"
|
||
+ " score 35-54 = neutre, peu de signal, attente\n"
|
||
+ " score 15-34 = contra-signal, régime défavorable, risque élevé\n"
|
||
+ " score 0-14 = aucune pertinence dans le contexte actuel\n"
|
||
+ "⛔ Ne pas mettre tous les patterns à 50 — c'est un échec de calibration.\n"
|
||
+ " Utilise les relevant_news_count, macro_regime.asset_class_bias, et contra_signals pour vraiment différencier.\n\n"
|
||
+ "⚠️ TRADE RANKINGS (OBLIGATOIRE): Un pattern peut avoir plusieurs suggested_trades (ex: Long Call WTI + Bull Spread XLE).\n"
|
||
+ "Ces trades ne méritent PAS tous le même score. Pour chaque pattern, remplis \"trade_rankings\" en:\n"
|
||
+ "- classant les trades du meilleur (rank 1) au moins bon\n"
|
||
+ "- assignant un \"score_delta\" entre -20 et +20 (ex: +10 pour le meilleur, 0 pour la moyenne, -8 pour le moins bon)\n"
|
||
+ "- expliquant en 1 phrase pourquoi chaque trade est au-dessus/en-dessous de la moyenne du pattern\n"
|
||
+ "- la somme des score_delta doit être ≈ 0 (les trades se compensent par rapport au score pattern)\n\n"
|
||
+ "Retourne UNIQUEMENT ce JSON valide:\n"
|
||
+ _return_schema
|
||
)
|
||
try:
|
||
res = _chat(SYSTEM_SCORER, batch_user, model="gpt-4o", json_mode=True, max_tokens=12000)
|
||
except Exception as e:
|
||
_scorer_log.error(f"[Scorer] GPT-4o call failed for batch {ids}: {e}")
|
||
res = None
|
||
scored = res.get("scored_patterns", []) if res else []
|
||
_scorer_log.info(f"[Scorer] Batch returned {len(scored)} scored_patterns (expected {len(batch)})")
|
||
# Guarantee every pattern in the batch has an entry — prevents silent drops on truncation
|
||
scored_ids = {str(s.get("pattern_id", "")) for s in scored}
|
||
for p in batch:
|
||
if str(p.get("id", "")) not in scored_ids:
|
||
_scorer_log.warning(f"[Scorer] Pattern id='{p.get('id')}' name='{p.get('name')}' missing from GPT-4o response — adding stub score=0")
|
||
scored.append({
|
||
"pattern_id": p["id"],
|
||
"score": 0,
|
||
"confidence": 0,
|
||
"buckets": [],
|
||
"key_catalyst": "Non pertinent dans le contexte actuel",
|
||
"recommended_trade": {},
|
||
"asset_class": p.get("asset_class", ""),
|
||
"geo_trigger": p.get("name", ""),
|
||
"summary": "[CONTRA] Pattern non pertinent dans le contexte actuel.",
|
||
"trade_rankings": [],
|
||
})
|
||
return scored
|
||
|
||
BATCH_SIZE = 4 # 4 patterns × ~800 tokens output = ~3200 tokens, safely within gpt-4o limits
|
||
|
||
# Score all batches in parallel
|
||
from concurrent.futures import ThreadPoolExecutor, as_completed
|
||
batches = [pattern_blocks[i:i+BATCH_SIZE] for i in range(0, len(pattern_blocks), BATCH_SIZE)]
|
||
_scorer_log.info(f"[Scorer] Scoring {len(pattern_blocks)} patterns in {len(batches)} batches of max {BATCH_SIZE}")
|
||
all_scored = []
|
||
with ThreadPoolExecutor(max_workers=min(len(batches), 4)) as executor:
|
||
futures = [executor.submit(_score_batch, b) for b in batches]
|
||
for future in as_completed(futures):
|
||
try:
|
||
results = future.result()
|
||
all_scored.extend(results)
|
||
except Exception as e:
|
||
_scorer_log.error(f"[Scorer] Batch future raised: {e}")
|
||
|
||
# Hardcoded max values per bucket id — used as fallback if GPT-4o omits the max field
|
||
_BUCKET_MAX = {"actualites": 30, "calendrier": 20, "prix": 35, "rr": 15}
|
||
_SUB_MAX = {
|
||
"geo": 12, "eco": 10, "flux": 8,
|
||
"banques": 10, "macro_cal": 10,
|
||
"taux": 7, "energie": 7, "forex_sig": 7, "actions": 7, "vix": 7,
|
||
"asymetrie": 10, "timing_rr": 5,
|
||
}
|
||
|
||
# Normalize bucket scores and recompute total from sub-buckets
|
||
for p in all_scored:
|
||
if p.get("buckets"):
|
||
total = 0
|
||
for b in p["buckets"]:
|
||
bid = b.get("id", "")
|
||
b_max = int(b.get("max") or _BUCKET_MAX.get(bid, 30))
|
||
sub_sum = 0
|
||
for sub in b.get("subs", []):
|
||
sid = sub.get("id", "")
|
||
s_max = int(sub.get("max") or _SUB_MAX.get(sid, 10))
|
||
sub["score"] = max(0, min(int(sub.get("score") or 0), s_max))
|
||
sub["max"] = s_max # ensure max is always set for frontend display
|
||
sub_sum += sub["score"]
|
||
b["score"] = max(0, min(int(b.get("score") or sub_sum), b_max))
|
||
b["max"] = b_max # ensure max is always set for frontend display
|
||
total += b["score"]
|
||
p["score"] = min(total, 100)
|
||
|
||
all_scored.sort(key=lambda x: x.get("score", 0), reverse=True)
|
||
return all_scored[:top_n]
|
||
|
||
|
||
# ── Suggest new patterns from live market context ─────────────────────────────
|
||
|
||
def suggest_patterns_from_market_context(
|
||
news: List[Dict],
|
||
quotes_by_class: Dict[str, List[Dict]],
|
||
calendar: List[Dict],
|
||
macro_regime: Optional[Dict] = None,
|
||
geo_score: Optional[Dict] = None,
|
||
portfolio_lessons: Optional[Dict] = None,
|
||
) -> List[Dict]:
|
||
"""Ask GPT-4o to propose new patterns based on current geo/market + macro regime context."""
|
||
top_news = sorted(news, key=lambda x: x.get("impact_score", 0), reverse=True)[:12]
|
||
news_block = "\n".join([
|
||
f"- [{n.get('source','')}] {n.get('title','')} (impact {n.get('impact_score',0):.2f})"
|
||
for n in top_news
|
||
])
|
||
|
||
market_lines = []
|
||
for cls, qs in quotes_by_class.items():
|
||
for q in qs[:3]:
|
||
if q.get("price"):
|
||
market_lines.append(f" {cls} | {q.get('name', q['symbol'])}: {q['price']} ({q.get('change_pct', 0):+.1f}%)")
|
||
market_block = "\n".join(market_lines)
|
||
|
||
cal_block = "\n".join([
|
||
f"- {e.get('date','')} [{e.get('importance','')}] {e.get('title','')}"
|
||
for e in (calendar or [])[:8]
|
||
])
|
||
|
||
# Macro regime block
|
||
macro_block = ""
|
||
if macro_regime:
|
||
sc = macro_regime.get("scenarios", {})
|
||
gauges = macro_regime.get("gauges", {})
|
||
dominant = sc.get("dominant", "incertain")
|
||
scores = sc.get("scores", {})
|
||
asset_bias = sc.get("asset_bias", {}).get(dominant, {})
|
||
reasons = sc.get("reasons", {}).get(dominant, [])
|
||
vix = gauges.get("vix", {}).get("value")
|
||
slope = gauges.get("slope_10y3m", {}).get("value")
|
||
gold_cu = gauges.get("gold_copper_ratio", {}).get("value")
|
||
spx_200 = gauges.get("spx_vs_200d", {}).get("value")
|
||
brent_chg = gauges.get("brent", {}).get("change_pct")
|
||
bias_lines = "\n".join([f" - {cls}: {b}" for cls, b in asset_bias.items()])
|
||
brent_str = f"{brent_chg:+.2f}%" if brent_chg is not None else "N/A"
|
||
macro_block = f"""
|
||
## Régime macro actuel (30 compteurs institutionnels)
|
||
- Scénario dominant: {dominant.upper()} | Scores: {json.dumps(scores, ensure_ascii=False)}
|
||
- Signaux clés: {', '.join(reasons[:4])}
|
||
- Compteurs: VIX={vix} | Pente 10Y-3M={slope}% | Or/Cuivre={gold_cu} | SPX vs 200j={spx_200}% | Brent J-1={brent_str}
|
||
- Biais par classe d'actif (scénario {dominant.upper()}):
|
||
{bias_lines}
|
||
|
||
⚠️ CONTRAINTE: Les patterns proposés doivent être COHÉRENTS avec ce régime macro.
|
||
- Favorise les patterns dont l'asset_class a un biais "bullish" ou "bullish+" dans le régime actuel.
|
||
- Évite les patterns haussiers sur des classes "bearish" ou "bearish+" sauf si un catalyseur géopolitique exceptionnel le justifie.
|
||
- Chaque pattern doit expliquer dans "macro_fit" pourquoi il est compatible (ou en tension) avec le régime {dominant.upper()}.
|
||
"""
|
||
|
||
geo_block = ""
|
||
if geo_score:
|
||
geo_block = f"\n## Risque géopolitique global\n- Score: {geo_score.get('score', 50)}/100 ({geo_score.get('level', 'medium')})\n- Top risques: {', '.join(str(r) for r in geo_score.get('top_risks', [])[:3])}\n"
|
||
|
||
lessons_block = ""
|
||
if portfolio_lessons:
|
||
super_ctx = portfolio_lessons.get("super_context", "")
|
||
priorities = portfolio_lessons.get("strategic_priorities", [])
|
||
mistakes = portfolio_lessons.get("recurring_mistakes", [])
|
||
lessons = portfolio_lessons.get("key_lessons") or []
|
||
super_block = ""
|
||
if super_ctx:
|
||
super_block = f"""
|
||
## 🧠 SUPER CONTEXTE — Base de raisonnement accumulée
|
||
{super_ctx[:600]}
|
||
Priorités stratégiques: {' | '.join(str(p) for p in priorities[:3])}
|
||
Erreurs récurrentes à éviter: {' | '.join(str(m) for m in mistakes[:3])}
|
||
"""
|
||
lessons_block = f"""
|
||
{super_block}
|
||
## ⚡ RETOUR DE PERFORMANCE — cycles précédents (rapport du {portfolio_lessons.get('created_at','?')[:10]})
|
||
Performance globale : {portfolio_lessons.get('headline', '')}
|
||
Pourquoi les gains : {portfolio_lessons.get('winners_analysis', '')[:200]}
|
||
Pourquoi les pertes : {portfolio_lessons.get('losers_analysis', '')[:200]}
|
||
Angles morts détectés : {portfolio_lessons.get('blind_spots', '')[:150]}
|
||
Priorités identifiées : {portfolio_lessons.get('next_cycle_priorities', '')[:200]}
|
||
Leçons clés :
|
||
{chr(10).join(f' - {l}' for l in lessons[:4])}
|
||
|
||
⚠️ CONSIGNE : Tiens compte de ce retour de performance et du Super Contexte pour proposer des patterns MIEUX CIBLÉS.
|
||
Évite les erreurs identifiées dans les pertes. Privilégie les types de thèses qui ont fonctionné.
|
||
"""
|
||
|
||
user = f"""Tu es un stratège géopolitique et financier senior.
|
||
{macro_block}{geo_block}{lessons_block}
|
||
## Actualités géopolitiques du moment (triées par impact)
|
||
{news_block}
|
||
|
||
## Prix des marchés (variation J-1)
|
||
{market_block}
|
||
|
||
## Calendrier économique à venir
|
||
{cal_block}
|
||
|
||
En analysant ce panorama, propose 4 à 6 NOUVEAUX patterns géopolitiques qui sont en train d'émerger RIGHT NOW et qui méritent d'être surveillés pour des opportunités d'options.
|
||
|
||
Ne reprend pas les patterns classiques connus (Middle East Oil Spike, Gold Flight to Safety, etc.) — propose des patterns SPÉCIFIQUES au contexte actuel, cohérents avec le régime macro.
|
||
|
||
IMPORTANT — CHAMP expected_move_pct:
|
||
Ce champ représente le RENDEMENT OPTION ATTENDU en % (levier inclus), PAS le mouvement du sous-jacent.
|
||
Raisonne: si le sous-jacent bouge de X% dans la direction attendue, combien gagne l'option en %?
|
||
- Long Call ATM (delta ~0.5, 30-90j): sous-jacent +5% → option +60 à +150%
|
||
- Long Call OTM (delta ~0.25): sous-jacent +8% → option +100 à +300%
|
||
- Bull Call Spread: sous-jacent +5% → spread +50 à +120% (plafonné)
|
||
- Long Straddle: mouvement ±10% → option +80 à +200%
|
||
Exemples réalistes: Long Call énergie sur catalyseur fort → 80-200%. Spread défensif → 40-100%.
|
||
|
||
Retourne UNIQUEMENT ce JSON:
|
||
{{
|
||
"patterns": [
|
||
{{
|
||
"name": "<nom court et percutant>",
|
||
"description": "<mécanisme géopolitique → impact marché, 2-3 phrases>",
|
||
"macro_fit": "<1-2 phrases: pourquoi ce pattern est cohérent ou en tension avec le régime macro actuel, et quel catalyseur géopolitique le justifie>",
|
||
"triggers": ["<trigger1>", "<trigger2>"],
|
||
"keywords": ["<kw1>", "<kw2>", "<kw3>"],
|
||
"asset_class": "<energy|metals|agriculture|indices|equities|forex>",
|
||
"expected_move_pct": <float, RENDEMENT OPTION MOYEN en % pour ce pattern, levier inclus. Typiquement 50-300%.>,
|
||
"probability": <float 0-1>,
|
||
"horizon_days": <int>,
|
||
"suggested_trades": [
|
||
{{
|
||
"strategy": "<Long Call|Long Put|Bull Call Spread|Bear Put Spread|Long Straddle>",
|
||
"underlying": "<ticker Yahoo Finance>",
|
||
"rationale": "<pourquoi ce trade dans ce contexte macro+géo>",
|
||
"asset_class": "<classe>",
|
||
"expected_move_pct": <float, RENDEMENT OPTION en % pour CE trade si thèse confirmée. Long Call: 80-250%, Spread: 40-120%, Straddle: 60-180%.>
|
||
}},
|
||
{{
|
||
"strategy": "<autre stratégie>",
|
||
"underlying": "<ticker Yahoo Finance>",
|
||
"rationale": "<rationale>",
|
||
"asset_class": "<classe>",
|
||
"expected_move_pct": <float, rendement option attendu en % pour ce trade spécifique>
|
||
}}
|
||
]
|
||
}}
|
||
]
|
||
}}"""
|
||
|
||
result = _chat(SYSTEM_SCORER, user, model="gpt-4o", json_mode=True, max_tokens=4000)
|
||
if not result:
|
||
return []
|
||
return result.get("patterns", [])
|
||
|
||
|
||
# ── AI news batch scoring: impact magnitude + directional signals ─────────────
|
||
|
||
def ai_score_news_batch(news_items: List[Dict]) -> List[Dict]:
|
||
"""Score news items with AI: accurate impact + per-asset directional signal.
|
||
Adds ai_dir_energy/metals/indices, ai_resolution, ai_insight, ai_scored fields.
|
||
Called before pattern scoring so contra-signals can be detected.
|
||
"""
|
||
if not get_client() or not news_items:
|
||
return news_items
|
||
|
||
to_score = [n for n in news_items[:20] if not n.get("ai_scored")]
|
||
if not to_score:
|
||
return news_items
|
||
|
||
compact = [
|
||
{"i": idx, "t": n.get("title", ""), "s": (n.get("summary", "") or "")[:150]}
|
||
for idx, n in enumerate(to_score)
|
||
]
|
||
|
||
user = f"""Score these geopolitical news items for TRUE market impact.
|
||
|
||
CRITICAL: Resolution events (peace deals, ceasefires, truces, agreements ending conflicts)
|
||
have HIGH impact (0.7-0.9) but are BEARISH for oil/energy and BEARISH for safe-haven patterns.
|
||
|
||
Items: {json.dumps(compact, ensure_ascii=False)}
|
||
|
||
For each item return:
|
||
- impact_score: 0.0-1.0 real magnitude (resolution = high, sports/culture = low)
|
||
- dir_energy: "bullish"|"bearish"|"neutral" (for oil/gas/energy)
|
||
- dir_metals: "bullish"|"bearish"|"neutral" (for gold/silver/copper)
|
||
- dir_indices: "bullish"|"bearish"|"neutral" (risk-on vs risk-off)
|
||
- resolution: true if this is a de-escalation/peace/deal that REDUCES a prior conflict
|
||
- insight: "<1 short French sentence on main market effect>"
|
||
|
||
JSON: {{"items": [{{"i":<int>,"impact_score":<float>,"dir_energy":"...","dir_metals":"...","dir_indices":"...","resolution":<bool>,"insight":"..."}}]}}"""
|
||
|
||
result = _chat(SYSTEM_NEWS, user, model="gpt-4o-mini", json_mode=True, max_tokens=2000)
|
||
if not result:
|
||
return news_items
|
||
|
||
scored_map = {s["i"]: s for s in result.get("items", [])}
|
||
for idx, n in enumerate(to_score):
|
||
s = scored_map.get(idx)
|
||
if s:
|
||
n["impact_score"] = max(0.0, min(1.0, float(s.get("impact_score") or n.get("impact_score", 0.1))))
|
||
n["ai_dir_energy"] = s.get("dir_energy", "neutral")
|
||
n["ai_dir_metals"] = s.get("dir_metals", "neutral")
|
||
n["ai_dir_indices"] = s.get("dir_indices", "neutral")
|
||
n["ai_resolution"] = bool(s.get("resolution", False))
|
||
n["ai_insight"] = s.get("insight", "")
|
||
n["ai_scored"] = True
|
||
|
||
return news_items
|
||
|
||
|
||
# ── Re-score news batch with AI ───────────────────────────────────────────────
|
||
|
||
def ai_rescore_news(news_items: List[Dict]) -> List[Dict]:
|
||
"""Batch re-score news items using AI for better classification."""
|
||
if not get_client() or not news_items:
|
||
return news_items
|
||
rescored = []
|
||
for item in news_items[:20]:
|
||
try:
|
||
ai = analyze_news_item(item.get("title", ""), item.get("summary", ""))
|
||
item["ai_category"] = ai.get("category", item.get("category"))
|
||
item["ai_impact"] = ai.get("impact_score", item.get("impact_score"))
|
||
item["ai_direction"] = ai.get("direction", "neutral")
|
||
item["ai_reasoning"] = ai.get("reasoning", "")
|
||
item["ai_entities"] = ai.get("key_entities", [])
|
||
if ai.get("affected_assets"):
|
||
item["asset_impacts"] = ai["affected_assets"]
|
||
except Exception:
|
||
pass
|
||
rescored.append(item)
|
||
return rescored
|