690 lines
23 KiB
Python
690 lines
23 KiB
Python
"""
|
|
indicators.py — Calcul de tous les indicateurs d'analyse technique.
|
|
|
|
Chaque fonction prend un DataFrame pandas (colonnes : date, price, open,
|
|
hight, low, vol) trié par date croissante et retourne un dict JSON-sérialisable.
|
|
"""
|
|
import numpy as np
|
|
import pandas as pd
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Helpers
|
|
# ---------------------------------------------------------------------------
|
|
def _safe_last(series):
|
|
"""Retourne la dernière valeur non-NaN d'une Series, ou None."""
|
|
if series is None or len(series) == 0:
|
|
return None
|
|
val = series.dropna()
|
|
return float(val.iloc[-1]) if len(val) > 0 else None
|
|
|
|
|
|
def _round(val, decimals=2):
|
|
"""Arrondi sécurisé (None si val est None)."""
|
|
if val is None:
|
|
return None
|
|
return round(float(val), decimals)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# 3) Performances
|
|
# ---------------------------------------------------------------------------
|
|
def calcul_performances(df):
|
|
"""Variation journalière et performances sur différentes fenêtres."""
|
|
close = df["price"]
|
|
ret = close.pct_change() * 100 # variation journalière en %
|
|
|
|
result = {
|
|
"variation_journaliere": _round(_safe_last(ret)),
|
|
"fenetres": {},
|
|
}
|
|
|
|
for fenetre in [5, 10, 20, 50, 100, 250]:
|
|
if len(close) > fenetre:
|
|
perf = (close.iloc[-1] / close.iloc[-1 - fenetre] - 1) * 100
|
|
result["fenetres"][f"{fenetre}j"] = _round(perf)
|
|
else:
|
|
result["fenetres"][f"{fenetre}j"] = None
|
|
|
|
# Performance annuelle (année civile complète la plus récente)
|
|
df_temp = df.copy()
|
|
df_temp["year"] = df_temp["date"].dt.year
|
|
annees = sorted(df_temp["year"].unique(), reverse=True)
|
|
if len(annees) >= 2:
|
|
annee_ref = annees[1] # dernière année complète
|
|
prix_debut = df_temp[df_temp["year"] == annee_ref]["price"].iloc[0]
|
|
prix_fin = df_temp[df_temp["year"] == annee_ref]["price"].iloc[-1]
|
|
result["performance_annuelle"] = {
|
|
"annee": int(annee_ref),
|
|
"valeur": _round((prix_fin / prix_debut - 1) * 100),
|
|
}
|
|
else:
|
|
result["performance_annuelle"] = None
|
|
|
|
# YTD (depuis le 1er janvier de l'année en cours)
|
|
annee_courante = annees[0] if annees else None
|
|
if annee_courante:
|
|
prix_ytd_debut = df_temp[df_temp["year"] == annee_courante]["price"].iloc[0]
|
|
prix_ytd_fin = df_temp["price"].iloc[-1]
|
|
result["ytd"] = _round((prix_ytd_fin / prix_ytd_debut - 1) * 100)
|
|
else:
|
|
result["ytd"] = None
|
|
|
|
return result
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# 4) Moyennes mobiles
|
|
# ---------------------------------------------------------------------------
|
|
def calcul_moyennes_mobiles(df):
|
|
"""SMA (5,10,20,50,100,200) et EMA (12,26) + distance du cours en %."""
|
|
close = df["price"]
|
|
result = {"sma": {}, "ema": {}}
|
|
|
|
sma_periods = [5, 10, 20, 50, 100, 200]
|
|
for p in sma_periods:
|
|
sma = close.rolling(window=p).mean()
|
|
val = _safe_last(sma)
|
|
result["sma"][f"MM{p}"] = _round(val)
|
|
if val:
|
|
dist = (close.iloc[-1] / val - 1) * 100
|
|
result["sma"][f"MM{p}_distance"] = _round(dist)
|
|
|
|
for p in [12, 26]:
|
|
ema = close.ewm(span=p, adjust=False).mean()
|
|
val = _safe_last(ema)
|
|
result["ema"][f"EMA{p}"] = _round(val)
|
|
if val:
|
|
dist = (close.iloc[-1] / val - 1) * 100
|
|
result["ema"][f"EMA{p}_distance"] = _round(dist)
|
|
|
|
return result
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# 5) Volatilité
|
|
# ---------------------------------------------------------------------------
|
|
def calcul_volatilite(df):
|
|
"""Volatilité historique annualisée (std des rendements * sqrt(252))."""
|
|
close = df["price"]
|
|
ret = close.pct_change().dropna()
|
|
|
|
result = {"fenetres": {}}
|
|
|
|
for fenetre in [10, 20, 50]:
|
|
if len(ret) >= fenetre:
|
|
vol = ret.rolling(window=fenetre).std() * np.sqrt(252) * 100
|
|
result["fenetres"][f"{fenetre}j"] = _round(_safe_last(vol))
|
|
else:
|
|
result["fenetres"][f"{fenetre}j"] = None
|
|
|
|
# Volatilité actuelle (20j par défaut)
|
|
if len(ret) >= 20:
|
|
vol_actuelle = ret.rolling(window=20).std().iloc[-1] * np.sqrt(252) * 100
|
|
result["actuelle"] = _round(vol_actuelle)
|
|
else:
|
|
result["actuelle"] = None
|
|
|
|
# Volatilité moyenne sur 1 an (252 jours)
|
|
if len(ret) >= 20:
|
|
vol_series = ret.rolling(window=20).std() * np.sqrt(252) * 100
|
|
vol_1an = vol_series.dropna().tail(252).mean()
|
|
result["moyenne_1an"] = _round(vol_1an)
|
|
else:
|
|
result["moyenne_1an"] = None
|
|
|
|
# Percentile de la volatilité actuelle
|
|
if len(ret) >= 50 and result["actuelle"] is not None:
|
|
vol_series = (ret.rolling(window=20).std() * np.sqrt(252) * 100).dropna()
|
|
if len(vol_series) > 0:
|
|
percentile = (vol_series < result["actuelle"]).sum() / len(vol_series) * 100
|
|
result["percentile"] = _round(percentile)
|
|
else:
|
|
result["percentile"] = None
|
|
else:
|
|
result["percentile"] = None
|
|
|
|
return result
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# 6) ATR
|
|
# ---------------------------------------------------------------------------
|
|
def calcul_atr(df):
|
|
"""Average True Range (14 et 20 périodes)."""
|
|
high = df["hight"]
|
|
low = df["low"]
|
|
close = df["price"]
|
|
|
|
prev_close = close.shift(1)
|
|
tr = pd.concat(
|
|
[
|
|
(high - low),
|
|
(high - prev_close).abs(),
|
|
(low - prev_close).abs(),
|
|
],
|
|
axis=1,
|
|
).max(axis=1)
|
|
|
|
result = {}
|
|
for p in [14, 20]:
|
|
atr = tr.rolling(window=p).mean()
|
|
val = _safe_last(atr)
|
|
result[f"ATR{p}"] = _round(val)
|
|
if val and close.iloc[-1] > 0:
|
|
result[f"ATR{p}_pct"] = _round(val / close.iloc[-1] * 100)
|
|
|
|
return result
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# 7) Analyse des gaps
|
|
# ---------------------------------------------------------------------------
|
|
def calcul_gaps(df):
|
|
"""Détection et statistiques des gaps (open vs close précédent)."""
|
|
open_ = df["open"]
|
|
close = df["price"]
|
|
dates = df["date"]
|
|
|
|
prev_close = close.shift(1)
|
|
gap_pct = (open_ / prev_close - 1) * 100
|
|
|
|
# Un gap est significatif si > 0.5% (sinon c'est du bruit)
|
|
seuil = 0.5
|
|
gaps_significatifs = gap_pct.abs() > seuil
|
|
|
|
gaps_list = []
|
|
for i in range(1, len(df)):
|
|
if gaps_significatifs.iloc[i]:
|
|
taille = gap_pct.iloc[i]
|
|
type_gap = "haussier" if taille > 0 else "baissier"
|
|
# Vérifier si le gap a été comblé dans les 30 jours suivants
|
|
niveau_gap = open_.iloc[i]
|
|
comble = False
|
|
jours_combles = None
|
|
for j in range(i + 1, min(i + 31, len(df))):
|
|
if taille > 0:
|
|
# Gap haussier : comblé si prix redescend sous le niveau d'ouverture
|
|
if df["low"].iloc[j] <= niveau_gap:
|
|
comble = True
|
|
jours_combles = j - i
|
|
break
|
|
else:
|
|
# Gap baissier : comblé si prix remonte au-dessus du niveau d'ouverture
|
|
if df["hight"].iloc[j] >= niveau_gap:
|
|
comble = True
|
|
jours_combles = j - i
|
|
break
|
|
|
|
gaps_list.append(
|
|
{
|
|
"date": dates.iloc[i].strftime("%Y-%m-%d"),
|
|
"type": type_gap,
|
|
"taille": _round(taille),
|
|
"comble": comble,
|
|
"jours_combles": jours_combles,
|
|
}
|
|
)
|
|
|
|
# Statistiques
|
|
nb_gaps = len(gaps_list)
|
|
nb_combles = sum(1 for g in gaps_list if g["comble"])
|
|
taux_combles = _round(nb_combles / nb_gaps * 100) if nb_gaps > 0 else 0
|
|
gap_moyen = _round(np.mean([abs(g["taille"]) for g in gaps_list])) if nb_gaps > 0 else 0
|
|
plus_gros_gap = _round(max([abs(g["taille"]) for g in gaps_list], default=0))
|
|
|
|
# Derniers gaps (les 10 plus récents)
|
|
derniers = gaps_list[-10:] if nb_gaps <= 10 else gaps_list[-10:]
|
|
|
|
return {
|
|
"nb_total": nb_gaps,
|
|
"taux_combles": taux_combles,
|
|
"gap_moyen": gap_moyen,
|
|
"plus_gros_gap": plus_gros_gap,
|
|
"derniers": derniers,
|
|
}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# 8) RSI
|
|
# ---------------------------------------------------------------------------
|
|
def calcul_rsi(df, period=14):
|
|
"""RSI (Relative Strength Index) — méthode de Wilder."""
|
|
close = df["price"]
|
|
delta = close.diff()
|
|
gain = delta.clip(lower=0)
|
|
loss = -delta.clip(upper=0)
|
|
|
|
# Moyenne mobile exponentielle (méthode Wilder = équivalent ewm alpha=1/period)
|
|
avg_gain = gain.ewm(alpha=1 / period, adjust=False).mean()
|
|
avg_loss = loss.ewm(alpha=1 / period, adjust=False).mean()
|
|
|
|
rs = avg_gain / avg_loss
|
|
rsi = 100 - (100 / (1 + rs))
|
|
|
|
val = _safe_last(rsi)
|
|
if val is None:
|
|
return {"valeur": None, "zone": "N/A"}
|
|
|
|
if val < 30:
|
|
zone = "survente"
|
|
elif val > 70:
|
|
zone = "surachat"
|
|
else:
|
|
zone = "neutre"
|
|
|
|
return {"valeur": _round(val), "zone": zone}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# 9) MACD
|
|
# ---------------------------------------------------------------------------
|
|
def calcul_macd(df):
|
|
"""MACD (EMA12 - EMA26), Signal (EMA9 du MACD), Histogramme."""
|
|
close = df["price"]
|
|
ema12 = close.ewm(span=12, adjust=False).mean()
|
|
ema26 = close.ewm(span=26, adjust=False).mean()
|
|
macd_line = ema12 - ema26
|
|
signal_line = macd_line.ewm(span=9, adjust=False).mean()
|
|
histogramme = macd_line - signal_line
|
|
|
|
macd_val = _safe_last(macd_line)
|
|
signal_val = _safe_last(signal_line)
|
|
hist_val = _safe_last(histogramme)
|
|
|
|
# Détection de croisement (sur les 2 dernières valeurs valides)
|
|
croisement = "neutre"
|
|
if len(macd_line) >= 2 and macd_val is not None:
|
|
prev_macd = macd_line.iloc[-2]
|
|
prev_signal = signal_line.iloc[-2]
|
|
if prev_macd is not None and prev_signal is not None:
|
|
if prev_macd <= prev_signal and macd_val > signal_val:
|
|
croisement = "haussier"
|
|
elif prev_macd >= prev_signal and macd_val < signal_val:
|
|
croisement = "baissier"
|
|
|
|
return {
|
|
"macd": _round(macd_val),
|
|
"signal": _round(signal_val),
|
|
"histogramme": _round(hist_val),
|
|
"croisement": croisement,
|
|
}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# 10) Bandes de Bollinger
|
|
# ---------------------------------------------------------------------------
|
|
def calcul_bollinger(df, window=20, nb_std=2):
|
|
"""Bandes de Bollinger (MM20 ± 2 écarts-types)."""
|
|
close = df["price"]
|
|
sma = close.rolling(window=window).mean()
|
|
std = close.rolling(window=window).std()
|
|
|
|
bande_haute = sma + nb_std * std
|
|
bande_basse = sma - nb_std * std
|
|
|
|
cours = close.iloc[-1]
|
|
bh = _safe_last(bande_haute)
|
|
bb = _safe_last(bande_basse)
|
|
mm = _safe_last(sma)
|
|
|
|
position = None
|
|
if bh is not None and bb is not None and (bh - bb) > 0:
|
|
position = (cours - bb) / (bh - bb) * 100
|
|
position = _round(position)
|
|
|
|
return {
|
|
"bande_haute": _round(bh),
|
|
"bande_basse": _round(bb),
|
|
"mm20": _round(mm),
|
|
"position": position,
|
|
}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# 11) Supports et résistances
|
|
# ---------------------------------------------------------------------------
|
|
def calcul_supports_resistances(df):
|
|
"""Plus hauts et plus bas sur différentes fenêtres."""
|
|
close = df["price"]
|
|
cours_actuel = close.iloc[-1]
|
|
|
|
result = {"plus_haut": {}, "plus_bas": {}, "distances": {}}
|
|
|
|
for p in [20, 50, 100, 250]:
|
|
if len(df) >= p:
|
|
ph = df["hight"].tail(p).max()
|
|
pb = df["low"].tail(p).min()
|
|
result["plus_haut"][f"{p}j"] = _round(ph)
|
|
result["plus_bas"][f"{p}j"] = _round(pb)
|
|
else:
|
|
result["plus_haut"][f"{p}j"] = None
|
|
result["plus_bas"][f"{p}j"] = None
|
|
|
|
# Distances par rapport au plus haut / plus bas annuel (250j)
|
|
ph_250 = result["plus_haut"].get("250j")
|
|
pb_250 = result["plus_bas"].get("250j")
|
|
|
|
if ph_250:
|
|
result["distances"]["plus_haut_annuel"] = _round(
|
|
(cours_actuel / ph_250 - 1) * 100
|
|
)
|
|
if pb_250:
|
|
result["distances"]["plus_bas_annuel"] = _round(
|
|
(cours_actuel / pb_250 - 1) * 100
|
|
)
|
|
|
|
# Support et résistance les plus proches du cours actuel
|
|
tous_plus_bas = [v for v in result["plus_bas"].values() if v is not None and v < cours_actuel]
|
|
tous_plus_haut = [v for v in result["plus_haut"].values() if v is not None and v > cours_actuel]
|
|
|
|
if tous_plus_bas:
|
|
support_proche = max(tous_plus_bas)
|
|
result["support_proche"] = _round(support_proche)
|
|
else:
|
|
result["support_proche"] = None
|
|
|
|
if tous_plus_haut:
|
|
resistance_proche = min(tous_plus_haut)
|
|
result["resistance_proche"] = _round(resistance_proche)
|
|
else:
|
|
result["resistance_proche"] = None
|
|
|
|
return result
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# 12) Analyse du volume
|
|
# ---------------------------------------------------------------------------
|
|
def calcul_volumes(df):
|
|
"""Analyse des volumes : moyennes mobiles et volume relatif."""
|
|
vol = df["vol"].astype(float)
|
|
|
|
vol_moy_20 = vol.rolling(window=20).mean()
|
|
vol_moy_50 = vol.rolling(window=50).mean()
|
|
|
|
vol_actuel = vol.iloc[-1] if len(vol) > 0 else None
|
|
|
|
vm20 = _safe_last(vol_moy_20)
|
|
vm50 = _safe_last(vol_moy_50)
|
|
|
|
vol_relatif = None
|
|
if vol_actuel is not None and vm20 and vm20 > 0:
|
|
vol_relatif = vol_actuel / vm20
|
|
vol_relatif = _round(vol_relatif, 2)
|
|
|
|
volume_exceptionnel = False
|
|
if vol_relatif is not None and vol_relatif >= 2.0:
|
|
volume_exceptionnel = True
|
|
|
|
return {
|
|
"volume_actuel": int(vol_actuel) if vol_actuel is not None else None,
|
|
"moyenne_20j": int(vm20) if vm20 else None,
|
|
"moyenne_50j": int(vm50) if vm50 else None,
|
|
"volume_relatif": vol_relatif,
|
|
"exceptionnel": volume_exceptionnel,
|
|
}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# 13) Drawdown
|
|
# ---------------------------------------------------------------------------
|
|
def calcul_drawdown(df):
|
|
"""Drawdown : écart par rapport au plus haut historique de la période."""
|
|
close = df["price"]
|
|
running_max = close.cummax()
|
|
drawdown = (close / running_max - 1) * 100
|
|
|
|
dd_actuel = _safe_last(drawdown)
|
|
dd_max = drawdown.min()
|
|
|
|
# Durée de récupération : nombre de jours depuis le dernier plus haut
|
|
# avant le point bas le plus récent
|
|
duree_recup = None
|
|
idx_dd_max = drawdown.idxmin()
|
|
if idx_dd_max is not None:
|
|
# On cherche le plus haut précédant le drawdown max
|
|
avant = close.iloc[: idx_dd_max + 1]
|
|
if len(avant) > 0:
|
|
idx_peak = avant.idxmax()
|
|
duree_recup = int(idx_dd_max - idx_peak)
|
|
|
|
return {
|
|
"actuel": _round(dd_actuel),
|
|
"maximum": _round(dd_max),
|
|
"duree_recuperation_jours": duree_recup,
|
|
}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# 14) Analyse des séries (jours consécutifs hausse/baisse)
|
|
# ---------------------------------------------------------------------------
|
|
def calcul_series(df):
|
|
"""Séries de jours hausse/baisse consécutifs + records."""
|
|
close = df["price"]
|
|
ret = close.pct_change()
|
|
|
|
# Direction : 1 = hausse, -1 = baisse, 0 = stable
|
|
direction = np.sign(ret)
|
|
direction.iloc[0] = 0 # 1er jour : pas de référence
|
|
|
|
# Compter les jours consécutifs actuels
|
|
serie_hausse = 0
|
|
serie_baisse = 0
|
|
if len(direction) >= 2:
|
|
derniere = direction.iloc[-1]
|
|
if derniere > 0:
|
|
# Compter en arrière
|
|
for i in range(len(direction) - 1, 0, -1):
|
|
if direction.iloc[i] > 0:
|
|
serie_hausse += 1
|
|
else:
|
|
break
|
|
elif derniere < 0:
|
|
for i in range(len(direction) - 1, 0, -1):
|
|
if direction.iloc[i] < 0:
|
|
serie_baisse += 1
|
|
else:
|
|
break
|
|
|
|
# Plus forte hausse / baisse journalière
|
|
plus_forte_hausse = ret.max() * 100 if len(ret) > 0 else None
|
|
plus_forte_baisse = ret.min() * 100 if len(ret) > 0 else None
|
|
|
|
return {
|
|
"jours_hausse_consecutifs": serie_hausse,
|
|
"jours_baisse_consecutifs": serie_baisse,
|
|
"plus_forte_hausse": _round(plus_forte_hausse),
|
|
"plus_forte_baisse": _round(plus_forte_baisse),
|
|
}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# 15) Chandeliers japonais
|
|
# ---------------------------------------------------------------------------
|
|
def calcul_chandeliers(df):
|
|
"""Détection des patterns de chandeliers japonais sur les derniers jours."""
|
|
open_ = df["open"]
|
|
high = df["hight"]
|
|
low = df["low"]
|
|
close = df["price"]
|
|
|
|
# Corps et ombres
|
|
body = (close - open_).abs()
|
|
range_total = (high - low).replace(0, np.nan)
|
|
lower_shadow = (open_.where(open_ < close, close) - low)
|
|
upper_shadow = (high - open_.where(open_ > close, close))
|
|
|
|
patterns_detectes = []
|
|
|
|
# On analyse les 10 derniers jours
|
|
for i in range(max(1, len(df) - 10), len(df)):
|
|
o, h, l, c = open_.iloc[i], high.iloc[i], low.iloc[i], close.iloc[i]
|
|
b = body.iloc[i]
|
|
r = range_total.iloc[i]
|
|
ls = lower_shadow.iloc[i]
|
|
us = upper_shadow.iloc[i]
|
|
|
|
if r is None or r == 0 or np.isnan(r):
|
|
continue
|
|
|
|
# Doji : corps très petit (< 10% du range)
|
|
if b / r < 0.1:
|
|
patterns_detectes.append({"date": df["date"].iloc[i].strftime("%Y-%m-%d"), "pattern": "Doji"})
|
|
|
|
# Marteau : petit corps en haut, longue ombre basse (> 2x corps)
|
|
elif b > 0 and ls > 2 * b and us < b * 0.5:
|
|
if c > o:
|
|
patterns_detectes.append(
|
|
{"date": df["date"].iloc[i].strftime("%Y-%m-%d"), "pattern": "Marteau"}
|
|
)
|
|
|
|
# Marteau inversé : petit corps en bas, longue ombre haute (> 2x corps)
|
|
elif b > 0 and us > 2 * b and ls < b * 0.5:
|
|
patterns_detectes.append(
|
|
{"date": df["date"].iloc[i].strftime("%Y-%m-%d"), "pattern": "Marteau inversé"}
|
|
if c > o
|
|
else {"date": df["date"].iloc[i].strftime("%Y-%m-%d"), "pattern": "Étoile filante"}
|
|
)
|
|
|
|
# Englobante : besoin de la bougie précédente
|
|
if i > 0:
|
|
prev_o, prev_c = open_.iloc[i - 1], close.iloc[i - 1]
|
|
# Englobante haussière : bougie précédente baissière, actuelle haussière et englobe
|
|
if prev_c < prev_o and c > o and o <= prev_c and c >= prev_o:
|
|
patterns_detectes.append(
|
|
{"date": df["date"].iloc[i].strftime("%Y-%m-%d"), "pattern": "Englobante haussière"}
|
|
)
|
|
# Englobante baissière : bougie précédente haussière, actuelle baissière et englobe
|
|
elif prev_c > prev_o and c < o and o >= prev_c and c <= prev_o:
|
|
patterns_detectes.append(
|
|
{"date": df["date"].iloc[i].strftime("%Y-%m-%d"), "pattern": "Englobante baissière"}
|
|
)
|
|
|
|
# Ne garder que les patterns du dernier jour pour le statut actuel
|
|
derniere_date = df["date"].iloc[-1].strftime("%Y-%m-%d") if len(df) > 0 else ""
|
|
pattern_actuel = [p["pattern"] for p in patterns_detectes if p["date"] == derniere_date]
|
|
|
|
return {
|
|
"pattern_actuel": pattern_actuel[0] if pattern_actuel else "Aucun",
|
|
"derniers_detectes": patterns_detectes[-10:] if len(patterns_detectes) > 10 else patterns_detectes,
|
|
}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# 16) Score global
|
|
# ---------------------------------------------------------------------------
|
|
def calcul_score_global(df, perf, mm, vol, rsi_data, macd_data, dd, volumes):
|
|
"""Score global de 0 à 100 basé sur une combinaison d'indicateurs.
|
|
Retourne (score, tendance, points_positifs, points_negatifs).
|
|
"""
|
|
score = 50 # neutre de base
|
|
positifs = []
|
|
negatifs = []
|
|
|
|
close = df["price"].iloc[-1]
|
|
|
|
# Cours > MM200
|
|
mm200 = mm["sma"].get("MM200")
|
|
if mm200:
|
|
if close > mm200:
|
|
score += 10
|
|
positifs.append("Cours supérieur à MM200")
|
|
else:
|
|
score -= 10
|
|
negatifs.append("Cours sous MM200")
|
|
|
|
# Cours > MM50
|
|
mm50 = mm["sma"].get("MM50")
|
|
if mm50:
|
|
if close > mm50:
|
|
score += 5
|
|
positifs.append("Cours supérieur à MM50")
|
|
else:
|
|
score -= 5
|
|
negatifs.append("Cours sous MM50")
|
|
|
|
# RSI
|
|
rsi_val = rsi_data["valeur"]
|
|
if rsi_val is not None:
|
|
if rsi_val < 30:
|
|
score += 5
|
|
positifs.append(f"RSI en zone survendue ({rsi_val})")
|
|
elif rsi_val > 70:
|
|
score -= 10
|
|
negatifs.append(f"RSI en zone surachat ({rsi_val})")
|
|
elif 40 <= rsi_val <= 60:
|
|
score += 3
|
|
positifs.append("RSI neutre")
|
|
|
|
# MACD
|
|
if macd_data["histogramme"] is not None:
|
|
if macd_data["histogramme"] > 0:
|
|
score += 8
|
|
positifs.append("MACD positif")
|
|
else:
|
|
score -= 8
|
|
negatifs.append("MACD négatif")
|
|
|
|
if macd_data["croisement"] == "haussier":
|
|
score += 5
|
|
positifs.append("Croisement MACD haussier")
|
|
elif macd_data["croisement"] == "baissier":
|
|
score -= 5
|
|
negatifs.append("Croisement MACD baissier")
|
|
|
|
# Volume
|
|
if volumes["volume_relatif"] is not None:
|
|
if volumes["volume_relatif"] > 1.5:
|
|
score += 5
|
|
positifs.append("Volume supérieur à la moyenne")
|
|
elif volumes["volume_relatif"] < 0.5:
|
|
score -= 3
|
|
negatifs.append("Volume faible")
|
|
|
|
# Drawdown
|
|
if dd["actuel"] is not None:
|
|
if dd["actuel"] < -20:
|
|
score -= 10
|
|
negatifs.append(f"Drawdown important ({dd['actuel']}%)")
|
|
elif dd["actuel"] > -5:
|
|
score += 5
|
|
positifs.append("Drawdown modéré")
|
|
|
|
# Volatilité
|
|
if vol["actuelle"] is not None and vol["moyenne_1an"] is not None:
|
|
if vol["actuelle"] > vol["moyenne_1an"] * 1.5:
|
|
score -= 5
|
|
negatifs.append("Volatilité excessive")
|
|
elif vol["actuelle"] < vol["moyenne_1an"] * 0.8:
|
|
score += 3
|
|
positifs.append("Volatilité contained")
|
|
|
|
# Performance 20j
|
|
perf_20 = perf["fenetres"].get("20j")
|
|
if perf_20 is not None:
|
|
if perf_20 > 5:
|
|
score += 5
|
|
positifs.append("Performance 20j positive")
|
|
elif perf_20 < -5:
|
|
score -= 5
|
|
negatifs.append("Performance 20j négative")
|
|
|
|
# Bornage 0-100
|
|
score = max(0, min(100, score))
|
|
|
|
# Tendance
|
|
if score >= 65:
|
|
tendance = "haussiere"
|
|
elif score <= 35:
|
|
tendance = "baissiere"
|
|
else:
|
|
tendance = "neutre"
|
|
|
|
return {
|
|
"score": score,
|
|
"tendance": tendance,
|
|
"points_positifs": positifs,
|
|
"points_negatifs": negatifs,
|
|
}
|