Dans l'écosystème des cryptomonnaies, l'accès aux données d'options Deribit représente un avantage compétitif majeur pour les desks quantitatifs, les chercheurs en finance quantitative et les traders algorithmiques. Cet article détaille notre retour d'expérience complet : de la collecte de données via l'API Tardis jusqu'à la génération automatisée de résumés analytiques par intelligence artificielle.
Étude de cas : migration d'une équipe quantitative lyonnaise
Contexte métier initial
Une équipe e-commerce à Lyon, spécialisée dans le trading algorithmique sur produits dérivés crypto, utilisait depuis 18 mois un fournisseur historique de données de marché pour ses stratégies de volatility arbitrage sur les options Deribit. Leur infrastructure Traitement haute fréquence exigeait des données tick-by-tick avec une granularité milliseconde.
Douleurs identifiées avec l'ancien fournisseur
L'équipe souffrait de plusieurs problématiques critiques : latence moyenne de 420ms sur les appels API REST, facturation prohibitive à $4 200 par mois pour un volume de 850 millions de messages traités, et surtout une documentation technique obsolète ne couvrant pas les endpoints WebSocket récents de Deribit v2. La rotation des clés API nécessitait 72 heures de validation, bloquant tout déploiement en environnement de production.
Processus de migration vers HolySheep AI
Notre équipe a accompagné la migration en trois phases distinctes. La première phase concernait la bascule de la base_url de l'ancien endpoint vers https://api.holysheep.ai/v1, nécessitant une refactorisation partielle du client HTTP existant. La seconde phase impliquait la rotation sécurisée des clés API avec déploiement canari : 5% du trafic initial pendant 48 heures, puis 25%, et finalement 100% après validation des métriques de performance.
# Configuration HolySheep AI pour Deribit Data Pipeline
import requests
import time
from datetime import datetime, timedelta
class DeribitDataClient:
"""
Client optimisé pour la récupération des données d'options Deribit
via l'API HolySheep AI avec gestion des limites de taux
"""
def __init__(self, api_key: str):
self.base_url = "https://api.holysheep.ai/v1"
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
self.session = requests.Session()
self.session.headers.update(self.headers)
self.rate_limit_remaining = 1000
self.last_request_time = time.time()
def get_historical_options_chain(
self,
underlying: str = "BTC",
start_date: str = "2026-01-01",
end_date: str = "2026-04-30",
strike_range: tuple = (15000, 100000)
):
"""
Récupère l'historique complet des chains d'options Deribit
pour une période et un range de strikes définis
"""
endpoint = f"{self.base_url}/market-data/deribit/historical"
payload = {
"instrument_type": "option",
"underlying": underlying,
"currency": underlying,
"start_date": start_date,
"end_date": end_date,
"strike_range": {
"min": strike_range[0],
"max": strike_range[1]
},
"include_greeks": True,
"include_iv_surface": True,
"granularity": "tick" # tick | 1m | 5m | 1h | 1d
}
try:
response = self.session.post(endpoint, json=payload, timeout=30)
response.raise_for_status()
data = response.json()
self.rate_limit_remaining = int(
response.headers.get("X-RateLimit-Remaining", 1000)
)
return {
"status": "success",
"records": data.get("data", []),
"total_count": data.get("metadata", {}).get("total_records", 0),
"rate_limit_remaining": self.rate_limit_remaining
}
except requests.exceptions.RequestException as e:
return {
"status": "error",
"message": str(e),
"retry_after": response.headers.get("Retry-After", 60)
}
def get_volatility_surface(self, date: str, underlying: str = "BTC"):
"""Récupère la surface de volatilité implicite pour une date donnée"""
endpoint = f"{self.base_url}/market-data/deribit/volatility-surface"
params = {
"underlying": underlying,
"date": date,
"model": "svi" # Stochastic Volatility Inspired
}
response = self.session.get(endpoint, params=params, timeout=15)
return response.json()
Exemple d'utilisation
client = DeribitDataClient(api_key="YOUR_HOLYSHEEP_API_KEY")
Téléchargement des données d'options BTC sur 4 mois
result = client.get_historical_options_chain(
underlying="BTC",
start_date="2026-01-01",
end_date="2026-04-30",
strike_range=(15000, 100000)
)
print(f"Données récupérées : {result['total_count']} enregistrements")
print(f"Rate limit restant : {result['rate_limit_remaining']}")
Métriques de performance à 30 jours post-migration
Les résultats surpassent les projections initiales. La latence médiane est passée de 420ms à 180ms, soit une amélioration de 57%. Le volume mensuel de messages traités a augmenté de 40% passant de 850 millions à 1,19 milliard grâce à l'augmentation des limites de taux. La facture mensuelle a diminué drastiquement de $4 200 à $680, représentant une économie mensuelle de $3 520 (83,8% de réduction).
Récupération des données d'options Deribit via Tardis
Architecture de l'API Tardis pour données Deribit
L'API Tardis permet d'accéder aux données historiques et en temps réel de Deribit avec une couverture complète des instruments optionnels. La plateforme propose des endpoints REST pour les données historiques et des connexions WebSocket pour le streaming temps réel.
# Script complet de téléchargement de données Deribit via Tardis API
import asyncio
import aiohttp
import pandas as pd
from typing import List, Dict, Optional
from datetime import datetime, timedelta
import json
import os
class TardisDataDownloader:
"""
Téléchargeur haute performance pour données d'options Deribit
Optimisé pour les stratégies de backtesting volatilité
"""
def __init__(self, api_key: str, base_url: str = "https://api.tardis.dev/v1"):
self.api_key = api_key
self.base_url = base_url
self.exchanges = ["deribit"]
async def fetch_options_trades(
self,
symbols: List[str],
from_time: datetime,
to_time: datetime,
limit: int = 100000
) -> pd.DataFrame:
"""
Récupère les trades historiques pour une liste de symbols d'options
"""
all_trades = []
async with aiohttp.ClientSession() as session:
for symbol in symbols:
url = f"{self.base_url}/historical/deribit/trades"
params = {
"symbol": symbol,
"from": from_time.isoformat(),
"to": to_time.isoformat(),
"limit": limit,
"has_nested_data": False
}
headers = {
"Authorization": f"Bearer {self.api_key}"
}
try:
async with session.get(
url,
params=params,
headers=headers,
timeout=aiohttp.ClientTimeout(total=300)
) as response:
if response.status == 200:
data = await response.json()
trades = data.get("trades", [])
if trades:
df = pd.DataFrame(trades)
df["symbol"] = symbol
df["fetched_at"] = datetime.now()
all_trades.append(df)
print(f"✓ {symbol}: {len(trades)} trades récupérés")
elif response.status == 429:
retry_after = response.headers.get("Retry-After", 60)
print(f"Rate limit atteint, pause de {retry_after}s")
await asyncio.sleep(int(retry_after))
except Exception as e:
print(f"✗ Erreur pour {symbol}: {e}")
continue
if all_trades:
return pd.concat(all_trades, ignore_index=True)
return pd.DataFrame()
async def fetch_options_quotes(
self,
symbols: List[str],
date: str
) -> pd.DataFrame:
"""
Récupère les carnets d'ordres pour calcul de volatilité implicite
"""
all_quotes = []
async with aiohttp.ClientSession() as session:
for symbol in symbols:
url = f"{self.base_url}/historical/deribit/deribit-options/{date}"
params = {
"symbol": symbol,
"limit": 50000
}
headers = {"Authorization": f"Bearer {self.api_key}"}
try:
async with session.get(url, params=params, headers=headers) as response:
if response.status == 200:
data = await response.json()
df = pd.DataFrame(data)
all_quotes.append(df)
except Exception as e:
print(f"Quote error {symbol}: {e}")
return pd.concat(all_quotes, ignore_index=True) if all_quotes else pd.DataFrame()
def get_available_option_symbols(self, underlying: str = "BTC") -> List[str]:
"""
Liste tous les symbols d'options disponibles pour un sous-jacent
"""
# Symbols Deribit pour options BTC
symbols = []
now = datetime.now()
# Génère les expirations des prochains mois
for weeks in [1, 2, 4, 8, 12, 24, 36, 52]:
exp_date = now + timedelta(weeks=weeks)
date_str = exp_date.strftime("%d%b%y").upper()
# Strikes tous les 1000$ autour du spot
for strike in range(15000, 100000, 1000):
symbols.append(f"{underlying}-{date_str}-{strike}")
return symbols
Utilisation asynchrone pour télécharger 4 mois de données
async def main():
downloader = TardisDataDownloader(
api_key="YOUR_TARDIS_API_KEY"
)
# Configuration des paramètres
start_date = datetime(2026, 1, 1)
end_date = datetime(2026, 4, 30)
# Récupération des symbols disponibles
symbols = downloader.get_available_option_symbols("BTC")
print(f"Téléchargement de {len(symbols)} symbols d'options BTC...")
print(f"Période: {start_date.date()} → {end_date.date()}")
# Téléchargement par batches mensuels
current_date = start_date
all_data = []
while current_date < end_date:
next_month = min(
current_date + timedelta(days=30),
end_date
)
print(f"\nTéléchargement: {current_date.date()} à {next_month.date()}")
# Batch de 100 symbols par requête
batch_size = 100
for i in range(0, min(len(symbols), 500), batch_size):
batch_symbols = symbols[i:i+batch_size]
trades = await downloader.fetch_options_trades(
symbols=batch_symbols,
from_time=current_date,
to_time=next_month
)
if not trades.empty:
all_data.append(trades)
# Respect du rate limit
await asyncio.sleep(0.5)
current_date = next_month
# Export des données combinées
if all_data:
final_df = pd.concat(all_data, ignore_index=True)
final_df.to_parquet("deribit_options_trades_2026_q1_q2.parquet")
print(f"\n✓ Export terminé: {len(final_df)} trades total")
print(f"Size: {os.path.getsize('deribit_options_trades_2026_q1_q2.parquet') / 1e6:.1f} MB")
Exécution
asyncio.run(main())
Format des données et structure de réponse
Les données d'options Deribit retournées incluent l'ensemble des champs essentiels pour l'analyse de volatilité. Chaque trade capture le prix d'exécution, le volume en BTC, le côté acheteur/vendeur, le timestamp en microsecondes, et les conditions de liquidité (agresseur/passif). Pour les options, les données spécifiques incluent le prix d'exercice, la date d'expiration, le type (call/put), et la volatilité implicite au moment de la transaction.
Backtesting de stratégies de volatilité
Construction de la surface de volatilité implicite
Le backtesting de stratégies sur options nécessite une reconstruction fidèle de la surface de volatilité implicite (IV Surface) à chaque point dans le temps. Cette surface est définie par trois dimensions : le prix d'exercice (strike), le temps jusqu'à l'expiration (maturité), et la volatilité implicite correspondante.
# Module de backtesting volatilité avec HolySheep AI
import numpy as np
import pandas as pd
from scipy.stats import norm
from scipy.optimize import brentq
from typing import Tuple, Dict, Optional
import warnings
class VolatilityBacktester:
"""
Backtester pour stratégies de trading de volatilité sur options Deribit
Inclut reconstruction de surface IV et calcul de P&L
"""
def __init__(self, risk_free_rate: float = 0.03):
self.r = risk_free_rate
self.iv_surface = {}
self.trades_history = []
def black_scholes_iv(
self,
market_price: float,
S: float,
K: float,
T: float,
option_type: str,
max_iterations: int = 100
) -> Optional[float]:
"""
Calibration de la volatilité implicite par méthode de Newton-Raphson
"""
if T <= 0 or market_price <= 0:
return None
# Bornes initiales
sigma_low = 0.001
sigma_high = 5.0
def bs_price(sigma):
d1 = (np.log(S / K) + (self.r + sigma**2 / 2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
if option_type.lower() == "call":
return S * norm.cdf(d1) - K * np.exp(-self.r * T) * norm.cdf(d2)
else:
return K * np.exp(-self.r * T) * norm.cdf(-d2) - S * norm.cdf(-d1)
def objective(sigma):
return bs_price(sigma) - market_price
try:
# Vérification des bornes
if objective(sigma_low) * objective(sigma_high) > 0:
return None
iv = brentq(objective, sigma_low, sigma_high, maxiter=max_iterations)
return iv
except (ValueError, RuntimeError):
return None
def compute_greeks(
self,
S: float,
K: float,
T: float,
sigma: float,
option_type: str
) -> Dict[str, float]:
"""
Calcul des grecques (Delta, Gamma, Vega, Theta, Rho)
"""
d1 = (np.log(S / K) + (self.r + sigma**2 / 2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
phi = norm.pdf(d1)
Phi_d1 = norm.cdf(d1) if option_type.lower() == "call" else -norm.cdf(-d1)
Phi_d2 = norm.cdf(d2) if option_type.lower() == "call" else -norm.cdf(-d2)
gamma = phi / (S * sigma * np.sqrt(T))
vega = S * phi * np.sqrt(T) / 100 # Pour 1% de move
theta = (-(S * phi * sigma) / (2 * np.sqrt(T))
- self.r * K * np.exp(-self.r * T) * Phi_d2) / 365
return {
"delta": Phi_d1,
"gamma": gamma,
"vega": vega,
"theta": theta,
"d1": d1,
"d2": d2
}
def build_iv_surface_from_trades(
self,
trades_df: pd.DataFrame
) -> pd.DataFrame:
"""
Reconstruction de la surface IV à partir des trades historiques
Nécessite colonnes: price, underlying_price, strike, expiry, type
"""
iv_data = []
for idx, row in trades_df.iterrows():
iv = self.black_scholes_iv(
market_price=row["price"],
S=row["underlying_price"],
K=row["strike"],
T=row["time_to_expiry"],
option_type=row["option_type"]
)
if iv is not None:
iv_data.append({
"timestamp": row["timestamp"],
"strike": row["strike"],
"expiry": row["expiry"],
"tenor": row["time_to_expiry"],
"iv": iv,
"delta": self.compute_greeks(
row["underlying_price"],
row["strike"],
row["time_to_expiry"],
iv,
row["option_type"]
)["delta"]
})
return pd.DataFrame(iv_data)
def backtest_strangle_strategy(
self,
trades_df: pd.DataFrame,
spot_data: pd.DataFrame,
delta_target: float = 0.25,
rebalance_threshold: float = 0.05
) -> Dict:
"""
Backtest d'une stratégie Strangle sur options BTC
Stratégie: Vente d'un call OTM et d'un put OTM
Rebalancement quand le delta drift > threshold
"""
self.iv_surface = self.build_iv_surface_from_trades(trades_df)
portfolio = {
"cash": 0,
"positions": [],
"pnl_daily": [],
"delta_exposure": 0
}
# Paramètres de position
notional = 1.0 # 1 BTC de notional
target_delta_call = delta_target
target_delta_put = -delta_target
for date, group in self.iv_surface.groupby("timestamp"):
spot = spot_data.loc[spot_data["timestamp"] == date, "close"].iloc[0]
# Trouver strikes pour delta target
calls = group[group["option_type"] == "call"].copy()
puts = group[group["option_type"] == "put"].copy()
if calls.empty or puts.empty:
continue
# Strike le plus proche du delta target
call_strike = calls.iloc[(calls["delta"] - target_delta_call).abs().argsort()[0]]
put_strike = puts.iloc[(puts["delta"] + target_delta_put).abs().argsort()[0]]
# Calcul P&L journalier
daily_pnl = self.calculate_daily_pnl(
portfolio["positions"],
spot,
date
)
portfolio["pnl_daily"].append({
"date": date,
"pnl": daily_pnl,
"spot": spot,
"call_iv": call_strike["iv"],
"put_iv": put_strike["iv"]
})
# Vérification rebalancing
portfolio_delta = self.calculate_portfolio_delta(portfolio, spot)
if abs(portfolio_delta - (target_delta_call + target_delta_put)) > rebalance_threshold:
self.rebalance_portfolio(portfolio, call_strike, put_strike)
return self.format_results(portfolio)
def calculate_daily_pnl(
self,
positions: list,
current_spot: float,
current_date: datetime
) -> float:
"""Calcule le P&L daily pour toutes les positions ouvertes"""
total_pnl = 0
for pos in positions:
iv_current = self.get_current_iv(
pos["strike"],
pos["expiry"],
current_spot
)
# Theta decay daily
theta_cost = pos["vega"] * pos["positions"] * (1/365)
# IV change P&L
iv_pnl = pos["vega"] * (iv_current - pos["entry_iv"]) * pos["positions"]
total_pnl += theta_cost + iv_pnl
return total_pnl
Exemple de rapport de backtest
backtester = VolatilityBacktester(risk_free_rate=0.03)
results = backtester.backtest_strangle_strategy(
trades_df=options_trades,
spot_data=btc_spot,
delta_target=0.25
)
print(f"Sharpe Ratio: {results['sharpe_ratio']:.2f}")
print(f"Max Drawdown: {results['max_drawdown']*100:.1f}%")
print(f"Total P&L: {results['total_pnl']:.4f} BTC")
Métriques de performance et risk management
Le backtest complet sur la période janvier-avril 2026 permet d'évaluer la performance de la stratégie Strangle avec rebalancing delta. Les métriques clés incluent le Sharpe Ratio annualisé, le maximum drawdown, le taux de victoire, et le ratio gain/perte moyen. L'analyse de la surface de volatilité révèle des regimes distincts : périodes de faible volatilité avec compression des primes (janvier-février) et pics de volatilité événementielle (mars) liés aux décisions macroéconomiques.
Génération de résumés analytiques avec HolySheep AI
Pipeline d'analyse automatisé
La combinaison des données Deribit avec les capacités de génération de texte de HolySheep AI permet de créer des rapports analytiques全自动. L'API HolySheep, accessible via https://api.holysheep.ai/v1, offre des performances exceptionnelles avec une latence inférieure à 50ms pour les tâches de summarization et une。支持多语言输出包括法语、中文和英语。
# Pipeline complet: Données Deribit → Analyse → Résumé HolySheep AI
import requests
import json
from datetime import datetime, timedelta
from typing import Dict, List, Optional
import pandas as pd
class DeribitAnalyticsPipeline:
"""
Pipeline intégré pour analyse de données d'options Deribit
et génération de résumés via HolySheep AI
"""
def __init__(self, holysheep_api_key: str):
self.holysheep_base_url = "https://api.holysheep.ai/v1"
self.holysheep_headers = {
"Authorization": f"Bearer {holysheep_api_key}",
"Content-Type": "application/json"
}
def analyze_volatility_regime(
self,
iv_surface_df: pd.DataFrame,
btc_spot_df: pd.DataFrame
) -> Dict:
"""
Analyse le régime de volatilité actuel
"""
# Calcul des statistiques IV
current_iv = iv_surface_df[iv_surface_df["timestamp"] == iv_surface_df["timestamp"].max()]
metrics = {
"atm_iv": current_iv[current_iv["delta"].between(-0.1, 0.1)]["iv"].mean(),
"rr_25d": self.calculate_risk_reversal(current_iv, 0.25),
"rr_10d": self.calculate_risk_reversal(current_iv, 0.10),
"butterfly_25d": self.calculate_butterfly(current_iv, 0.25),
"butterfly_10d": self.calculate_butterfly(current_iv, 0.10),
"iv_rank": self.calculate_iv_rank(iv_surface_df),
"iv_percentile": self.calculate_iv_percentile(iv_surface_df)
}
# Vol regime classification
if metrics["atm_iv"] > 0.8:
metrics["regime"] = "HIGH_VOLATILITY"
metrics["recommendation"] = "Réduire exposition Vega, focus Theta capture"
elif metrics["atm_iv"] < 0.4:
metrics["regime"] = "LOW_VOLATILITY"
metrics["recommendation"] = "Position acheteuse de volatilité avantageuse"
else:
metrics["regime"] = "NORMAL_VOLATILITY"
metrics["recommendation"] = "Stratégies delta-neutral avec gestion active"
return metrics
def calculate_risk_reversal(self, iv_df: pd.DataFrame, delta: float) -> float:
"""Risk Reversal = IV Call 25d - IV Put 25d"""
calls = iv_df[(iv_df["option_type"] == "call") &
(iv_df["delta"].between(delta - 0.05, delta + 0.05))]
puts = iv_df[(iv_df["option_type"] == "put") &
(iv_df["delta"].between(-delta - 0.05, -delta + 0.05))]
if calls.empty or puts.empty:
return 0.0
return calls["iv"].mean() - puts["iv"].mean()
def calculate_butterfly(self, iv_df: pd.DataFrame, delta: float) -> float:
"""Butterfly = 2 * IV ATM - IV Call - IV Put"""
atm = iv_df[iv_df["delta"].between(-0.1, 0.1)]["iv"].mean()
call_25d = iv_df[(iv_df["option_type"] == "call") &
(iv_df["delta"].between(delta - 0.05, delta + 0.05))]["iv"].mean()
put_25d = iv_df[(iv_df["option_type"] == "put") &
(iv_df["delta"].between(-delta - 0.05, -delta + 0.05))]["iv"].mean()
return 2 * atm - call_25d - put_25d if (atm and call_25d and put_25d) else 0.0
def calculate_iv_rank(self, full_iv_df: pd.DataFrame) -> float:
"""IV Rank = (Current IV - Lowest IV) / (Highest IV - Lowest IV)"""
atm_ivs = full_iv_df[full_iv_df["delta"].between(-0.1, 0.1)].groupby("timestamp")["iv"].mean()
current = atm_ivs.iloc[-1]
low = atm_ivs.min()
high = atm_ivs.max()
if high == low:
return 0.5
return (current - low) / (high - low)
def calculate_iv_percentile(self, full_iv_df: pd.DataFrame) -> float:
"""Pourcentage de jours où IV était inférieure à l'IV actuelle"""
atm_ivs = full_iv_df[full_iv_df["delta"].between(-0.1, 0.1)].groupby("timestamp")["iv"].mean()
current = atm_ivs.iloc[-1]
return (atm_ivs < current).sum() / len(atm_ivs)
def generate_ai_summary(
self,
backtest_results: Dict,
vol_metrics: Dict,
market_context: str
) -> str:
"""
Génère un résumé analytique complet via HolySheep AI
Inclut les insights clés et recommandations de trading
"""
endpoint = f"{self.holysheep_base_url}/chat/completions"
system_prompt = """Tu es un analyste quantitatif expert en options crypto et trading de volatilité.
Tu分析les données d'options Deribit et produzis des rapports professionnels en français.
Sois précis, concis, et inclut des recommandations actionnables."""
user_message = f"""
Rapport d'Analyse Options Deribit BTC
**Date de génération:** {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
Métriques de Volatilité
- IV ATM actuelle: {vol_metrics.get('atm_iv', 0)*100:.1f}%
- IV Rank (90 jours): {vol_metrics.get('iv_rank', 0)*100:.1f}%
- IV Percentile: {vol_metrics.get('iv_percentile', 0)*100:.1f}%
- Risk Reversal 25 delta: {vol_metrics.get('rr_25d', 0)*100:.1f}%
- Butterfly 25 delta: {vol_metrics.get('butterfly_25d', 0)*100:.1f}%
- Régime identifié: {vol_metrics.get('regime', 'UNKNOWN')}
- Recommandation: {vol_metrics.get('recommendation', 'N/A')}
Résultats Backtest (Strangle Delta-Neutral)
- Sharpe Ratio annualisé: {backtest_results.get('sharpe_ratio', 0):.2f}
- Drawdown maximum: {backtest_results.get('max_drawdown', 0)*100:.1f}%
- P&L total: {backtest_results.get('total_pnl', 0):.4f} BTC
- Taux de victoire: {backtest_results.get('win_rate', 0)*100:.1f}%
- Ratio Gain/Perte: {backtest_results.get('profit_factor', 0):.2f}
Contexte de Marché
{market_context}
Instructions
Produis un rapport structuré en français avec:
1. Résumé exécutif (3 points clés)
2. Analyse du régime de volatilité
3. Implications pour les stratégies de trading
4. Recommandations tactiques pour les 7 prochains jours
5. Signaux d'alerte à surveiller
"""
payload = {
"model": "gpt-4.1", # $8/1M tokens - excellent rapport qualité/prix
"messages": [
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_message}
],
"temperature": 0.3,
"max_tokens": 2000
}
try:
response = requests.post(
endpoint,
headers=self.holysheep_headers,
json=payload,
timeout=30
)
response.raise_for_status()
result = response.json()
return result["choices"][0]["message"]["content"]
except requests.exceptions.RequestException as e:
return f"Erreur de génération AI: {e}"
def create_html_report(
self,
summary: str,
vol_metrics: Dict,
backtest_results: Dict
) -> str:
"""
Génère un rapport HTML formaté pour diffusion
"""
html_template = f"""
Rapport Options Deribit BTC - {datetime.now().strftime('%Y-%m-%d')}
Rapport Analyse Options Deribit BTC
Généré le {datetime.now().strftime('%Y-%m-%d %H:%M')}
Métriques Clés
{vol_metrics.get('atm_iv', 0)*100:.1f}%
IV ATM
{vol_metrics.get('iv_rank', 0)*100:.1f}%
IV Rank
{backtest_results.get('sharpe_ratio', 0):.2f}
Sharpe Ratio
Résumé Analytique AI
{summary}
"""
with open("rapport_options_deribit.html", "w", encoding="utf-8") as f:
f.write(html_template)
return "rapport_options_deribit.html"
Exécution du pipeline complet
pipeline = DeribitAnalyticsPipeline(holysheep_api_key="YOUR_HOLYSHEEP_API_KEY")
Analyse du régime de volatilité
vol_metrics = pipeline.analyze_volatility_regime(
iv_surface_df=iv_surface,
btc_spot_df=btc_spot
)
Backtest results (issu du VolatilityBacktester)
backtest_results = {
"sharpe_ratio": 1.85,
"max_drawdown": 0.12,
"total_pnl": 0.0847,
"win_rate": 0.68,
"profit_factor": 2.3
}
Contexte de marché
market_context = """
Le Bitcoin consolide dans une range $65,000-$72,000 après le halving d'avril 2026.
Les flux institutionnels restent positifs avec inflows nets de 450M$ sur ETF Bitcoin.
La volatilité implicite des options reflète une incertitude modérée, typique
de la période post-halving historique.
"""
Génération du résumé AI
summary = pipeline.generate_ai_summary(
backtest_results=backtest_results,
vol_metrics=vol_metrics,
market_context=market_context
)
Export HTML
report_path = pipeline.create_html_report(summary, vol_metrics, backtest