optPricing 2.0.0__tar.gz

optpricing-2.0.0/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Changelog
+
+## [2.0.0] - 2025-06-26
+### Added
+- Shipped to PyPI `pyproject.toml`
+

optpricing-2.0.0/LICENSE

@@ -0,0 +1,9 @@
+# MIT LICENSE
+
+Copyright 2025 Diljit Singh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

optpricing-2.0.0/MANIFEST.in

@@ -0,0 +1,6 @@
+include README.md
+include LICENSE
+include CHANGELOG.md
+include pyproject.toml
+include mkdocs.yml
+recursive-include docs *

optpricing-2.0.0/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: optPricing
+Version: 2.0.0
+Summary: A financial options pricing and analysis library.
+Author-email: Diljit Singh <first_last22@google.com>
+License: # MIT LICENSE
+        
+        Copyright 2025 Diljit Singh
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+        
+Project-URL: Homepage, https://diljit22.github.io/quantFin/
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy==2.2.5
+Requires-Dist: scipy==1.15.2
+Requires-Dist: pandas==2.2.3
+Requires-Dist: numba==0.61.2
+Requires-Dist: pyyaml==6.0.2
+Requires-Dist: polygon-api-client==1.14.6
+Requires-Dist: typer==0.15.2
+Provides-Extra: app
+Requires-Dist: streamlit==1.45.1; extra == "app"
+Requires-Dist: matplotlib==3.10.1; extra == "app"
+Requires-Dist: plotly==6.1.2; extra == "app"
+Requires-Dist: yfinance==0.2.63; extra == "app"
+Requires-Dist: tabulate==0.9.0; extra == "app"
+Provides-Extra: dev
+Requires-Dist: pytest==8.3.5; extra == "dev"
+Requires-Dist: pytest-cov==6.2.1; extra == "dev"
+Requires-Dist: ruff==0.11.6; extra == "dev"
+Requires-Dist: mkdocs==1.6.1; extra == "dev"
+Requires-Dist: mkdocs-material==9.6.14; extra == "dev"
+Requires-Dist: mkdocstrings[python]==0.29.1; extra == "dev"
+Requires-Dist: mkdocs-section-index==0.3.10; extra == "dev"
+Requires-Dist: line_profiler==4.2.0; extra == "dev"
+Dynamic: license-file
+
+# QuantFin
+
+[![CI/CD](https://github.com/diljit22/quantfin/actions/workflows/ci.yml/badge.svg)](https://github.com/diljit22/quantfin/actions/workflows/ci.yml)
+[![PyPI Version](https://badge.fury.io/py/quantfin.svg)](https://pypi.org/project/quantfin/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+
+**A Python library for pricing and calibrating financial options.**
+
+## Introduction
+
+Welcome to **QuantFin**, a comprehensive Python toolkit for pricing and calibrating financial derivatives. This library was originally designed for me to learn about the more nuanced methods of quantitative finance and has since grown into a robust framework for analysis.
+
+QuantFin is structured around four core pillars:
+
+- **Atoms**: Fundamental data types (`Option`, `Stock`, `Rate`) that ensure consistency and clarity of inputs across the library.
+- **Models**: A broad library ranging from classical Black-Scholes-Merton to advanced stochastic volatility (Heston, SABR) and jump/Lévy processes.
+- **Techniques**: Multiple pricing engines—closed-form formulas, FFT, numerical integration, PDE solvers, lattice methods, and Monte Carlo (`numba`-accelerated with variance reduction methods baked in).
+- **Workflows**: High-level orchestrators that automate end-to-end tasks like daily calibration and out-of-sample backtesting, all accessible via a CLI or an interactive dashboard.
+
+---
+
+## Quick Start
+
+Get started in minutes using the command-line interface.
+
+```bash
+# 1. Install the library with all features, including the dashboard
+pip install optPricing[app]
+
+# 2. Download historical data for a ticker (used by some models)
+quantfin data download --ticker SPY
+
+# 3. Launch the interactive dashboard to visualize the results
+quantfin dashboard
+
+# 4. See a demo of the engine
+quantfin demo
+```
+
+## Documentation & Links
+
+For a detailed tutorial, full API reference, and more examples, please see the official documentation.
+
+- **Getting Started**: [Installation Guide](installation.md) · [Walkthrough](getting_started.md)  
+- **Documentation**: [API Reference](reference/atoms/index.md)
+- **Interactive Dashboard**: [Launch the UI](dashboard.md)  
+- **About Me**: [LinkedIn]([dashboard.md](https://www.linkedin.com/in/singhdiljit/))  
+
+To explore all available commands, run:
+
+```bash
+quantfin --help
+```
+
+## Contributing & License
+
+See [CONTRIBUTING](/CONTRIBUTING.md) and [LICENSE](LICENSE).

optpricing-2.0.0/README.md

@@ -0,0 +1,58 @@
+# QuantFin
+
+[![CI/CD](https://github.com/diljit22/quantfin/actions/workflows/ci.yml/badge.svg)](https://github.com/diljit22/quantfin/actions/workflows/ci.yml)
+[![PyPI Version](https://badge.fury.io/py/quantfin.svg)](https://pypi.org/project/quantfin/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+
+**A Python library for pricing and calibrating financial options.**
+
+## Introduction
+
+Welcome to **QuantFin**, a comprehensive Python toolkit for pricing and calibrating financial derivatives. This library was originally designed for me to learn about the more nuanced methods of quantitative finance and has since grown into a robust framework for analysis.
+
+QuantFin is structured around four core pillars:
+
+- **Atoms**: Fundamental data types (`Option`, `Stock`, `Rate`) that ensure consistency and clarity of inputs across the library.
+- **Models**: A broad library ranging from classical Black-Scholes-Merton to advanced stochastic volatility (Heston, SABR) and jump/Lévy processes.
+- **Techniques**: Multiple pricing engines—closed-form formulas, FFT, numerical integration, PDE solvers, lattice methods, and Monte Carlo (`numba`-accelerated with variance reduction methods baked in).
+- **Workflows**: High-level orchestrators that automate end-to-end tasks like daily calibration and out-of-sample backtesting, all accessible via a CLI or an interactive dashboard.
+
+---
+
+## Quick Start
+
+Get started in minutes using the command-line interface.
+
+```bash
+# 1. Install the library with all features, including the dashboard
+pip install optPricing[app]
+
+# 2. Download historical data for a ticker (used by some models)
+quantfin data download --ticker SPY
+
+# 3. Launch the interactive dashboard to visualize the results
+quantfin dashboard
+
+# 4. See a demo of the engine
+quantfin demo
+```
+
+## Documentation & Links
+
+For a detailed tutorial, full API reference, and more examples, please see the official documentation.
+
+- **Getting Started**: [Installation Guide](installation.md) · [Walkthrough](getting_started.md)  
+- **Documentation**: [API Reference](reference/atoms/index.md)
+- **Interactive Dashboard**: [Launch the UI](dashboard.md)  
+- **About Me**: [LinkedIn]([dashboard.md](https://www.linkedin.com/in/singhdiljit/))  
+
+To explore all available commands, run:
+
+```bash
+quantfin --help
+```
+
+## Contributing & License
+
+See [CONTRIBUTING](/CONTRIBUTING.md) and [LICENSE](LICENSE).

optpricing-2.0.0/docs/guide/dashboard.md

@@ -0,0 +1,45 @@
+# Using the Interactive Dashboard
+
+The `quantfin` library includes an interactive dashboard built with Streamlit,
+providing a visual interface for the library's core features.
+
+## Launching the Dashboard
+
+To use the dashboard, you must first install the library with the `[app]` extra dependencies:
+
+```bash
+pip install optPricing[app]
+```
+
+Once installed, you can launch the application from your terminal with a single command:
+
+```bash
+quantfin dashboard
+```
+
+This will open the application in a new browser tab.
+
+## Dashboard Pages
+
+The dashboard is organized into several pages, accessible from the sidebar on the left.
+
+### Calibration
+
+This is the main page for model calibration. It allows you to select a ticker and one or more models, run the calibration workflow, and see a detailed analysis of the results.
+
+![alt text](../images/calibration.png)
+
+### Pricer and Greeks
+
+This page is an interactive pricing tool that allows you to explore the behavior of different models and techniques in real-time. You can adjust all market and model parameters to see their effect on the option price and its Greeks.
+![alt text](../images/bates.png)
+
+### Financial Tools
+
+This page provides access to several utility functions from the library for more specific analyses.
+Historical Jump Fitter: Select a ticker to estimate jump-diffusion parameters directly from its historical returns data.
+![alt text](../images/fit_jump.png)
+
+Term Structure Pricer: Price a zero-coupon bond using interest rate models like Vasicek or CIR.
+
+![alt text](../images/zcb.png)

optpricing-2.0.0/docs/guide/getting_started.md

@@ -0,0 +1,218 @@
+# Getting Started: A Walkthrough
+
+This guide is a hands-on tutorial that will walk you through the library's core features,
+from pricing a single option to running a full model calibration, using the command-line
+interface (CLI).
+
+---
+
+## 1. Run the Built-In Demo
+
+The quickest way to see QuantFin in action is with the included benchmark script.
+
+**Prerequisite**: install the library if you haven’t already:
+
+```bash
+pip install optPricing
+```
+
+Then execute:
+
+```bash
+quantfin demo
+```
+
+This will price a standard option across multiple models and techniques and print a
+formatted comparison table.
+
+---
+
+## 2. Pricing an Option Programmatically
+
+First, import and configure the objects you need:
+
+```python
+from quantfin.atoms import Option, Stock, Rate, OptionType, ZeroCouponBond
+from quantfin.models import BSMModel, VasicekModel, CIRModel
+from quantfin.techniques import ClosedFormTechnique
+
+# 1. Define an option, underlying and rate
+option = Option(strike=105, maturity=1.0, option_type=OptionType.CALL)
+stock  = Stock(spot=100, dividend=0.01)
+rate   = Rate(rate=0.05)
+
+# 2. Choose a model and technique
+bsm_model     = BSMModel(params={"sigma": 0.20})
+cf_technique  = ClosedFormTechnique()
+```
+
+### 2.1 Compute the Price
+
+```python
+result = cf_technique.price(option, stock, bsm_model, rate)
+print(f"The option price is: {result.price:.4f}")
+>>> The option price is: 7.4917
+```
+
+### 2.2 Compute the Greeks
+
+```python
+delta = cf_technique.delta(option, stock, bsm_model, rate)
+gamma = cf_technique.gamma(option, stock, bsm_model, rate)
+vega  = cf_technique.vega(option, stock, bsm_model, rate)
+
+print(f"Delta: {delta:.4f}")
+print(f"Gamma: {gamma:.4f}")
+print(f"Vega:  {vega:.4f}")
+
+>>> Delta: 0.5172
+>>> Gamma: 0.0197
+>>> Vega:  39.4353
+```
+
+### 2.3 Find Implied Volatility
+
+```python
+target_price = 7.50
+iv = cf_technique.implied_volatility(
+    option, stock, bsm_model, rate, target_price=target_price
+)
+print(f"Implied volatility for price ${target_price:.2f}: {iv:.4%}")
+>>> Implied volatility for price $7.50: 20.0211%
+```
+
+---
+
+## 3. Pricing Interest‐Rate Instruments
+
+QuantFin reuses the same pricing interfaces for interest‐rate models:
+
+```python
+# Zero‐coupon bond maturing in 1 year
+bond      = ZeroCouponBond(maturity=1.0)
+r0_stock  = Stock(spot=0.05)    # initial short rate
+dummy_rate = Rate(rate=0.0)     # ignored by rate models
+
+vasicek = VasicekModel(params={"kappa":0.86, "theta":0.09, "sigma":0.02})
+cir     = CIRModel(params={"kappa":0.86, "theta":0.09, "sigma":0.02})
+
+p_vasi = cf_technique.price(bond, r0_stock, vasicek, dummy_rate).price
+p_cir  = cf_technique.price(bond, r0_stock, cir,     dummy_rate).price
+
+print(f"Vasicek ZCB Price: {p_vasi:.4f}")
+print(f"CIR ZCB Price:     {p_cir:.4f}")
+
+>>> Vasicek ZCB Price: 0.9388
+>>> CIR ZCB Price:     0.9388
+```
+
+---
+
+## 4. Live Pricing and Analysis via CLI
+
+### 4.1 Price an Option
+
+```bash
+quantfin price \
+  --ticker SPY \
+  --strike 500 \
+  --maturity 2025-12-19 \
+  --type call \
+  --model Heston \
+  --param "v0=0.04" \
+  --param "kappa=2.0" \
+  --param "theta=0.05" \
+  --param "rho=-0.7" \
+  --param "vol_of_vol=0.5"
+```
+
+### 4.2 Implied Rate from Put-Call Parity
+
+The tools implied-rate command fetches live prices for a call-put pair and calculates the risk-free rate implied by put-call parity.
+
+```bash
+quantfin tools implied-rate --ticker SPY --strike 500 --maturity 2025-12-19
+```
+
+---
+
+## 5. Model Calibration with the CLI
+
+Download historical returns (for initial guesses and jump paramaters):
+
+```bash
+quantfin data download --ticker SPY
+```
+
+Download a snapshot of the market-data
+
+```bash
+# For the 25 benchmark stocks use --all
+quantfin data snapshot --all
+
+# If just a particular ticker use e.g.
+quantfin data snapshot --ticker SPY --ticker AAPL
+```
+
+A simple calibration for the Merton Jump model. The workflow will find the latest market data
+for SPY and solve for the implied volatility that best fits the front-month options.
+
+The `--verbose` flag provides detailed logs from the workflow.
+
+```bash
+quantfin calibrate --ticker SPY --model Merton --verbose
+```
+
+The final calibrated parameters are printed to the console and saved to a JSON file in
+the `artifacts/calibrated_params/` directory.
+
+---
+
+## 6. Managing Data
+
+* Download specific tickers:
+
+  ```bash
+  quantfin data download --ticker AAPL --ticker TSLA
+  ```
+
+* Download all defaults (from `config.yaml`):
+
+  ```bash
+  quantfin data download --all
+  ```
+
+* Snapshot the live option chain:
+
+  ```bash
+  quantfin data snapshot --ticker NVDA
+  ```
+
+---
+
+## 7. Running Tests
+
+If you have installed dev dependencies:
+
+```bash
+pip install -e .[dev]
+pytest
+```
+
+---
+
+## 8. Launching the Dashboard
+
+Make sure you have the `[app]` extras installed:
+
+```bash
+pip install optPricing[app]
+```
+
+Then run:
+
+```bash
+quantfin dashboard
+```
+
+This will open the Streamlit application in your browser for interactive exploration.

optpricing-2.0.0/docs/guide/installation.md

@@ -0,0 +1,33 @@
+# Installation
+
+The QuantFin library is published on the Python Package Index (PyPI) and can be easily installed using `pip`. A Python version of 3.10 or higher is required.
+
+## Standard Installation
+
+For most use cases, including running the command-line interface for calibration and backtesting, you can install the core library with the following command:
+
+```bash
+pip install optPricing
+```
+
+This will install the library and all its core dependencies, such as numpy, scipy, and typer.
+
+## Full Installation (with Dashboard)
+
+The library includes an optional interactive dashboard built with Streamlit, which provides a visual way to interact with the pricing and calibration tools. To install the core library along with the dependencies needed to run the dashboard, use the [app] extra:
+
+```bash
+pip install optPricing[app]
+```
+
+This is the recommended installation if you plan to use the visual tools.
+
+## Developer Installation
+
+If you wish to contribute to the development of QuantFin, or if you want to make local modifications to the source code, you should clone the repository and install it in "editable" mode.
+
+```bash
+git clone https://github.com/diljit22/quantfin.git
+cd quantfin
+pip install -e .[app,dev]
+```

optpricing-2.0.0/docs/guide/introduction.md

@@ -0,0 +1,35 @@
+# Introduction
+
+Welcome to the QuantFin library! This documentation is your comprehensive guide to understanding and using all the features this library has to offer.
+
+## What is QuantFin?
+
+QuantFin is a Python library designed to provide a toolkit for quantitative finance, with a primary focus on the pricing and analysis of financial derivatives.
+
+The library is organized around a few core concepts; understanding these will help you navigate the codebase and documentation.
+
+- **Atoms**: These are the fundamental, immutable data structures representing core financial concepts like `Option`, `Stock`, and `Rate`. By using these "atoms," we ensure that data is passed through the system in a consistent and predictable way.
+
+- **Models**: This is a collection of classes representing financial models. It includes everything from the standard Black-Scholes-Merton to advanced models with stochastic volatility (Heston, SABR) and jumps (Merton, Bates, Kou). Each model is a self-contained representation of a specific financial theory.
+
+- **Techniques**: These are the numerical or analytical algorithms used for pricing, such as Monte Carlo simulation, Fast Fourier Transform (FFT), or finite difference methods (PDEs). This design choice decouples the "what" (the model) from the "how" (the pricing algorithm), allowing you to, for example, price a Heston model using either FFT or Monte Carlo.
+
+- **Workflows**: These are high-level orchestrators that combine data, models, and techniques to perform complex, real-world tasks like daily model calibration or historical backtesting. They are the engines that power the command-line interface and the dashboard.
+
+## Our Philosophy
+
+The library was designed with the following principles in mind:
+
+- **Speed**: For computationally intensive tasks like Monte Carlo simulation, we use `numba` to JIT-compile the core numerical kernels, resulting in performance that rivals compiled languages like C or Fortran.
+
+- **Accuracy**: Standard, well-vetted numerical algorithms are used for pricing, calibration, and root-finding, providing a reliable foundation for your analysis.
+
+- **Extensibility**: The object-oriented design, centered around the `BaseModel` and `BaseTechnique` abstract classes, makes it straightforward for you or other developers to add new models or pricing methods without disrupting the existing structure.
+
+- **Usability**: A powerful command-line interface (CLI) and an interactive Streamlit dashboard are provided for common tasks, making the library accessible to users who may not want to write Python code for every analysis.
+
+Ready to get started? Head over to:
+
+- [Getting Started](guide/getting_started.md)
+- [API Reference](reference/atoms/index.md)
+- [Interactive Dashboard](guide/dashboard.md)

optpricing-2.0.0/docs/index.md

@@ -0,0 +1,19 @@
+# Welcome to QuantFin
+
+QuantFin is a Python library for pricing and calibrating financial derivatives.
+
+It features a rich CLI, as well as an interactive dashboard;
+
+```bash
+quantfin dashboard
+```
+
+This will open a Streamlit application in your browser where you can perform calibrations, price options, and visualize results without writing any code.
+
+![QuantFin Calibration Dashboard](images/calibration.png)
+
+---
+
+- [Getting Started](guide/getting_started.md)
+- [API Reference](reference/atoms/index.md)
+- [Interactive Dashboard](guide/dashboard.md)

optpricing-2.0.0/docs/reference/atoms/bond.md

@@ -0,0 +1,3 @@
+# ZeroCouponBond
+
+::: src.quantfin.atoms.bond.ZeroCouponBond

optpricing-2.0.0/docs/reference/atoms/index.md

@@ -0,0 +1,8 @@
+# Atoms Package
+
+The `atoms` package provides the fundamental data structures used throughout the `quantfin` library. These classes are immutable containers that represent core financial concepts.
+
+-   **Stock**: Represents the underlying asset.
+-   **Option**: Represents a vanilla option contract, including its type and style.
+-   **Rate**: Represents the risk-free interest rate structure.
+-   **Bond**: Represents a simple zero-coupon bond.

optpricing-2.0.0/docs/reference/atoms/option.md

@@ -0,0 +1,11 @@
+# Option
+
+::: src.quantfin.atoms.option.Option
+
+## OptionType
+
+::: src.quantfin.atoms.option.OptionType
+
+## ExerciseStyle
+
+::: src.quantfin.atoms.option.ExerciseStyle

optpricing-2.0.0/docs/reference/atoms/rate.md

@@ -0,0 +1,3 @@
+# Rate
+
+::: src.quantfin.atoms.rate.Rate

optpricing-2.0.0/docs/reference/atoms/stock.md

@@ -0,0 +1,3 @@
+# Stock
+
+::: src.quantfin.atoms.stock.Stock

optpricing-2.0.0/docs/reference/calibration/calibrator.md

@@ -0,0 +1,3 @@
+# Calibrator
+
+::: src.quantfin.calibration.calibrator.Calibrator

optpricing-2.0.0/docs/reference/calibration/fit_jump_parameters.md

@@ -0,0 +1,3 @@
+# Fit Jump Parameters
+
+::: src.quantfin.calibration.fit_jump_parameters.fit_jump_params_from_history

optpricing-2.0.0/docs/reference/calibration/fit_market_params.md

@@ -0,0 +1,11 @@
+# Fit Market Parameters
+
+This module provides utilities to fit market-implied parameters from option prices.
+
+### Fit Rate and Dividend
+
+::: src.quantfin.calibration.fit_market_params.fit_rate_and_dividend
+
+### Find ATM Options
+
+::: src.quantfin.calibration.fit_market_params.find_atm_options

optpricing-2.0.0/docs/reference/calibration/index.md

@@ -0,0 +1,9 @@
+# Calibration Package
+
+The `calibration` package provides a comprehensive suite of tools for fitting financial models to market data, estimating parameters from historical data, and calculating implied volatility surfaces.
+
+-   **Calibrator**: The main class for orchestrating the optimization process to fit model parameters to market option prices.
+-   **VolatilitySurface**: A class to compute and manage implied volatility surfaces from both market and model-generated prices.
+-   **Parameter Fitters**: Utility functions to estimate specific parameters, such as `fit_rate_and_dividend` from put-call parity or `fit_jump_params_from_history` from historical returns.
+-   **Technique Selector**: A helper function to automatically select the most efficient pricing technique for a given model.
+-   **IV Solvers**: High-performance, vectorized solvers for calculating implied volatility.

optpricing-2.0.0/docs/reference/calibration/iv_surface.md

@@ -0,0 +1,3 @@
+# Volatility Surface
+
+::: src.quantfin.calibration.iv_surface.VolatilitySurface

optpricing-2.0.0/docs/reference/calibration/technique_selector.md

@@ -0,0 +1,3 @@
+# Technique Selector
+
+::: src.quantfin.calibration.technique_selector.select_fastest_technique

optpricing-2.0.0/docs/reference/calibration/vectorized_bsm_iv.md

@@ -0,0 +1,3 @@
+# Vectorized BSM IV Solver
+
+::: src.quantfin.calibration.vectorized_bsm_iv.BSMIVSolver

optpricing-2.0.0/docs/reference/calibration/vectorized_integration_iv.md

@@ -0,0 +1,3 @@
+# Vectorized Integration IV Solver
+
+::: src.quantfin.calibration.vectorized_integration_iv.VectorizedIntegrationIVSolver

optpricing-2.0.0/docs/reference/cli.md

@@ -0,0 +1,7 @@
+# Command-Line Interface (CLI)
+
+The `quantfin` library provides a powerful command-line interface for running common tasks like data downloading, model calibration, and backtesting.
+
+The main entry point is the `quantfin` command. You can see all available commands by running:
+```bash
+quantfin --help

optpricing-2.0.0/docs/reference/dashboard/index.md

@@ -0,0 +1,7 @@
+# Dashboard Package
+
+The `dashboard` package provides all the necessary components to build and run the Streamlit user interface. It is organized into three main parts:
+
+-   **Service**: The core logic and state management for the application.
+-   **Plots**: Functions dedicated to creating visualizations.
+-   **Widgets**: Reusable UI components for displaying specific analyses.