Update app.py

app.py

@@ -1,316 +1,217 @@
+# -*- coding: utf-8 -*-
 import streamlit as st
 import yfinance as yf
 import pandas as pd
 import numpy as np
 import plotly.graph_objects as go
 from datetime import datetime, timedelta
-import time # Für Fehlerbehandlung Ticker
+import time
 
 # --- Konfiguration ---
-st.set_page_config(layout="wide", page_title="Option Yield Pro (Lokal)")
+st.set_page_config(layout="wide", page_title="Option Yield Pro (Premium Focus)")
 
 # --- Hilfsfunktionen ---
 
-# -- Caching --
-@st.cache_resource(ttl=600) # Cache das Ticker-OBJEKT für 10 Min.
+# -- Caching -- (Funktionen bleiben gleich wie vorher)
+@st.cache_resource(ttl=600)
 def get_ticker_object(ticker_symbol):
-    """Holt und cacht das yfinance Ticker-Objekt."""
-    if not ticker_symbol: return None # Frühzeitiger Ausstieg, wenn kein Ticker vorhanden
+    if not ticker_symbol: return None
     try:
         ticker = yf.Ticker(ticker_symbol)
-        # Prüfe Gültigkeit (löst einen kleinen Download aus)
-        # .info kann manchmal leer sein, auch wenn Ticker gültig. Besser: History-Check?
         if ticker.history(period="1d").empty:
-             raise ValueError(f"Keine Daten für {ticker_symbol} abrufbar. Ungültiger Ticker?")
+             raise ValueError(f"Keine Daten für {ticker_symbol}")
         return ticker
     except Exception as e:
-        # Fehler nicht im UI anzeigen, wenn die Funktion im Hintergrund läuft
-        print(f"Fehler beim Erstellen des Ticker-Objekts für {ticker_symbol}: {e}")
-        return None # Return None on failure
-
-@st.cache_data(ttl=300) # Cache die AKTIENDATEN (dict) für 5 Minuten
-def get_stock_data(_ticker_obj): # Nimm Objekt statt Symbol
-    """Holt Aktieninformationen und Preis mithilfe des Ticker-Objekts."""
-    if _ticker_obj is None:
-        return None, "Ungültiges Ticker-Objekt"
+        print(f"Ticker Fehler {ticker_symbol}: {e}")
+        return None
 
+@st.cache_data(ttl=300)
+def get_stock_data(_ticker_obj):
+    if _ticker_obj is None: return None, "Ungültiges Ticker-Objekt"
     try:
         info = _ticker_obj.info
-        # Verschiedene Felder für den aktuellen Preis prüfen
         price = info.get('currentPrice') or info.get('regularMarketPrice') or info.get('bid') or info.get('ask')
         prev_close = info.get('previousClose') or info.get('regularMarketPreviousClose')
-
-        # History-Fallback, wenn Preis/Schlusskurs fehlen
         if price is None or prev_close is None:
              hist = _ticker_obj.history(period="2d")
              if not hist.empty:
                  price = hist['Close'].iloc[-1]
-                 prev_close = hist['Close'].iloc[-2] if len(hist) > 1 else price # Fallback für nur einen Tag History
+                 prev_close = hist['Close'].iloc[-2] if len(hist) > 1 else price
              else:
-                 # Fallback: Versuche 'financialData'
                  fdata = info.get('financialData', {})
                  price = fdata.get('currentPrice')
-                 if price is None:
-                     return None, "Aktueller Preis konnte nicht ermittelt werden."
-                 # Wenn prev_close immer noch fehlt, nehmen wir einfach den aktuellen Preis (suboptimal)
-                 if prev_close is None:
-                     prev_close = price
-
-
+                 if price is None: return None, "Aktueller Preis nicht ermittelbar."
+                 if prev_close is None: prev_close = price
         change = price - prev_close
-        change_percent = (change / prev_close) * 100 if prev_close != 0 else 0 # Vermeide Division durch Null
+        change_percent = (change / prev_close) * 100 if prev_close != 0 else 0
         name = info.get('shortName', _ticker_obj.ticker)
-        currency = info.get('currency', '$') # Währung holen
+        currency = info.get('currency', '$')
         fifty_two_week_low = info.get('fiftyTwoWeekLow')
         fifty_two_week_high = info.get('fiftyTwoWeekHigh')
-
         stock_data = {
-            "name": name,
-            "price": price,
-            "change": change,
-            "change_percent": change_percent,
-            "currency": currency,
-            "fifty_two_week_low": fifty_two_week_low,
-            "fifty_two_week_high": fifty_two_week_high,
+            "name": name, "price": price, "change": change, "change_percent": change_percent,
+            "currency": currency, "fifty_two_week_low": fifty_two_week_low, "fifty_two_week_high": fifty_two_week_high,
         }
-        return stock_data, None # Return data dict and None for error
+        return stock_data, None
     except Exception as e:
-        return None, f"Fehler beim Abrufen der Aktiendaten für {_ticker_obj.ticker}: {e}"
+        return None, f"Fehler Aktiendaten ({_ticker_obj.ticker}): {e}"
 
-@st.cache_data(ttl=600) # Cache die Liste der ABLAUFDATEN
+@st.cache_data(ttl=600)
 def get_option_dates(_ticker_obj):
-    """Holt verfügbare Optionsablaufdaten."""
     if _ticker_obj is None: return []
     try:
-        # Manchmal gibt .options einen Fehler, wenn keine Optionen existieren
         opts = _ticker_obj.options
         return opts if opts else []
     except Exception as e:
-        print(f"Fehler beim Abrufen der Optionsdaten ({_ticker_obj.ticker}): {e}")
+        print(f"Fehler Optionsdaten ({_ticker_obj.ticker}): {e}")
         return []
 
-@st.cache_data(ttl=300) # Cache die OPTIONSKETTE DataFrame für 5 Min.
+@st.cache_data(ttl=300)
 def get_option_chain(_ticker_obj, expiration_date):
-    """Holt die Optionskette für ein spezifisches Datum."""
     if _ticker_obj is None or not expiration_date: return pd.DataFrame()
     try:
         chain = _ticker_obj.option_chain(expiration_date)
-        # Nur Calls, Index zurücksetzen und sicherstellen, dass Spalten existieren
         calls = chain.calls.reset_index(drop=True).copy()
-        # Standardwerte für fehlende Griechen setzen (falls yfinance sie nicht liefert)
         for greek in ['delta', 'gamma', 'theta', 'vega']:
-            if greek not in calls.columns:
-                calls[greek] = np.nan
+            if greek not in calls.columns: calls[greek] = np.nan
         return calls
     except Exception as e:
-        # Oft passiert "KeyError: 'calls'" wenn keine Kette für das Datum existiert
-        print(f"Fehler/Warnung beim Abrufen der Optionskette für {_ticker_obj.ticker} am {expiration_date}: {e}")
-        return pd.DataFrame() # Return empty dataframe on error
+        print(f"Fehler/Warnung Optionskette ({_ticker_obj.ticker} / {expiration_date}): {e}")
+        return pd.DataFrame()
 
-@st.cache_data(ttl=1800) # Cache History länger (30 Min)
+@st.cache_data(ttl=1800)
 def get_stock_history(_ticker_obj, period='1y', interval='1d'):
-    """Holt historische Kurse für den Chart."""
     if _ticker_obj is None: return pd.DataFrame()
     try:
-        # yfinance erwartet manchmal Großbuchstaben für Intervalle wie '1WK'
-        interval_map = {'1d': '1d', '1wk': '1wk', '1mo': '1mo'} # Mapping zur Sicherheit
+        interval_map = {'1d': '1d', '1wk': '1wk', '1mo': '1mo'}
         hist = _ticker_obj.history(period=period, interval=interval_map.get(interval.lower(), '1d'))
         return hist
     except Exception as e:
-        st.error(f"Fehler beim Laden der Historie für {_ticker_obj.ticker} (Periode: {period}, Intervall: {interval}): {e}")
+        st.error(f"Fehler Historie ({_ticker_obj.ticker}, {period}, {interval}): {e}")
         return pd.DataFrame()
 
 # -- Berechnungen & Logik --
 def calculate_covered_calls(calls_df, current_price, shares_owned, cost_basis, expiration_date, assumed_premium_price_type='bid', custom_premium=None, commission_per_contract=0.0):
-    """Berechnet Covered Call Metriken und fügt sie dem DataFrame hinzu."""
     if calls_df.empty: return calls_df
-
     df = calls_df.copy()
 
-    # --- Prämienberechnung ---
-    if custom_premium is not None and custom_premium > 0:
-        df['assumedPremiumPerShare'] = float(custom_premium) # Stelle sicher, dass es float ist
+    # Prämie
+    if custom_premium is not None and custom_premium > 0: df['assumedPremiumPerShare'] = float(custom_premium)
     elif assumed_premium_price_type == 'mid':
-        bid_filled = df['bid'].fillna(0)
-        ask_filled = df['ask'].fillna(df['lastPrice']).fillna(bid_filled) # Fallback: Last -> Bid -> 0
+        bid_filled = df['bid'].fillna(0); ask_filled = df['ask'].fillna(df['lastPrice']).fillna(bid_filled)
         df['assumedPremiumPerShare'] = (bid_filled + ask_filled) / 2
-    elif assumed_premium_price_type == 'last':
-         df['assumedPremiumPerShare'] = df['lastPrice'].fillna(0)
-    else: # Default to Bid
-        df['assumedPremiumPerShare'] = df['bid'].fillna(0)
-
-    # Stelle sicher, dass Prämie nicht negativ ist und float ist
+    elif assumed_premium_price_type == 'last': df['assumedPremiumPerShare'] = df['lastPrice'].fillna(0)
+    else: df['assumedPremiumPerShare'] = df['bid'].fillna(0)
     df['assumedPremiumPerShare'] = df['assumedPremiumPerShare'].apply(lambda x: max(0, float(x)))
-
     num_contracts = float(shares_owned) / 100.0
     df['premiumGrossTotal'] = df['assumedPremiumPerShare'] * float(shares_owned)
     total_commission = num_contracts * float(commission_per_contract)
-    df['premiumNetTotal'] = df['premiumGrossTotal'] - total_commission # Nettoprämie nach Provision
-
-    # --- Kostenbasis & Kernberechnungen ---
-    cost_basis = float(cost_basis)
-    shares_owned = float(shares_owned)
-    current_price = float(current_price)
+    df['premiumNetTotal'] = df['premiumGrossTotal'] - total_commission
 
+    # Basis & Kernberechnungen
+    cost_basis = float(cost_basis); shares_owned = float(shares_owned); current_price = float(current_price)
     df['costBasisTotal'] = cost_basis * shares_owned
     df['strike'] = df['strike'].astype(float)
+    df['maxProfitAssignedNet'] = ((df['strike'] - cost_basis) * shares_owned) + df['premiumNetTotal'] # Behalten für optionale Anzeige
 
-    # Max Profit if Assigned (Nettoprämie verwenden)
-    df['maxProfitAssignedNet'] = ((df['strike'] - cost_basis) * shares_owned) + df['premiumNetTotal']
-
-    # --- Prozentuale Metriken (auf Basis der Nettoprämie) ---
+    # Prozentuale Metriken (Netto)
     cost_basis_total_val = df['costBasisTotal'].iloc[0] if not df.empty else 0
-    # Berechne premium_net_per_share als Series
     premium_net_per_share = df['premiumNetTotal'] / shares_owned if shares_owned > 0 else pd.Series([0.0] * len(df), index=df.index)
+    if not isinstance(premium_net_per_share, pd.Series): # Sicherstellen, dass es Series ist
+        premium_net_per_share = pd.Series([premium_net_per_share] * len(df), index=df.index)
 
-    # Fall: Kostenbasis > 0
     if cost_basis_total_val > 0:
-        df['maxProfitPercentNet'] = (df['maxProfitAssignedNet'] / cost_basis_total_val) * 100
+        df['maxProfitPercentNet'] = (df['maxProfitAssignedNet'] / cost_basis_total_val) * 100 # Behalten für optionale Anzeige
         df['returnIfFlatPercentNet'] = (df['premiumNetTotal'] / cost_basis_total_val) * 100
-        # Downside Protection braucht premium_net_per_share (Series) und cost_basis (Skalar)
         df['downsideProtectionPercentNet'] = (premium_net_per_share / cost_basis) * 100 if cost_basis > 0 else np.inf
-        # Return on Risk braucht premium_net_per_share (Series) und capital_at_risk (Series)
         capital_at_risk = cost_basis - premium_net_per_share
-        df['returnOnRiskPercentNet'] = np.where(
-            capital_at_risk > 0, (premium_net_per_share / capital_at_risk) * 100, np.inf
-        )
-    # Fall: Kostenbasis <= 0 (oder nicht berechenbar)
+        df['returnOnRiskPercentNet'] = np.where(capital_at_risk > 0, (premium_net_per_share / capital_at_risk) * 100, np.inf)
     else:
-        for col in ['maxProfitPercentNet', 'returnIfFlatPercentNet', 'downsideProtectionPercentNet', 'returnOnRiskPercentNet']:
-             df[col] = np.inf
+        for col in ['maxProfitPercentNet', 'returnIfFlatPercentNet', 'downsideProtectionPercentNet', 'returnOnRiskPercentNet']: df[col] = np.inf
 
-    # --- DTE (Days To Expiration) ---
+    # DTE
     try:
-        # Verwende datetime.date für reinen Datumsvergleich
-        exp_date_obj = datetime.strptime(expiration_date, '%Y-%m-%d').date()
-        today = datetime.now().date()
-        dte = (exp_date_obj - today).days
-        if dte < 0: dte = 0 # Falls bereits abgelaufen
-    except ValueError:
-        dte = 0
-        # st.warning nicht in cached function, print ist besser für Debugging
-        print(f"Konnte Datum {expiration_date} nicht für DTE-Berechnung parsen.")
-
+        exp_date_obj = datetime.strptime(expiration_date, '%Y-%m-%d').date(); today = datetime.now().date()
+        dte = (exp_date_obj - today).days; dte = max(0, dte)
+    except ValueError: dte = 0
     df['DTE'] = dte
 
-    # --- Annualisierte Rendite (Basis: Nettoprämie, wenn Flat) ---
-    df['annualizedReturnPercentNet'] = 0.0 # Initialisiere Spalte
-    # Stelle sicher, dass returnIfFlatPercentNet existiert und numerisch ist
+    # Annualisierte Rendite (Netto)
+    df['annualizedReturnPercentNet'] = 0.0
     if 'returnIfFlatPercentNet' in df.columns:
-         df['returnIfFlatPercentNet'] = pd.to_numeric(df['returnIfFlatPercentNet'], errors='coerce') # Umwandeln, Fehler -> NaN
+         df['returnIfFlatPercentNet'] = pd.to_numeric(df['returnIfFlatPercentNet'], errors='coerce')
          valid_annual_mask = (df['DTE'] > 0) & df['returnIfFlatPercentNet'].notna() & (df['returnIfFlatPercentNet'] > 0)
-         safe_dte = df.loc[valid_annual_mask, 'DTE'].replace(0, 1) # Ersetze 0 durch 1 für Berechnung
-         df.loc[valid_annual_mask, 'annualizedReturnPercentNet'] = \
-             df.loc[valid_annual_mask, 'returnIfFlatPercentNet'] * (365.0 / safe_dte)
-         # Setze NaN für ungültige Fälle
+         safe_dte = df.loc[valid_annual_mask, 'DTE'].replace(0, 1)
+         df.loc[valid_annual_mask, 'annualizedReturnPercentNet'] = df.loc[valid_annual_mask, 'returnIfFlatPercentNet'] * (365.0 / safe_dte)
          df['annualizedReturnPercentNet'] = df['annualizedReturnPercentNet'].fillna(0.0)
 
-
-    # --- Breakeven (Basis: Nettoprämie pro Aktie) ---
-    # premium_net_per_share ist bereits eine Series
+    # Breakeven (Netto)
     df['breakeven'] = cost_basis - premium_net_per_share
 
-    # --- % OTM (Out of the Money) ---
+    # % OTM
     df['percentOTM'] = 0.0
     otm_mask = df['strike'] > current_price
-    # Wende Berechnung nur auf OTM-Strikes an
     df.loc[otm_mask, 'percentOTM'] = ((df.loc[otm_mask, 'strike'] - current_price) / current_price) * 100
 
-    # --- Griechen (Standardwerte NaN, wenn nicht vorhanden) ---
+    # Griechen & P.OTM
     for greek in ['delta', 'gamma', 'theta', 'vega']:
-        if greek in df.columns:
-             df[greek] = pd.to_numeric(df[greek], errors='coerce').fillna(np.nan) # Sicherstellen, dass numerisch oder NaN
+        if greek in df.columns: df[greek] = pd.to_numeric(df[greek], errors='coerce').fillna(np.nan)
+        else: df[greek] = np.nan # Sicherstellen, dass Spalte existiert
+
+    # Wahrscheinlichkeit OTM (vereinfacht: 1 - Delta)
+    # Fülle fehlende Deltas mit 0.5 (50/50 Chance) oder 0? 0.5 ist konservativer.
+    df['prob_OTM'] = (1.0 - df['delta'].fillna(0.5)).clip(0, 1) # Auf 0-1 begrenzen
 
     return df
 
+# -- Datums-Prüfungen -- (Funktionen bleiben gleich)
 def is_monthly_expiration(date_str):
-    """Prüft, ob ein Datum wahrscheinlich ein Monatsverfall ist (3. Freitag)."""
-    try:
-        date_obj = datetime.strptime(date_str, '%Y-%m-%d')
-        # Standard US equity monthly expiration
-        return 15 <= date_obj.day <= 21 and date_obj.weekday() == 4 # 4 = Freitag
-    except ValueError:
-        return False
-
+    try: date_obj = datetime.strptime(date_str, '%Y-%m-%d'); return 15 <= date_obj.day <= 21 and date_obj.weekday() == 4
+    except ValueError: return False
 def is_weekly_expiration(date_str):
-    """Prüft, ob ein Datum wahrscheinlich ein Wochenverfall ist (Freitag, aber nicht der 3.)."""
-    try:
-        date_obj = datetime.strptime(date_str, '%Y-%m-%d')
-        # Freitag, aber nicht der 3. Freitag des Monats
-        is_friday = date_obj.weekday() == 4
-        is_third_friday = 15 <= date_obj.day <= 21
-        return is_friday and not is_third_friday
-    except ValueError:
-        return False
-
-# --- Plotting Funktion ---
-def plot_stock_chart(hist_df, ticker_symbol, indicators, sma_periods):
-    """Erstellt einen interaktiven Plotly Chart."""
-    if hist_df.empty: return go.Figure() # Leere Figur zurückgeben, wenn keine Daten
+    try: date_obj = datetime.strptime(date_str, '%Y-%m-%d'); is_friday = date_obj.weekday() == 4; is_third_friday = 15 <= date_obj.day <= 21; return is_friday and not is_third_friday
+    except ValueError: return False
 
+# --- Plotting Funktion --- (Funktion bleibt gleich)
+def plot_stock_chart(hist_df, ticker_symbol, indicators, sma_periods):
+    if hist_df.empty: return go.Figure()
     fig = go.Figure()
-
-    # Candlestick Chart hinzufügen (nur wenn notwendige Spalten vorhanden sind)
     required_cols = ['Open', 'High', 'Low', 'Close']
     if all(col in hist_df.columns for col in required_cols):
-        fig.add_trace(go.Candlestick(x=hist_df.index,
-                        open=hist_df['Open'],
-                        high=hist_df['High'],
-                        low=hist_df['Low'],
-                        close=hist_df['Close'],
-                        name='Kurs'))
-    else:
-        st.warning("Notwendige Spalten (Open, High, Low, Close) für Candlestick fehlen in historischen Daten.")
-        # Fallback: Linienchart für Schlusskurs
-        if 'Close' in hist_df.columns:
-            fig.add_trace(go.Scatter(x=hist_df.index, y=hist_df['Close'], mode='lines', name='Schlusskurs'))
-
-    # Indikatoren hinzufügen
+        fig.add_trace(go.Candlestick(x=hist_df.index, open=hist_df['Open'], high=hist_df['High'], low=hist_df['Low'], close=hist_df['Close'], name='Kurs'))
+    elif 'Close' in hist_df.columns:
+        fig.add_trace(go.Scatter(x=hist_df.index, y=hist_df['Close'], mode='lines', name='Schlusskurs'))
     if 'SMA' in indicators and 'Close' in hist_df.columns:
         for period in sma_periods:
-            if period <= 0: continue # Ungültige Periode überspringen
+            if period <= 0: continue
             sma_col = f'SMA_{period}'
-            hist_df[sma_col] = hist_df['Close'].rolling(window=period, min_periods=1).mean() # min_periods=1 für Anfangswerte
+            hist_df[sma_col] = hist_df['Close'].rolling(window=period, min_periods=1).mean()
             fig.add_trace(go.Scatter(x=hist_df.index, y=hist_df[sma_col], mode='lines', name=sma_col))
-
     if 'Bollinger Bands' in indicators and 'Close' in hist_df.columns:
-        # Nutze erste gültige SMA-Periode oder Standard 20
         bb_period = next((p for p in sma_periods if p > 0), 20)
         sma_col = f'SMA_{bb_period}'
-        # Berechne SMA falls noch nicht vorhanden oder Periode ungültig war
-        if sma_col not in hist_df.columns:
-             hist_df[sma_col] = hist_df['Close'].rolling(window=bb_period, min_periods=1).mean()
-
+        if sma_col not in hist_df.columns: hist_df[sma_col] = hist_df['Close'].rolling(window=bb_period, min_periods=1).mean()
         std_dev = hist_df['Close'].rolling(window=bb_period, min_periods=1).std()
-        upper_band = hist_df[sma_col] + (std_dev * 2)
-        lower_band = hist_df[sma_col] - (std_dev * 2)
-        # Nur hinzufügen, wenn Bänder berechnet werden konnten
-        if not upper_band.empty:
-             fig.add_trace(go.Scatter(x=hist_df.index, y=upper_band, mode='lines', name=f'Upper Band ({bb_period})', line=dict(width=1, dash='dash', color='rgba(150,150,150,0.7)')))
-        if not lower_band.empty:
-             fig.add_trace(go.Scatter(x=hist_df.index, y=lower_band, mode='lines', name=f'Lower Band ({bb_period})', line=dict(width=1, dash='dash', color='rgba(150,150,150,0.7)'), fill='tonexty', fillcolor='rgba(173,216,230,0.2)'))
-
-    fig.update_layout(
-        title=f'{ticker_symbol} Kursverlauf & Indikatoren',
-        xaxis_title='Datum',
-        yaxis_title='Preis',
-        xaxis_rangeslider_visible=False,
-        legend_title_text='Legende',
-        height=500,
-        margin=dict(l=20, r=20, t=40, b=20) # Ränder reduzieren
-    )
+        upper_band = hist_df[sma_col] + (std_dev * 2); lower_band = hist_df[sma_col] - (std_dev * 2)
+        if not upper_band.empty: fig.add_trace(go.Scatter(x=hist_df.index, y=upper_band, mode='lines', name=f'Upper Band ({bb_period})', line=dict(width=1, dash='dash', color='rgba(150,150,150,0.7)')))
+        if not lower_band.empty: fig.add_trace(go.Scatter(x=hist_df.index, y=lower_band, mode='lines', name=f'Lower Band ({bb_period})', line=dict(width=1, dash='dash', color='rgba(150,150,150,0.7)'), fill='tonexty', fillcolor='rgba(173,216,230,0.2)'))
+    fig.update_layout(title=f'{ticker_symbol} Kursverlauf & Indikatoren', xaxis_title='Datum', yaxis_title='Preis', xaxis_rangeslider_visible=False, legend_title_text='Legende', height=500, margin=dict(l=20, r=20, t=40, b=20))
     return fig
 
 # --- Session State Initialisierung ---
-# Definiere die Basis-Spaltennamen mit einem Platzhalter
-base_default_columns = [
-    'Strike', 'Bid', 'Ask', 'Last', 'Impl. Vol (%)', 'Prämie Netto ({currency})',
-    'Rendite (Statisch %)', 'Rendite p.a. (%)', 'Max. Gewinn ({currency})', 'Max. Gewinn (%)',
-    'Breakeven ({currency})', 'Risikopuffer (%)', 'Return on Risk (%)', '% OTM', 'Delta', 'Theta', 'DTE'
+# Neue Standardspalten mit Fokus auf Prämie/Risiko
+base_default_columns_premium = [
+    'Strike', 'Bid', 'Ask', '% OTM', 'Delta', 'prob_OTM', 'Impl. Vol (%)',
+    'Prämie Netto ({currency})', 'Rendite (Statisch %)', 'Rendite p.a. (%)',
+    'Risikopuffer (%)', 'Return on Risk (%)', 'Theta', 'DTE'
+]
+# Optionale Spalten (inkl. der alten Max-Profit-Spalten)
+other_possible_cols_premium = [
+    'Last', 'Volumen', 'Open Int.', 'Gamma', 'Vega',
+    'Max. Gewinn ({currency})', 'Max. Gewinn (%)', 'Breakeven ({currency})'
 ]
-other_possible_cols = ['Volumen', 'Open Int.', 'Gamma', 'Vega']
 
-# Initialisiere State, falls nicht vorhanden
+# Initialisiere State
 if 'ticker_symbol' not in st.session_state: st.session_state.ticker_symbol = "TSLA"
 if 'shares_owned' not in st.session_state: st.session_state.shares_owned = 100
 if 'cost_basis' not in st.session_state: st.session_state.cost_basis = 100.00
@@ -318,190 +219,112 @@ if 'stock_data' not in st.session_state: st.session_state.stock_data = None
 if 'commission' not in st.session_state: st.session_state.commission = 0.65
 if 'premium_price_type' not in st.session_state: st.session_state.premium_price_type = 'bid'
 if 'custom_premium' not in st.session_state: st.session_state.custom_premium = None
+# Initialisiere mit den *neuen* Premium-fokussierten Defaults
 if 'selected_columns' not in st.session_state:
-    st.session_state.selected_columns = [col.format(currency='$') for col in base_default_columns] # Initial mit $
-if 'min_annual_return_filter' not in st.session_state: st.session_state.min_annual_return_filter = 0.0
+    st.session_state.selected_columns = [col.format(currency='$') for col in base_default_columns_premium]
+if 'min_annual_return_filter' not in st.session_state: st.session_state.min_annual_return_filter = 5.0 # Höherer Standard-Min.-Filter
 if 'max_annual_return_filter' not in st.session_state: st.session_state.max_annual_return_filter = 1000.0
 if 'min_delta_filter' not in st.session_state: st.session_state.min_delta_filter = 0.0
-if 'max_delta_filter' not in st.session_state: st.session_state.max_delta_filter = 1.0
-if 'highlight_min_return' not in st.session_state: st.session_state.highlight_min_return = 20.0
+if 'max_delta_filter' not in st.session_state: st.session_state.max_delta_filter = 0.35 # Standardmäßig OTM fokussieren
+if 'highlight_min_return' not in st.session_state: st.session_state.highlight_min_return = 25.0 # Höherer Schwellenwert
+if 'highlight_max_delta' not in st.session_state: st.session_state.highlight_max_delta = 0.30 # Delta-Schwelle für Hervorhebung
+if 'show_only_otm' not in st.session_state: st.session_state.show_only_otm = True # Standardmäßig nur OTM zeigen
+# Chart & Datum Filter State (bleiben gleich)
 if 'chart_period' not in st.session_state: st.session_state.chart_period = '1y'
 if 'chart_interval' not in st.session_state: st.session_state.chart_interval = '1d'
 if 'chart_indicators' not in st.session_state: st.session_state.chart_indicators = ['SMA']
 if 'chart_sma_periods' not in st.session_state: st.session_state.chart_sma_periods = [50, 200]
 if 'date_filter_type' not in st.session_state: st.session_state.date_filter_type = 'Alle'
 
+
 # --- Währung und Spaltennamen VOR der Sidebar bestimmen ---
-current_currency_symbol = '$' # Default
+current_currency_symbol = '$'
 if st.session_state.stock_data and isinstance(st.session_state.stock_data, dict):
      current_currency_symbol = st.session_state.stock_data.get('currency', '$')
 
-current_default_columns = [col.format(currency=current_currency_symbol) for col in base_default_columns]
-current_all_possible_columns = current_default_columns + other_possible_cols
+# Verwende die *neuen* Basis-Spaltenlisten
+current_default_columns = [col.format(currency=current_currency_symbol) for col in base_default_columns_premium]
+current_all_possible_columns = current_default_columns + [col.format(currency=current_currency_symbol) for col in other_possible_cols_premium]
 
-# Stelle sicher, dass die Defaults im State die aktuelle Währung verwenden
-# Ersetze bekannte Währungssymbole im State, falls sie nicht zur aktuellen passen
+# Passe Defaults im State an aktuelle Währung an
 temp_selected_columns = []
 for col in st.session_state.selected_columns:
-     # Ersetze bekannte Währungssymbole oder Platzhalter
-     updated_col = col.replace("($)", f"({current_currency_symbol})")
-     updated_col = updated_col.replace("(USD)", f"({current_currency_symbol})")
-     updated_col = updated_col.replace("(EUR)", f"({current_currency_symbol})")
-     # Füge hinzu, wenn es jetzt eine gültige Spalte ist
-     if updated_col in current_all_possible_columns:
-         temp_selected_columns.append(updated_col)
-     # Fallback: Wenn Originalspalte (ohne Währung) existiert, füge sie mit neuer Währung hinzu
-     elif any(base_col.replace("{currency}", "") in updated_col for base_col in base_default_columns) and updated_col.format(currency=current_currency_symbol) in current_all_possible_columns:
-         temp_selected_columns.append(updated_col.format(currency=current_currency_symbol))
-
-
+     updated_col = col.replace("($)", f"({current_currency_symbol})").replace("(USD)", f"({current_currency_symbol})").replace("(EUR)", f"({current_currency_symbol})")
+     if updated_col in current_all_possible_columns: temp_selected_columns.append(updated_col)
 st.session_state.selected_columns = temp_selected_columns
-# Filtere Defaults auf nur die, die jetzt in den aktuellen Optionen vorkommen
-valid_defaults_for_multiselect = [
-    col for col in st.session_state.selected_columns if col in current_all_possible_columns
-]
-# Wenn nach Filterung keine Defaults mehr übrig sind, nimm die Standard-Defaults
-if not valid_defaults_for_multiselect:
-     valid_defaults_for_multiselect = current_default_columns
+valid_defaults_for_multiselect = [col for col in st.session_state.selected_columns if col in current_all_possible_columns]
+if not valid_defaults_for_multiselect: valid_defaults_for_multiselect = current_default_columns
 
 
 # --- SIDEBAR ---
 with st.sidebar:
     st.header("⚙️ Eingaben & Einstellungen")
-
-    # -- Positionsdetails --
     st.subheader("Positionsdetails")
-    ticker_input = st.text_input(
-        "Aktien Ticker", value=st.session_state.ticker_symbol, key="ticker_input_key"
-    ).upper()
-    shares_input = st.number_input(
-        "Anzahl Aktien", min_value=100, step=100, value=st.session_state.shares_owned, key="shares_input_key"
-    )
-    cost_basis_input = st.number_input(
-        "Ø Einstandskurs / Aktie", min_value=0.01, step=0.01, value=st.session_state.cost_basis, format="%.2f", key="cost_basis_input_key"
-    )
-
-    # -- Annahmen --
+    ticker_input = st.text_input("Aktien Ticker", value=st.session_state.ticker_symbol, key="ticker_input_key").upper()
+    shares_input = st.number_input("Anzahl Aktien", min_value=100, step=100, value=st.session_state.shares_owned, key="shares_input_key")
+    cost_basis_input = st.number_input("Ø Einstandskurs / Aktie", min_value=0.01, step=0.01, value=st.session_state.cost_basis, format="%.2f", key="cost_basis_input_key", help="Wird für Breakeven & optionale Max-Profit-Spalten verwendet.")
+
     st.subheader("Annahmen")
-    premium_price_type_input = st.selectbox(
-        "Preis für Prämie?", options=['bid', 'mid', 'last'],
-        index=['bid', 'mid', 'last'].index(st.session_state.premium_price_type),
-        help="Welcher Preis für Prämienberechnung? 'Bid' konservativ.", key="premium_select_key"
-    )
-    custom_premium_input = st.number_input(
-        "Manuelle Prämie / Aktie", min_value=0.0, step=0.01,
-        value=st.session_state.custom_premium if st.session_state.custom_premium is not None else 0.0,
-        format="%.2f", help="> 0 überschreibt Auswahl oben.", key="custom_prem_key"
-    )
-    commission_input = st.number_input(
-        "Provision / Kontrakt", min_value=0.0, step=0.01, value=st.session_state.commission, format="%.2f", key="commission_key"
-    )
-
-    # -- Analyse Knopf --
+    premium_price_type_input = st.selectbox("Preis für Prämie?", ['bid', 'mid', 'last'], index=['bid', 'mid', 'last'].index(st.session_state.premium_price_type), help="Welcher Preis für Prämienberechnung?", key="premium_select_key")
+    custom_premium_input = st.number_input("Manuelle Prämie / Aktie", 0.0, step=0.01, value=st.session_state.custom_premium or 0.0, format="%.2f", help="> 0 überschreibt Auswahl.", key="custom_prem_key")
+    commission_input = st.number_input("Provision / Kontrakt", 0.0, step=0.01, value=st.session_state.commission, format="%.2f", key="commission_key")
+
     if st.button("Analyse Starten / Werte Übernehmen", key="analyze_sidebar", use_container_width=True):
         ticker_changed = (ticker_input != st.session_state.ticker_symbol)
-
-        # Update state from inputs
-        st.session_state.ticker_symbol = ticker_input
-        st.session_state.shares_owned = shares_input
-        st.session_state.cost_basis = cost_basis_input
-        st.session_state.premium_price_type = premium_price_type_input
-        st.session_state.custom_premium = custom_premium_input if custom_premium_input > 0 else None
-        st.session_state.commission = commission_input
-
-        # Reset stock data if ticker changed to force reload
+        st.session_state.ticker_symbol = ticker_input; st.session_state.shares_owned = shares_input; st.session_state.cost_basis = cost_basis_input
+        st.session_state.premium_price_type = premium_price_type_input; st.session_state.custom_premium = custom_premium_input if custom_premium_input > 0 else None; st.session_state.commission = commission_input
         if ticker_changed:
             st.session_state.stock_data = None
-            # Reset selected columns to default with '$' placeholder when ticker changes,
-            # as we don't know the new currency yet.
-            st.session_state.selected_columns = [col.format(currency='$') for col in base_default_columns]
+            # Setze auf neue Premium-Defaults zurück
+            st.session_state.selected_columns = [col.format(currency='$') for col in base_default_columns_premium]
+        st.rerun()
 
-        st.rerun() # Force rerun to apply changes and reload data if needed
+    st.divider()
+    st.subheader("Tabellen-Anzeige")
+    # Neuer Filter: Nur OTM anzeigen
+    st.session_state.show_only_otm = st.toggle("Nur OTM-Optionen anzeigen", value=st.session_state.show_only_otm, key="otm_toggle")
 
-    st.divider() # Visuelle Trennung
+    selected_cols_input = st.multiselect("Angezeigte Spalten:", options=sorted(list(set(current_all_possible_columns))), default=valid_defaults_for_multiselect, key="col_select_key")
+    if selected_cols_input != st.session_state.selected_columns: st.session_state.selected_columns = selected_cols_input; st.rerun()
 
-    # -- Tabellen-Anpassung --
-    st.subheader("Tabellen-Anzeige")
-    selected_cols_input = st.multiselect(
-        "Angezeigte Spalten:",
-        options=sorted(list(set(current_all_possible_columns))), # Use current options
-        default=valid_defaults_for_multiselect,                  # Use filtered current defaults
-        key="col_select_key"
-    )
-    # Update state only if selection actually changed to prevent unnecessary reruns
-    if selected_cols_input != st.session_state.selected_columns:
-         st.session_state.selected_columns = selected_cols_input
-         st.rerun() # Rerun to apply column selection
-
-    # -- Hervorhebung --
-    st.session_state.highlight_min_return = st.number_input(
-        "Rendite p.a. hervorheben > X%",
-        min_value=0.0, step=1.0,
-        value=st.session_state.highlight_min_return,
-        format="%.1f", key="highlight_key"
-    )
+    st.subheader("Hervorhebung (Tabelle)")
+    hc1, hc2 = st.columns(2)
+    with hc1: st.session_state.highlight_min_return = st.number_input("Min. Rendite p.a. >", 0.0, step=1.0, value=st.session_state.highlight_min_return, format="%.1f", key="highlight_ret_key")
+    with hc2: st.session_state.highlight_max_delta = st.number_input("Max. Delta <", 0.0, 1.0, step=0.01, value=st.session_state.highlight_max_delta, format="%.2f", key="highlight_delta_key")
 
     st.divider()
-
-    # -- Chart-Einstellungen --
     st.subheader("Chart-Einstellungen")
+    # Chart Inputs bleiben gleich
     st.session_state.chart_period = st.selectbox("Zeitraum:", ['1mo', '3mo', '6mo', 'ytd', '1y', '2y', '5y', 'max'], index=4, key="chart_period_key")
     st.session_state.chart_interval = st.selectbox("Intervall:", ['1d', '1wk', '1mo'], index=0, key="chart_interval_key")
     st.session_state.chart_indicators = st.multiselect("Indikatoren:", ['SMA', 'Bollinger Bands'], default=st.session_state.chart_indicators, key="chart_ind_key")
     if 'SMA' in st.session_state.chart_indicators or 'Bollinger Bands' in st.session_state.chart_indicators:
-        sma_periods_str = st.text_input(
-            "SMA Perioden (kommagetrennt):",
-            value=", ".join(map(str, st.session_state.chart_sma_periods)),
-            key="chart_sma_key"
-        )
+        sma_periods_str = st.text_input("SMA Perioden (kommagetrennt):", value=", ".join(map(str, st.session_state.chart_sma_periods)), key="chart_sma_key")
         try:
-            parsed_periods = [int(p.strip()) for p in sma_periods_str.split(',') if p.strip().isdigit() and int(p.strip()) > 0] # Nur positive Zahlen
-            if parsed_periods: # Nur updaten, wenn gültige Perioden gefunden wurden
-                 st.session_state.chart_sma_periods = parsed_periods
-            else: # Wenn Eingabe leer oder ungültig war
-                 if sma_periods_str.strip(): # Nur warnen wenn etwas eingegeben wurde
-                     st.warning("Ungültige Eingabe für SMA Perioden. Bsp: 50, 200")
-                 st.session_state.chart_sma_periods = [50, 200] # Fallback
-        except:
-            st.warning("Fehler beim Verarbeiten der SMA Perioden.")
-            st.session_state.chart_sma_periods = [50, 200] # Fallback
+            parsed_periods = [int(p.strip()) for p in sma_periods_str.split(',') if p.strip().isdigit() and int(p.strip()) > 0]
+            if parsed_periods: st.session_state.chart_sma_periods = parsed_periods
+            else:
+                 if sma_periods_str.strip(): st.warning("Ungültige SMA Perioden.")
+                 st.session_state.chart_sma_periods = [50, 200]
+        except: st.warning("Fehler bei SMA Perioden."); st.session_state.chart_sma_periods = [50, 200]
 
 # --- HAUPTSEITE ---
-st.title("📈 Option Yield Pro (Lokal)")
+st.title("📈 Option Yield Pro (Premium Focus)")
 
-# Nur weitermachen, wenn Ticker im State ist
-if not st.session_state.ticker_symbol:
-    st.info("👈 Bitte geben Sie links einen Aktien-Ticker ein und klicken Sie auf 'Analyse Starten'.")
-    st.stop()
+if not st.session_state.ticker_symbol: st.info("👈 Bitte Ticker eingeben & Analysieren."); st.stop()
 
 # --- Aktiendaten Laden & Anzeigen ---
-# Versuche Ticker Objekt zu holen (aus Cache oder neu)
 ticker_obj = get_ticker_object(st.session_state.ticker_symbol)
 if ticker_obj is None:
-     st.error(f"Konnte Ticker-Objekt für '{st.session_state.ticker_symbol}' nicht laden. Ist der Ticker gültig?")
-     st.session_state.ticker_symbol = "" # Reset ticker
-     st.session_state.stock_data = None  # Reset data
-     time.sleep(2) # Allow user to see the message
-     st.rerun()
-     # st.stop() # Alternative
-
-# Lade Aktiendaten nur, wenn sie noch nicht im State sind für diesen Ticker
+     st.error(f"Ticker-Objekt für '{st.session_state.ticker_symbol}' ungültig."); st.session_state.ticker_symbol = ""; st.session_state.stock_data = None; time.sleep(2); st.rerun()
+
 rerun_needed_after_data_load = False
 if st.session_state.stock_data is None:
-     with st.spinner(f"Lade Daten für {st.session_state.ticker_symbol}..."):
-        stock_data_result, error_msg = get_stock_data(ticker_obj)
-     if error_msg:
-         st.error(f"Fehler Aktiendaten: {error_msg}")
-         st.stop()
-     st.session_state.stock_data = stock_data_result
-     rerun_needed_after_data_load = True # Mark that a rerun is needed
-
-# Wichtig: Wenn Daten gerade geladen wurden, neu ausführen, damit die Währung
-# korrekt in der Sidebar *beim nächsten Durchlauf* verwendet wird!
-if rerun_needed_after_data_load:
-    st.rerun()
-
-# --- Ab hier gehen wir davon aus, dass stock_data im State ist ---
+     with st.spinner(f"Lade Daten für {st.session_state.ticker_symbol}..."): stock_data_result, error_msg = get_stock_data(ticker_obj)
+     if error_msg: st.error(f"Fehler Aktiendaten: {error_msg}"); st.stop()
+     st.session_state.stock_data = stock_data_result; rerun_needed_after_data_load = True
+if rerun_needed_after_data_load: st.rerun()
+
 stock_data = st.session_state.stock_data
 currency_symbol = stock_data.get('currency', '$')
 
@@ -510,134 +333,80 @@ display_columns = {
     'strike': 'Strike', 'bid': 'Bid', 'ask': 'Ask', 'lastPrice': 'Last',
     'volume': 'Volumen', 'openInterest': 'Open Int.', 'impliedVolatility': 'Impl. Vol (%)',
     'premiumNetTotal': f'Prämie Netto ({currency_symbol})',
-    'returnIfFlatPercentNet': 'Rendite (Statisch %)',
-    'annualizedReturnPercentNet': 'Rendite p.a. (%)',
-    'maxProfitAssignedNet': f'Max. Gewinn ({currency_symbol})',
-    'maxProfitPercentNet': 'Max. Gewinn (%)',
-    'breakeven': f'Breakeven ({currency_symbol})',
+    'returnIfFlatPercentNet': 'Rendite (Statisch %)', # Prämienrendite
+    'annualizedReturnPercentNet': 'Rendite p.a. (%)', # Prämie p.a.
+    'maxProfitAssignedNet': f'Max. Gewinn ({currency_symbol})', # Optional
+    'maxProfitPercentNet': 'Max. Gewinn (%)', # Optional
+    'breakeven': f'Breakeven ({currency_symbol})', # Optional
     'downsideProtectionPercentNet': 'Risikopuffer (%)',
     'returnOnRiskPercentNet': 'Return on Risk (%)',
-    '% OTM': '% OTM', 'delta': 'Delta', 'theta': 'Theta',
-    'gamma': 'Gamma', 'vega': 'Vega','DTE': 'DTE'
+    'percentOTM': '% OTM', 'delta': 'Delta', 'theta': 'Theta',
+    'gamma': 'Gamma', 'vega': 'Vega', 'prob_OTM': 'W\'keit OTM (%)', # Neu
+    'DTE': 'DTE'
 }
 
 # --- Anzeige der Aktiendaten ---
 st.header(f"📊 {stock_data['name']} ({st.session_state.ticker_symbol})")
 price_color = "green" if stock_data['change'] >= 0 else "red"
 mcol1, mcol2, mcol3 = st.columns(3)
-with mcol1:
-    st.metric(f"Akt. Kurs ({currency_symbol})", f"{stock_data.get('price', 0):.2f}", f"{stock_data.get('change', 0):.2f} ({stock_data.get('change_percent', 0):.2f}%)", delta_color="normal" if price_color == "green" else "inverse")
-with mcol2:
-    low_52w = stock_data.get('fifty_two_week_low')
-    if low_52w is not None: st.metric("52W Tief", f"{currency_symbol}{low_52w:.2f}")
-with mcol3:
-    high_52w = stock_data.get('fifty_two_week_high')
-    if high_52w is not None: st.metric("52W Hoch", f"{currency_symbol}{high_52w:.2f}")
+with mcol1: st.metric(f"Akt. Kurs ({currency_symbol})", f"{stock_data.get('price', 0):.2f}", f"{stock_data.get('change', 0):.2f} ({stock_data.get('change_percent', 0):.2f}%)", delta_color="normal" if price_color == "green" else "inverse")
+with mcol2: low_52w = stock_data.get('fifty_two_week_low'); high_52w = stock_data.get('fifty_two_week_high') # Hole beide
+if low_52w is not None and high_52w is not None: with mcol2: st.metric("52W Spanne", f"{currency_symbol}{low_52w:.2f} - {high_52w:.2f}")
 
 # --- Chart Sektion ---
 with st.expander("📈 Detailierter Aktienchart Anzeigen/Verbergen"):
     hist_df = get_stock_history(ticker_obj, st.session_state.chart_period, st.session_state.chart_interval)
-    if not hist_df.empty:
-            fig = plot_stock_chart(hist_df, st.session_state.ticker_symbol, st.session_state.chart_indicators, st.session_state.chart_sma_periods)
-            st.plotly_chart(fig, use_container_width=True)
-    else:
-            st.warning("Keine historischen Daten für die gewählten Chart-Parameter verfügbar.")
+    if not hist_df.empty: fig = plot_stock_chart(hist_df, st.session_state.ticker_symbol, st.session_state.chart_indicators, st.session_state.chart_sma_periods); st.plotly_chart(fig, use_container_width=True)
+    else: st.warning("Keine Chart-Daten verfügbar.")
 
-st.divider()
-st.header("🔍 Options-Analyse")
+st.divider(); st.header("🔍 Options-Analyse")
 
 # --- Ablaufdatum Auswahl ---
 col_d1, col_d2 = st.columns([1, 3])
 with col_d1:
-        st.markdown("###### Verfallstyp Filtern:")
-        date_filter_options = ['Alle', 'Monatlich', 'Wöchentlich']
-        # Stelle sicher, dass der Index gültig ist, falls Option nicht existiert (sollte nicht passieren)
-        try:
-             date_filter_idx = date_filter_options.index(st.session_state.date_filter_type)
-        except ValueError:
-             date_filter_idx = 0 # Fallback auf 'Alle'
-        st.session_state.date_filter_type = st.radio(
-            "Typ:", options=date_filter_options, index=date_filter_idx,
-            horizontal=True, label_visibility="collapsed"
-            )
+        st.markdown("###### Verfallstyp Filter:")
+        date_filter_options = ['Alle', 'Monatlich', 'Wöchentlich']; date_filter_idx = 0
+        try: date_filter_idx = date_filter_options.index(st.session_state.date_filter_type)
+        except ValueError: pass
+        st.session_state.date_filter_type = st.radio("Typ:", date_filter_options, index=date_filter_idx, horizontal=True, label_visibility="collapsed")
 with col_d2:
         st.markdown("###### Ablaufdatum Wählen:")
         option_dates_all = get_option_dates(ticker_obj)
-        if not option_dates_all:
-            st.warning("Keine Optionsdaten gefunden.")
-            st.stop()
-
-        # Filter dates based on selection
-        if st.session_state.date_filter_type == 'Monatlich':
-            option_dates_filtered = [d for d in option_dates_all if is_monthly_expiration(d)]
-        elif st.session_state.date_filter_type == 'Wöchentlich':
-            option_dates_filtered = [d for d in option_dates_all if is_weekly_expiration(d)]
-        else: # Alle
-            option_dates_filtered = option_dates_all
-
-        if not option_dates_filtered:
-              st.warning(f"Keine '{st.session_state.date_filter_type}' Ablaufdaten gefunden.")
-              selected_exp_date = None
-        else:
-              selected_exp_date = st.selectbox(
-                  "Verfügbare Daten:", options=option_dates_filtered, index=0, label_visibility="collapsed"
-              )
+        if not option_dates_all: st.warning("Keine Optionsdaten gefunden."); st.stop()
+        if st.session_state.date_filter_type == 'Monatlich': option_dates_filtered = [d for d in option_dates_all if is_monthly_expiration(d)]
+        elif st.session_state.date_filter_type == 'Wöchentlich': option_dates_filtered = [d for d in option_dates_all if is_weekly_expiration(d)]
+        else: option_dates_filtered = option_dates_all
+        if not option_dates_filtered: st.warning(f"Keine '{st.session_state.date_filter_type}' Ablaufdaten."); selected_exp_date = None
+        else: selected_exp_date = st.selectbox("Verfügbare Daten:", option_dates_filtered, index=0, label_visibility="collapsed")
 
 # --- Optionskette Laden & Berechnen ---
 if selected_exp_date:
-    # Lade Kette mit Spinner
-    with st.spinner(f"Lade Optionskette für {selected_exp_date}..."):
-        calls_chain = get_option_chain(ticker_obj, selected_exp_date)
-
+    with st.spinner(f"Lade Optionskette für {selected_exp_date}..."): calls_chain = get_option_chain(ticker_obj, selected_exp_date)
     if not calls_chain.empty:
-        # Berechne Metriken mit Spinner
-        with st.spinner("Berechne Metriken..."):
-            calculated_df_unfiltered = calculate_covered_calls(
-                calls_chain, stock_data['price'], st.session_state.shares_owned,
-                st.session_state.cost_basis, selected_exp_date, st.session_state.premium_price_type,
-                st.session_state.custom_premium, st.session_state.commission
-            )
+        with st.spinner("Berechne Metriken..."): calculated_df_unfiltered = calculate_covered_calls(calls_chain, stock_data['price'], st.session_state.shares_owned, st.session_state.cost_basis, selected_exp_date, st.session_state.premium_price_type, st.session_state.custom_premium, st.session_state.commission)
 
         # --- Tabellenfilter Widgets ---
         st.markdown("###### Tabellenfilter:")
         fcol1, fcol2 = st.columns(2)
-        with fcol1:
-                # Stelle sicher, dass min <= max
-                min_r, max_r = st.slider(
-                    "Filter: Rendite p.a. (%)", 0.0, 500.0,
-                    (st.session_state.min_annual_return_filter, st.session_state.max_annual_return_filter),
-                    step=5.0
-                )
-                st.session_state.min_annual_return_filter = min(min_r, max_r)
-                st.session_state.max_annual_return_filter = max(min_r, max_r)
-
-        with fcol2:
-                min_d, max_d = st.slider(
-                    "Filter: Delta", 0.0, 1.0,
-                    (st.session_state.min_delta_filter, st.session_state.max_delta_filter),
-                    step=0.01
-                )
-                st.session_state.min_delta_filter = min(min_d, max_d)
-                st.session_state.max_delta_filter = max(min_d, max_d)
+        with fcol1: min_r, max_r = st.slider("Filter: Rendite p.a. (%)", 0.0, 500.0, (st.session_state.min_annual_return_filter, st.session_state.max_annual_return_filter), 5.0); st.session_state.min_annual_return_filter, st.session_state.max_annual_return_filter = min(min_r, max_r), max(min_r, max_r)
+        with fcol2: min_d, max_d = st.slider("Filter: Delta", 0.0, 1.0, (st.session_state.min_delta_filter, st.session_state.max_delta_filter), 0.01); st.session_state.min_delta_filter, st.session_state.max_delta_filter = min(min_d, max_d), max(min_d, max_d)
 
         # --- Filter anwenden ---
         filtered_df = calculated_df_unfiltered.copy()
-        # Rendite (behandle NaN und unendliche Werte korrekt)
-        rendite_col = 'annualizedReturnPercentNet'
+        # OTM Filter (wenn aktiviert)
+        if st.session_state.show_only_otm:
+             # Behalte auch NaNs bei percentOTM oder wenn percentOTM == 0 (ATM) - strike >= current_price
+             filtered_df = filtered_df[(filtered_df['strike'] >= stock_data['price']) | filtered_df['percentOTM'].isna()]
+
+        # Rendite Filter
+        rendite_col = 'annualizedReturnPercentNet'; delta_col = 'delta'
         if rendite_col in filtered_df.columns:
              numeric_rendite = pd.to_numeric(filtered_df[rendite_col], errors='coerce')
-             filtered_df = filtered_df[
-                 numeric_rendite.between(st.session_state.min_annual_return_filter, st.session_state.max_annual_return_filter, inclusive='both') |
-                 numeric_rendite.isna() # Behalte NaNs bei
-                 ]
-        # Delta (behandle NaN korrekt)
-        delta_col = 'delta'
+             filtered_df = filtered_df[numeric_rendite.between(st.session_state.min_annual_return_filter, st.session_state.max_annual_return_filter, inclusive='both') | numeric_rendite.isna()]
+        # Delta Filter
         if delta_col in filtered_df.columns:
              numeric_delta = pd.to_numeric(filtered_df[delta_col], errors='coerce')
-             filtered_df = filtered_df[
-                 numeric_delta.between(st.session_state.min_delta_filter, st.session_state.max_delta_filter, inclusive='both') |
-                 numeric_delta.isna() # Behalte NaNs bei
-                 ]
+             filtered_df = filtered_df[numeric_delta.between(st.session_state.min_delta_filter, st.session_state.max_delta_filter, inclusive='both') | numeric_delta.isna()]
 
         # --- Tabelle Anzeigen ---
         st.markdown(f"###### Call-Optionen für {datetime.strptime(selected_exp_date, '%Y-%m-%d').strftime('%d. %B %Y')} ({len(filtered_df)} angezeigt)")
@@ -647,115 +416,81 @@ if selected_exp_date:
         original_cols_keys_to_display = [key for key, value in display_columns.items() if value in selected_display_names]
         cols_to_display_final = [col for col in original_cols_keys_to_display if col in filtered_df.columns]
 
-        if not cols_to_display_final:
-            st.warning("Keine gültigen Spalten zur Anzeige ausgewählt oder in den Daten vorhanden.")
-            display_df_render = pd.DataFrame()
-        else:
-            display_df_render = filtered_df[cols_to_display_final].rename(columns=display_columns)
+        if not cols_to_display_final: st.warning("Keine gültigen Spalten zur Anzeige ausgewählt."); display_df_render = pd.DataFrame()
+        else: display_df_render = filtered_df[cols_to_display_final].rename(columns=display_columns)
 
         if not display_df_render.empty:
-            # Formatierungsregeln dynamisch anwenden
+            # Formatierung
             format_dict = { col: '{:.2f}' for col in display_df_render.columns if col.startswith(('Strike', 'Bid', 'Ask', 'Last')) }
             format_dict.update({ col: '{:,.2f}' for col in display_df_render.columns if f'({currency_symbol})' in col })
-            format_dict.update({ col: '{:.1f}%' for col in display_df_render.columns if '%' in col and 'Impl. Vol' not in col })
-            format_dict.update({
-                'Impl. Vol (%)': '{:.1%}', 'Delta': '{:.3f}', 'Theta': '{:.3f}',
-                'Gamma': '{:.4f}', 'Vega': '{:.3f}', 'Volumen': '{:,}',
-                'Open Int.': '{:,}', 'DTE': '{:,d}'
-            })
+            format_dict.update({ col: '{:.1f}%' for col in display_df_render.columns if '%' in col and 'Impl. Vol' not in col and 'W\'keit OTM' not in col}) # W'keit extra formatieren
+            format_dict.update({ 'Impl. Vol (%)': '{:.1%}', 'W\'keit OTM (%)': '{:.1%}', 'Delta': '{:.3f}', 'Theta': '{:.3f}', 'Gamma': '{:.4f}', 'Vega': '{:.3f}', 'Volumen': '{:,}', 'Open Int.': '{:,}', 'DTE': '{:,d}' })
             final_format_dict = {k: v for k, v in format_dict.items() if k in display_df_render.columns}
 
             # Styler
             styler = display_df_render.style.format(final_format_dict, na_rep="-")
 
-            # --- Dynamisches Styling anwenden (mit Fehlerbehandlung) ---
-            # Highlight Rendite
-            highlight_return_col = 'Rendite p.a. (%)'
-            if highlight_return_col in display_df_render.columns:
-                min_ret_highlight = st.session_state.highlight_min_return
+            # Highlight basierend auf Rendite UND Delta
+            highlight_ret_col = 'Rendite p.a. (%)'; highlight_delta_col = 'Delta'
+            min_ret = st.session_state.highlight_min_return; max_delta = st.session_state.highlight_max_delta
+            if highlight_ret_col in display_df_render.columns and highlight_delta_col in display_df_render.columns:
                 try:
-                    styler.applymap(
-                        lambda x: f'background-color: #e8f5e9' if pd.notna(x) and isinstance(x, (int, float)) and x >= min_ret_highlight else '',
-                        subset=[highlight_return_col]
-                    )
-                except Exception as e: print(f"Styling Error (Highlight): {e}")
-
-            # Farbverläufe
-            gradient_cols = {
-                'Rendite p.a. (%)': 'Greens', 'Return on Risk (%)': 'Greens',
-                'Impl. Vol (%)': 'RdYlGn', 'Delta': 'Blues', 'Theta': 'Reds_r'
-            }
+                    def highlight_premium_sweetspot(row):
+                         ret = pd.to_numeric(row[highlight_ret_col], errors='coerce')
+                         delta = pd.to_numeric(row[highlight_delta_col], errors='coerce')
+                         if pd.notna(ret) and pd.notna(delta) and ret >= min_ret and delta <= max_delta:
+                             return ['background-color: #e8f5e9'] * len(row) # Helles Grün
+                         return [''] * len(row)
+                    styler.apply(highlight_premium_sweetspot, axis=1)
+                except Exception as e: print(f"Styling Error (Highlight Sweetspot): {e}")
+
+            # Farbverläufe etc. (wie vorher)
+            gradient_cols = {'Rendite p.a. (%)': 'Greens', 'Return on Risk (%)': 'Greens', 'Impl. Vol (%)': 'RdYlGn', 'Delta': 'Blues', 'Theta': 'Reds_r', 'W\'keit OTM (%)': 'Greens'}
             for col, cmap in gradient_cols.items():
                 if col in display_df_render.columns:
-                    try: styler.background_gradient(cmap=cmap, subset=[col], axis=0) # axis=0 für spaltenweisen Verlauf
+                    try: styler.background_gradient(cmap=cmap, subset=[col], axis=0)
                     except Exception as e: print(f"Styling Error (Gradient {col}): {e}")
-
-            # Balken
             bar_cols = ["Volumen", "Open Int.", "% OTM"]
             for col in bar_cols:
                 if col in display_df_render.columns:
-                        try: styler.bar(subset=[col], color='lightblue', align='zero', vmin=0)
-                        except Exception as e: print(f"Styling Error (Bar {col}): {e}")
+                    try: styler.bar(subset=[col], color='lightblue', align='zero', vmin=0)
+                    except Exception as e: print(f"Styling Error (Bar {col}): {e}")
 
-            # Tabelle anzeigen
             st.dataframe(styler, use_container_width=True, height=500)
-            st.caption("🖱️ Klicken Sie auf Spaltenüberschriften zum Sortieren.")
+            st.caption("🖱️ Spalten sortieren. Grüner Hintergrund: Erfüllt Hervorhebungs-Kriterien (Rendite & Delta).")
 
             # --- Payoff Visualisierung ---
-            st.divider()
-            st.subheader("💡 Payoff & Kennzahlen (Auswahl)")
+            st.divider(); st.subheader("💡 Payoff & Kennzahlen (Auswahl)")
             available_strikes = sorted(calculated_df_unfiltered['strike'].round(2).unique().tolist())
             if available_strikes:
-                current_p = stock_data['price']
-                # Index des Strikes finden, der dem aktuellen Preis am nächsten ist
-                default_strike_idx = np.abs(np.array(available_strikes) - current_p).argmin()
-
-                selected_strike_for_chart = st.selectbox(
-                    "Strike zur Visualisierung wählen:", options=available_strikes,
-                    index=default_strike_idx, # Standardmäßig nächster Strike
-                    format_func=lambda x: f"{currency_symbol}{x:.2f}",
-                    key="payoff_strike_select"
-                )
-                # Finde die Zeile im *ungefilterten* DF mit Toleranz
+                current_p = stock_data['price']; default_strike_idx = np.abs(np.array(available_strikes) - current_p).argmin()
+                selected_strike_for_chart = st.selectbox("Strike zur Visualisierung:", available_strikes, index=default_strike_idx, format_func=lambda x: f"{currency_symbol}{x:.2f}", key="payoff_strike_select")
                 selected_row = calculated_df_unfiltered[np.isclose(calculated_df_unfiltered['strike'], selected_strike_for_chart)].iloc[0]
 
-                # Payoff-Berechnung und Chart
-                premium_net_chart = selected_row['premiumNetTotal']
-                strike_chart = selected_row['strike']
-                cost_basis_chart = st.session_state.cost_basis
-                shares_chart = st.session_state.shares_owned
-                min_price_chart = cost_basis_chart * 0.7
-                max_price_chart = max(current_p, strike_chart) * 1.3
-                stock_prices_at_exp = np.linspace(min_price_chart, max_price_chart, 150)
-                profit_loss = [
-                    ((strike_chart - cost_basis_chart) * shares_chart + premium_net_chart) if price_exp > strike_chart
-                    else ((price_exp - cost_basis_chart) * shares_chart + premium_net_chart)
-                    for price_exp in stock_prices_at_exp
-                ]
+                # Payoff Chart (wie vorher)
+                premium_net_chart = selected_row['premiumNetTotal']; strike_chart = selected_row['strike']; cost_basis_chart = st.session_state.cost_basis; shares_chart = st.session_state.shares_owned
+                min_price_chart = cost_basis_chart * 0.7; max_price_chart = max(current_p, strike_chart) * 1.3; stock_prices_at_exp = np.linspace(min_price_chart, max_price_chart, 150)
+                profit_loss = [((strike_chart - cost_basis_chart) * shares_chart + premium_net_chart) if px > strike_chart else ((px - cost_basis_chart) * shares_chart + premium_net_chart) for px in stock_prices_at_exp]
                 payoff_df = pd.DataFrame({'Aktienkurs bei Ablauf': stock_prices_at_exp, f'Gewinn/Verlust ({currency_symbol})': profit_loss})
-                st.line_chart(payoff_df, x='Aktienkurs bei Ablauf', y=f'Gewinn/Verlust ({currency_symbol})')
-                st.caption(f"Payoff für Verkauf des {currency_symbol}{strike_chart:.2f} Calls (Netto).")
+                st.line_chart(payoff_df, x='Aktienkurs bei Ablauf', y=f'Gewinn/Verlust ({currency_symbol})'); st.caption(f"Payoff für {currency_symbol}{strike_chart:.2f} Call (Netto).")
 
-                # Kennzahlen anzeigen (mit Prüfung auf NaN/Inf für Formatierung)
+                # Kennzahlen (Fokus auf Prämie & Risiko OTM)
                 st.markdown("###### Kennzahlen für ausgewählten Strike:")
                 kcol1, kcol2, kcol3, kcol4 = st.columns(4)
-                with kcol1: st.metric("Max. Gewinn (Netto)", f"{currency_symbol}{selected_row['maxProfitAssignedNet']:,.2f}", f"{selected_row['maxProfitPercentNet']:.1f}%" if pd.notna(selected_row['maxProfitPercentNet']) and np.isfinite(selected_row['maxProfitPercentNet']) else "N/A")
-                with kcol2: st.metric("Prämie (Netto)", f"{currency_symbol}{selected_row['premiumNetTotal']:,.2f}", f"{selected_row['returnIfFlatPercentNet']:.1f}% Stat." if pd.notna(selected_row['returnIfFlatPercentNet']) and np.isfinite(selected_row['returnIfFlatPercentNet']) else "N/A")
-                with kcol3: st.metric("Breakeven Kurs", f"{currency_symbol}{selected_row['breakeven']:,.2f}" if pd.notna(selected_row['breakeven']) else "-")
-                with kcol4: st.metric("Risikopuffer", f"{selected_row['downsideProtectionPercentNet']:.1f}%" if pd.notna(selected_row['downsideProtectionPercentNet']) and np.isfinite(selected_row['downsideProtectionPercentNet']) else "N/A")
+                with kcol1: st.metric("Prämie (Netto)", f"{currency_symbol}{selected_row['premiumNetTotal']:,.2f}", f"{selected_row['returnIfFlatPercentNet']:.1f}% Stat." if pd.notna(selected_row['returnIfFlatPercentNet']) and np.isfinite(selected_row['returnIfFlatPercentNet']) else "N/A")
+                with kcol2: st.metric("Rendite p.a.", f"{selected_row['annualizedReturnPercentNet']:.1f}%" if pd.notna(selected_row['annualizedReturnPercentNet']) and selected_row['annualizedReturnPercentNet'] > 0 else "N/A")
+                with kcol3: st.metric("Risikopuffer", f"{selected_row['downsideProtectionPercentNet']:.1f}%" if pd.notna(selected_row['downsideProtectionPercentNet']) and np.isfinite(selected_row['downsideProtectionPercentNet']) else "N/A")
+                with kcol4: st.metric("W'keit OTM", f"{selected_row['prob_OTM']:.1%}" if pd.notna(selected_row['prob_OTM']) else "-", help="Ca. W'keit, dass die Option wertlos verfällt (1 - Delta).")
                 kcol5, kcol6, kcol7, kcol8 = st.columns(4)
-                with kcol5: st.metric("Rendite p.a.", f"{selected_row['annualizedReturnPercentNet']:.1f}%" if pd.notna(selected_row['annualizedReturnPercentNet']) and selected_row['annualizedReturnPercentNet'] > 0 else "N/A") # Zeige N/A für 0 oder negativ
-                with kcol6: st.metric("Return on Risk", f"{selected_row['returnOnRiskPercentNet']:.1f}%" if pd.notna(selected_row['returnOnRiskPercentNet']) and np.isfinite(selected_row['returnOnRiskPercentNet']) else "N/A")
-                with kcol7: st.metric("Delta", f"{selected_row['delta']:.3f}" if pd.notna(selected_row['delta']) else "-", help="Sensitivität / ca. W'keit ITM.")
-                with kcol8: st.metric("Theta", f"{selected_row['theta']:.3f}" if pd.notna(selected_row['theta']) else "-", help="Zeitwertverfall / Tag.")
-
-        else: # Falls keine Strikes für Payoff verfügbar
-            st.info("Keine Strikes zur Visualisierung verfügbar (möglicherweise alle herausgefiltert).")
-
-    else: # Falls keine Kette für Datum gefunden wurde
-        st.warning(f"Keine Call-Optionen für {st.session_state.ticker_symbol} am {selected_exp_date} gefunden.")
+                with kcol5: st.metric("Return on Risk", f"{selected_row['returnOnRiskPercentNet']:.1f}%" if pd.notna(selected_row['returnOnRiskPercentNet']) and np.isfinite(selected_row['returnOnRiskPercentNet']) else "N/A")
+                with kcol6: st.metric("Delta", f"{selected_row['delta']:.3f}" if pd.notna(selected_row['delta']) else "-")
+                with kcol7: st.metric("Theta", f"{selected_row['theta']:.3f}" if pd.notna(selected_row['theta']) else "-")
+                with kcol8: st.metric("DTE", f"{selected_row['DTE']:.0f}" if pd.notna(selected_row['DTE']) else "-")
 
+            else: st.info("Keine Strikes zur Visualisierung.")
+        else: st.info("Keine Optionen entsprechen den aktuellen Filterkriterien.")
+    else: st.warning(f"Keine Call-Optionen für {st.session_state.ticker_symbol} am {selected_exp_date} gefunden.")
 
 # --- Footer ---
 st.divider()
-st.caption(f"Haftungsausschluss: Nur zu Informationszwecken. Keine Finanzberatung. Daten von yfinance können verzögert sein. Berechnungen ohne Gewähr. Letzte Aktualisierung: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+st.caption(f"Haftungsausschluss: Nur zu Informationszwecken...") # Gekürzt