utils fix 1-d

utils_vol.py

@@ -1,29 +1,128 @@
+# utils_vol.py — robuste Version
+
 import yfinance as yf
 import numpy as np
 import pandas as pd
 
-def fetch_close_series(ticker: str, start="2015-01-01", interval="1d") -> pd.Series:
-    """Downloadet Daten von yfinance und gibt die Schlusskurse zurück."""
-    df = yf.download(ticker, start=start, interval=interval, progress=False, threads=True)
+def _to_1d_series(obj: pd.Series | pd.DataFrame) -> pd.Series:
+    """
+    Erzwingt eine 1D-Serie:
+    - DataFrame (n,1) -> squeeze
+    - MultiIndex -> erste passende Spalte
+    - alles in float konvertieren, NaNs droppen
+    """
+    if isinstance(obj, pd.DataFrame):
+        # (n,1) -> Serie
+        if obj.shape[1] == 1:
+            ser = obj.squeeze(axis=1)
+        else:
+            # Fallback: nimm die erste numerische Spalte
+            num_cols = obj.select_dtypes(include=[np.number]).columns
+            if len(num_cols) > 0:
+                ser = obj[num_cols[0]]
+            else:
+                # nimm einfach die erste Spalte
+                ser = obj.iloc[:, 0]
+    else:
+        ser = obj
+
+    ser = pd.to_numeric(ser, errors="coerce")
+    ser = ser.dropna()
+    # Index in DatetimeIndex verwandeln, wenn möglich
+    if not isinstance(ser.index, pd.DatetimeIndex):
+        try:
+            ser.index = pd.to_datetime(ser.index, errors="coerce")
+            ser = ser[ser.index.notna()]
+        except Exception:
+            # notfalls RangeIndex lassen
+            pass
+    return ser.astype(float)
+
+
+def fetch_close_series(ticker: str, start: str = "2015-01-01", interval: str = "1d") -> pd.Series:
+    """
+    Lädt OHLCV via yfinance und gibt eine 1D-Schlusskurs-Serie zurück.
+    Nutzt auto_adjust=True (aktuelles yfinance-Default) bewusst,
+    damit der FutureWarning verschwindet und Adjusted/Close konsistent ist.
+    """
+    df = yf.download(
+        ticker.strip(),
+        start=start,
+        interval=interval,
+        auto_adjust=True,      # explizit setzen, um Warnung zu vermeiden
+        progress=False,
+        threads=True,
+    )
     if df is None or df.empty:
-        raise ValueError(f"Keine Daten für {ticker}.")
-    col = None
-    for c in ["Adj Close", "Close", "close", "adj close"]:
-        if c in df.columns:
-            col = c; break
-    if col is None:
-        col = df.select_dtypes("number").columns[-1]
-    return df[col].dropna()
-
-def realized_vol(close: pd.Series, window=20, annualize=True) -> pd.Series:
+        raise ValueError(f"Keine Daten für {ticker} (start={start}, interval={interval}).")
+
+    # MultiIndex-Handling (bei mehreren Tickern oder Börsen-Suffixen)
+    if isinstance(df.columns, pd.MultiIndex):
+        # versuche 'Close' auf Level 0
+        if "Close" in df.columns.get_level_values(0):
+            sub = df.xs("Close", axis=1, level=0)
+            # falls mehrere Spalten (mehrere Ticker): nimm die erste
+            if sub.shape[1] > 1:
+                sub = sub.iloc[:, 0]
+            return _to_1d_series(sub)
+        # Fallback: erste numerische Spalte
+        num_cols = df.select_dtypes(include=[np.number]).columns
+        if len(num_cols) > 0:
+            sub = df[num_cols[0]]
+            return _to_1d_series(sub)
+        # letzter Ausweg: erste Spalte
+        return _to_1d_series(df.iloc[:, 0])
+
+    # Flache Spalten
+    for name in ["Close", "Adj Close", "close", "adj close", "Price", "price"]:
+        if name in df.columns:
+            return _to_1d_series(df[name])
+
+    # Fallback: erste numerische Spalte
+    num_cols = df.select_dtypes(include=[np.number]).columns
+    if len(num_cols) == 0:
+        raise ValueError("Keine numerische Close-Spalte gefunden.")
+    return _to_1d_series(df[num_cols[0]])
+
+
+def realized_vol(close: pd.Series, window: int = 20, annualize: bool = True) -> pd.Series:
+    """
+    20-Tage-Rolling-Std der Logrenditen; gibt IMMER eine 1D-Serie zurück.
+    """
+    close = _to_1d_series(close)
     r = np.log(close).diff().dropna()
     rv = r.rolling(window, min_periods=window).std()
     if annualize:
-        rv *= np.sqrt(252)
-    return rv.dropna()
+        rv = rv * np.sqrt(252.0)
+    rv = rv.dropna()
+    # Sicherheitshalber 1D
+    return _to_1d_series(rv)
+
+
+def rv_to_autogluon_df(rv: pd.Series | pd.DataFrame) -> pd.DataFrame:
+    """
+    Formatiert Realized Vol als DataFrame für AutoGluon TimeSeries:
+      columns: ['item_id', 'timestamp', 'target']
+    """
+    # Erzwinge Serie 1D
+    rv = _to_1d_series(rv)
 
-def rv_to_autogluon_df(rv: pd.Series) -> pd.DataFrame:
-    """Formatiert Realized Vol als DataFrame für AutoGluon TimeSeries."""
-    df = pd.DataFrame({"timestamp": rv.index, "target": rv.values})
-    df["item_id"] = "series_1"
+    # Werte & Index robust extrahieren
+    values = np.asarray(rv.values).reshape(-1)  # 1D
+    idx = rv.index
+    if not isinstance(idx, pd.DatetimeIndex):
+        try:
+            idx = pd.to_datetime(idx, errors="coerce")
+        except Exception:
+            # Fallback: generiere einfache Range-Dates
+            idx = pd.date_range(start="2000-01-01", periods=len(values), freq="D")
+    # gültige Punkte
+    mask = ~np.isnan(values)
+    df = pd.DataFrame({
+        "item_id": "series_1",
+        "timestamp": idx[mask],
+        "target": values[mask],
+    })
+    # sortiert & ohne NaN-Timestamps
+    df = df[df["timestamp"].notna()].sort_values("timestamp")
     return df