d256b65d30
Stack: FastAPI + React/TypeScript + SQLite + GPT-4o Features: Radar géopolitique, Marchés, Régime Macro, Journal de Bord MTM, Rapport IA, Super Contexte (base de raisonnement évolutive), Boucle feedback IA. Deploy: Docker + docker-compose + nginx pour openfin.open-squared.tech Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
594 lines
29 KiB
Python
594 lines
29 KiB
Python
"""
|
||
Market data fetcher using yfinance + free public APIs.
|
||
All functions are async-compatible where possible.
|
||
"""
|
||
import yfinance as yf
|
||
import pandas as pd
|
||
import numpy as np
|
||
from datetime import datetime, timedelta
|
||
from typing import Dict, List, Optional, Any
|
||
import feedparser
|
||
import httpx
|
||
import asyncio
|
||
|
||
|
||
# ── Watchlist by asset class ──────────────────────────────────────────────────
|
||
WATCHLIST: Dict[str, List[Dict[str, str]]] = {
|
||
"energy": [
|
||
{"symbol": "CL=F", "name": "WTI Crude Oil", "currency": "USD"},
|
||
{"symbol": "BZ=F", "name": "Brent Crude Oil", "currency": "USD"},
|
||
{"symbol": "NG=F", "name": "Natural Gas", "currency": "USD"},
|
||
{"symbol": "XLE", "name": "Energy ETF (XLE)", "currency": "USD"},
|
||
{"symbol": "UNG", "name": "US Natural Gas ETF", "currency": "USD"},
|
||
],
|
||
"metals": [
|
||
{"symbol": "GC=F", "name": "Gold Futures", "currency": "USD"},
|
||
{"symbol": "SI=F", "name": "Silver Futures", "currency": "USD"},
|
||
{"symbol": "HG=F", "name": "Copper Futures", "currency": "USD"},
|
||
{"symbol": "PL=F", "name": "Platinum Futures", "currency": "USD"},
|
||
{"symbol": "GDX", "name": "Gold Miners ETF", "currency": "USD"},
|
||
],
|
||
"agriculture": [
|
||
{"symbol": "ZC=F", "name": "Corn Futures", "currency": "USD"},
|
||
{"symbol": "ZW=F", "name": "Wheat Futures", "currency": "USD"},
|
||
{"symbol": "ZS=F", "name": "Soybean Futures", "currency": "USD"},
|
||
{"symbol": "KC=F", "name": "Coffee Futures", "currency": "USD"},
|
||
{"symbol": "SB=F", "name": "Sugar #11 Futures", "currency": "USD"},
|
||
],
|
||
"indices": [
|
||
{"symbol": "^GSPC", "name": "S&P 500", "currency": "USD"},
|
||
{"symbol": "^NDX", "name": "NASDAQ 100", "currency": "USD"},
|
||
{"symbol": "^DJI", "name": "Dow Jones", "currency": "USD"},
|
||
{"symbol": "^STOXX50E", "name": "Euro Stoxx 50", "currency": "EUR"},
|
||
{"symbol": "^N225", "name": "Nikkei 225", "currency": "JPY"},
|
||
{"symbol": "^VIX", "name": "VIX Volatility", "currency": "USD"},
|
||
],
|
||
"equities": [
|
||
{"symbol": "XOM", "name": "Exxon Mobil", "currency": "USD"},
|
||
{"symbol": "CVX", "name": "Chevron", "currency": "USD"},
|
||
{"symbol": "LMT", "name": "Lockheed Martin", "currency": "USD"},
|
||
{"symbol": "RTX", "name": "Raytheon", "currency": "USD"},
|
||
{"symbol": "BA", "name": "Boeing", "currency": "USD"},
|
||
],
|
||
"forex": [
|
||
{"symbol": "EURUSD=X", "name": "EUR/USD", "currency": "USD"},
|
||
{"symbol": "USDJPY=X", "name": "USD/JPY", "currency": "JPY"},
|
||
{"symbol": "GBP=X", "name": "GBP/USD", "currency": "USD"},
|
||
{"symbol": "USDCHF=X", "name": "USD/CHF", "currency": "CHF"},
|
||
{"symbol": "UUP", "name": "US Dollar ETF (UUP)", "currency": "USD"},
|
||
],
|
||
}
|
||
|
||
|
||
def get_quote(symbol: str) -> Optional[Dict[str, Any]]:
|
||
for period in ("5d", "1mo"):
|
||
try:
|
||
ticker = yf.Ticker(symbol)
|
||
hist = ticker.history(period=period, interval="1d", auto_adjust=True)
|
||
if hist.empty:
|
||
continue
|
||
# Drop rows where Close is NaN
|
||
hist = hist.dropna(subset=["Close"])
|
||
if hist.empty:
|
||
continue
|
||
price = float(hist["Close"].iloc[-1])
|
||
prev = float(hist["Close"].iloc[-2]) if len(hist) > 1 else price
|
||
change = price - prev
|
||
change_pct = (change / prev * 100) if prev else 0
|
||
return {
|
||
"symbol": symbol,
|
||
"price": round(price, 4),
|
||
"change": round(change, 4),
|
||
"change_pct": round(change_pct, 2),
|
||
"volume": int(hist["Volume"].iloc[-1]) if "Volume" in hist.columns else 0,
|
||
"timestamp": datetime.utcnow().isoformat(),
|
||
}
|
||
except Exception:
|
||
continue
|
||
return {"symbol": symbol, "price": None, "error": "no data"}
|
||
|
||
|
||
def get_all_quotes() -> Dict[str, List[Dict[str, Any]]]:
|
||
result = {}
|
||
for asset_class, assets in WATCHLIST.items():
|
||
quotes = []
|
||
for asset in assets:
|
||
q = get_quote(asset["symbol"])
|
||
if q:
|
||
q["name"] = asset["name"]
|
||
q["asset_class"] = asset_class
|
||
quotes.append(q)
|
||
result[asset_class] = quotes
|
||
return result
|
||
|
||
|
||
def get_historical(symbol: str, period: str = "1y", interval: str = "1d") -> List[Dict[str, Any]]:
|
||
try:
|
||
from urllib.parse import unquote
|
||
symbol = unquote(symbol)
|
||
ticker = yf.Ticker(symbol)
|
||
hist = ticker.history(period=period, interval=interval)
|
||
if hist.empty:
|
||
return []
|
||
hist = hist.reset_index()
|
||
records = []
|
||
for _, row in hist.iterrows():
|
||
records.append({
|
||
"date": row["Date"].isoformat() if hasattr(row["Date"], "isoformat") else str(row["Date"]),
|
||
"open": round(float(row["Open"]), 4),
|
||
"high": round(float(row["High"]), 4),
|
||
"low": round(float(row["Low"]), 4),
|
||
"close": round(float(row["Close"]), 4),
|
||
"volume": int(row["Volume"]) if "Volume" in row else 0,
|
||
})
|
||
return records
|
||
except Exception as e:
|
||
return []
|
||
|
||
|
||
def compute_historical_iv(symbol: str, window: int = 30) -> float:
|
||
"""Estimate realized vol as proxy for IV when options data unavailable."""
|
||
try:
|
||
ticker = yf.Ticker(symbol)
|
||
hist = ticker.history(period="3mo", interval="1d")
|
||
if len(hist) < 10:
|
||
return 0.25
|
||
returns = np.log(hist["Close"] / hist["Close"].shift(1)).dropna()
|
||
return float(returns.rolling(window).std().iloc[-1] * np.sqrt(252))
|
||
except Exception:
|
||
return 0.25
|
||
|
||
|
||
# ── News feeds ────────────────────────────────────────────────────────────────
|
||
GEO_RSS_FEEDS = [
|
||
{"name": "Reuters World", "url": "https://feeds.reuters.com/reuters/worldNews"},
|
||
{"name": "Reuters Business", "url": "https://feeds.reuters.com/reuters/businessNews"},
|
||
{"name": "Reuters Commodities", "url": "https://feeds.reuters.com/reuters/USenergyNews"},
|
||
{"name": "AP Top News", "url": "https://feeds.apnews.com/rss/apf-topnews"},
|
||
{"name": "Al Jazeera", "url": "https://www.aljazeera.com/xml/rss/all.xml"},
|
||
{"name": "Financial Times", "url": "https://www.ft.com/rss/home"},
|
||
{"name": "Bloomberg Markets", "url": "https://feeds.bloomberg.com/markets/news.rss"},
|
||
]
|
||
|
||
GEO_KEYWORDS = {
|
||
"military": ["war", "attack", "missile", "troops", "conflict", "invasion", "airstrike", "NATO", "ceasefire"],
|
||
"energy": ["OPEC", "oil production", "gas pipeline", "LNG", "energy sanctions", "crude", "petroleum"],
|
||
"sanctions": ["sanctions", "embargo", "tariff", "trade ban", "export control", "blacklist"],
|
||
"elections": ["election", "poll", "vote", "presidency", "referendum", "coup"],
|
||
"natural_disaster": ["earthquake", "hurricane", "flood", "drought", "wildfire", "tsunami", "volcano"],
|
||
"health_crisis": ["pandemic", "outbreak", "epidemic", "WHO", "virus", "quarantine", "lockdown"],
|
||
"resource_scarcity": ["shortage", "supply chain", "famine", "water crisis", "food security", "rare earth"],
|
||
"trade_war": ["trade war", "tariff", "WTO", "dumping", "protectionism", "trade deal"],
|
||
"political_speech": ["Trump", "Biden", "Xi Jinping", "Putin", "Macron", "Zelensky", "Fed", "ECB"],
|
||
}
|
||
|
||
|
||
def fetch_geo_news() -> List[Dict[str, Any]]:
|
||
news = []
|
||
for feed_info in GEO_RSS_FEEDS:
|
||
try:
|
||
feed = feedparser.parse(feed_info["url"])
|
||
for entry in feed.entries[:10]:
|
||
title = entry.get("title", "")
|
||
summary = entry.get("summary", entry.get("description", ""))
|
||
published = entry.get("published", "")
|
||
link = entry.get("link", "")
|
||
category = classify_news(title + " " + summary)
|
||
impact = estimate_impact(title + " " + summary, category)
|
||
news.append({
|
||
"id": link,
|
||
"title": title,
|
||
"summary": summary[:300],
|
||
"source": feed_info["name"],
|
||
"category": category,
|
||
"impact_score": impact,
|
||
"asset_impacts": compute_asset_impacts(category, impact),
|
||
"date": published,
|
||
"tags": extract_tags(title + " " + summary),
|
||
"url": link,
|
||
})
|
||
except Exception:
|
||
pass
|
||
return news[:50]
|
||
|
||
|
||
def classify_news(text: str) -> str:
|
||
text_lower = text.lower()
|
||
scores = {}
|
||
for cat, keywords in GEO_KEYWORDS.items():
|
||
scores[cat] = sum(1 for kw in keywords if kw.lower() in text_lower)
|
||
best = max(scores, key=scores.get)
|
||
return best if scores[best] > 0 else "general"
|
||
|
||
|
||
def estimate_impact(text: str, category: str) -> float:
|
||
high_impact = ["attack", "invasion", "collapse", "crisis", "war", "ban", "default", "Trump", "Fed",
|
||
"ceasefire", "truce", "nuclear", "coup", "massacre", "bombed", "strike"]
|
||
medium_impact = ["tension", "sanctions", "shortage", "election", "rate", "OPEC",
|
||
"peace", "deal", "agreement", "accord", "treaty", "negotiation"]
|
||
text_lower = text.lower()
|
||
score = 0.1
|
||
for word in high_impact:
|
||
if word.lower() in text_lower:
|
||
score += 0.2
|
||
for word in medium_impact:
|
||
if word.lower() in text_lower:
|
||
score += 0.1
|
||
return min(1.0, round(score, 2))
|
||
|
||
|
||
def compute_asset_impacts(category: str, impact: float) -> Dict[str, float]:
|
||
impact_map = {
|
||
"military": {"energy": 0.8, "metals": 0.6, "forex": 0.4, "indices": -0.5, "agriculture": 0.3},
|
||
"energy": {"energy": 0.9, "metals": 0.2, "forex": 0.3, "indices": -0.3},
|
||
"sanctions": {"forex": 0.6, "energy": 0.5, "metals": 0.3, "indices": -0.4},
|
||
"elections": {"forex": 0.7, "indices": 0.4, "equities": 0.3},
|
||
"natural_disaster": {"agriculture": 0.8, "energy": 0.4, "indices": -0.3},
|
||
"health_crisis": {"indices": -0.8, "agriculture": 0.5, "metals": 0.4},
|
||
"resource_scarcity": {"agriculture": 0.9, "metals": 0.7, "energy": 0.5},
|
||
"trade_war": {"indices": -0.6, "forex": 0.5, "agriculture": -0.3},
|
||
"political_speech": {"forex": 0.5, "indices": 0.4, "energy": 0.3},
|
||
}
|
||
base = impact_map.get(category, {})
|
||
return {k: round(v * impact, 3) for k, v in base.items()}
|
||
|
||
|
||
def extract_tags(text: str) -> List[str]:
|
||
all_tags = [
|
||
"Trump", "Russia", "Ukraine", "China", "Iran", "Israel", "Gaza", "NATO",
|
||
"OPEC", "Fed", "ECB", "Biden", "Xi", "Putin", "Zelensky", "Macron",
|
||
"oil", "gold", "wheat", "dollar", "yuan", "euro", "S&P", "VIX",
|
||
]
|
||
return [tag for tag in all_tags if tag.lower() in text.lower()]
|
||
|
||
|
||
# ── Economic calendar (using free Trading Economics RSS or static) ────────────
|
||
def get_economic_calendar() -> List[Dict[str, Any]]:
|
||
"""Return next 30 days of major economic events (static + scraped)."""
|
||
from datetime import date, timedelta
|
||
today = date.today()
|
||
events = [
|
||
{"title": "US Non-Farm Payrolls", "country": "US", "importance": "high",
|
||
"date": (today + timedelta(days=(4 - today.weekday()) % 7 + 7)).isoformat(),
|
||
"asset_impact": ["indices", "forex", "rates"]},
|
||
{"title": "US CPI (Consumer Price Index)", "country": "US", "importance": "high",
|
||
"date": (today + timedelta(days=12)).isoformat(),
|
||
"asset_impact": ["indices", "forex", "metals"]},
|
||
{"title": "FOMC Meeting / Fed Rate Decision", "country": "US", "importance": "high",
|
||
"date": (today + timedelta(days=18)).isoformat(),
|
||
"asset_impact": ["indices", "forex", "metals", "energy"]},
|
||
{"title": "ECB Rate Decision", "country": "EU", "importance": "high",
|
||
"date": (today + timedelta(days=20)).isoformat(),
|
||
"asset_impact": ["forex", "indices"]},
|
||
{"title": "US GDP (Preliminary)", "country": "US", "importance": "high",
|
||
"date": (today + timedelta(days=25)).isoformat(),
|
||
"asset_impact": ["indices", "forex"]},
|
||
{"title": "OPEC+ Meeting", "country": "Global", "importance": "high",
|
||
"date": (today + timedelta(days=14)).isoformat(),
|
||
"asset_impact": ["energy"]},
|
||
{"title": "US Crude Oil Inventories (EIA)", "country": "US", "importance": "medium",
|
||
"date": (today + timedelta(days=3)).isoformat(),
|
||
"asset_impact": ["energy"]},
|
||
{"title": "EU Inflation (CPI)", "country": "EU", "importance": "medium",
|
||
"date": (today + timedelta(days=8)).isoformat(),
|
||
"asset_impact": ["forex", "indices"]},
|
||
{"title": "China Trade Balance", "country": "CN", "importance": "medium",
|
||
"date": (today + timedelta(days=10)).isoformat(),
|
||
"asset_impact": ["metals", "agriculture", "forex"]},
|
||
{"title": "US Unemployment Claims", "country": "US", "importance": "medium",
|
||
"date": (today + timedelta(days=2)).isoformat(),
|
||
"asset_impact": ["forex", "indices"]},
|
||
{"title": "USDA Crop Report", "country": "US", "importance": "medium",
|
||
"date": (today + timedelta(days=6)).isoformat(),
|
||
"asset_impact": ["agriculture"]},
|
||
{"title": "G7 Summit", "country": "Global", "importance": "high",
|
||
"date": (today + timedelta(days=30)).isoformat(),
|
||
"asset_impact": ["forex", "indices", "metals"]},
|
||
]
|
||
return sorted(events, key=lambda x: x["date"])
|
||
|
||
|
||
# ── Macro Gauges & Scenario Scoring ──────────────────────────────────────────
|
||
|
||
MACRO_GAUGE_CONFIG = [
|
||
# (id, label, ticker, unit, bloc)
|
||
("dxy", "Dollar DXY", "DX-Y.NYB", "index", "liquidite"),
|
||
("us10y", "UST 10Y", "^TNX", "%", "liquidite"),
|
||
("us3m", "UST 3M", "^IRX", "%", "liquidite"),
|
||
("tips", "TIPS ETF", "TIP", "$", "liquidite"),
|
||
("vix", "VIX", "^VIX", "pts", "credit"),
|
||
("hyg", "HY Bonds (HYG)", "HYG", "$", "credit"),
|
||
("lqd", "IG Bonds (LQD)", "LQD", "$", "credit"),
|
||
("ief", "Trésor 7-10Y (IEF)", "IEF", "$", "credit"),
|
||
("brent", "Brent", "BZ=F", "$", "energie"),
|
||
("ng", "Gaz naturel", "NG=F", "$", "energie"),
|
||
("gold", "Or", "GC=F", "$", "metaux"),
|
||
("copper", "Cuivre", "HG=F", "$/lb", "metaux"),
|
||
("spx", "S&P 500", "^GSPC", "pts", "croissance"),
|
||
("iwm", "Russell 2000", "IWM", "$", "croissance"),
|
||
("xli", "Industriels XLI", "XLI", "$", "croissance"),
|
||
]
|
||
|
||
SCENARIO_META = {
|
||
"goldilocks": {"label": "Goldilocks", "color": "#10b981", "emoji": "🟢"},
|
||
"desinflation": {"label": "Désinflation / Baisse taux","color": "#3b82f6", "emoji": "🔵"},
|
||
"soft_landing": {"label": "Soft Landing", "color": "#06b6d4", "emoji": "🔷"},
|
||
"reflation": {"label": "Reflation", "color": "#f97316", "emoji": "🟠"},
|
||
"stagflation": {"label": "Stagflation", "color": "#f59e0b", "emoji": "🟡"},
|
||
"inflation_shock": {"label": "Choc Inflationniste", "color": "#dc2626", "emoji": "🔥"},
|
||
"recession": {"label": "Récession", "color": "#ef4444", "emoji": "🔴"},
|
||
"crise_liquidite": {"label": "Crise de liquidité", "color": "#7c3aed", "emoji": "🟣"},
|
||
}
|
||
|
||
SCENARIO_ASSET_BIAS = {
|
||
"goldilocks": {"energy": "neutral", "metals": "bullish", "indices": "bullish+", "equities": "bullish+", "forex": "neutral", "agriculture": "neutral"},
|
||
"desinflation": {"energy": "bearish", "metals": "bullish+", "indices": "bullish+", "equities": "bullish", "forex": "neutral", "agriculture": "neutral"},
|
||
"soft_landing": {"energy": "neutral", "metals": "bullish", "indices": "bullish+", "equities": "bullish", "forex": "neutral", "agriculture": "neutral"},
|
||
"reflation": {"energy": "bullish+", "metals": "bullish+", "indices": "bullish", "equities": "bullish+", "forex": "neutral", "agriculture": "bullish+"},
|
||
"stagflation": {"energy": "bullish+", "metals": "bullish", "indices": "bearish", "equities": "bearish", "forex": "defensive", "agriculture": "bullish"},
|
||
"inflation_shock": {"energy": "bullish+", "metals": "bullish+", "indices": "bearish", "equities": "bearish", "forex": "defensive", "agriculture": "bullish+"},
|
||
"recession": {"energy": "bearish", "metals": "neutral", "indices": "bearish+", "equities": "bearish+", "forex": "defensive", "agriculture": "neutral"},
|
||
"crise_liquidite": {"energy": "neutral", "metals": "bullish+", "indices": "bearish+", "equities": "bearish+", "forex": "defensive", "agriculture": "neutral"},
|
||
}
|
||
|
||
|
||
def get_macro_gauges() -> Dict[str, Any]:
|
||
"""Fetch macro gauges from yfinance in parallel and compute derived metrics."""
|
||
from concurrent.futures import ThreadPoolExecutor, as_completed
|
||
|
||
raw: Dict[str, Any] = {}
|
||
with ThreadPoolExecutor(max_workers=min(len(MACRO_GAUGE_CONFIG), 12)) as exe:
|
||
futures = {
|
||
exe.submit(get_quote, ticker): (gid, label, ticker, unit, bloc)
|
||
for gid, label, ticker, unit, bloc in MACRO_GAUGE_CONFIG
|
||
}
|
||
for fut in as_completed(futures):
|
||
gid, label, ticker, unit, bloc = futures[fut]
|
||
try:
|
||
q = fut.result()
|
||
except Exception:
|
||
q = None
|
||
raw[gid] = {
|
||
"id": gid, "label": label, "ticker": ticker,
|
||
"value": q.get("price") if q else None,
|
||
"change_pct": q.get("change_pct") if q else None,
|
||
"unit": unit, "bloc": bloc,
|
||
}
|
||
|
||
# Normalize Treasury yields (yfinance sometimes returns 10x the actual %)
|
||
for yid in ("us10y", "us3m"):
|
||
v = raw[yid]["value"]
|
||
if v is not None and v > 20:
|
||
raw[yid]["value"] = round(v / 10, 3)
|
||
|
||
# Derived: yield curve slope 10Y – 3M (% pts; negative = inverted)
|
||
v10 = raw["us10y"]["value"]
|
||
v3m = raw["us3m"]["value"]
|
||
slope = round(v10 - v3m, 3) if (v10 is not None and v3m is not None) else None
|
||
raw["slope_10y3m"] = {
|
||
"id": "slope_10y3m", "label": "Pente 10Y–3M", "ticker": None,
|
||
"value": slope, "change_pct": None, "unit": "% pts", "bloc": "liquidite",
|
||
"note": ("inversée ⚠️" if slope is not None and slope < 0
|
||
else ("plate" if slope is not None and slope < 0.5 else "normale")),
|
||
}
|
||
|
||
# Derived: Gold / Copper ratio (oz gold / lb copper; >700 = fear, <500 = growth)
|
||
gv = raw["gold"]["value"]
|
||
cv = raw["copper"]["value"]
|
||
gcr = round(gv / cv, 1) if (gv and cv) else None
|
||
raw["gold_copper_ratio"] = {
|
||
"id": "gold_copper_ratio", "label": "Ratio Or/Cuivre",
|
||
"ticker": None, "value": gcr, "change_pct": None, "unit": "ratio", "bloc": "derive",
|
||
"note": ("peur/récession" if gcr and gcr > 700 else ("neutre" if gcr and gcr > 550 else "croissance")),
|
||
}
|
||
|
||
# Derived: S&P 500 % above/below 200-day MA
|
||
try:
|
||
spx_hist = get_historical("^GSPC", period="1y", interval="1d")
|
||
closes = [h["close"] for h in spx_hist if h.get("close")]
|
||
if len(closes) >= 50:
|
||
n = min(200, len(closes))
|
||
ma = sum(closes[-n:]) / n
|
||
vs200 = round((closes[-1] - ma) / ma * 100, 2)
|
||
else:
|
||
vs200 = None
|
||
except Exception:
|
||
vs200 = None
|
||
raw["spx_vs_200d"] = {
|
||
"id": "spx_vs_200d", "label": "S&P vs 200j MA",
|
||
"ticker": None, "value": vs200, "change_pct": None, "unit": "%", "bloc": "derive",
|
||
"note": ("bull market" if vs200 is not None and vs200 > 5
|
||
else ("au-dessus" if vs200 is not None and vs200 > 0
|
||
else ("en-dessous ⚠️" if vs200 is not None else None))),
|
||
}
|
||
|
||
# Derived: Russell 2000 vs S&P 500 relative daily performance
|
||
# Positive = small caps outperforming (risk-on breadth); negative = large cap defensiveness
|
||
iwm_c = raw.get("iwm", {}).get("change_pct") or 0.0
|
||
spx_c_val = raw.get("spx", {}).get("change_pct") or 0.0
|
||
rel_perf = round(iwm_c - spx_c_val, 2)
|
||
raw["iwm_spx_ratio"] = {
|
||
"id": "iwm_spx_ratio", "label": "Russell vs S&P (perf. rel.)",
|
||
"ticker": None, "value": rel_perf, "change_pct": None, "unit": "pts%", "bloc": "derive",
|
||
"note": ("small caps > large (risk-on)" if rel_perf > 0.2
|
||
else ("parité" if rel_perf > -0.2 else "large caps dominants (défensif)")),
|
||
}
|
||
|
||
return _sanitize_floats(raw)
|
||
|
||
|
||
def _sanitize_floats(obj: Any) -> Any:
|
||
"""Recursively replace NaN/Inf floats with None so json.dumps never crashes."""
|
||
import math
|
||
if isinstance(obj, dict):
|
||
return {k: _sanitize_floats(v) for k, v in obj.items()}
|
||
if isinstance(obj, list):
|
||
return [_sanitize_floats(v) for v in obj]
|
||
if isinstance(obj, float) and (math.isnan(obj) or math.isinf(obj)):
|
||
return None
|
||
return obj
|
||
|
||
|
||
def score_macro_scenarios(gauges: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""Rule-based scoring of the 5 macro regimes (0-100 each) from live gauge values."""
|
||
def gv(k): return gauges.get(k, {}).get("value")
|
||
def gc(k): return gauges.get(k, {}).get("change_pct") or 0.0
|
||
|
||
vix = gv("vix") or 20.0
|
||
slope = gv("slope_10y3m")
|
||
gcr = gv("gold_copper_ratio")
|
||
vs200 = gv("spx_vs_200d")
|
||
brent_c = gc("brent")
|
||
ng_c = gc("ng")
|
||
gold_c = gc("gold")
|
||
copper_c = gc("copper")
|
||
hyg_c = gc("hyg")
|
||
lqd_c = gc("lqd")
|
||
ief_c = gc("ief")
|
||
dxy_c = gc("dxy")
|
||
iwm_c = gc("iwm")
|
||
xli_c = gc("xli")
|
||
rel_perf = gv("iwm_spx_ratio") or 0.0 # Russell vs S&P relative perf
|
||
|
||
scores: Dict[str, int] = {}
|
||
reasons: Dict[str, List[str]] = {}
|
||
|
||
# GOLDILOCKS — croissance + faible volatilité + crédit serré
|
||
s = 0; r: List[str] = []
|
||
if vix < 15: s += 30; r.append("VIX<15")
|
||
elif vix < 18: s += 20; r.append("VIX<18")
|
||
elif vix < 22: s += 10
|
||
if slope is not None:
|
||
if slope > 1.0: s += 20; r.append("Courbe +1%pt")
|
||
elif slope > 0.3: s += 10; r.append("Courbe légèrement positive")
|
||
if gcr is not None:
|
||
if gcr < 500: s += 20; r.append(f"Or/Cu {gcr} (croissance)")
|
||
elif gcr < 600: s += 10
|
||
if hyg_c > 0.2: s += 15; r.append("HYG↑ (crédit OK)")
|
||
elif hyg_c > 0: s += 5
|
||
if vs200 is not None:
|
||
if vs200 > 5: s += 15; r.append(f"S&P+{vs200}% vs 200j")
|
||
elif vs200 > 0: s += 7
|
||
if copper_c > 0.5: s += 10; r.append("Cuivre↑")
|
||
scores["goldilocks"] = min(100, s); reasons["goldilocks"] = r
|
||
|
||
# DÉSINFLATION / BAISSE DE TAUX
|
||
s = 0; r = []
|
||
if brent_c < -1.0: s += 25; r.append("Brent↓↓ (désinflationniste)")
|
||
elif brent_c < 0: s += 10
|
||
if ng_c < -1.0: s += 10; r.append("Gaz↓")
|
||
if ief_c > 0.2: s += 20; r.append("IEF↑ (taux longs baissent)")
|
||
elif ief_c > 0: s += 10
|
||
if vix < 20: s += 15; r.append("VIX<20")
|
||
if vs200 is not None and vs200 > 0: s += 20; r.append("S&P au-dessus 200j")
|
||
if hyg_c > 0: s += 10; r.append("HYG↑")
|
||
if gold_c > 0 and brent_c < 0: s += 10; r.append("Or↑+Brent↓ (taux réels ↓)")
|
||
scores["desinflation"] = min(100, s); reasons["desinflation"] = r
|
||
|
||
# STAGFLATION — inflation + croissance faible
|
||
s = 0; r = []
|
||
if brent_c > 2.0: s += 30; r.append("Brent↑↑")
|
||
elif brent_c > 0.5: s += 15; r.append("Brent↑")
|
||
if ng_c > 2.0: s += 15; r.append("Gaz↑↑")
|
||
elif ng_c > 0.5: s += 7
|
||
if slope is not None:
|
||
if slope < 0: s += 20; r.append("Courbe inversée")
|
||
elif slope < 0.3: s += 10; r.append("Courbe plate")
|
||
if gold_c > 0.5: s += 15; r.append("Or↑ (protection inflation)")
|
||
if copper_c < 0: s += 15; r.append("Cuivre↓ (demande faible)")
|
||
if vix > 18: s += 10; r.append("VIX élevé")
|
||
scores["stagflation"] = min(100, s); reasons["stagflation"] = r
|
||
|
||
# RÉCESSION
|
||
s = 0; r = []
|
||
if slope is not None:
|
||
if slope < -0.5: s += 30; r.append("Courbe fortement inversée")
|
||
elif slope < 0: s += 15; r.append("Courbe inversée")
|
||
if gcr is not None:
|
||
if gcr > 750: s += 25; r.append(f"Or/Cu {gcr} (peur)")
|
||
elif gcr > 650: s += 10
|
||
if vix > 28: s += 25; r.append("VIX>28")
|
||
elif vix > 22: s += 12
|
||
if copper_c < -1.5: s += 20; r.append("Cuivre↓↓")
|
||
elif copper_c < -0.5: s += 8
|
||
if hyg_c < -0.5: s += 15; r.append("HYG↓ (spreads s'écartent)")
|
||
elif hyg_c < 0: s += 5
|
||
if gold_c > 0.3: s += 10; r.append("Or↑ (refuge)")
|
||
scores["recession"] = min(100, s); reasons["recession"] = r
|
||
|
||
# CRISE DE LIQUIDITÉ
|
||
s = 0; r = []
|
||
if vix > 35: s += 35; r.append("VIX>35 (panique)")
|
||
elif vix > 28: s += 20; r.append("VIX>28")
|
||
elif vix > 22: s += 8
|
||
if hyg_c < -1.5: s += 35; r.append("HYG↓↓ (crise crédit)")
|
||
elif hyg_c < -0.5: s += 15
|
||
if lqd_c < -0.5: s += 10; r.append("IG↓ (spreads s'écartent)")
|
||
if vs200 is not None:
|
||
if vs200 < -10: s += 25; r.append("S&P<200j -10%")
|
||
elif vs200 < -3: s += 10
|
||
if gold_c > 1.0 and copper_c < -1.0: s += 20; r.append("Or↑+Cuivre↓ (fuite sécurité)")
|
||
if dxy_c > 1.0: s += 15; r.append("Dollar↑↑")
|
||
if ief_c > 0.5: s += 10; r.append("Obligations souveraines↑↑")
|
||
scores["crise_liquidite"] = min(100, s); reasons["crise_liquidite"] = r
|
||
|
||
# REFLATION — croissance accélère + inflation remonte (cuivre, énergie, small caps explosent)
|
||
s = 0; r = []
|
||
if copper_c > 1.5: s += 25; r.append("Cuivre↑↑ (Dr Copper = croissance)")
|
||
elif copper_c > 0.5: s += 12; r.append("Cuivre↑")
|
||
if xli_c > 0.8: s += 20; r.append("Industriels↑↑ (activité mfg forte)")
|
||
elif xli_c > 0.2: s += 10; r.append("Industriels↑")
|
||
if brent_c > 1.5: s += 15; r.append("Brent↑ (reflation énergie)")
|
||
elif brent_c > 0.3: s += 6
|
||
if vs200 is not None and vs200 > 8: s += 20; r.append(f"S&P+{vs200}% vs 200j (bull fort)")
|
||
elif vs200 is not None and vs200 > 3: s += 10
|
||
if slope is not None and slope > 1.0: s += 15; r.append("Courbe pentue (anticipation croissance)")
|
||
elif slope is not None and slope > 0.3: s += 6
|
||
if rel_perf > 0.3: s += 10; r.append("Small caps > large (risk-on large)")
|
||
elif rel_perf > 0: s += 4
|
||
if vix < 18: s += 5
|
||
scores["reflation"] = min(100, s); reasons["reflation"] = r
|
||
|
||
# SOFT LANDING — croissance positive + inflation en repli, pas encore basse
|
||
# Intermédiaire entre Goldilocks (idéal) et Désinflation (taux baissent fortement)
|
||
s = 0; r = []
|
||
if vs200 is not None and vs200 > 0: s += 20; r.append("S&P > MA200 (croissance intacte)")
|
||
if brent_c < -0.5 and brent_c > -3: s += 20; r.append("Brent légèrement ↓ (désinflation graduelle)")
|
||
elif brent_c < 0: s += 8
|
||
if vix < 20: s += 15; r.append("VIX<20 (pas de stress)")
|
||
if hyg_c > 0: s += 12; r.append("HYG↑ (crédit solide)")
|
||
if lqd_c > 0: s += 8; r.append("IG↑ (spreads IG calmes)")
|
||
if slope is not None and slope > 0: s += 10; r.append("Courbe non-inversée")
|
||
if xli_c > 0: s += 8; r.append("Industriels positifs")
|
||
if copper_c > 0: s += 5; r.append("Cuivre stable")
|
||
if ief_c > 0 and brent_c < 0: s += 7; r.append("Taux baissent + énergie recule")
|
||
scores["soft_landing"] = min(100, s); reasons["soft_landing"] = r
|
||
|
||
# CHOC INFLATIONNISTE — spike énergie/supply soudain (guerre, OPEC, sécheresse)
|
||
# Différent de Stagflation : c'est un choc externe aigu, pas un régime durable
|
||
s = 0; r = []
|
||
if brent_c > 4.0: s += 40; r.append("Brent↑↑↑ (choc énergie majeur)")
|
||
elif brent_c > 2.0: s += 25; r.append("Brent↑↑")
|
||
elif brent_c > 0.8: s += 10
|
||
if ng_c > 4.0: s += 20; r.append("Gaz↑↑↑ (choc supply gaz)")
|
||
elif ng_c > 2.0: s += 12; r.append("Gaz↑↑")
|
||
if gold_c > 1.0: s += 20; r.append("Or↑↑ (refuge inflation/géo)")
|
||
elif gold_c > 0.3: s += 8; r.append("Or↑")
|
||
if vix > 22: s += 15; r.append("VIX↑ (stress montant)")
|
||
elif vix > 18: s += 5
|
||
if copper_c < -0.5: s += 8; r.append("Cuivre↓ (demand destruction)")
|
||
if ief_c < -0.2: s += 8; r.append("Trésor↓ (taux longs remontent)")
|
||
scores["inflation_shock"] = min(100, s); reasons["inflation_shock"] = r
|
||
|
||
ranked = sorted(scores.items(), key=lambda x: x[1], reverse=True)
|
||
dominant = ranked[0][0] if ranked[0][1] > 20 else "incertain"
|
||
|
||
return {
|
||
"scores": scores,
|
||
"ranked": [[k, v] for k, v in ranked],
|
||
"dominant": dominant,
|
||
"reasons": reasons,
|
||
"meta": SCENARIO_META,
|
||
"asset_bias": SCENARIO_ASSET_BIAS,
|
||
}
|