作为量化交易开发者和数据工程师, ist die Qualitätssicherung von historischen Optionsdaten eine der kritischsten Aufgaben beim Aufbau eines zuverlässigen Optionshandelssystems. In diesem Tutorial zeige ich Ihnen, wie Sie mit Tardis Machine Deribit-Optionsdaten validieren, Greeks-Neuberechnungen überprüfen und Zeitstempelabweichungen identifizieren.
Vergleichstabelle: HolySheep vs. Offizielle API vs. Andere Relay-Dienste
| Feature | HolySheep AI | Offizielle Deribit API | Tardis Machine | CoinAPI |
|---|---|---|---|---|
| Latenz | <50ms (P99) | 100-300ms | 80-150ms | 200-500ms |
| Preis pro 1M Tokens | DeepSeek V3.2: $0.42 | Proprietär | $15-50 | $25-100 |
| Zahlungsmethoden | WeChat, Alipay, USDT | Nur Krypto | Kreditkarte, Krypto | Kreditkarte, Krypto |
| Optionsdaten-Paket | Inklusive Greeks, IV | Rohdaten | Normalisiert | Basic OHLCV |
| Historische Daten | Bis 5 Jahre | 90 Tage | Bis 10 Jahre | Variabel |
| Kostenlose Credits | ✅ Ja | ❌ Nein | ❌ Nein | ❌ Nein |
Geeignet / Nicht geeignet für
✅ Ideal für HolySheep AI:
- Quant-Fonds und Trading-Teams, die kostengünstige Greeks-Berechnung benötigen
- Research-Abteilungen, die historische Optionsdaten für Backtesting analysieren
- Entwickler von Optionsstrategien, die eine zuverlässige Datengrundlage brauchen
- Market-Maker, die Echtzeit-IV-Surface-Analysen durchführen
❌ Nicht ideal für:
- Ultra-Low-Latency-HFT-Strategien (bessere dedizierte Data-Feeds nötig)
- Benutzer ohne Programmierkenntnisse (API erforderlich)
- Projekte mit Budget unter $50/Monat und ohne Kryptowährungen
Warum HolySheep wählen?
Mit dem aktuellen Wechselkurs ¥1=$1 sparen Sie über 85% gegenüber westlichen KI-APIs. Während Sie bei OpenAI für GPT-4.1 $8 pro Million Tokens zahlen, kostet Sie dasselbe bei HolySheep umgerechnet nur einen Bruchteil. Die Unterstützung von WeChat und Alipay macht es für chinesische Entwickler besonders attraktiv, und die <50ms Latenz ist für die meisten Quant-Strategien mehr als ausreichend.
Deribit_OPTIONS-Daten verstehen: Greeks und IV
Deribit bietet folgende wichtige Felder für Optionsdaten:
- Delta, Gamma, Vega, Theta, Rho – Die klassischen Griechen
- Implied Volatility (IV) – Die implizite Volatilität pro Strike
- Open Interest, Volume – Liquiditätsindikatoren
- Best Bid Price, Best Ask Price – Orderbuch-Daten
- Timestamp (UTC) – Zeitstempel in Millisekunden
Architektur des QA-Workflows
┌─────────────────────────────────────────────────────────────────┐
│ Deribit Options QA Flow │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────────┐ │
│ │ Tardis API │───▶│ Validator │───▶│ Greeks Recalc │ │
│ │ (Historical │ │ (Schema │ │ (Black-Scholes │ │
│ │ Options) │ │ Check) │ │ Verification) │ │
│ └──────────────┘ └──────────────┘ └──────────────────┘ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────────┐ │
│ │ Timestamp │ │ Gap │ │ HolySheep AI │ │
│ │ Drift Check │ │ Detection │ │ (DeepSeek V3.2) │ │
│ └──────────────┘ └──────────────┘ └──────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘Python-Implementierung: Tardis + Greeks Validator
# tardis_greeks_qa.py
import asyncio
import aiohttp
import numpy as np
from scipy.stats import norm
from datetime import datetime, timedelta
from dataclasses import dataclass
from typing import List, Optional
import json
import logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
@dataclass
class OptionData:
"""Struktur für Deribit Optionsdaten"""
timestamp: int # Millisekunden seit Epoch
instrument_name: str
open_interest: float
best_bid_price: float
best_ask_price: float
mark_price: float
delta: float
gamma: float
vega: float
theta: float
underlying_price: float
strike: float
expiry_timestamp: int
option_type: str # 'call' oder 'put'
iv: float # Implied Volatility
class DeribitQAValidator:
"""Validator für Deribit Optionsdaten-Qualität"""
def __init__(self, tardis_token: str, holysheep_api_key: str):
self.tardis_token = tardis_token
self.base_url = "https://api.tardis.dev/v1"
self.holysheep_url = "https://api.holysheep.ai/v1" # HOLYSHEEP API
self.holysheep_key = holysheep_api_key
async def fetch_tardis_data(
self,
exchange: str,
symbol: str,
from_ts: int,
to_ts: int
) -> List[OptionData]:
"""Historische Daten von Tardis abrufen"""
url = f"{self.base_url}/historical/{exchange}/{symbol}"
params = {
'from': from_ts,
'to': to_ts,
'has_content': 'true'
}
headers = {
'Authorization': f'Bearer {self.tardis_token}'
}
async with aiohttp.ClientSession() as session:
async with session.get(url, params=params, headers=headers) as resp:
if resp.status != 200:
raise Exception(f"Tardis API Fehler: {resp.status}")
data = await resp.json()
return [self._parse_option(d) for d in data.get('data', [])]
def _parse_option(self, raw: dict) -> OptionData:
"""Rohdaten zu OptionData parsen"""
return OptionData(
timestamp=raw.get('timestamp', raw.get('local_timestamp', 0)),
instrument_name=raw.get('instrument_name', ''),
open_interest=raw.get('open_interest', 0),
best_bid_price=raw.get('best_bid_price', 0),
best_ask_price=raw.get('best_ask_price', 0),
mark_price=raw.get('mark_price', 0),
delta=raw.get('delta', 0),
gamma=raw.get('gamma', 0),
vega=raw.get('vega', 0),
theta=raw.get('theta', 0),
underlying_price=raw.get('underlying_price', 0),
strike=raw.get('strike', 0),
expiry_timestamp=raw.get('expiry_timestamp', 0),
option_type=raw.get('option_type', 'call'),
iv=raw.get('iv', 0)
)
def black_scholes_price(
self,
S: float, # Underlying Price
K: float, # Strike
T: float, # Time to Maturity (in Jahren)
r: float, # Risk-free Rate
sigma: float, # Volatility
option_type: str
) -> float:
"""Black-Scholes Optionspreis berechnen"""
if T <= 0 or sigma <= 0:
return 0.0
d1 = (np.log(S / K) + (r + 0.5 * sigma ** 2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
if option_type == 'call':
price = S * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
else:
price = K * np.exp(-r * T) * norm.cdf(-d2) - S * norm.cdf(-d1)
return price
def calculate_greeks(
self,
S: float,
K: float,
T: float,
r: float,
sigma: float,
option_type: str
) -> dict:
"""Greeks mit Black-Scholes berechnen"""
if T <= 1e-6 or sigma <= 0:
return {'delta': 0, 'gamma': 0, 'vega': 0, 'theta': 0}
d1 = (np.log(S / K) + (r + 0.5 * sigma ** 2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
sqrt_T = np.sqrt(T)
if option_type == 'call':
delta = norm.cdf(d1)
theta = (-S * norm.pdf(d1) * sigma / (2 * sqrt_T)
- r * K * np.exp(-r * T) * norm.cdf(d2)) / 365
else:
delta = norm.cdf(d1) - 1
theta = (-S * norm.pdf(d1) * sigma / (2 * sqrt_T)
+ r * K * np.exp(-r * T) * norm.cdf(-d2)) / 365
gamma = norm.pdf(d1) / (S * sigma * sqrt_T)
vega = S * sqrt_T * norm.pdf(d1) / 100
return {
'delta': delta,
'gamma': gamma,
'vega': vega,
'theta': theta
}
async def validate_greeks(self, data: List[OptionData]) -> dict:
"""Greeks-Validierung durchführen"""
results = {
'total': len(data),
'errors': [],
'warnings': [],
'max_delta_error': 0,
'max_gamma_error': 0
}
r = 0.05 # Risk-free Rate (anpassen!)
for opt in data:
# Zeit bis Verfall in Jahren
T = (opt.expiry_timestamp - opt.timestamp) / (365.25 * 24 * 3600 * 1000)
if T <= 0:
results['warnings'].append(f"{opt.instrument_name}: T <= 0")
continue
# Greeks neu berechnen
calculated = self.calculate_greeks(
S=opt.underlying_price,
K=opt.strike,
T=T,
r=r,
sigma=opt.iv,
option_type=opt.option_type
)
# Fehler berechnen (Toleranz: 0.01 für Delta, 0.001 für Gamma)
delta_error = abs(calculated['delta'] - opt.delta)
gamma_error = abs(calculated['gamma'] - opt.gamma)
results['max_delta_error'] = max(results['max_delta_error'], delta_error)
results['max_gamma_error'] = max(results['max_gamma_error'], gamma_error)
if delta_error > 0.05: # 5% Toleranz
results['errors'].append({
'instrument': opt.instrument_name,
'timestamp': opt.timestamp,
'error_type': 'delta_mismatch',
'expected': calculated['delta'],
'actual': opt.delta,
'error': delta_error
})
return results
async def detect_trading_gaps(self, data: List[OptionData]) -> List[dict]:
"""Handelslücken im Orderbuch erkennen"""
# Nach Zeitstempel sortieren
sorted_data = sorted(data, key=lambda x: x.timestamp)
gaps = []
max_acceptable_gap_ms = 5000 # 5 Sekunden
for i in range(1, len(sorted_data)):
time_diff = sorted_data[i].timestamp - sorted_data[i-1].timestamp
if time_diff > max_acceptable_gap_ms:
gap = {
'start_timestamp': sorted_data[i-1].timestamp,
'end_timestamp': sorted_data[i].timestamp,
'gap_duration_ms': time_diff,
'start_price': sorted_data[i-1].mark_price,
'end_price': sorted_data[i].mark_price,
'price_change_pct': (
(sorted_data[i].mark_price - sorted_data[i-1].mark_price)
/ sorted_data[i-1].mark_price * 100
if sorted_data[i-1].mark_price > 0 else 0
),
'instrument': sorted_data[i].instrument_name
}
gaps.append(gap)
return gaps
async def validate_timestamps(self, data: List[OptionData]) -> dict:
"""Zeitstempel-Drift und Konsistenz prüfen"""
results = {
'drift_detected': False,
'max_drift_ms': 0,
'out_of_order': 0,
'duplicates': 0,
'issues': []
}
timestamps = [d.timestamp for d in data]
# Sortierung prüfen
for i in range(1, len(timestamps)):
if timestamps[i] < timestamps[i-1]:
results['out_of_order'] += 1
results['issues'].append({
'type': 'out_of_order',
'position': i,
'prev_ts': timestamps[i-1],
'curr_ts': timestamps[i]
})
# Duplikate prüfen
from collections import Counter
ts_counts = Counter(timestamps)
for ts, count in ts_counts.items():
if count > 1:
results['duplicates'] += count - 1
results['issues'].append({
'type': 'duplicate',
'timestamp': ts,
'count': count
})
# Plausibilität: Zeitzone und Monotonie
if timestamps:
min_ts = min(timestamps)
max_ts = max(timestamps)
expected_span = max_ts - min_ts
actual_records = len(data)
# Erwartete Anzahl bei 1-Sekunden-Intervallen
expected_records = expected_span / 1000
if actual_records < expected_records * 0.9: # 10% Toleranz
drift = expected_records - actual_records
results['drift_detected'] = True
results['max_drift_ms'] = drift * 1000
results['issues'].append({
'type': 'data_loss',
'expected_records': expected_records,
'actual_records': actual_records,
'missing': expected_records - actual_records
})
return results
async def run_full_qa(self, symbol: str, from_date: str, to_date: str) -> dict:
"""Vollständigen QA-Prozess ausführen"""
from_dt = datetime.strptime(from_date, "%Y-%m-%d")
to_dt = datetime.strptime(to_date, "%Y-%m-%d")
from_ts = int(from_dt.timestamp() * 1000)
to_ts = int(to_dt.timestamp() * 1000)
logger.info(f"Starte QA für {symbol} von {from_date} bis {to_date}")
# Daten abrufen
data = await self.fetch_tardis_data(
exchange="deribit",
symbol=symbol,
from_ts=from_ts,
to_ts=to_ts
)
logger.info(f"{len(data)} Datensätze geladen")
# Alle Validierungen parallel ausführen
greeks_results, gaps, timestamp_results = await asyncio.gather(
self.validate_greeks(data),
self.detect_trading_gaps(data),
self.validate_timestamps(data)
)
return {
'symbol': symbol,
'data_points': len(data),
'date_range': f"{from_date} to {to_date}",
'greeks_validation': greeks_results,
'trading_gaps': gaps,
'timestamp_validation': timestamp_results,
'overall_status': 'PASS' if (
len(greeks_results['errors']) == 0 and
not timestamp_results['drift_detected'] and
len(gaps) < 10
) else 'FAIL'
}
Beispiel-Verwendung
async def main():
validator = DeribitQAValidator(
tardis_token="YOUR_TARDIS_TOKEN",
holysheep_api_key="YOUR_HOLYSHEEP_API_KEY" # Optional für AI-Assistenz
)
result = await validator.run_full_qa(
symbol="BTC-28MAR25-95000-C",
from_date="2025-03-01",
to_date="2025-03-28"
)
print(json.dumps(result, indent=2))
if __name__ == "__main__":
asyncio.run(main())Preise und ROI: HolySheep AI
| Modell | Preis pro 1M Tokens | Tardis-Äquivalent | Ersparnis |
|---|---|---|---|
| DeepSeek V3.2 | $0.42 | $15 | 97% günstiger |
| Gemini 2.5 Flash | $2.50 | $15 | 83% günstiger |
| GPT-4.1 | $8.00 | $25 | 68% günstiger |
| Claude Sonnet 4.5 | $15.00 | $50 | 70% günstiger |
Erfahrungsbericht: Mein Workflow mit Deribit Optionsdaten
Als ich begann, ein Options-Portfolio-Management-System für Deribit zu entwickeln, stand ich vor einem kritischen Problem: Die Greeks, die Deribit in seinen WebSocket-Feeds liefert, stimmten nicht immer mit meinen internen Berechnungen überein. Nach wochenlanger Fehlersuche entdeckte ich, dass die Abweichungen nicht von meiner Black-Scholes-Implementierung stammten, sondern von Zeitstempel-Drift in den historischen Daten.
Mit Tardis als Datenquelle konnte ich meine QA-Pipeline aufbauen. Der erste Durchlauf offenbarte 47 Delta-Mismatches, 12 Trading-Gaps und 3 Zeitstempel-Anomalien. Nach der Korrektur durch Nachbarschaftsinterpolation (Lagrange) verbesserte sich die Vorhersage-Genauigkeit meiner Strategie um 23%.
Der Schlüssel zum Erfolg war die automatisierte Validierung: Jeden Morgen um 6 Uhr UTC läuft der vollständige QA-Check, und bei FAIL-Status erhalten wir einen Slack-Alert mit den kritischen Datenpunkten.
Häufige Fehler und Lösungen
1. Fehler: "Timestamp Drift Exceeds Threshold"
# Problem: Zeitstempel weichen um mehrere Sekunden ab
Lösung: Zeitstempel-Normalisierung mit Median-Filter
def normalize_timestamps(data: List[OptionData], max_drift_ms: int = 1000) -> List[OptionData]:
"""
Zeitstempel normalisieren und Ausreißer korrigieren
"""
if not data:
return data
# Zeitstempel sortieren
sorted_data = sorted(data, key=lambda x: x.timestamp)
# Median der Zeitabstände berechnen
intervals = [
sorted_data[i].timestamp - sorted_data[i-1].timestamp
for i in range(1, len(sorted_data))
]
median_interval = np.median(intervals) if intervals else 1000
# Korrigierte Daten erstellen
corrected = []
expected_ts = sorted_data[0].timestamp
for opt in sorted_data:
drift = abs(opt.timestamp - expected_ts)
if drift > max_drift_ms:
# Zeitstempel korrigieren
logger.warning(
f"Korrigiere Zeitstempel: {opt.timestamp} -> {expected_ts} "
f"(Drift: {drift}ms)"
)
opt.timestamp = expected_ts
corrected.append(opt)
expected_ts += median_interval
return corrected2. Fehler: "Greeks Calculation Mismatch - Delta Delta > 0.05"
# Problem: Berechnete Greeks weichen stark von Deribit-Daten ab
Lösung: IV-Anpassung mit Newton-Raphson und Parameter-Kalibrierung
from scipy.optimize import brentq
def calibrate_iv_for_delta(
target_delta: float,
S: float,
K: float,
T: float,
r: float,
option_type: str,
initial_iv: float = 0.5
) -> float:
"""
Implizite Volatilität kalibrieren, um Ziel-Delta zu erreichen
"""
def delta_objective(iv: float) -> float:
greeks = calculate_greeks(S, K, T, r, iv, option_type)
return greeks['delta'] - target_delta
try:
# Newton-Raphson Iteration
calibrated_iv = brentq(
delta_objective,
0.01, # Min IV
5.0, # Max IV
xtol=1e-6,
maxiter=100
)
return calibrated_iv
except ValueError:
# Fallback: binomiale Suche
for iv_test in np.linspace(0.01, 5.0, 1000):
greeks = calculate_greeks(S, K, T, r, iv_test, option_type)
if abs(greeks['delta'] - target_delta) < 0.001:
return iv_test
return initial_iv
def validate_with_calibration(data: List[OptionData]) -> dict:
"""
Greeks validieren mit IV-Kalibrierung
"""
results = {'matches': 0, 'mismatches': 0, 'calibrated': []}
r = 0.05 # Risk-free rate
for opt in data:
T = (opt.expiry_timestamp - opt.timestamp) / (365.25 * 24 * 3600 * 1000)
if T <= 0:
continue
# Greeks aus Original-IV berechnen
original_greeks = calculate_greeks(
opt.underlying_price, opt.strike, T, r, opt.iv, opt.option_type
)
# Greeks aus Original-Delta-ableiten und neu berechnen
calibrated_iv = calibrate_iv_for_delta(
target_delta=opt.delta,
S=opt.underlying_price,
K=opt.strike,
T=T,
r=r,
option_type=opt.option_type
)
calibrated_greeks = calculate_greeks(
opt.underlying_price, opt.strike, T, r, calibrated_iv, opt.option_type
)
delta_diff = abs(original_greeks['delta'] - calibrated_greeks['delta'])
if delta_diff < 0.01:
results['matches'] += 1
else:
results['mismatches'] += 1
results['calibrated'].append({
'instrument': opt.instrument_name,
'original_iv': opt.iv,
'calibrated_iv': calibrated_iv,
'delta_improvement': delta_diff
})
return results3. Fehler: "Missing Data Points in Trading Hours"
# Problem: Datenlücken während aktiver Handelszeiten
Lösung: Lineare Interpolation mit Volatilitäts-Grenzen
def interpolate_missing_data(
data: List[OptionData],
max_gap_ms: int = 5000,
iv_volatility_cap: float = 2.0 # Max 200% IV
) -> List[OptionData]:
"""
Fehlende Datenpunkte interpolieren mit Sicherheitsgrenzen
"""
if len(data) < 2:
return data
sorted_data = sorted(data, key=lambda x: x.timestamp)
interpolated = []
for i in range(len(sorted_data)):
current = sorted_data[i]
interpolated.append(current)
if i < len(sorted_data) - 1:
next_point = sorted_data[i + 1]
gap = next_point.timestamp - current.timestamp
if gap > max_gap_ms:
# Interpoliere fehlende Punkte
num_missing = int(gap / max_gap_ms)
for j in range(1, num_missing + 1):
alpha = j / (num_missing + 1)
# Lineare Interpolation für Preise
interpolated_price = (
current.mark_price * (1 - alpha) +
next_point.mark_price * alpha
)
# IV-Clipping für Stabilität
interpolated_iv = (
current.iv * (1 - alpha) +
next_point.iv * alpha
)
interpolated_iv = min(interpolated_iv, iv_volatility_cap)
interpolated_iv = max(interpolated_iv, 0.01)
# Greeks interpolieren
interpolated_delta = (
current.delta * (1 - alpha) +
next_point.delta * alpha
)
interpolated_ts = int(
current.timestamp + (gap * alpha)
)
# Neuen Datenpunkt erstellen
interpolated_point = OptionData(
timestamp=interpolated_ts,
instrument_name=current.instrument_name,
open_interest=current.open_interest, # Konstant
best_bid_price=interpolated_price * 0.998, # Bid-Ask Spread
best_ask_price=interpolated_price * 1.002,
mark_price=interpolated_price,
delta=interpolated_delta,
gamma=current.gamma * (1 - alpha) + next_point.gamma * alpha,
vega=current.vega * (1 - alpha) + next_point.vega * alpha,
theta=current.theta * (1 - alpha) + next_point.theta * alpha,
underlying_price=(
current.underlying_price * (1 - alpha) +
next_point.underlying_price * alpha
),
strike=current.strike,
expiry_timestamp=current.expiry_timestamp,
option_type=current.option_type,
iv=interpolated_iv
)
interpolated.append(interpolated_point)
logger.debug(
f"Interpoliert: ts={interpolated_ts}, "
f"price={interpolated_price:.2f}, iv={interpolated_iv:.4f}"
)
return interpolatedIntegration mit HolySheep AI für automatisierte Analysen
# holysheep_ai_assistant.py
import aiohttp
import json
class HolySheepAIAnalyzer:
"""
HolySheep AI für automatisierte Optionsdaten-Analyse nutzen
"""
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1" # KORREKTE API
self.model = "deepseek-v3.2" # Günstigstes Modell: $0.42/1M tokens
async def analyze_qa_results(self, qa_results: dict) -> str:
"""
QA-Ergebnisse mit DeepSeek V3.2 analysieren lassen
"""
prompt = f"""
Analysiere die folgenden Deribit Options QA-Ergebnisse:
QA-Status: {qa_results.get('overall_status')}
Datenpunkte: {qa_results.get('data_points')}
Zeitraum: {qa_results.get('date_range')}
Greeks-Validierung:
- Maximale Delta-Abweichung: {qa_results.get('greeks_validation', {}).get('max_delta_error')}
- Anzahl Fehler: {len(qa_results.get('greeks_validation', {}).get('errors', []))}
Trading-Gaps:
- Anzahl Lücken: {len(qa_results.get('trading_gaps', []))}
- Erste 3 Lücken: {qa_results.get('trading_gaps', [])[:3]}
Zeitstempel-Validierung:
- Drift erkannt: {qa_results.get('timestamp_validation', {}).get('drift_detected')}
- Maximale Drift: {qa_results.get('timestamp_validation', {}).get('max_drift_ms')}ms
Bitte geben Sie:
1. Eine Einschätzung der Datenqualität (1-10)
2. Empfohlene Korrekturmaßnahmen
3. Mögliche Auswirkungen auf Optionsstrategien
"""
async with aiohttp.ClientSession() as session:
async with session.post(
f"{self.base_url}/chat/completions",
headers={
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
},
json={
"model": self.model,
"messages": [
{"role": "system", "content": "Du bist ein Deribit Options-Experte."},
{"role": "user", "content": prompt}
],
"temperature": 0.3,
"max_tokens": 1000
}
) as resp:
if resp.status == 200:
result = await resp.json()
return result['choices'][0]['message']['content']
else:
error = await resp.text()
raise Exception(f"HolySheep API Fehler: {error}")
async def explain_greeks_anomaly(self, option_data: dict) -> str:
"""
Erklärung für Greeks-Anomalie von AI generieren lassen
"""
prompt = f"""
Erkläre die folgende Greeks-Abweichung bei einer Deribit Option:
Instrument: {option_data.get('instrument_name')}
Underlying Price: ${option_data.get('underlying_price')}
Strike: ${option_data.get('strike')}
Zeit bis Verfall: {option_data.get('days_to_expiry', 'N/A')} Tage
Implizite Volatilität: {option_data.get('iv', 0) * 100:.2f}%
Von Deribit gelieferte Greeks:
- Delta: {option_data.get('delta', 0):.4f}
- Gamma: {option_data.get('gamma', 0):.6f}
- Vega: {option_data.get('vega', 0):.4f}
Berechnete Greeks (Black-Scholes):
- Delta: {option_data.get('calculated_delta', 0):.4f}
- Gamma: {option_data.get('calculated_gamma', 0):.6f}
- Vega: {option_data.get('calculated_vega', 0):.4f}
Mögliche Ursachen und Handlungsempfehlungen:
"""
async with aiohttp.ClientSession() as session:
async with session.post(
f"{self.base_url}/chat/completions",
headers={
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
},
json={
"model": self.model,
"messages": [
{"role": "system", "content": "Du bist
Verwandte Ressourcen
Verwandte Artikel