optPricing 2.0.0__py3-none-any.whl

quantfin/dashboard/pages/2_Pricer_and_Greeks.py

@@ -0,0 +1,150 @@
+import pandas as pd
+import streamlit as st
+
+from quantfin.atoms import Option, OptionType, Rate, Stock
+from quantfin.models import *
+from quantfin.techniques import *
+
+st.set_page_config(layout="wide", page_title="QuantFin | Pricer")
+st.title("On-Demand Pricer & Greek Analysis")
+# ruff: noqa: E501
+st.caption(
+    "Price any option with any model and technique. Manually set all parameters to see their effect."
+)
+
+# Model and Technique Selection
+MODEL_MAP = {
+    "BSM": BSMModel,
+    "Merton": MertonJumpModel,
+    "Heston": HestonModel,
+    "Bates": BatesModel,
+    "Kou": KouModel,
+    "NIG": NIGModel,
+    "VG": VarianceGammaModel,
+    "CGMY": CGMYModel,
+    "SABR": SABRModel,
+    "CEV": CEVModel,
+}
+TECHNIQUE_MAP = {
+    "Analytic/Closed-Form": ClosedFormTechnique,
+    "Integration": IntegrationTechnique,
+    "FFT": FFTTechnique,
+    "Monte Carlo": MonteCarloTechnique,
+    "PDE": PDETechnique,
+    "Leisen-Reimer": LeisenReimerTechnique,
+    "CRR": CRRTechnique,
+    "TOPM": TOPMTechnique,
+}
+
+col1, col2 = st.columns(2)
+with col1:
+    model_name = st.selectbox("Select Model", list(MODEL_MAP.keys()))
+
+# Get the selected model class and create a dummy instance to check its properties
+model_class = MODEL_MAP[model_name]
+if hasattr(model_class, "default_params"):
+    dummy_model_instance = model_class()  # Uses default params
+else:
+    st.error(f"Model {model_name} is missing 'default_params' attribute.")
+    st.stop()
+
+# Dynamic Technique Selector
+supported_techs = []
+if dummy_model_instance.has_closed_form:
+    supported_techs.append("Analytic/Closed-Form")
+if dummy_model_instance.supports_cf:
+    supported_techs.extend(["Integration", "FFT"])
+if (
+    dummy_model_instance.supports_sde
+    or getattr(dummy_model_instance, "is_pure_levy", False)
+    or getattr(dummy_model_instance, "has_exact_sampler", False)
+):
+    supported_techs.append("Monte Carlo")
+if dummy_model_instance.supports_pde:
+    supported_techs.append("PDE")
+if model_name == "BSM":
+    supported_techs.extend(["Leisen-Reimer", "CRR", "TOPM"])
+
+with col2:
+    # Ensure a default is available if the list of techniques changes
+    selected_index = 0
+    if st.session_state.get("technique_name") in supported_techs:
+        selected_index = supported_techs.index(st.session_state.technique_name)
+    technique_name = st.selectbox(
+        "Select Technique", supported_techs, index=selected_index, key="technique_name"
+    )
+
+# Parameter Inputs
+st.subheader("Market Parameters")
+cols = st.columns(4)
+spot = cols[0].number_input("Spot Price", value=100.0, step=1.0)
+strike = cols[1].number_input("Strike Price", value=100.0, step=1.0)
+maturity = cols[2].number_input("Maturity (Years)", value=1.0, min_value=0.01, step=0.1)
+rate_val = cols[3].number_input("Risk-Free Rate", value=0.05, step=0.01, format="%.2f")
+div_val = cols[0].number_input("Dividend Yield", value=0.02, step=0.01, format="%.2f")
+option_type = cols[1].selectbox("Option Type", ("CALL", "PUT"))
+
+# Dynamic Model Parameter Inputs
+st.subheader(f"{model_name} Model Parameters")
+params = {}
+if hasattr(dummy_model_instance, "param_defs"):
+    param_defs = dummy_model_instance.param_defs
+    num_cols = 4
+    cols = st.columns(num_cols)
+    for i, (p_name, p_def) in enumerate(param_defs.items()):
+        params[p_name] = cols[i % num_cols].number_input(
+            p_def["label"],
+            value=p_def["default"],
+            min_value=p_def.get("min"),
+            max_value=p_def.get("max"),
+            step=p_def.get("step"),
+            format="%.4f",
+        )
+
+if st.button("Calculate Price & Greeks"):
+    # Instantiate Objects
+    stock = Stock(spot=spot, dividend=div_val)
+    rate = Rate(rate=rate_val)
+    option = Option(
+        strike=strike, maturity=maturity, option_type=OptionType[option_type]
+    )
+
+    # merge UI params with non-UI default params
+    full_params = model_class.default_params.copy()
+    full_params.update(params)
+
+    model = model_class(params=full_params)
+    technique = TECHNIQUE_MAP[technique_name]()
+
+    # Prepare kwargs for techniques that need extra info (e.g., Heston's v0)
+    pricing_kwargs = full_params.copy()
+
+    # Calculate and Display
+    with st.spinner("Calculating..."):
+        try:
+            results_data = {}
+
+            results_data["Price"] = technique.price(
+                option, stock, model, rate, **pricing_kwargs
+            ).price
+
+            results_data["Delta"] = technique.delta(
+                option, stock, model, rate, **pricing_kwargs
+            )
+            results_data["Gamma"] = technique.gamma(
+                option, stock, model, rate, **pricing_kwargs
+            )
+            results_data["Vega"] = technique.vega(
+                option, stock, model, rate, **pricing_kwargs
+            )
+            results_data["Theta"] = technique.theta(
+                option, stock, model, rate, **pricing_kwargs
+            )
+            results_data["Rho"] = technique.rho(
+                option, stock, model, rate, **pricing_kwargs
+            )
+
+            st.dataframe(pd.DataFrame([results_data]))
+        except Exception as e:
+            st.error(f"Calculation failed: {e}")
+            st.exception(e)

quantfin/dashboard/pages/3_Financial_Tools.py

@@ -0,0 +1,69 @@
+import pandas as pd
+import streamlit as st
+
+from quantfin.atoms import Rate, Stock, ZeroCouponBond
+from quantfin.calibration import fit_jump_params_from_history
+from quantfin.data import load_historical_returns
+from quantfin.models import CIRModel, VasicekModel
+from quantfin.parity import ImpliedRateModel
+from quantfin.techniques import ClosedFormTechnique
+
+st.set_page_config(layout="wide", page_title="QuantFin | Tools")
+st.title("Financial Utilities & Tools")
+
+# Jump Parameter Fitter
+st.header("Historical Jump Parameter Fitter")
+TICKERS = ["SPY", "AAPL", "META", "GOOGL", "TSLA", "NVDA", "AMD", "MSFT", "AMZN", "JPM"]
+ticker_jump = st.selectbox("Select Ticker for Jump Analysis", TICKERS)
+if st.button("Fit Jump Parameters"):
+    with st.spinner(f"Loading 10y returns for {ticker_jump} and fitting..."):
+        try:
+            returns = load_historical_returns(ticker_jump, period="10y")
+            jump_params = fit_jump_params_from_history(returns)
+            st.dataframe(pd.DataFrame([jump_params]))
+        except Exception as e:
+            st.error(f"Could not fit parameters: {e}")
+
+# Rate Model Pricer
+st.header("Term Structure Model Pricer")
+col1, col2, col3 = st.columns(3)
+model_name = col1.selectbox("Select Rate Model", ["Vasicek", "CIR"])
+r0 = col2.number_input("Initial Short Rate (r0)", value=0.05, step=0.01)
+bond_maturity = col3.number_input("Bond Maturity (T)", value=1.0, step=0.5)
+params = {}
+if model_name == "Vasicek":
+    cols_vasicek = st.columns(3)
+    params["kappa"] = cols_vasicek[0].number_input("Mean Reversion (kappa)", value=0.86)
+    params["theta"] = cols_vasicek[1].number_input("Long-Term Mean (theta)", value=0.09)
+    params["sigma"] = cols_vasicek[2].number_input("Volatility (sigma)", value=0.02)
+    model = VasicekModel(params=params)
+else:  # CIR
+    cols_cir = st.columns(3)
+    params["kappa"] = cols_cir[0].number_input("Mean Reversion (kappa)", value=0.86)
+    params["theta"] = cols_cir[1].number_input("Long-Term Mean (theta)", value=0.09)
+    params["sigma"] = cols_cir[2].number_input("Volatility (sigma)", value=0.02)
+    model = CIRModel(params=params)
+if st.button("Price Zero-Coupon Bond"):
+    bond = ZeroCouponBond(maturity=bond_maturity)
+    r0_stock = Stock(spot=r0)
+    dummy_rate = Rate(rate=0.0)
+    technique = ClosedFormTechnique()
+    price = technique.price(bond, r0_stock, model, dummy_rate).price
+    st.metric(label=f"{model_name} ZCB Price", value=f"{price:.6f}")
+
+st.header("Put-Call Parity Tools")
+c1, c2, c3, c4, c5 = st.columns(5)
+call_p = c1.number_input("Call Price", value=10.0)
+put_p = c2.number_input("Put Price", value=5.0)
+spot_p = c3.number_input("Spot Price ", value=100.0)
+strike_p = c4.number_input("Strike Price ", value=100.0)
+T_p = c5.number_input("Maturity ", value=1.0)
+
+implied_rate_model = ImpliedRateModel(params={"eps": 1e-9, "max_iter": 100})
+try:
+    implied_r = implied_rate_model.price_closed_form(
+        call_price=call_p, put_price=put_p, spot=spot_p, strike=strike_p, t=T_p, q=0
+    )
+    st.metric("Implied Risk-Free Rate (r)", f"{implied_r:.4%}")
+except Exception as e:
+    st.error(f"Could not calculate implied rate: {e}")

quantfin/dashboard/plots.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import plotly.graph_objects as go
+
+__doc__ = """
+Contains plotting functions used by the dashboard to visualize
+volatility surfaces and smiles.
+"""
+
+
+def plot_smiles_by_expiry(
+    market_surface: pd.DataFrame,
+    model_surfaces: dict[str, pd.DataFrame],
+    ticker: str,
+    snapshot_date: str,
+):
+    """
+    Generates a matplotlib figure with volatility smiles for key expiries.
+
+    Compares the market implied volatility to the volatilities implied by
+    calibrated models across different strikes for a few selected expiration dates.
+
+    Parameters
+    ----------
+    market_surface : pd.DataFrame
+        DataFrame containing the market's implied volatility surface.
+        Must have 'expiry', 'strike', and 'iv' columns.
+    model_surfaces : dict[str, pd.DataFrame]
+        A dictionary mapping model names to their implied volatility surfaces.
+    ticker : str
+        The stock ticker, used for the plot title.
+    snapshot_date : str
+        The snapshot date, used for the plot title.
+
+    Returns
+    -------
+    matplotlib.figure.Figure
+        The matplotlib figure object containing the subplots of volatility smiles.
+    """
+    expiries = sorted(market_surface["expiry"].unique())
+    # Select up to 4 expiries to plot
+    plot_indices = np.linspace(0, len(expiries) - 1, min(4, len(expiries)), dtype=int)
+    plot_expiries = [expiries[i] for i in plot_indices]
+
+    fig, axes = plt.subplots(2, 2, figsize=(15, 11), sharey=True)
+    fig.suptitle(f"Volatility Smiles for {ticker} on {snapshot_date}", fontsize=18)
+    axes = axes.flatten()
+
+    for i, expiry in enumerate(plot_expiries):
+        ax = axes[i]
+        market_slice = market_surface[market_surface["expiry"] == expiry]
+
+        ax.scatter(
+            market_slice["strike"],
+            market_slice["iv"] * 100,
+            label="Market IV",
+            alpha=0.7,
+            s=20,
+            zorder=10,
+        )
+
+        for model_name, model_surface in model_surfaces.items():
+            model_slice = model_surface[model_surface["expiry"] == expiry].sort_values(
+                "strike"
+            )
+            ax.plot(
+                model_slice["strike"],
+                model_slice["iv"] * 100,
+                label=f"{model_name} IV",
+                lw=2.5,
+                alpha=0.8,
+            )
+
+        expiry_date_str = pd.to_datetime(expiry).strftime("%Y-%m-%d")
+        maturity = market_slice["maturity"].iloc[0]
+        ax.set_title(f"Expiry: {expiry_date_str} (T={maturity:.2f}y)")
+        ax.set_xlabel("Strike")
+        ax.set_ylabel("Implied Volatility (%)")
+        ax.legend()
+        ax.grid(True, linestyle="--", alpha=0.6)
+        ax.set_ylim(bottom=max(0, market_slice["iv"].min() * 100 - 5))
+
+    for j in range(i + 1, len(axes)):
+        axes[j].set_visible(False)
+
+    plt.tight_layout(rect=[0, 0.03, 1, 0.95])
+    return fig
+
+
+def plot_iv_surface_3d(
+    market_surface: pd.DataFrame, model_surfaces: dict[str, pd.DataFrame], ticker: str
+):
+    """
+    Creates an interactive 3D plot of the volatility surfaces.
+
+    Renders the market IV surface as a mesh and overlays the model-implied
+    IV surfaces as line plots for comparison.
+
+    Parameters
+    ----------
+    market_surface : pd.DataFrame
+        DataFrame containing the market's implied volatility surface.
+        Must have 'maturity', 'strike', and 'iv' columns.
+    model_surfaces : dict[str, pd.DataFrame]
+        A dictionary mapping model names to their implied volatility surfaces.
+    ticker : str
+        The stock ticker, used for the plot title.
+
+    Returns
+    -------
+    plotly.graph_objects.Figure
+        The Plotly figure object for the 3D surface plot.
+    """
+    fig = go.Figure()
+    fig.add_trace(
+        go.Mesh3d(
+            x=market_surface["maturity"],
+            y=market_surface["strike"],
+            z=market_surface["iv"],
+            opacity=0.5,
+            color="grey",
+            name="Market IV",
+        )
+    )
+
+    colors = [
+        "#3a7fc1",  # Deep ocean blue
+        "#ff8c00",  # Sunset orange
+        "#4aac26",  # Fresh sprout green
+        "#d03530",  # Warning red
+    ]
+
+    for i, (name, surface) in enumerate(model_surfaces.items()):
+        fig.add_trace(
+            go.Scatter3d(
+                x=surface["maturity"],
+                y=surface["strike"],
+                z=surface["iv"],
+                mode="lines",
+                name=f"{name} IV",
+                line=dict(color=colors[i % len(colors)], width=6),
+            )
+        )
+
+    fig.update_layout(
+        title=f"Implied Volatility Surface for {ticker}",
+        scene=dict(
+            xaxis_title="Maturity (Years)",
+            yaxis_title="Strike",
+            zaxis_title="Implied Volatility",
+        ),
+        margin=dict(l=0, r=0, b=0, t=40),
+    )
+    return fig

quantfin/dashboard/service.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+from typing import Any
+
+import pandas as pd
+
+from quantfin.atoms import Rate, Stock
+from quantfin.calibration import VolatilitySurface, fit_rate_and_dividend
+from quantfin.calibration.technique_selector import select_fastest_technique
+from quantfin.dashboard.plots import plot_iv_surface_3d, plot_smiles_by_expiry
+from quantfin.data.market_data_manager import (
+    get_live_option_chain,
+    load_market_snapshot,
+)
+from quantfin.workflows import DailyWorkflow
+
+__doc__ = """
+Defines the main service layer that orchestrates all backend logic for the
+Streamlit dashboard, from data loading to model calibration and plot generation.
+"""
+
+
+class DashboardService:
+    """
+    Orchestrates all logic for the Streamlit dashboard.
+
+    This class acts as a stateful service to manage data loading,
+    model calibration, and result generation for a given ticker and date.
+
+    Parameters
+    ----------
+    ticker : str
+        The stock ticker to analyze.
+    snapshot_date : str
+        The market data snapshot date ('YYYY-MM-DD') or 'Live Data'.
+    model_configs : dict[str, Any]
+        A dictionary of model configurations to be used for calibration.
+    """
+
+    def __init__(
+        self,
+        ticker: str,
+        snapshot_date: str,
+        model_configs: dict[str, Any],
+    ):
+        self.ticker = ticker
+        self.snapshot_date = snapshot_date
+        self.model_configs = model_configs
+        self._market_data: pd.DataFrame | None = None
+        self._stock: Stock | None = None
+        self._rate: Rate | None = None
+        self.calibrated_models: dict[str, Any] = {}
+        self.summary_df: pd.DataFrame | None = None
+
+    @property
+    def market_data(self) -> pd.DataFrame:
+        """
+        Lazily loads the market data for the selected ticker and date.
+
+        Returns
+        -------
+        pd.DataFrame
+            A DataFrame containing the option chain market data.
+        """
+        if self._market_data is None:
+            if self.snapshot_date == "Live Data":
+                self._market_data = get_live_option_chain(self.ticker)
+
+            else:
+                self._market_data = load_market_snapshot(
+                    self.ticker, self.snapshot_date
+                )
+        return self._market_data
+
+    @property
+    def stock(self) -> Stock:
+        """
+        Lazily computes and caches the underlying Stock object.
+
+        The dividend yield is implied from put-call parity.
+
+        Returns
+        -------
+        Stock
+            A Stock instance representing the underlying asset.
+        """
+        if self._stock is None:
+            spot = self.market_data["spot_price"].iloc[0]
+            _, div = fit_rate_and_dividend(
+                self.market_data[self.market_data["optionType"] == "call"],
+                self.market_data[self.market_data["optionType"] == "put"],
+                spot,
+            )
+            self._stock = Stock(spot=spot, dividend=div)
+
+        return self._stock
+
+    @property
+    def rate(self) -> Rate:
+        """
+        Lazily computes and caches the risk-free Rate object.
+
+        The rate is implied from put-call parity.
+
+        Returns
+        -------
+        Rate
+            A Rate instance representing the risk-free rate.
+        """
+        if self._rate is None:
+            spot = self.market_data["spot_price"].iloc[0]
+            r, _ = fit_rate_and_dividend(
+                self.market_data[self.market_data["optionType"] == "call"],
+                self.market_data[self.market_data["optionType"] == "put"],
+                spot,
+            )
+            self._rate = Rate(rate=r)
+
+        return self._rate
+
+    def run_calibrations(self):
+        """
+        Runs the daily calibration workflow for all selected models.
+
+        This method iterates through the model configurations, runs the
+        `DailyWorkflow` for each, and stores the calibrated models and
+        a summary of the results.
+        """
+        all_results = []
+        for model_name, config in self.model_configs.items():
+            workflow = DailyWorkflow(market_data=self.market_data, model_config=config)
+            workflow.run()
+            all_results.append(workflow.results)
+            if workflow.results.get("Status") == "Success":
+                params = workflow.results.get("Calibrated Params")
+                self.calibrated_models[model_name] = config["model_class"](
+                    params=params
+                )
+        self.summary_df = pd.DataFrame(all_results)
+
+    def get_iv_plots(self):
+        """
+        Generates and returns the volatility smile and 3D surface plots.
+
+        It first computes the market IV surface, then computes the IV surface
+        for each successfully calibrated model, and finally generates the plots.
+
+        Returns
+        -------
+        tuple[matplotlib.figure.Figure, plotly.graph_objects.Figure]
+            A tuple containing the volatility smile figure and the 3D surface figure.
+        """
+        market_surface = (
+            VolatilitySurface(self.market_data)
+            .calculate_market_iv(self.stock, self.rate)
+            .surface
+        )
+
+        model_surfaces = {}
+        for name, model in self.calibrated_models.items():
+            technique = select_fastest_technique(model)
+            model_surfaces[name] = (
+                VolatilitySurface(self.market_data)
+                .calculate_model_iv(self.stock, self.rate, model, technique)
+                .surface
+            )
+
+        smile_fig = plot_smiles_by_expiry(
+            market_surface,
+            model_surfaces,
+            self.ticker,
+            self.snapshot_date,
+        )
+        surface_fig = plot_iv_surface_3d(market_surface, model_surfaces, self.ticker)
+
+        return smile_fig, surface_fig

quantfin/dashboard/widgets.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+import streamlit as st
+
+from quantfin.atoms import Rate, Stock
+from quantfin.parity import ParityModel
+
+__doc__ = """
+Contains reusable Streamlit components (widgets) for displaying
+specific analyses on the dashboard, such as put-call parity checks.
+"""
+
+
+def render_parity_analysis_widget(
+    market_data: pd.DataFrame,
+    stock: Stock,
+    rate: Rate,
+):
+    """
+    Creates a Streamlit container to display put-call parity analysis.
+
+    This function takes market data and computes the arbitrage gap based on
+    the put-call parity relationship for a user-selected expiration date.
+
+    Parameters
+    ----------
+    market_data : pd.DataFrame
+        The full option chain data for the asset.
+    stock : Stock
+        The underlying Stock object, containing spot price and dividend yield.
+    rate : Rate
+        The risk-free Rate object.
+    """
+    st.subheader("Put-Call Parity Analysis")
+
+    # TODO: support for ParityModel; needs vecotrizing. Currently do it here.
+    parity_model = ParityModel()  # noqa: F841
+
+    expiries = sorted(market_data["expiry"].unique())
+    selected_expiry = st.select_slider(
+        "Select Expiry to Analyze",
+        options=[pd.to_datetime(e).strftime("%Y-%m-%d") for e in expiries],
+    )
+
+    expiry_df = market_data[
+        market_data["expiry"] == pd.to_datetime(selected_expiry)
+    ].copy()
+
+    calls = expiry_df[expiry_df["optionType"] == "call"].set_index("strike")
+    puts = expiry_df[expiry_df["optionType"] == "put"].set_index("strike")
+
+    # Find common strikes
+    common_strikes = calls.index.intersection(puts.index)
+    if len(common_strikes) == 0:
+        st.warning("No common strikes found for this expiry to check parity.")
+        return
+
+    calls = calls.loc[common_strikes]
+    puts = puts.loc[common_strikes]
+
+    # C - P
+    price_diff = calls["last_price"] - puts["last_price"]
+
+    # S*exp(-qT) - K*exp(-rT)
+    T = calls["maturity"].iloc[0]
+    r = rate.get_rate(T)
+    q = stock.dividend
+
+    parity_diff = stock.spot * np.exp(-q * T) - calls.index.values * np.exp(-r * T)
+
+    error = price_diff - parity_diff
+
+    results_df = pd.DataFrame(
+        {
+            "C - P": price_diff,
+            "S*e⁻qT - K*e⁻rT": parity_diff,
+            "Arbitrage Gap ($)": error,
+        }
+    )
+
+    st.dataframe(results_df)
+    st.caption(
+        "A non-zero 'Arbitrage Gap' suggests a violation of put-call parity "
+        "(or stale data)."  # noqa: E501
+    )

quantfin/data/__init__.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+__doc__ = """
+The `data` package provides a clean, unified interface for fetching, loading,
+and saving all market and historical data required by the quantfin library.
+"""
+
+from .historical_manager import (
+    load_historical_returns,
+    save_historical_returns,
+)
+from .market_data_manager import (
+    get_available_snapshot_dates,
+    get_live_option_chain,
+    load_market_snapshot,
+    save_market_snapshot,
+)
+
+__all__ = [
+    "get_available_snapshot_dates",
+    "get_live_option_chain",
+    "load_historical_returns",
+    "load_market_snapshot",
+    "save_historical_returns",
+    "save_market_snapshot",
+]