panelbeater 0.0.17__tar.gz → 0.2.12__tar.gz

{panelbeater-0.0.17/panelbeater.egg-info → panelbeater-0.2.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: panelbeater
-Version: 0.0.17
+Version: 0.2.12
 Summary: A CLI for finding mispriced options.
 Home-page: https://github.com/8W9aG/panelbeater
 Author: Will Sackfield
@@ -18,8 +18,15 @@ Requires-Dist: numpy>=2.2.6
 Requires-Dist: feature-engine>=1.9.3
 Requires-Dist: requests-cache>=1.2.1
 Requires-Dist: scikit-learn>=1.6.1
-Requires-Dist: wavetrainer>=0.2.43
+Requires-Dist: wavetrainer>=0.3.4
 Requires-Dist: tqdm>=4.67.1
+Requires-Dist: pyvinecopulib>=0.7.5
+Requires-Dist: fredapi>=0.5.2
+Requires-Dist: python-dotenv>=1.1.0
+Requires-Dist: kaleido>=1.2.0
+Requires-Dist: plotly>=6.3.1
+Requires-Dist: scipy>=1.16.3
+Requires-Dist: joblib>=1.5.2
 
 # panelbeater
 
@@ -42,6 +49,12 @@ Python 3.11.6:
 - [scikit-learn](https://scikit-learn.org/stable/)
 - [wavetrainer](https://github.com/8W9aG/wavetrainer/)
 - [tqdm](https://tqdm.github.io/)
+- [pyvinecopulib](https://github.com/vinecopulib/pyvinecopulib)
+- [python-dotenv](https://saurabh-kumar.com/python-dotenv/)
+- [kaleido](https://github.com/plotly/kaleido)
+- [plotly](https://plotly.com/)
+- [scipy](https://scipy.org/)
+- [joblib](https://joblib.readthedocs.io/en/stable/)
 
 ## Raison D'être :thought_balloon:
 
@@ -52,7 +65,7 @@ Python 3.11.6:
 `panelbeater` goes through the following steps:
 1. Downloads the historical data.
 2. Performs feature engineering on the data.
-3. Trains the required models to operate on the data panel.
+3. Trains the required models and copulas to operate on the data panel.
 4. Downloads the current data.
 5. Runs inference on t+X for the latest options to find the probability distribution on the asset prices to their expiry dates.
 6. Finds any mispriced options and size the position accordingly.

{panelbeater-0.0.17 → panelbeater-0.2.12}/README.md

@@ -19,6 +19,12 @@ Python 3.11.6:
 - [scikit-learn](https://scikit-learn.org/stable/)
 - [wavetrainer](https://github.com/8W9aG/wavetrainer/)
 - [tqdm](https://tqdm.github.io/)
+- [pyvinecopulib](https://github.com/vinecopulib/pyvinecopulib)
+- [python-dotenv](https://saurabh-kumar.com/python-dotenv/)
+- [kaleido](https://github.com/plotly/kaleido)
+- [plotly](https://plotly.com/)
+- [scipy](https://scipy.org/)
+- [joblib](https://joblib.readthedocs.io/en/stable/)
 
 ## Raison D'être :thought_balloon:
 
@@ -29,7 +35,7 @@ Python 3.11.6:
 `panelbeater` goes through the following steps:
 1. Downloads the historical data.
 2. Performs feature engineering on the data.
-3. Trains the required models to operate on the data panel.
+3. Trains the required models and copulas to operate on the data panel.
 4. Downloads the current data.
 5. Runs inference on t+X for the latest options to find the probability distribution on the asset prices to their expiry dates.
 6. Finds any mispriced options and size the position accordingly.

panelbeater-0.2.12/panelbeater/__init__.py

@@ -0,0 +1,18 @@
+"""panelbeater initialisation."""
+
+from .download import download
+from .fit import fit
+from .simulate import SIMULATION_FILENAME, run_single_simulation, simulate
+from .trades import trades
+from .wt import create_wt
+
+__VERSION__ = "0.2.12"
+__all__ = [
+    "download",
+    "fit",
+    "create_wt",
+    "simulate",
+    "run_single_simulation",
+    "trades",
+    "SIMULATION_FILENAME",
+]

panelbeater-0.2.12/panelbeater/__main__.py

@@ -0,0 +1,100 @@
+"""The CLI for finding mispriced options."""
+
+# pylint: disable=too-many-locals,use-dict-literal,invalid-name
+import argparse
+
+import requests_cache
+from dotenv import load_dotenv
+
+from .download import download
+from .fit import fit
+from .simulate import simulate
+from .trades import trades
+
+_TICKERS = [
+    # Equities
+    "SPY",
+    "QQQ",
+    "EEM",
+    # Commodities
+    "GC=F",
+    "CL=F",
+    "SI=F",
+    # FX
+    # "EURUSD=X",
+    # "USDJPY=X",
+    # Crypto
+    # "BTC-USD",
+    # "ETH-USD",
+]
+_MACROS = [
+    "GDP",
+    "UNRATE",
+    "CPIAUCSL",
+    "FEDFUNDS",
+    "DGS10",
+    "T10Y2Y",
+    # "M2SL",
+    # "VIXCLS",
+    # "DTWEXBGS",
+    # "INDPRO",
+]
+_WINDOWS = [
+    5,
+    10,
+    20,
+    60,
+    120,
+    200,
+]
+_LAGS = [1, 3, 5, 10, 20, 30]
+_DAYS_OUT = 30
+_SIMS = 1000
+
+
+def main() -> None:
+    """The main CLI function."""
+    load_dotenv()
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--inference",
+        help="Whether to do inference.",
+        required=False,
+        default=True,
+        action=argparse.BooleanOptionalAction,
+    )
+    parser.add_argument(
+        "--train",
+        help="Whether to do training.",
+        required=False,
+        default=True,
+        action=argparse.BooleanOptionalAction,
+    )
+    parser.add_argument(
+        "--trades",
+        help="Whether to generate trades.",
+        required=False,
+        default=True,
+        action=argparse.BooleanOptionalAction,
+    )
+    args = parser.parse_args()
+
+    # Setup main objects
+    session = requests_cache.CachedSession("panelbeater-cache")
+
+    # Fit the models
+    df_y = download(tickers=_TICKERS, macros=_MACROS, session=session)
+    if args.train:
+        fit(df_y=df_y, windows=_WINDOWS, lags=_LAGS)
+
+    if args.inference:
+        simulate(
+            sims=_SIMS, df_y=df_y, days_out=_DAYS_OUT, windows=_WINDOWS, lags=_LAGS
+        )
+
+    if args.trades:
+        trades(df_y=df_y, days_out=_DAYS_OUT, tickers=_TICKERS)
+
+
+if __name__ == "__main__":
+    main()

panelbeater-0.2.12/panelbeater/copula.py

@@ -0,0 +1,65 @@
+"""Handle joint distributions."""
+
+# pylint: disable=too-many-locals,pointless-string-statement
+import os
+import pickle
+import time
+from typing import Any, cast
+
+import numpy as np
+import pandas as pd
+import pyvinecopulib as pv
+
+
+def _vine_filename(df_returns: pd.DataFrame) -> str:
+    struct_str = "-".join(sorted(df_returns.columns.values.tolist()))
+    return f"market_structure_{struct_str}.pkl"
+
+
+def load_vine_copula(df_returns: pd.DataFrame) -> pv.Vinecop:
+    """Loads a vine copula model."""
+    df_returns = df_returns.reindex(sorted(df_returns.columns), axis=1)
+    with open(_vine_filename(df_returns=df_returns), "rb") as f:
+        return pickle.load(f)
+
+
+def fit_vine_copula(df_returns: pd.DataFrame, ttl_days: int = 30) -> pv.Vinecop:
+    """
+    Returns a fitted vine copula.
+    Loads from disk if a valid (non-expired) model exists; otherwise fits and saves.
+    """
+    df_returns = df_returns.reindex(sorted(df_returns.columns), axis=1)
+    vine_file = _vine_filename(df_returns=df_returns)
+
+    # 1. Check for valid cached model
+    if os.path.exists(vine_file):
+        file_age_seconds = time.time() - os.path.getmtime(vine_file)
+        if file_age_seconds < (ttl_days * 24 * 60 * 60):
+            print(f"Loading cached vine copula from {vine_file}")
+            return load_vine_copula(df_returns=df_returns)
+
+    # 2. If expired or missing, fit a new one
+    print("Vine copula is missing or expired. Fitting new model...")
+    n = len(df_returns)
+    # Manual PIT transform to Uniform [0, 1]
+    u = df_returns.rank(method="average").values / (n + 1)
+
+    controls = pv.FitControlsVinecop(
+        family_set=[pv.BicopFamily.gaussian, pv.BicopFamily.student],  # type: ignore
+        tree_criterion="tau",
+    )
+
+    cop = pv.Vinecop.from_data(u, controls=controls)
+
+    # 3. Save via Pickle
+    with open(vine_file, "wb") as f:
+        # HIGHEST_PROTOCOL is faster and produces smaller files (currently Protocol 5)
+        pickle.dump(cop, f, protocol=pickle.HIGHEST_PROTOCOL)
+
+    return cop
+
+
+def sample_joint_step(cop: pv.Vinecop) -> np.ndarray[Any, np.dtype[np.float64]]:
+    """Returns one joint sample vector for the panel."""
+    simulated = np.array(cop.simulate(1))
+    return cast(np.ndarray[Any, np.dtype[np.float64]], simulated[0])

{panelbeater-0.0.17 → panelbeater-0.2.12}/panelbeater/download.py

@@ -1,11 +1,23 @@
 """Download historical data."""
 
+# pylint: disable=invalid-name,global-statement,unused-argument
+import os
+
 import numpy as np
 import pandas as pd
 import requests_cache
 import tqdm
 import yfinance as yf
-from pandas_datareader import data as fred
+from fredapi import Fred  # type: ignore
+
+_FRED_CLIENT = None
+
+
+def _get_fred_client() -> Fred:
+    global _FRED_CLIENT
+    if _FRED_CLIENT is None:
+        _FRED_CLIENT = Fred(api_key=os.environ["FRED_API_KEY"])
+    return _FRED_CLIENT
 
 
 def _load_yahoo_prices(tickers: list[str]) -> pd.DataFrame:
@@ -35,11 +47,32 @@ def _load_fred_series(
     codes: list[str], session: requests_cache.CachedSession
 ) -> pd.DataFrame:
     """Load FRED series, forward-fill to daily to align with markets."""
-    dfs = []
+    client = _get_fred_client()
+    dfs: list[pd.Series] = []
     for code in tqdm.tqdm(codes, desc="Downloading macros"):
-        s = fred.DataReader(code, "fred", start="2000-01-01", session=session)
-        s.columns = [code]
-        dfs.append(s)
+        try:
+            df = client.get_series_all_releases(code)
+            df["date"] = pd.to_datetime(df["date"])
+            df["realtime_start"] = pd.to_datetime(df["realtime_start"])
+
+            def select_latest(group: pd.DataFrame) -> pd.DataFrame:
+                latest_df = group[
+                    group["realtime_start"] == group["realtime_start"].max()
+                ]
+                if not isinstance(latest_df, pd.DataFrame):
+                    raise ValueError("latest_df is not a DataFrame")
+                return latest_df
+
+            df = df.groupby("date").apply(select_latest)
+            df = df.set_index("date")
+            df.index = df.index.date  # type: ignore
+            df = df.sort_index()
+            dfs.append(df["value"].rename(code))  # type: ignore
+        except ValueError:
+            df = client.get_series(code)
+            df.index = df.index.date  # type: ignore
+            df = df.sort_index()
+            dfs.append(df.rename(code))
     macro = pd.concat(dfs, axis=1).sort_index()
     # daily frequency with forward-fill (macro is slower cadence)
     macro = macro.asfreq("D").ffill()
@@ -63,4 +96,5 @@ def download(
     levels = pd.concat(
         [prices.add_prefix("PX_"), macro.add_prefix("MACRO_")], axis=1
     ).ffill()
+    print(levels)
     return levels.replace([np.inf, -np.inf], np.nan)

{panelbeater-0.0.17 → panelbeater-0.2.12}/panelbeater/features.py

@@ -4,13 +4,12 @@ import warnings
 
 import numpy as np
 import pandas as pd
-import tqdm
 from feature_engine.datetime import DatetimeFeatures
 
 
 def _ticker_features(df: pd.DataFrame, windows: list[int]) -> pd.DataFrame:
     cols = df.columns.values.tolist()
-    for col in tqdm.tqdm(cols, desc="Generating ticker features"):
+    for col in cols:
         s = df[col]
         for w in windows:
             with warnings.catch_warnings():
@@ -31,16 +30,15 @@ def _meta_ticker_feature(
     df: pd.DataFrame, lags: list[int], windows: list[int]
 ) -> pd.DataFrame:
     dfs = [df]
-    for lag in tqdm.tqdm(lags, desc="Generating lags"):
+    for lag in lags:
         dfs.append(df.shift(lag).add_suffix(f"_lag{lag}"))
-    for window in tqdm.tqdm(windows, desc="Generating window features"):
+    for window in windows:
         dfs.append(df.rolling(window).mean().add_suffix(f"_rmean{window}"))  # type: ignore
         dfs.append(df.rolling(window).std().add_suffix(f"_rstd{window}"))  # type: ignore
     return pd.concat(dfs, axis=1).replace([np.inf, -np.inf], np.nan)
 
 
 def _dt_features(df: pd.DataFrame) -> pd.DataFrame:
-    print("Generating datetime features")
     dtf = DatetimeFeatures(features_to_extract="all", variables="index")
     return dtf.fit_transform(df)
 

panelbeater-0.2.12/panelbeater/fit.py

@@ -0,0 +1,35 @@
+"""Handles fitting models."""
+
+import warnings
+from typing import Any, Callable
+
+import pandas as pd
+
+from .copula import fit_vine_copula
+from .features import features
+from .normalizer import normalize
+from .wt import create_wt
+
+
+def fit(
+    df_y: pd.DataFrame,
+    windows: list[int],
+    lags: list[int],
+    fit_func: Callable[[pd.DataFrame, pd.DataFrame, Any], None] | None = None,
+) -> None:
+    """Fit the models."""
+    wavetrainer = create_wt()
+    # Fit Vine Copula on historical returns
+    # We use pct_change to capture the dependency of returns
+    returns = df_y.pct_change().dropna()
+    if isinstance(returns, pd.Series):
+        returns = returns.to_frame()
+    fit_vine_copula(returns)
+    df_x = features(df=df_y.copy(), windows=windows, lags=lags)
+    df_y_norm = normalize(df=df_y.copy())
+    if fit_func is None:
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", category=RuntimeWarning)
+            wavetrainer.fit(df_x, y=df_y_norm)
+    else:
+        fit_func(df_x, df_y_norm, wavetrainer)

panelbeater-0.2.12/panelbeater/normalizer.py

@@ -0,0 +1,92 @@
+"""Normalize the Y targets to standard deviations."""
+
+# pylint: disable=too-many-locals
+import math
+
+import numpy as np
+import pandas as pd
+from wavetrainer.model.model import PROBABILITY_COLUMN_PREFIX
+
+
+def _is_float(s: str) -> bool:
+    try:
+        float(s)
+        return True
+    except ValueError:
+        return False
+
+
+def normalize(df: pd.DataFrame) -> pd.DataFrame:
+    """Normalize the dataframe per column by z-score bucketing."""
+    df = df.pct_change(fill_method=None).replace([np.inf, -np.inf], np.nan)
+    mu = df.rolling(365).mean()
+    sigma = df.rolling(365).std()
+    df = ((((df - mu) / sigma) * 2.0).round() / 2.0).clip(-3, 3)
+    dfs = []
+    for col in df.columns:
+        for unique_val in df[col].unique():
+            if math.isnan(unique_val):
+                continue
+            s = (df[col] == unique_val).rename(f"{col}_{unique_val}")
+            dfs.append(s)
+    return pd.concat(dfs, axis=1)
+
+
+def denormalize(
+    df: pd.DataFrame, y: pd.DataFrame, u_sample: np.ndarray | None = None
+) -> pd.DataFrame:
+    """Denormalize the dataframe back to a total value."""
+    df = df.reindex(y.index)
+    for col in y.columns:
+        df[col] = y[col]
+    date_to_add = df.index[-1] + pd.Timedelta(days=1)
+
+    cols = set(df.columns.values.tolist())
+    target_cols = {"_".join(x.split("_")[:2]) for x in cols}
+    asset_idx = 0
+    for col in target_cols:
+        # 1. Gather all predicted probabilities for this asset's buckets
+        z_cols = {x for x in cols if x.startswith(col) and x != col}
+        if not z_cols:
+            continue
+        historical_series = y[col].pct_change().dropna()
+
+        # Sort buckets (stds) and their associated probabilities
+        stds = sorted(
+            [
+                float(x.replace(col, "").split("_")[1])
+                for x in z_cols
+                if _is_float(x.replace(col, "").split("_")[1])
+            ]
+        )
+        probs = []
+        for std in stds:
+            std_suffix = f"{col}_{std}_{PROBABILITY_COLUMN_PREFIX}"
+            prob_col = sorted([x for x in cols if x.startswith(std_suffix)])[-1]
+            prob = df[prob_col].dropna().iloc[-1]
+            probs.append(prob)
+
+        # Normalize probabilities (ensure they sum to 1.0)
+        probs = np.array(probs) / np.sum(probs)
+
+        # 2. Select the bucket using Inverse Transform Sampling
+        highest_std = 0.0
+        if u_sample is not None and asset_idx < len(u_sample):
+            cumulative_probs = np.cumsum(probs)
+            idx = np.searchsorted(cumulative_probs, u_sample[asset_idx])
+            highest_std = stds[min(idx, len(stds) - 1)]
+            asset_idx += 1
+        else:
+            highest_std = np.random.choice(stds, p=probs)
+
+        # 3. Use Pandas rolling on the historical y dataframe to avoid ndarray errors
+        mu = float(historical_series.rolling(365).mean().fillna(0.0).iloc[-1])  # pyright: ignore
+        sigma = float(historical_series.rolling(365).std().fillna(0.0).iloc[-1])
+
+        lower_bound = highest_std - 0.25
+        upper_bound = highest_std + 0.25
+        jittered_std = np.random.uniform(lower_bound, upper_bound)
+        value = (jittered_std * sigma) + mu
+        df.loc[date_to_add, col] = y[col].iloc[-1] * (1.0 + value)
+
+    return df[sorted(target_cols)]  # pyright: ignore

panelbeater-0.2.12/panelbeater/options.py

@@ -0,0 +1,352 @@
+"""Process the options for the assets."""
+
+# pylint: disable=too-many-locals,consider-using-f-string,use-dict-literal,invalid-name,too-many-arguments,too-many-positional-arguments,too-many-statements,line-too-long
+from datetime import datetime
+
+import numpy as np
+import pandas as pd
+import plotly.express as px
+import yfinance as yf
+from scipy import stats
+
+
+def get_price_probabilities(sim_df, target_date, bin_width=1.0):
+    """
+    Calculates the probability distribution of prices for a specific date.
+
+    Args:
+        sim_df: The simulation DataFrame (rows=dates, cols=paths)
+        target_date: The specific date (index) or integer location to analyze
+        bin_width: The size of the price buckets (e.g., $1.00)
+    """
+    # 1. Slice the simulation at the specific point in time
+    # This handles both a date-string index or a simple integer row index
+    if isinstance(target_date, int):
+        prices_at_t = sim_df.iloc[target_date]
+    else:
+        prices_at_t = sim_df.loc[target_date]
+
+    # 2. Define bins based on the range of prices on that specific day
+    min_p = np.floor(prices_at_t.min() / bin_width) * bin_width
+    max_p = np.ceil(prices_at_t.max() / bin_width) * bin_width
+    bins = np.arange(min_p, max_p + bin_width, bin_width)
+
+    # 3. Calculate probabilities
+    counts, bin_edges = np.histogram(prices_at_t, bins=bins)
+    probabilities = counts / len(prices_at_t)
+
+    # 4. Format into a DataFrame
+    price_points = bin_edges[:-1] + (bin_width / 2)
+    dist_df = pd.DataFrame({"price_point": price_points, "probability": probabilities})
+
+    return dist_df[dist_df["probability"] > 0].reset_index(drop=True)
+
+
+def calculate_full_kelly(row, sim_df):
+    """Calculate the kelly criterion for a probability mispricing."""
+    target_date = row["date"]
+    strike = row["strike"]
+    price = row["market_ask"]
+
+    if price <= 0:
+        return 0, 0
+
+    # Extract the simulated prices for this specific date
+    prices_at_t = sim_df.loc[target_date].values
+
+    # Calculate the Payoff for every path
+    if row["type"] == "call":
+        payoffs = np.maximum(prices_at_t - strike, 0)
+    else:
+        payoffs = np.maximum(strike - prices_at_t, 0)
+
+    expected_payoff = np.mean(payoffs)
+
+    # 1. Probability of winning (p)
+    p = row["model_prob"]
+    if p <= 0:
+        return 0, 0
+
+    # 2. Net Odds (b)
+    # This is (Expected Profit if we win) / (Amount Lost if we lose)
+    # Average payoff of the winning paths
+    avg_win_payoff = expected_payoff / p
+    net_profit_if_win = avg_win_payoff - price
+    b = net_profit_if_win / price
+
+    if b <= 0:
+        return 0, 0
+
+    # 3. Full Kelly Formula: f* = (p(b+1) - 1) / b
+    f_star = (p * (b + 1) - 1) / b
+
+    return max(0, f_star), expected_payoff - price
+
+
+def black_scholes_price(S, K, T, r, sigma, option_type="put"):
+    """Calculate the black scholes price for an option."""
+    # S = Trigger Asset Price, K = Strike, T = Time remaining, r = Risk-free rate, sigma = IV
+    d1 = (np.log(S / K) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
+    d2 = d1 - sigma * np.sqrt(T)
+    if option_type == "call":
+        return S * stats.norm.cdf(d1) - K * np.exp(-r * T) * stats.norm.cdf(d2)
+    return K * np.exp(-r * T) * stats.norm.cdf(-d2) - S * stats.norm.cdf(-d1)
+
+
+def find_mispriced_options(ticker_symbol: str, sim_df: pd.DataFrame) -> None:
+    """Find any mispriced options for an asset."""
+
+    # 1. Initialize the Ticker
+    ticker = yf.Ticker(ticker_symbol)
+
+    # 1. Get dates from your simulation
+    sim_dates = pd.to_datetime(sim_df.index).date.tolist()  # pyright: ignore
+
+    # 2. Get available expiries from the market
+    available_expiries = [
+        datetime.strptime(d, "%Y-%m-%d").date() for d in ticker.options
+    ]
+
+    # 3. Find the common dates
+    # We want to find which days in our simulation actually have a tradeable option chain
+    common_dates = sorted(list(set(sim_dates).intersection(set(available_expiries))))
+
+    print(f"Simulation covers {len(sim_dates)} days.")
+    print(f"Market has {len(available_expiries)} expiries available.")
+    print(f"Matches found for: {common_dates}")
+
+    # Storage for our comparison results
+    date_results = []
+
+    for target_date in common_dates:
+        print(f"\n--- Processing Date: {target_date} ---")
+
+        # 1. Get YOUR model's probability for this specific day
+        # We use the function we built earlier
+        date_str = target_date.strftime("%Y-%m-%d")
+
+        # 2. Download the MARKET's chain for this specific day
+        chain = ticker.option_chain(date_str)
+        spot = ticker.history(period="1d")["Close"].iloc[-1]
+        calls = chain.calls[["strike", "bid", "ask", "impliedVolatility"]].copy()
+        calls = calls[calls["strike"] > spot * 1.02]
+        calls["option_type"] = "call"
+        puts = chain.puts[["strike", "bid", "ask", "impliedVolatility"]].copy()
+        puts = puts[puts["strike"] < spot * 0.98]
+        puts["option_type"] = "put"
+
+        # 3. Combine into one market view
+        full_chain = pd.concat([calls, puts])
+
+        # 4. Get your Model's Price Distribution for this specific day
+        # We grab the prices from sim_df for this row/date
+        model_prices_at_t = sim_df.loc[date_str].values
+
+        # 5. Compare every strike in the market to your model's probability
+        for _, row in full_chain.iterrows():
+            k = row["strike"]
+
+            if row["option_type"] == "call":
+                # Prob of finishing ABOVE the strike
+                model_prob = np.mean(model_prices_at_t > k)
+            else:
+                # Prob of finishing BELOW the strike
+                model_prob = np.mean(model_prices_at_t < k)
+
+            date_results.append(
+                {
+                    "date": date_str,
+                    "strike": k,
+                    "type": row["option_type"],
+                    "market_iv": row["impliedVolatility"],
+                    "market_ask": row["ask"],
+                    "model_prob": model_prob,
+                }
+            )
+
+    comparison_df = pd.DataFrame(date_results)
+    # Apply the calculation
+    results = comparison_df.apply(lambda row: calculate_full_kelly(row, sim_df), axis=1)
+    if results.empty:
+        return
+
+    comparison_df[["kelly_fraction", "expected_profit"]] = pd.DataFrame(
+        results.tolist(), index=comparison_df.index
+    )
+
+    # Filter for liquid options and positive edge
+    top_5 = (
+        comparison_df[comparison_df["market_ask"] > 0.10]  # pyright: ignore
+        .sort_values(by="kelly_fraction", ascending=False)
+        .head(4)
+    )
+
+    # Formatting for the final report
+    summary_report = top_5[
+        ["date", "strike", "type", "model_prob", "kelly_fraction", "expected_profit"]
+    ].copy()
+    summary_report["model_prob"] = summary_report["model_prob"].map("{:.1%}".format)  # pyright: ignore
+    summary_report["kelly_fraction"] = summary_report["kelly_fraction"].map(  # pyright: ignore
+        "{:.2%}".format
+    )
+    summary_report["expected_profit"] = summary_report["expected_profit"].map(  # pyright: ignore
+        "${:,.2f}".format
+    )
+
+    print(summary_report)
+
+    fig = px.scatter(
+        comparison_df[comparison_df["kelly_fraction"] > 0],
+        x="strike",
+        y="kelly_fraction",
+        color="type",
+        size="model_prob",
+        hover_data=["date"],
+        title="Full Kelly Allocation: Conviction by Strike and Option Type",
+        labels={"kelly_fraction": "Kelly Bet Size (%)", "strike": "Strike Price ($)"},
+        template="plotly_dark",
+    )
+
+    # Highlight the top 5 with annotations or larger markers
+    fig.update_traces(marker=dict(line=dict(width=1, color="White")))
+    fig.write_image(
+        f"kelly_conviction_report_{ticker_symbol}.png", width=1200, height=800
+    )
+
+    exit_strategies = []
+
+    for _, trade in top_5.iterrows():
+        # Select appropriate simulation slices
+        sim_slice = sim_df.loc[trade["date"]]
+
+        # Calculate distribution stats for this specific expiry
+        mu = sim_slice.mean()
+        sigma = sim_slice.std()
+
+        # --- REASONABLE LOGIC START ---
+        # Instead of 95/5, use 0.5 to 1.0 standard deviation for targets
+        # This targets the 'meat' of the move your model predicts
+        if trade["type"] == "call":
+            # TP: The mean predicted price (where the bulk of the probability lies)
+            # SL: Half a standard deviation below the current spot or the mean
+            tp_price = mu + (0.2 * sigma)
+            sl_price = mu - (0.5 * sigma)
+        else:
+            # Put: Profit on the downside mean
+            tp_price = mu - (0.2 * sigma)
+            sl_price = mu + (0.5 * sigma)
+        # --- REASONABLE LOGIC END ---
+
+        # 1. Get today's date and calculate time to expiry
+        today = datetime.now()
+        expiry_date = datetime.strptime(trade["date"], "%Y-%m-%d")  # type: ignore
+        days_remaining = (expiry_date - today).days
+
+        # IMPORTANT: Exit triggers should be modeled for 'Today' or 'Soon',
+        # not the moment of expiry, otherwise extrinsic value is 0.
+        # We assume we hold for 25% of the remaining duration or at least 1 day.
+        holding_period_days = max(days_remaining * 0.25, 1)
+        time_to_trigger = max(days_remaining - holding_period_days, 0.5) / 365.0
+
+        tp_option_price = black_scholes_price(
+            tp_price,
+            trade["strike"],
+            time_to_trigger,
+            0.04,
+            trade["market_iv"],
+            str(trade["type"]),
+        )
+        sl_option_price = black_scholes_price(
+            sl_price,
+            trade["strike"],
+            time_to_trigger,
+            0.04,
+            trade["market_iv"],
+            str(trade["type"]),
+        )
+
+        exit_strategies.append(
+            {
+                "Strike": trade["strike"],
+                "Type": trade["type"],
+                "Kelly %": trade["kelly_fraction"],
+                "TP Asset Trigger": tp_price,
+                "SL Asset Trigger": sl_price,
+                "TP Option Price": tp_option_price,
+                "SL Option Price": sl_option_price,
+            }
+        )
+
+    exit_df = pd.DataFrame(exit_strategies)
+    print(exit_df)
+
+
+def determine_spot_position(ticker_symbol: str, sim_df: pd.DataFrame) -> None:
+    """
+    Determines optimal spot position (Long/Short), Kelly sizing,
+    and path-based exit levels for assets without options.
+    """
+    # 1. Get Current Market Data
+    ticker = yf.Ticker(ticker_symbol)
+    spot_history = ticker.history(period="1d")
+
+    if spot_history.empty:
+        print(f"No market data for {ticker_symbol}")
+        return
+
+    spot_price = spot_history["Close"].iloc[-1]
+
+    # 2. Extract the Terminal Distribution
+    # Find the latest date in the index
+    last_date = sim_df.index.max()
+
+    # Filter the DF for that date.
+    # This results in N rows (where N = number of simulations)
+    terminal_distribution = sim_df.loc[[last_date]]
+
+    # Extract the specific ticker column
+    # terminal_prices is now a Series of predicted prices across all paths
+    terminal_prices = terminal_distribution[f"PX_{ticker_symbol}"]
+
+    # 3. Determine Bias and Winning Path Ratio (p)
+    median_terminal = terminal_prices.median()  # This will now work!
+    is_long = median_terminal > spot_price
+
+    if is_long:
+        # Probability of finishing higher than spot
+        p = np.mean(terminal_prices > spot_price)
+        tp_price = terminal_prices.quantile(0.95)
+        sl_price = terminal_prices.quantile(0.05)
+    else:
+        # Probability of finishing lower than spot
+        p = np.mean(terminal_prices < spot_price)
+        tp_price = terminal_prices.quantile(0.05)
+        sl_price = terminal_prices.quantile(0.95)
+
+    # 3. Calculate Odds (b) for Kelly
+    # b = (Expected Profit) / (Expected Loss if Stopped)
+    expected_profit = abs(tp_price - spot_price)
+    expected_loss = abs(spot_price - sl_price)
+    b = expected_profit / expected_loss
+
+    # 4. Full Kelly Formula: f* = (p(b+1) - 1) / b
+    if b > 0 and p > 0:
+        f_star = (p * (b + 1) - 1) / b
+        kelly_size = max(0, f_star)
+    else:
+        kelly_size = 0
+
+    # 5. Apply a 'Trader's Cap' (e.g., 10% of portfolio for spot)
+    final_size = min(kelly_size, 0.10)
+
+    # Output Results
+    print(f"\n--- SPOT ANALYSIS FOR {ticker_symbol} ---")
+    print(f"Current Price: ${spot_price:.2f}")
+    print(f"Position: {'LONG' if is_long else 'SHORT'}")
+    print(f"Win Probability (p): {p:.1%}")
+    print(f"Risk/Reward Ratio (b): {b:.2f}")
+    print(f"Kelly Fraction: {kelly_size:.2%}")
+    print(f"Recommended Size (Capped): {final_size:.2%}")
+    print("-" * 30)
+    print(f"Take Profit Target: ${tp_price:.2f}")
+    print(f"Stop Loss (Invalidation): ${sl_price:.2f}")

panelbeater-0.2.12/panelbeater/simulate.py

@@ -0,0 +1,87 @@
+"""Handle simulations from the models."""
+# pylint: disable=too-many-arguments,too-many-positional-arguments
+
+from typing import Callable
+
+import pandas as pd
+import pyvinecopulib as pv
+import tqdm
+from joblib import Parallel, delayed
+
+from .copula import load_vine_copula, sample_joint_step
+from .features import features
+from .normalizer import denormalize
+from .wt import create_wt
+
+SIMULATION_COLUMN = "simulation"
+SIMULATION_FILENAME = "sims.parquet"
+
+
+def run_single_simulation(
+    sim_idx: int,
+    df_y,
+    days_out: int,
+    windows: list[int],
+    lags: list[int],
+    vine_cop: pv.Vinecop,
+):
+    """
+    Encapsulates a single Monte Carlo path generation.
+    """
+    # Local copies for thread-safety (though joblib uses processes)
+    df_y = df_y.copy()
+    wavetrainer = create_wt()
+
+    for _ in tqdm.tqdm(range(days_out), desc="Simulation Days"):
+        # 1. Feature Engineering
+        df_x = features(df=df_y.copy(), windows=windows, lags=lags)
+
+        # 2. Get Model Prediction (u_step sample from Copula)
+        u_step = sample_joint_step(vine_cop)
+
+        # 3. Transform and Denormalize to get next day prices
+        df_next = wavetrainer.transform(df_x.iloc[[-1]], ignore_no_dates=True).drop(
+            columns=df_x.columns.values.tolist()
+        )
+        df_y = denormalize(df_next, y=df_y.copy(), u_sample=u_step)
+
+    # Mark the simulation index and return only the relevant tail (for memory efficiency)
+    df_result = df_y.tail(days_out + 1).copy()
+    df_result[SIMULATION_COLUMN] = sim_idx
+    return df_result
+
+
+def simulate(
+    sims: int,
+    df_y: pd.DataFrame,
+    days_out: int,
+    windows: list[int],
+    lags: list[int],
+    sim_func: Callable[
+        [int, pd.DataFrame, int, list[int], list[int], pv.Vinecop], list[pd.DataFrame]
+    ]
+    | None = None,
+) -> pd.DataFrame:
+    """Simulate from trained models."""
+    print(f"Starting {sims} simulations in parallel...")
+    vine_cop = load_vine_copula(df_returns=df_y)
+    print("Loaded vine copula")
+    if sim_func is None:
+        # n_jobs=-1 uses all available CPU cores
+        all_sims = Parallel(n_jobs=-1)(
+            delayed(run_single_simulation)(
+                i, df_y.copy(), days_out, windows, lags, vine_cop
+            )
+            for i in tqdm.tqdm(range(sims), desc="Simulating")
+        )
+    else:
+        all_sims = sim_func(sims, df_y.copy(), days_out, windows, lags, vine_cop)
+    # Combine all simulations into one large DataFrame
+    df_mc = pd.concat(all_sims)  # type: ignore
+    df_mc.to_parquet(SIMULATION_FILENAME)
+    return df_mc
+
+
+def load_simulations() -> pd.DataFrame:
+    """Load the rendered simulations."""
+    return pd.read_parquet(SIMULATION_FILENAME)

panelbeater-0.2.12/panelbeater/trades.py

@@ -0,0 +1,40 @@
+"""Handle generating trades."""
+
+# pylint: disable=use-dict-literal
+import pandas as pd
+import tqdm
+
+from .options import determine_spot_position, find_mispriced_options
+from .simulate import SIMULATION_COLUMN, load_simulations
+
+
+def trades(df_y: pd.DataFrame, days_out: int, tickers: list[str]) -> None:
+    """Calculate new trades."""
+    df_mc = load_simulations()
+    pd.options.plotting.backend = "plotly"
+    for col in tqdm.tqdm(df_y.columns.values.tolist(), desc="Plotting assets"):
+        if col == SIMULATION_COLUMN:
+            continue
+        plot_df = df_mc.pivot(columns=SIMULATION_COLUMN, values=col).tail(days_out + 1)
+        # Plotting
+        fig = plot_df.plot(
+            title=f"Monte Carlo Simulation: {col}",
+            labels={"value": "Price", "index": "Date", "simulation": "Path ID"},
+            template="plotly_dark",
+        )
+        # Add any additional styling
+        fig.add_scatter(
+            x=plot_df.index,
+            y=plot_df.median(axis=1),
+            name="Median",
+            line=dict(color="white", width=10),
+        )
+        fig.write_image(
+            f"monte_carlo_results_{col}.png", width=1200, height=800, scale=2
+        )
+
+    # Find the current options prices
+    for ticker in tickers:
+        print(f"Finding pricing options for {ticker}")
+        find_mispriced_options(ticker, df_mc[f"PX_{ticker}"].copy())  # pyright: ignore
+        determine_spot_position(ticker, df_mc[f"PX_{ticker}"].copy())  # pyright: ignore

panelbeater-0.2.12/panelbeater/wt.py

@@ -0,0 +1,18 @@
+"""Handles wavetrainer interaction."""
+
+import datetime
+
+import wavetrainer
+
+
+def create_wt() -> wavetrainer.trainer.Trainer:  # pyright: ignore
+    """Creates a wavetrainer instance."""
+    return wavetrainer.create(
+        "panelbeater-train",
+        walkforward_timedelta=datetime.timedelta(days=30),
+        validation_size=datetime.timedelta(days=365),
+        test_size=datetime.timedelta(days=365),
+        allowed_models={"catboost"},
+        max_false_positive_reduction_steps=0,
+        use_power_transformer=True,
+    )

{panelbeater-0.0.17 → panelbeater-0.2.12/panelbeater.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: panelbeater
-Version: 0.0.17
+Version: 0.2.12
 Summary: A CLI for finding mispriced options.
 Home-page: https://github.com/8W9aG/panelbeater
 Author: Will Sackfield
@@ -18,8 +18,15 @@ Requires-Dist: numpy>=2.2.6
 Requires-Dist: feature-engine>=1.9.3
 Requires-Dist: requests-cache>=1.2.1
 Requires-Dist: scikit-learn>=1.6.1
-Requires-Dist: wavetrainer>=0.2.43
+Requires-Dist: wavetrainer>=0.3.4
 Requires-Dist: tqdm>=4.67.1
+Requires-Dist: pyvinecopulib>=0.7.5
+Requires-Dist: fredapi>=0.5.2
+Requires-Dist: python-dotenv>=1.1.0
+Requires-Dist: kaleido>=1.2.0
+Requires-Dist: plotly>=6.3.1
+Requires-Dist: scipy>=1.16.3
+Requires-Dist: joblib>=1.5.2
 
 # panelbeater
 
@@ -42,6 +49,12 @@ Python 3.11.6:
 - [scikit-learn](https://scikit-learn.org/stable/)
 - [wavetrainer](https://github.com/8W9aG/wavetrainer/)
 - [tqdm](https://tqdm.github.io/)
+- [pyvinecopulib](https://github.com/vinecopulib/pyvinecopulib)
+- [python-dotenv](https://saurabh-kumar.com/python-dotenv/)
+- [kaleido](https://github.com/plotly/kaleido)
+- [plotly](https://plotly.com/)
+- [scipy](https://scipy.org/)
+- [joblib](https://joblib.readthedocs.io/en/stable/)
 
 ## Raison D'être :thought_balloon:
 
@@ -52,7 +65,7 @@ Python 3.11.6:
 `panelbeater` goes through the following steps:
 1. Downloads the historical data.
 2. Performs feature engineering on the data.
-3. Trains the required models to operate on the data panel.
+3. Trains the required models and copulas to operate on the data panel.
 4. Downloads the current data.
 5. Runs inference on t+X for the latest options to find the probability distribution on the asset prices to their expiry dates.
 6. Finds any mispriced options and size the position accordingly.

{panelbeater-0.0.17 → panelbeater-0.2.12}/panelbeater.egg-info/SOURCES.txt

@@ -5,9 +5,15 @@ requirements.txt
 setup.py
 panelbeater/__init__.py
 panelbeater/__main__.py
+panelbeater/copula.py
 panelbeater/download.py
 panelbeater/features.py
+panelbeater/fit.py
 panelbeater/normalizer.py
+panelbeater/options.py
+panelbeater/simulate.py
+panelbeater/trades.py
+panelbeater/wt.py
 panelbeater.egg-info/PKG-INFO
 panelbeater.egg-info/SOURCES.txt
 panelbeater.egg-info/dependency_links.txt

panelbeater-0.2.12/panelbeater.egg-info/requires.txt

@@ -0,0 +1,16 @@
+yfinance==0.2.66
+pandas>=2.3.3
+pandas-datareader>=0.10.0
+numpy>=2.2.6
+feature-engine>=1.9.3
+requests-cache>=1.2.1
+scikit-learn>=1.6.1
+wavetrainer>=0.3.4
+tqdm>=4.67.1
+pyvinecopulib>=0.7.5
+fredapi>=0.5.2
+python-dotenv>=1.1.0
+kaleido>=1.2.0
+plotly>=6.3.1
+scipy>=1.16.3
+joblib>=1.5.2

panelbeater-0.0.17/panelbeater.egg-info/requires.txt → panelbeater-0.2.12/requirements.txt

@@ -5,5 +5,12 @@ numpy>=2.2.6
 feature-engine>=1.9.3
 requests-cache>=1.2.1
 scikit-learn>=1.6.1
-wavetrainer>=0.2.43
+wavetrainer>=0.3.4
 tqdm>=4.67.1
+pyvinecopulib>=0.7.5
+fredapi>=0.5.2
+python-dotenv>=1.1.0
+kaleido>=1.2.0
+plotly>=6.3.1
+scipy>=1.16.3
+joblib>=1.5.2

{panelbeater-0.0.17 → panelbeater-0.2.12}/setup.py

@@ -23,7 +23,7 @@ def install_requires() -> typing.List[str]:
 
 setup(
     name='panelbeater',
-    version='0.0.17',
+    version='0.2.12',
     description='A CLI for finding mispriced options.',
     long_description=long_description,
     long_description_content_type='text/markdown',

panelbeater-0.0.17/panelbeater/__init__.py

@@ -1,3 +0,0 @@
-"""panelbeater initialisation."""
-
-__VERSION__ = "0.0.17"

panelbeater-0.0.17/panelbeater/__main__.py

@@ -1,95 +0,0 @@
-"""The CLI for finding mispriced options."""
-
-import argparse
-import datetime
-
-import requests_cache
-import tqdm
-import wavetrainer as wt
-from wavetrainer.model_type import QUANTILE_KEY
-
-from .download import download
-from .features import features
-from .normalizer import denormalize, normalize
-
-_TICKERS = [
-    # Equities
-    "SPY",
-    "QQQ",
-    "EEM",
-    # Commodities
-    "GC=F",
-    "CL=F",
-    "SI=F",
-    # FX
-    "EURUSD=X",
-    "USDJPY=X",
-    # Crypto
-    "BTC-USD",
-    "ETH-USD",
-]
-_MACROS = [
-    "GDP",
-    "UNRATE",
-    "CPIAUCSL",
-    "FEDFUNDS",
-    "DGS10",
-    "T10Y2Y",
-    "M2SL",
-    "VIXCLS",
-    "DTWEXBGS",
-    "INDPRO",
-]
-_WINDOWS = [
-    5,
-    10,
-    20,
-    60,
-    120,
-    200,
-]
-_LAGS = [1, 3, 5, 10, 20, 30]
-_DAYS_OUT = 30
-
-
-def main() -> None:
-    """The main CLI function."""
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--inference",
-        help="Whether to skip training and just do inference.",
-        required=False,
-        default=False,
-        action="store_true",
-    )
-    args = parser.parse_args()
-
-    # Setup main objects
-    session = requests_cache.CachedSession("panelbeater-cache")
-    wavetrainer = wt.create(
-        "panelbeater-train",
-        walkforward_timedelta=datetime.timedelta(days=30),
-        validation_size=datetime.timedelta(days=365),
-        test_size=datetime.timedelta(days=365),
-        allowed_models={"catboost"},
-        max_false_positive_reduction_steps=0,
-    )
-
-    # Fit the models
-    df_y = download(tickers=_TICKERS, macros=_MACROS, session=session)
-    df_x = features(df=df_y.copy(), windows=_WINDOWS, lags=_LAGS)
-    df_y_norm = normalize(df=df_y.copy())
-    df_y_norm.attrs = {QUANTILE_KEY: True}
-    if not args.inference:
-        wavetrainer.fit(df_x, y=df_y_norm)
-    for _ in tqdm.tqdm(range(_DAYS_OUT), desc="Running t+X simulation"):
-        df_next = wavetrainer.transform(df_x, ignore_no_dates=True).drop(columns=df_x)
-        df_y = denormalize(df_next, y=df_y)
-        df_x = features(df=df_y.copy(), windows=_WINDOWS, lags=_LAGS)
-        df_y_norm = normalize(df=df_y.copy())
-
-    # Find the current options prices
-
-
-if __name__ == "__main__":
-    main()

panelbeater-0.0.17/panelbeater/normalizer.py

@@ -1,64 +0,0 @@
-"""Normalize the Y targets to standard deviations."""
-
-# pylint: disable=too-many-locals
-
-import numpy as np
-import pandas as pd
-from wavetrainer.model.model import PROBABILITY_COLUMN_PREFIX
-
-
-def _is_float(s: str) -> bool:
-    try:
-        float(s)
-        return True
-    except ValueError:
-        return False
-
-
-def normalize(df: pd.DataFrame) -> pd.DataFrame:
-    """Normalize the dataframe per column by z-score bucketing."""
-    df = df.pct_change(fill_method=None).replace([np.inf, -np.inf], np.nan)
-    mu = df.rolling(365).mean()
-    sigma = df.rolling(365).std()
-    return ((df - mu) / sigma).fillna(0.0)
-
-
-def denormalize(df: pd.DataFrame, y: pd.DataFrame) -> pd.DataFrame:
-    """Denormalize the dataframe back to a total value."""
-    for col in y.columns:
-        df[col] = y[col]
-    date_to_add = df.index[-1] + pd.Timedelta(days=1)
-
-    cols = set(df.columns.values.tolist())
-    target_cols = {"_".join(x.split("_")[:2]) for x in cols}
-    for col in target_cols:
-        # Find the standard deviations
-        z_cols = {x for x in cols if x.startswith(col) and x != col}
-        if not z_cols:
-            continue
-        stds = sorted(
-            [
-                float(x.replace(col, "").split("_")[1])
-                for x in z_cols
-                if _is_float(x.replace(col, "").split("_")[1])
-            ]
-        )
-
-        # Find the highest probability standard deviation
-        highest_std_value = 0.0
-        highest_std = None
-        for std in stds:
-            std_suffix = f"{col}_{std}_{PROBABILITY_COLUMN_PREFIX}"
-            std_true_col = sorted([x for x in cols if x.startswith(std_suffix)])[-1]
-            std_value = df[std_true_col].iloc[-1]
-            if std_value > highest_std_value:
-                highest_std_value = std_value
-                highest_std = std
-
-        # Convert the standard deviation back to a value
-        mu = df[col].rolling(365).mean()
-        sigma = df[col].rolling(365).std()
-        value = (highest_std * sigma) + mu
-        df.loc[date_to_add, col] = df[col].iloc[-1] * (1.0 + value)
-
-    return df.drop(columns=list(cols))

panelbeater-0.0.17/requirements.txt

@@ -1,9 +0,0 @@
-yfinance==0.2.66
-pandas>=2.3.3
-pandas-datareader>=0.10.0
-numpy>=2.2.6
-feature-engine>=1.9.3
-requests-cache>=1.2.1
-scikit-learn>=1.6.1
-wavetrainer>=0.2.43
-tqdm>=4.67.1