Blame for amazon_derivatives_analysis.py

#!/usr/bin/env python3
"""Amazon leveraged product analysis from a private EUR investor view.

The script intentionally separates two things:
- real observable data where public historical quotes are available
- transparent model columns where retail derivative histories are not reliably
  available from a stable public endpoint
"""

from __future__ import annotations

import argparse
import json
import math
import time
import urllib.parse
import urllib.request
from dataclasses import dataclass
from datetime import date, datetime, timedelta, timezone
from pathlib import Path
from typing import Iterable

import numpy as np
import pandas as pd


START_DATE = "2026-01-01"
END_DATE = "2026-04-14"


@dataclass(frozen=True)
class Trade:
    execution_time: str
    isin: str
    name: str
    quantity: float
    price_eur: float
    venue: str

    @property
    def amount_eur(self) -> float:
        return self.quantity * self.price_eur


ETP_TRADES = [
    Trade(
        execution_time="2026-02-03 15:55:09",
        isin="IE00BK5BZQ82",
        name="Leverage Shares 3x Amazon ETP",
        quantity=1000.0,
        price_eur=8.2385,
        venue="EIX",
    ),
    Trade(
        execution_time="2026-02-03 16:05:06",
        isin="IE00BK5BZQ82",
        name="Leverage Shares 3x Amazon ETP",
        quantity=2000.0,
        price_eur=7.9890,
        venue="EIX",
    ),
    Trade(
        execution_time="2026-02-06 07:42:37",
        isin="IE00BK5BZQ82",
        name="Leverage Shares 3x Amazon ETP",
        quantity=4000.0,
        price_eur=4.5000,
        venue="gettex",
    ),
]


PRODUCTS = {
    "amzn_usd": {
        "symbol": "AMZN",
        "kind": "basiswert_usd",
        "source": "Yahoo Finance chart API",
    },
    "amzn_eur": {
        "symbol": "AMZ.DE",
        "kind": "basiswert_eur",
        "source": "Yahoo Finance chart API",
    },
    "eurusd": {
        "symbol": "EURUSD=X",
        "kind": "fx",
        "source": "Yahoo Finance chart API",
    },
    "etp_real": {
        "symbol": "3AN.DE",
        "isin": "IE00BK5BZQ82",
        "kind": "real_quote",
        "source": "Yahoo Finance chart API",
        "annual_product_cost": 0.0475,
    },
    "turbo_model": {
        "wkn": "UG523U",
        "isin": "DE000UG523U8",
        "kind": "model_only",
        "issuer": "UniCredit Bank GmbH / HVB",
        "name": "HVB TuBull O.EndAmazon172,9414",
        "basis_price_usd": 172.9414,
        "note": "Model uses constant financing level from product name; real issuer financing adjustments and spreads are not included.",
    },
    "factor_model": {
        "wkn": "MC2W9J",
        "isin": "DE000MC2W9J9",
        "kind": "model_only",
        "issuer": "Morgan Stanley",
        "factor": 3.0,
        "note": "Selected real 3x long Amazon factor product, but historical public quotes are not fetched; model uses 3x daily AMZN EUR path.",
    },
    "option_model": {
        "wkn": "HT0Q26",
        "isin": "DE000HT0Q262",
        "kind": "model_only",
        "issuer": "HSBC Trinkaus & Burkhardt GmbH",
        "type": "call",
        "strike_usd": 245.0,
        "ratio": 0.1,
        "expiry": "2026-12-18",
        "implied_volatility": 0.3676,
        "risk_free_rate": 0.03,
        "note": "Black-Scholes proxy with constant IV from 2026-04-13 finanzen.net snapshot; real warrant prices can diverge materially.",
    },
}


def yahoo_chart(symbol: str, start: str, end: str) -> pd.DataFrame:
    """Fetch daily close prices from Yahoo's chart endpoint."""
    start_dt = datetime.fromisoformat(start).replace(tzinfo=timezone.utc)
    end_dt = datetime.fromisoformat(end).replace(tzinfo=timezone.utc) + timedelta(days=1)
    params = urllib.parse.urlencode(
        {
            "period1": int(start_dt.timestamp()),
            "period2": int(end_dt.timestamp()),
            "interval": "1d",
            "events": "history",
        }
    )
    url = f"https://query2.finance.yahoo.com/v8/finance/chart/{urllib.parse.quote(symbol)}?{params}"
    req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"})
    with urllib.request.urlopen(req, timeout=30) as response:
        payload = json.loads(response.read().decode("utf-8"))

    result = payload.get("chart", {}).get("result")
    if not result:
        error = payload.get("chart", {}).get("error")
        raise RuntimeError(f"Yahoo returned no result for {symbol}: {error}")

    data = result[0]
    timestamps = data.get("timestamp") or []
    quote = data.get("indicators", {}).get("quote", [{}])[0]
    closes = quote.get("close") or []
    volumes = quote.get("volume") or []

    rows = []
    for ts, close, volume in zip(timestamps, closes, volumes):
        if close is None:
            continue
        rows.append(
            {
                "date": datetime.fromtimestamp(ts, tz=timezone.utc).date(),
                "close": float(close),
                "volume": np.nan if volume is None else float(volume),
            }
        )

    if not rows:
        raise RuntimeError(f"Yahoo returned no close prices for {symbol}")

    return pd.DataFrame(rows).drop_duplicates("date").sort_values("date")


def norm_cdf(x: float) -> float:
    return 0.5 * (1.0 + math.erf(x / math.sqrt(2.0)))


def norm_pdf(x: float) -> float:
    return math.exp(-0.5 * x * x) / math.sqrt(2.0 * math.pi)


def black_scholes_call(
    spot: float,
    strike: float,
    years: float,
    volatility: float,
    risk_free_rate: float,
) -> dict[str, float]:
    if years <= 0 or volatility <= 0 or spot <= 0 or strike <= 0:
        intrinsic = max(spot - strike, 0.0)
        return {
            "price": intrinsic,
            "delta": 1.0 if spot > strike else 0.0,
            "theta_per_day": 0.0,
            "vega": 0.0,
        }

    sigma_sqrt_t = volatility * math.sqrt(years)
    d1 = (math.log(spot / strike) + (risk_free_rate + 0.5 * volatility**2) * years) / sigma_sqrt_t
    d2 = d1 - sigma_sqrt_t
    price = spot * norm_cdf(d1) - strike * math.exp(-risk_free_rate * years) * norm_cdf(d2)
    delta = norm_cdf(d1)
    theta_annual = (
        -(spot * norm_pdf(d1) * volatility) / (2.0 * math.sqrt(years))
        - risk_free_rate * strike * math.exp(-risk_free_rate * years) * norm_cdf(d2)
    )
    vega = spot * norm_pdf(d1) * math.sqrt(years) / 100.0
    return {
        "price": price,
        "delta": delta,
        "theta_per_day": theta_annual / 365.0,
        "vega": vega,
    }


def max_drawdown(series: pd.Series) -> float:
    clean = series.dropna()
    if clean.empty:
        return np.nan
    peak = clean.cummax()
    drawdown = clean / peak - 1.0
    return float(drawdown.min())


def first_valid_value(series: pd.Series) -> float:
    clean = series.dropna()
    if clean.empty:
        return np.nan
    return float(clean.iloc[0])


def fair_value(series: pd.Series, start_value: float = 1000.0) -> pd.Series:
    base = first_valid_value(series)
    if not np.isfinite(base) or base == 0:
        return pd.Series(np.nan, index=series.index)
    return start_value * series / base


def model_factor_path(returns: pd.Series, leverage: float, start_value: float = 1000.0) -> pd.Series:
    out = pd.Series(index=returns.index, dtype=float)
    value = start_value
    first_seen = False
    for idx, ret in returns.items():
        if pd.isna(ret):
            if not first_seen:
                out.loc[idx] = value
                first_seen = True
            else:
                out.loc[idx] = np.nan
            continue
        if not first_seen:
            out.loc[idx] = value
            first_seen = True
            continue
        value *= max(1.0 + leverage * float(ret), 0.0)
        out.loc[idx] = value
    return out.ffill()


def build_daily(start: str, end: str) -> pd.DataFrame:
    raw = {}
    for key in ("amzn_usd", "amzn_eur", "eurusd", "etp_real"):
        symbol = PRODUCTS[key]["symbol"]
        raw[key] = yahoo_chart(symbol, start, end).rename(columns={"close": key})
        time.sleep(0.2)

    # EUR investor view: keep the German Amazon trading calendar. FX can have
    # extra rows that would otherwise create dates without a basis-value move.
    all_dates = sorted(set(raw["amzn_eur"]["date"]))
    daily = pd.DataFrame({"date": all_dates})
    for key, frame in raw.items():
        daily = daily.merge(frame[["date", key]], on="date", how="left")

    daily["eurusd"] = daily["eurusd"].ffill().bfill()
    daily["amzn_eur_from_usd"] = daily["amzn_usd"] / daily["eurusd"]
    daily["amzn_eur_used"] = daily["amzn_eur"].combine_first(daily["amzn_eur_from_usd"])
    daily["amzn_usd_used"] = daily["amzn_usd"].combine_first(daily["amzn_eur_used"] * daily["eurusd"])
    daily["amzn_daily_return"] = daily["amzn_eur_used"].pct_change()
    daily["amzn_usd_daily_return"] = daily["amzn_usd"].pct_change()

    daily["etp_real_daily_return"] = daily["etp_real"].pct_change()
    daily["etp_model_3x"] = np.nan
    first_etp = first_valid_value(daily["etp_real"])
    if np.isfinite(first_etp):
        model = model_factor_path(daily["amzn_daily_return"], 3.0, first_etp)
        daily["etp_model_3x"] = model
        daily["etp_model_3x_daily_return"] = daily["etp_model_3x"].pct_change()
        daily["etp_drag_tracking"] = daily["etp_real"] / daily["etp_model_3x"] - 1.0

    turbo_basis = PRODUCTS["turbo_model"]["basis_price_usd"]
    daily["turbo_intrinsic_usd_per_unit"] = (daily["amzn_usd_used"] - turbo_basis).clip(lower=0.0)
    daily["turbo_intrinsic_eur_per_unit"] = daily["turbo_intrinsic_usd_per_unit"] / daily["eurusd"]
    daily["turbo_knocked_out_model"] = daily["amzn_usd_used"] <= turbo_basis
    daily["turbo_leverage_model"] = daily["amzn_usd_used"] / (daily["amzn_usd_used"] - turbo_basis)
    daily.loc[daily["turbo_intrinsic_usd_per_unit"] <= 0, "turbo_leverage_model"] = np.nan
    daily["turbo_ko_distance_pct"] = daily["amzn_usd_used"] / turbo_basis - 1.0
    daily["fair_1000_turbo_model"] = fair_value(daily["turbo_intrinsic_eur_per_unit"])

    daily["factor_model_3x"] = model_factor_path(daily["amzn_daily_return"], 3.0, 1000.0)

    option = PRODUCTS["option_model"]
    expiry = date.fromisoformat(option["expiry"])
    option_rows = []
    for _, row in daily.iterrows():
        trade_date = row["date"]
        years = max((expiry - trade_date).days / 365.0, 0.0)
        bs = black_scholes_call(
            spot=float(row["amzn_usd_used"]),
            strike=option["strike_usd"],
            years=years,
            volatility=option["implied_volatility"],
            risk_free_rate=option["risk_free_rate"],
        )
        price_eur = option["ratio"] * bs["price"] / row["eurusd"]
        theta_eur_day = option["ratio"] * bs["theta_per_day"] / row["eurusd"]
        intrinsic_eur = option["ratio"] * max(float(row["amzn_usd_used"]) - option["strike_usd"], 0.0) / row["eurusd"]
        option_rows.append(
            {
                "option_model_price": price_eur,
                "option_delta": bs["delta"],
                "option_omega": (bs["delta"] * float(row["amzn_usd_used"]) / bs["price"]) if bs["price"] > 0 else np.nan,
                "option_theta_per_day": theta_eur_day,
                "option_vega_per_vol_point_eur": option["ratio"] * bs["vega"] / row["eurusd"],
                "option_intrinsic_eur": intrinsic_eur,
                "option_time_value_eur": price_eur - intrinsic_eur,
            }
        )
    daily = pd.concat([daily, pd.DataFrame(option_rows)], axis=1)
    daily["fair_1000_option_model"] = fair_value(daily["option_model_price"])

    daily["fair_1000_amzn_eur"] = fair_value(daily["amzn_eur_used"])
    daily["fair_1000_etp_real"] = fair_value(daily["etp_real"])
    daily["fair_1000_etp_model_3x"] = fair_value(daily["etp_model_3x"])

    total_quantity = sum(trade.quantity for trade in ETP_TRADES)
    total_cost = sum(trade.amount_eur for trade in ETP_TRADES)
    avg_entry = total_cost / total_quantity
    daily["portfolio_etp_quantity"] = total_quantity
    daily["portfolio_etp_cost_basis_eur"] = total_cost
    daily["portfolio_etp_avg_entry_eur"] = avg_entry
    daily["portfolio_etp_value_eur"] = daily["etp_real"] * total_quantity
    daily["portfolio_etp_pnl_eur"] = daily["portfolio_etp_value_eur"] - total_cost
    daily["portfolio_etp_pnl_pct"] = daily["portfolio_etp_value_eur"] / total_cost - 1.0
    daily["portfolio_etp_break_even_gap_pct"] = daily["etp_real"] / avg_entry - 1.0

    preferred = [
        "date",
        "amzn_eur_used",
        "amzn_eur",
        "amzn_usd",
        "amzn_usd_used",
        "eurusd",
        "amzn_daily_return",
        "etp_real",
        "etp_real_daily_return",
        "etp_model_3x",
        "etp_model_3x_daily_return",
        "etp_drag_tracking",
        "turbo_intrinsic_eur_per_unit",
        "turbo_leverage_model",
        "turbo_ko_distance_pct",
        "turbo_knocked_out_model",
        "factor_model_3x",
        "option_model_price",
        "option_delta",
        "option_omega",
        "option_theta_per_day",
        "option_vega_per_vol_point_eur",
        "option_intrinsic_eur",
        "option_time_value_eur",
        "fair_1000_amzn_eur",
        "fair_1000_etp_real",
        "fair_1000_etp_model_3x",
        "fair_1000_turbo_model",
        "fair_1000_option_model",
        "portfolio_etp_value_eur",
        "portfolio_etp_pnl_eur",
        "portfolio_etp_pnl_pct",
        "portfolio_etp_break_even_gap_pct",
    ]
    return daily[[col for col in preferred if col in daily.columns]]


def build_summary(daily: pd.DataFrame) -> pd.DataFrame:
    metrics = []
    series_map = {
        "Amazon EUR": daily["fair_1000_amzn_eur"],
        "ETP real IE00BK5BZQ82": daily["fair_1000_etp_real"],
        "ETP modeled 3x": daily["fair_1000_etp_model_3x"],
        "Turbo model UG523U": daily["fair_1000_turbo_model"],
        "Factor model MC2W9J": daily["factor_model_3x"],
        "Option model HT0Q26": daily["fair_1000_option_model"],
    }
    for name, series in series_map.items():
        clean = series.dropna()
        if clean.empty:
            continue
        metrics.append(
            {
                "instrument": name,
                "start_value": float(clean.iloc[0]),
                "end_value": float(clean.iloc[-1]),
                "performance_pct": float(clean.iloc[-1] / clean.iloc[0] - 1.0),
                "max_drawdown_pct": max_drawdown(clean),
                "daily_volatility_pct": float(clean.pct_change().std(skipna=True)),
                "observations": int(clean.shape[0]),
            }
        )

    total_quantity = sum(trade.quantity for trade in ETP_TRADES)
    total_cost = sum(trade.amount_eur for trade in ETP_TRADES)
    avg_entry = total_cost / total_quantity
    last = daily.dropna(subset=["etp_real"]).iloc[-1]
    metrics.append(
        {
            "instrument": "Depot ETP position",
            "start_value": total_cost,
            "end_value": float(last["portfolio_etp_value_eur"]),
            "performance_pct": float(last["portfolio_etp_pnl_pct"]),
            "max_drawdown_pct": max_drawdown(daily["portfolio_etp_value_eur"]),
            "daily_volatility_pct": float(daily["portfolio_etp_value_eur"].pct_change().std(skipna=True)),
            "observations": int(daily["portfolio_etp_value_eur"].dropna().shape[0]),
            "quantity": total_quantity,
            "avg_entry_eur": avg_entry,
            "break_even_gap_pct": float(last["portfolio_etp_break_even_gap_pct"]),
        }
    )
    return pd.DataFrame(metrics)


def write_trade_summary(output_dir: Path) -> None:
    trades = pd.DataFrame(
        [
            {
                "execution_time": trade.execution_time,
                "isin": trade.isin,
                "name": trade.name,
                "quantity": trade.quantity,
                "price_eur": trade.price_eur,
                "amount_eur": trade.amount_eur,
                "venue": trade.venue,
            }
            for trade in ETP_TRADES
        ]
    )
    trades.to_csv(output_dir / "amazon_etp_trades.csv", index=False)


def write_readme(output_dir: Path, start: str, end: str) -> None:
    total_quantity = sum(trade.quantity for trade in ETP_TRADES)
    total_cost = sum(trade.amount_eur for trade in ETP_TRADES)
    avg_entry = total_cost / total_quantity
    text = f"""# Amazon Derivatives Analysis Outputs

Generated for {start} to {end}.

## Source hierarchy

1. Broker PDFs are the source of truth for executed ETP trades.
2. Official issuer documents are the source of truth for product mechanics.
3. Exchange/broker bid-ask quotes are the source of truth for tradable prices.
4. This model is a learning, risk, and plausibility model.

## ETP position

- ISIN: IE00BK5BZQ82
- Quantity: {total_quantity:,.0f}
- Cost basis: {total_cost:,.2f} EUR
- Weighted average entry: {avg_entry:.4f} EUR
- Running product cost from PDFs: 4.75% p.a.

## Model limitations

- `3AN.DE`, `AMZ.DE`, `AMZN`, and `EURUSD=X` are fetched from Yahoo Finance.
- UG523U is modeled from a constant USD financing level of 172.9414; issuer financing adjustments, spreads, and intraday knock-out handling are not included.
- MC2W9J is represented by a transparent 3x daily factor model because a stable public historical quote endpoint was not found.
- HT0Q26 is represented by a Black-Scholes proxy with constant IV 36.76%, strike 245 USD, ratio 0.1, and expiry 2026-12-18.
"""
    (output_dir / "README.md").write_text(text, encoding="utf-8")


def write_interpretation(output_dir: Path, daily: pd.DataFrame, summary: pd.DataFrame) -> None:
    by_name = summary.set_index("instrument")
    depot = by_name.loc["Depot ETP position"]
    amazon = by_name.loc["Amazon EUR"]
    etp_real = by_name.loc["ETP real IE00BK5BZQ82"]
    etp_model = by_name.loc["ETP modeled 3x"]
    turbo = by_name.loc["Turbo model UG523U"]
    factor = by_name.loc["Factor model MC2W9J"]
    option = by_name.loc["Option model HT0Q26"]

    end = daily.dropna(subset=["etp_real"]).iloc[-1]
    weighted_days = (
        sum(
            (end["date"] - date.fromisoformat(trade.execution_time[:10])).days * trade.amount_eur
            for trade in ETP_TRADES
        )
        / sum(trade.amount_eur for trade in ETP_TRADES)
    )
    etp_running_cost_pct = PRODUCTS["etp_real"]["annual_product_cost"] * weighted_days / 365.0
    etp_running_cost_eur = float(depot["start_value"] * etp_running_cost_pct)

    text = f"""# Was deine Wahl bis {end['date']} gezeigt hat

## Harte Depot-Wahrheit

- Dein gewichteter ETP-Einstieg: {depot['avg_entry_eur']:.4f} EUR.
- Letzter verwendeter ETP-Schlusskurs: {end['etp_real']:.4f} EUR.
- Depotwert ETP: {depot['end_value']:,.2f} EUR.
- P/L auf deine 7.000 Stk.: {end['portfolio_etp_pnl_eur']:,.2f} EUR ({depot['performance_pct']:.2%}).
- Geschätzte laufende Produktkosten über die gewichtete Haltedauer von {weighted_days:.1f} Tagen: ca. {etp_running_cost_pct:.2%} bzw. {etp_running_cost_eur:,.2f} EUR. Diese Kosten sind nicht als separate Brokerabbuchung sichtbar, sondern in der Produkt-/Indexentwicklung enthalten.

## 1.000-EUR-Vergleich seit Jahresanfang

| Instrument | Endwert | Performance | Max. Drawdown | Einordnung |
|---|---:|---:|---:|---|
| Amazon EUR | {amazon['end_value']:,.2f} EUR | {amazon['performance_pct']:.2%} | {amazon['max_drawdown_pct']:.2%} | Basiswert, kein Hebel |
| ETP real IE00BK5BZQ82 | {etp_real['end_value']:,.2f} EUR | {etp_real['performance_pct']:.2%} | {etp_real['max_drawdown_pct']:.2%} | echte Historie über 3AN.DE |
| ETP/Faktor 3x Modell | {etp_model['end_value']:,.2f} EUR | {etp_model['performance_pct']:.2%} | {etp_model['max_drawdown_pct']:.2%} | täglicher 3x-Pfad |
| Turbo UG523U Modell | {turbo['end_value']:,.2f} EUR | {turbo['performance_pct']:.2%} | {turbo['max_drawdown_pct']:.2%} | stärkste Performance, höchstes KO-Risiko |
| Optionsschein HT0Q26 Modell | {option['end_value']:,.2f} EUR | {option['performance_pct']:.2%} | {option['max_drawdown_pct']:.2%} | hoher Hebel, stark abhängig von IV/Zeitwert |

## Urteil zur Produktwahl

Deine Wahl war aus heutiger Sicht nicht schlecht, aber sie war nicht das maximal aggressive Produkt. Der Turbo hätte im Modell am meisten gebracht, hatte aber auch den tiefsten zwischenzeitlichen Absturz. Das ist genau der Trade-off: mehr Performance gegen viel höheres Knock-out- und Timing-Risiko.

Der echte ETP hat Amazon klar geschlagen und lag nahe am transparenten 3x-Tagesmodell. Am Ende lag er rund {end['etp_drag_tracking']:.2%} unter dem modellierten 3x-Pfad. Das ist die Zone, in der Tracking, Swap-/Indexkosten, FX, Handelsplatz und Spread sichtbar werden. Es ist kein Beweis für Fehlpreisung, aber ein guter Plausibilitätscheck.

Kosten-/Mechanik-Vergleich:

- ETP: laufende Kosten aus deinen PDFs 4,75% p.a.; kein Knock-out; täglicher Reset mit Variance Drain.
- Turbo: keine tägliche Reset-Mechanik; dafür Finanzierungslevel, Spread und Knock-out. Performance kann viel besser sein, aber ein falscher Gap kann die Position komplett beenden.
- Faktor: ähnlich wie ETP, täglicher Faktorpfad; privat gut modellierbar, echte Emittentenbedingungen bleiben entscheidend.
- Optionsschein: privat nur approximativ modellierbar, weil implizite Volatilität und Zeitwert den Preis stark bewegen.

## Praktische Lesart

Wenn dein Hauptproblem war, dass du das Produkt anfangs nicht vollständig verstanden hattest, dann war der ETP trotzdem die robustere gehebelte Wahl als ein Turbo: Du hattest keine KO-Schwelle, und der Nachkauf zu 4,50 EUR hat deinen Durchschnitt stark verbessert. Der Preis dafür war Variance Drain und laufende Produktkosten.

Wenn du ex post nur auf Rendite schaust, wäre der Turbo im Modell besser gewesen. Wenn du Risiko, KO-Gefahr und Produktverständnis mitbewertest, war der ETP die defensivere Hebelentscheidung.
"""
    (output_dir / "amazon_choice_interpretation.md").write_text(text, encoding="utf-8")


def write_cost_overview(output_dir: Path) -> None:
    total_cost = sum(trade.amount_eur for trade in ETP_TRADES)
    text = f"""# Kosten der verglichenen Produkte

## Wichtigste Einordnung

Bei diesen Produkten gibt es nicht nur "Gebühren" wie bei einem Fonds. Ein großer Teil der Kosten steckt in Geld/Brief-Spreads, Finanzierungskomponenten, Indexformeln, impliziter Volatilität und Emittentenpreisstellung. Deshalb ist der Broker-Ausführungskurs die Wahrheit für den Einstieg, und der handelbare Geldkurs die Wahrheit für den Ausstieg.

## Kostenmatrix

| Produkt | Explizit sichtbar | Im Preis versteckt | In unserem Modell |
|---|---:|---|---|
| ETP IE00BK5BZQ82 | laut deinen Scalable-PDFs: 0 EUR Einstieg, 0 EUR Ausstieg, 4,75% p.a. laufende Produktkosten | Swap-/Indexfinanzierung, Tracking, FX, Geld/Brief-Spread | echte Kursreihe `3AN.DE`, Kosten wirken im Kurs; zusätzlich grob ausgewiesen |
| Turbo UG523U | meist keine separate Orderproduktgebühr im Produkt selbst | Finanzierungskosten über steigendes Finanzierungslevel/Basispreis, Emittentenmarge, Spread, KO-Risiko | nur linearer Innerer-Wert-Proxy; Finanzierung/Spread nicht enthalten |
| Faktor MC2W9J | keine klassische TER; Morgan Stanley nennt u.a. Zinsanpassungssatz 2,00% p.a. | Geld/Brief-Spread, Management-/Finanzierungskomponente im virtuellen Index, Reset-Mechanik | 3x-Tagesmodell; reale Indexkosten/Spread nicht enthalten |
| Optionsschein HT0Q26 | keine laufende TER wie Fonds | Spread, Zeitwertverlust/Theta, implizite Volatilität, Emittentenmarge | Black-Scholes-Proxy mit konstantem IV; echter Emittentenpreis kann abweichen |

## ETP-Kosten aus deinen PDFs

Deine Kosteninformationen für IE00BK5BZQ82 zeigen:

- Einstiegskosten: 0,00 EUR
- Ausstiegskosten: 0,00 EUR
- Laufende Produktkosten: 4,75% p.a.
- bezogen auf deinen Einsatz von {total_cost:,.2f} EUR entspricht 4,75% p.a. rechnerisch {total_cost * 0.0475:,.2f} EUR pro Jahr, wenn der Positionswert konstant bliebe.

Für die gewichtete Haltedauer bis 2026-04-14 hat das Script grob ca. 0,89% bzw. rund 377,55 EUR laufende ETP-Kosten geschätzt. Das ist keine separate Abbuchung, sondern steckt in der Produktentwicklung.

Wichtig: Öffentliche ETF-Portale zeigen für IE00BK5BZQ82 teils eine TER von 0,75% p.a. Diese Zahl ist nicht identisch mit deiner ex-ante Broker-Kosteninformation von 4,75% p.a. Für deine konkrete Kaufentscheidung/Ex-ante-Kostensicht zählt die Broker-Kosteninformation; für Produktbasisdaten sollte man zusätzlich KID/Prospekt prüfen.

## Warum Turbo/Faktor/Optionsschein schwerer sind

Turbo:

- Die Kosten laufen primär über das Finanzierungslevel. Bei Open-End-Turbos wird der Basispreis/Finanzierungslevel typischerweise angepasst.
- Du siehst die Kosten nicht als Abbuchung, sondern als schlechtere Produktentwicklung gegenüber einem idealen linearen Modell.
- Zusätzlich kostet der Spread beim Kauf/Verkauf sofort Performance.

Faktor:

- Der Faktorpfad ist ähnlich wie beim ETP täglich neu gehebelt.
- Kosten stecken in der Index-/Faktorformel, im Zinsanpassungssatz und im Spread.
- Der wichtigste "Kostenblock" bei Seitwärtsbewegung ist aber nicht nur Gebühr, sondern Variance Drain durch täglichen Reset.

Optionsschein:

- Der größte laufende Effekt ist Theta/Zeitwertverlust.
- Zusätzlich kann implizite Volatilität den Schein teurer oder billiger machen, unabhängig davon, was Amazon macht.
- Spread ist sofortiger Einstiegsnachteil.

## Praktisches Fazit

Für Kostenwahrheit gilt:

1. Broker-Kosteninformation und Abrechnung für deinen Trade.
2. KID/Final Terms/Prospekt für Produktmechanik.
3. Aktueller Bid/Ask am Handelsplatz für real handelbare Kosten.
4. Modellrechnung nur als Plausibilitätscheck.

Wenn du die Produkte wirklich ex post kostenbereinigt vergleichen willst, brauchst du für Turbo/Faktor/Optionsschein historische Geld-/Briefkurse oder mindestens tägliche Schlusskurse vom Handelsplatz/Emittenten. Ohne diese Daten kann man nur approximieren.
"""
    (output_dir / "amazon_costs.md").write_text(text, encoding="utf-8")


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--start", default=START_DATE)
    parser.add_argument("--end", default=END_DATE)
    parser.add_argument("--output-dir", default="outputs")
    return parser.parse_args()


def main() -> None:
    args = parse_args()
    output_dir = Path(args.output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)

    daily = build_daily(args.start, args.end)
    summary = build_summary(daily)

    daily.to_csv(output_dir / "amazon_derivate_daily.csv", index=False)
    summary.to_csv(output_dir / "amazon_derivate_summary.csv", index=False)
    write_trade_summary(output_dir)
    write_readme(output_dir, args.start, args.end)
    write_interpretation(output_dir, daily, summary)
    write_cost_overview(output_dir)

    print(f"Wrote {output_dir / 'amazon_derivate_daily.csv'}")
    print(f"Wrote {output_dir / 'amazon_derivate_summary.csv'}")
    print(f"Wrote {output_dir / 'amazon_etp_trades.csv'}")
    print(f"Wrote {output_dir / 'amazon_choice_interpretation.md'}")
    print(f"Wrote {output_dir / 'amazon_costs.md'}")


if __name__ == "__main__":
    main()