jfgiraud/BoursePython
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
a25043dc3f1e84ee528dd79de2ab57e797265e84
BoursePython/app/services/indicators.py
T

690 lines
23 KiB
Python
Raw Normal View History

Projet terminé V1.0
2026-08-03 21:09:33 +02:00
"""
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,
}
Reference in New Issue Copy Permalink