stochvolmodels 1.0.25__tar.gz → 1.0.26__tar.gz

{stochvolmodels-1.0.25 → stochvolmodels-1.0.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: stochvolmodels
-Version: 1.0.25
+Version: 1.0.26
 Summary: Implementation of stochastic volatility models for option pricing
 License: LICENSE.txt
 Keywords: volatility,options,Black-Scholes,Heston,Monte-Carlo
@@ -32,7 +32,6 @@ Requires-Dist: numpy (>=1.22.4)
 Requires-Dist: pandas (>=0.19)
 Requires-Dist: scipy (>=1.3)
 Requires-Dist: seaborn (>=0.11.2)
-Requires-Dist: statsmodels (>=0.13.0)
 Project-URL: Documentation, https://github.com/ArturSepp/StochVolModels
 Project-URL: Issues, https://github.com/ArturSepp/StochVolModels/issues
 Project-URL: Personal website, https://artursepp.com
@@ -75,6 +74,19 @@ Close using
 git clone https://github.com/ArturSepp/StochVolModels.git
 ```
 
+Core dependencies:
+    python = ">=3.8",
+    numba = ">=0.56.4",
+    numpy = ">=1.22.4",
+    scipy = ">=1.10",
+    pandas = ">=2.2.0",
+    matplotlib = ">=3.2.2",
+    seaborn = ">=0.12.2"
+
+Optional dependencies:
+    qis ">=2.1.38" (for running code in my_papers and volatility_book)
+
+
 # Table of contents
 1. [Model Interface](#introduction)
     1. [Log-normal stochastic volatility model](#logsv)

{stochvolmodels-1.0.25 → stochvolmodels-1.0.26}/README.md

@@ -34,6 +34,19 @@ Close using
 git clone https://github.com/ArturSepp/StochVolModels.git
 ```
 
+Core dependencies:
+    python = ">=3.8",
+    numba = ">=0.56.4",
+    numpy = ">=1.22.4",
+    scipy = ">=1.10",
+    pandas = ">=2.2.0",
+    matplotlib = ">=3.2.2",
+    seaborn = ">=0.12.2"
+
+Optional dependencies:
+    qis ">=2.1.38" (for running code in my_papers and volatility_book)
+
+
 # Table of contents
 1. [Model Interface](#introduction)
     1. [Log-normal stochastic volatility model](#logsv)

{stochvolmodels-1.0.25 → stochvolmodels-1.0.26}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "stochvolmodels"
-version = "1.0.25"
+version = "1.0.26"
 description = "Implementation of stochastic volatility models for option pricing"
 license = "LICENSE.txt"
 authors = ["Artur Sepp <artursepp@gmail.com>"]
@@ -37,7 +37,6 @@ python = ">=3.8"
 numba = ">=0.55"
 numpy = ">=1.22.4"
 scipy = ">=1.3"
-statsmodels = ">=0.13.0"
 pandas = ">=0.19"
 matplotlib = ">=3.5.2"
 seaborn = ">=0.11.2"
@@ -45,5 +44,3 @@ seaborn = ">=0.11.2"
 [build-system]
 requires = ["poetry-core>=1.0.0"]
 build-backend = "poetry.core.masonry.api"
-
-

{stochvolmodels-1.0.25 → stochvolmodels-1.0.26}/stochvolmodels/__init__.py

@@ -22,7 +22,8 @@ from stochvolmodels.utils.funcs import (
     to_flat_np_array,
     update_kwargs,
     ncdf,
-    npdf
+    npdf,
+    find_nearest
 )
 
 from stochvolmodels.pricers.analytic.bsm import (
@@ -111,8 +112,7 @@ from stochvolmodels.pricers.logsv.logsv_params import LogSvParams
 
 from stochvolmodels.pricers.gmm_pricer import (
     GmmParams,
-    GmmPricer,
-    plot_gmm_pdfs
+    GmmPricer
 )
 
 from stochvolmodels.pricers.tdist_pricer import (

{stochvolmodels-1.0.25 → stochvolmodels-1.0.26}/stochvolmodels/data/option_chain.py

@@ -8,16 +8,15 @@ data is provided as:
 from __future__ import annotations
 
 import numpy as np
+import pandas as pd
 from dataclasses import dataclass
 from typing import Tuple, Optional
-
-import pandas as pd
 from numba.typed import List
 
 import stochvolmodels.pricers.analytic.bsm as bsm
-from  stochvolmodels.utils.var_swap_pricer import compute_var_swap_strike
-from stochvolmodels.pricers.factor_hjm.rate_core import get_default_swap_term_structure, swap_rate
 import stochvolmodels.pricers.analytic.bachelier as bachel
+from stochvolmodels.utils.var_swap_pricer import compute_var_swap_strike
+from stochvolmodels.pricers.factor_hjm.rate_core import get_default_swap_term_structure, swap_rate
 
 
 @dataclass

{stochvolmodels-1.0.25 → stochvolmodels-1.0.26}/stochvolmodels/examples/run_heston_sv_pricer.py

@@ -1,8 +1,6 @@
 
 import numpy as np
 import matplotlib.pyplot as plt
-from enum import Enum
-
 import stochvolmodels as sv
 from stochvolmodels import HestonPricer, HestonParams, OptionChain, BTC_HESTON_PARAMS
 

{stochvolmodels-1.0.25 → stochvolmodels-1.0.26}/stochvolmodels/examples/run_pricing_options_on_qvar.py

@@ -3,7 +3,6 @@ run valuation for options on quadratic variance
 """
 import numpy as np
 import matplotlib.pyplot as plt
-import qis as qis
 import stochvolmodels.data.test_option_chain as chains
 from numba.typed import List
 from stochvolmodels import (LogSVPricer, LogSvParams, compute_analytic_qvar, OptionChain,
@@ -37,7 +36,7 @@ fig1 = logsv_pricer.plot_model_ivols_vs_mc(option_chain=option_chain,
                                            params=LOGSV_BTC_PARAMS,
                                            variable_type=VariableType.Q_VAR,
                                            nb_path=nb_path)
-qis.set_suptitle(fig1, title='Implied variance skew by Log-Normal SV model')
+fig1.suptitle('Implied variance skew by Log-Normal SV model')
 
 # run Heston prices
 heston_pricer = HestonPricer()
@@ -45,7 +44,7 @@ fig2 = heston_pricer.plot_model_ivols_vs_mc(option_chain=option_chain,
                                             params=BTC_HESTON_PARAMS,
                                             variable_type=VariableType.Q_VAR,
                                             nb_path=nb_path)
-qis.set_suptitle(fig2, title='Implied variance skew by Heston SV model')
+fig2.suptitle('Implied variance skew by Heston SV model')
 
 
 plt.show()

{stochvolmodels-1.0.25 → stochvolmodels-1.0.26}/stochvolmodels/pricers/gmm_pricer.py

@@ -4,16 +4,12 @@ implementation of gaussian mixture pricer and calibration
 import numpy as np
 import matplotlib.pyplot as plt
 from dataclasses import dataclass
-
-import pandas as pd
-import qis as qis
-import seaborn as sns
 from scipy.optimize import minimize
 from numba import njit
 from numba.typed import List
 from typing import Tuple
 from enum import Enum
-
+# project
 import stochvolmodels.pricers.analytic.bsm as bsm
 from stochvolmodels.utils.funcs import to_flat_np_array, timer, npdf
 from stochvolmodels.pricers.model_pricer import ModelParams, ModelPricer
@@ -263,56 +259,6 @@ def gmm_vanilla_chain_pricer(gmm_weights: np.ndarray,
     return model_prices_ttms
 
 
-def plot_gmm_pdfs(params: GmmParams,
-                  option_chain0: OptionChain,
-                  nstdev: float = 10.0,
-                  titles: List[str] = None,
-                  axs: List[plt.Subplot] = None
-                  ) -> plt.Figure:
-    """
-    plot gmm pdf and model fit
-    """
-    stdev = nstdev * params.get_get_avg_vol() * np.sqrt(params.ttm)
-    x = np.linspace(-stdev, stdev, 3000)
-    state_pdfs, agg_pdf = params.compute_state_pdfs(x=x)
-
-    columns = []
-    for idx in range(len(params.gmm_weights)):
-        columns.append(
-            f"state-{idx + 1}: mean={params.gmm_mus[idx]:0.2f}, vol={params.gmm_vols[idx]:0.2f}, weight={params.gmm_weights[idx]:0.2f}")
-
-    state_pdfs = pd.DataFrame(state_pdfs, index=x, columns=columns)
-    agg_pdf = pd.Series(agg_pdf, index=x, name='Aggregate PDF')
-    df = pd.concat([agg_pdf, state_pdfs], axis=1)
-
-    kwargs = dict(fontsize=14, framealpha=0.80)
-
-    if axs is None:
-        with sns.axes_style("darkgrid"):
-            fig, axs = plt.subplots(1, 2, figsize=(16, 4.5))
-    else:
-        fig = None
-
-    qis.plot_line(df=df,
-                  linestyles=['--'] + ['-'] * len(params.gmm_weights),
-                  y_limits=(0.0, None),
-                  xvar_format='{:,.2f}',
-                  xlabel='log-price',
-                  first_color_fixed=True,
-                  ax=axs[0],
-                  **kwargs)
-    axs[0].get_lines()[0].set_linewidth(4.0)
-    axs[0].get_legend().get_lines()[0].set_linewidth(4.0)
-    qis.set_title(ax=axs[0], title='(A) State PDF and Aggregate Risk-Neutral PDF', **kwargs)
-
-    gmm_pricer = GmmPricer()
-    gmm_pricer.plot_model_ivols_vs_bid_ask(option_chain=option_chain0, params=params,
-                                           is_log_strike_xaxis=True,
-                                           axs=[axs[1]],
-                                           **kwargs)
-    return fig
-
-
 class UnitTests(Enum):
     CALIBRATOR = 1
 

{stochvolmodels-1.0.25 → stochvolmodels-1.0.26}/stochvolmodels/pricers/heston_pricer.py

@@ -348,6 +348,7 @@ class UnitTests(Enum):
     MC_COMPARISION = 4
     MC_COMPARISION_QVAR = 5
 
+
 def run_unit_test(unit_test: UnitTests):
 
     import stochvolmodels.data.test_option_chain as chains

{stochvolmodels-1.0.25 → stochvolmodels-1.0.26}/stochvolmodels/pricers/logsv/logsv_params.py

@@ -1,12 +1,13 @@
-from dataclasses import dataclass, asdict
-from typing import Optional, Dict, Any
-
+"""
+implementation of log sv params
+"""
 import numpy as np
 import pandas as pd
 from numpy import linalg as la
-from qis import find_nearest
+from dataclasses import dataclass, asdict
+from typing import Optional, Dict, Any
 
-from stochvolmodels import VariableType
+from stochvolmodels import VariableType, find_nearest
 from stochvolmodels.pricers.model_pricer import ModelParams
 
 

{stochvolmodels-1.0.25 → stochvolmodels-1.0.26}/stochvolmodels/tests/bsm_mgf_pricer.py

@@ -9,7 +9,7 @@ import seaborn as sns
 from typing import Tuple
 from enum import Enum
 
-from stochvolmodels.pricers.analytic import mgf_pricer as mgfp
+import stochvolmodels.utils.mgf_pricer as mgfp
 from stochvolmodels.pricers.analytic.bsm import infer_bsm_ivols_from_model_chain_prices
 from stochvolmodels.utils.config import VariableType
 

{stochvolmodels-1.0.25 → stochvolmodels-1.0.26}/stochvolmodels/utils/funcs.py

@@ -94,3 +94,29 @@ def ncdf(x: Union[float, np.ndarray]) -> Union[float, np.ndarray]:
 @njit(cache=False, fastmath=True)
 def npdf(x: Union[float, np.ndarray], mu: float = 0.0, vol: float = 1.0) -> Union[float, np.ndarray]:
     return np.exp(-0.5*np.square((x-mu)/vol))/(vol*np.sqrt(2.0*np.pi))
+
+
+def find_nearest(a: np.ndarray,
+                 value: float,
+                 is_sorted: bool = True,
+                 is_equal_or_largest: bool = False
+                 ) -> float:
+    """
+    find closes element
+    https://stackoverflow.com/questions/2566412/find-nearest-value-in-numpy-array
+    """
+    if is_sorted:
+        idx = np.searchsorted(a, value, side="left")
+        if is_equal_or_largest:  # return the equal or largest element
+            return a[idx]
+        else:
+            if idx > 0 and (idx == len(a) or np.abs(value - a[idx - 1]) < np.abs(value - a[idx])):
+                return a[idx - 1]
+            else:
+                return a[idx]
+    else:
+        a = np.asarray(a)
+        idx = (np.abs(a - value)).argmin()
+    return a[idx]
+
+

{stochvolmodels-1.0.25 → stochvolmodels-1.0.26}/stochvolmodels/utils/mc_payoffs.py

@@ -4,7 +4,6 @@ Montecarlo analytics for option pay-off computations
 
 import numpy as np
 from numba import njit
-
 from stochvolmodels.utils.config import VariableType
 
 

{stochvolmodels-1.0.25 → stochvolmodels-1.0.26}/stochvolmodels/utils/mgf_pricer.py

@@ -5,7 +5,6 @@ generic analytics for option pricing using Fourier transforms of payoffs
 import numpy as np
 from numba import njit
 from typing import Tuple
-
 from stochvolmodels.utils.config import VariableType
 
 

stochvolmodels-1.0.25/stochvolmodels/data/fetch_option_chain.py

@@ -1,176 +0,0 @@
-"""
-this module is using option-chain-analytics package
-to fetch OptionChain data with options data
-see https://pypi.org/project/option-chain-analytics
-"""
-
-import pandas as pd
-import numpy as np
-import matplotlib.pyplot as plt
-import qis
-from qis import TimePeriod
-from typing import Dict, Tuple, Optional, Literal
-from numba.typed import List
-from enum import Enum
-
-# chain
-from option_chain_analytics import OptionsDataDFs, create_chain_from_from_options_dfs
-from option_chain_analytics.option_chain import SliceColumn, SlicesChain
-
-# analytics
-from stochvolmodels.data.option_chain import OptionChain
-
-
-def generate_vol_chain_np(chain: SlicesChain,
-                          value_time: pd.Timestamp,
-                          days_map: Dict[str, int] = {'1w': 7, '1m': 21},
-                          delta_bounds: Tuple[Optional[float], Optional[float]] = (-0.1, 0.1),
-                          is_filtered: bool = True
-                          ) -> OptionChain:
-    """
-    given SlicesChain generate OptionChain for calibration inputs
-    """
-
-    ttms, future_prices, discfactors = List(), List(), List()
-    optiontypes_ttms, strikes_ttms = List(), List()
-    bid_ivs, ask_ivs = List(), List()
-    bid_prices, ask_prices = List(), List()
-    slice_ids = []
-    for label, day in days_map.items():
-        next_date = value_time + pd.DateOffset(days=day)  # if overlapping next date will be last avilable maturity
-        slice_date = chain.get_next_slice_after_date(mat_date=next_date)
-        slice_t = chain.expiry_slices[slice_date]
-        df = slice_t.get_joint_slice(delta_bounds=delta_bounds, is_filtered=is_filtered)
-        if not df.empty:
-            slice_ids.append(f"{label}: {slice_t.expiry_id}")
-            ttms.append(slice_t.get_ttm())
-            future_prices.append(slice_t.get_future_price())
-            discfactors.append(1.0)
-            strikes_ttms.append(df.index.to_numpy())
-            optiontypes_ttms.append(df[SliceColumn.OPTION_TYPE].to_numpy(dtype=str))
-            bid_ivs.append(df[SliceColumn.BID_IV].to_numpy())
-            ask_ivs.append(df[SliceColumn.ASK_IV].to_numpy())
-            bid_prices.append(df[SliceColumn.BID_PRICE].to_numpy())
-            ask_prices.append(df[SliceColumn.ASK_PRICE].to_numpy())
-
-    out = OptionChain(ttms=np.array(ttms),
-                      forwards=np.array(future_prices),
-                      discfactors=np.array(discfactors),
-                      ids=np.array(slice_ids),
-                      strikes_ttms=strikes_ttms,
-                      optiontypes_ttms=optiontypes_ttms,
-                      bid_ivs=bid_ivs,
-                      ask_ivs=ask_ivs,
-                      bid_prices=bid_prices,
-                      ask_prices=ask_prices)
-    return out
-
-
-def load_option_chain(options_data_dfs: OptionsDataDFs,
-                      value_time: pd.Timestamp = pd.Timestamp('2023-02-06 08:00:00+00:00'),
-                      days_map: Dict[str, int] = {'1w': 7, '1m': 21},
-                      delta_bounds: Tuple[Optional[float], Optional[float]] = (-0.1, 0.1),
-                      is_filtered: bool = True
-                      ) -> Optional[OptionChain]:
-    chain = create_chain_from_from_options_dfs(options_data_dfs=options_data_dfs, value_time=value_time)
-    if chain is not None:
-        option_chain = generate_vol_chain_np(chain=chain,
-                                             value_time=value_time,
-                                             days_map=days_map,
-                                             delta_bounds=delta_bounds,
-                                             is_filtered=is_filtered)
-    else:
-        option_chain = None
-
-    return option_chain
-
-
-def sample_option_chain_at_times(options_data_dfs: OptionsDataDFs,
-                                 time_period: TimePeriod,
-                                 freq: str = 'W-FRI',
-                                 days_map: Dict[str, int] = {'1w': 7, '1m': 21},
-                                 delta_bounds: Tuple[Optional[float], Optional[float]] = (-0.1, 0.1),
-                                 hour_offset: int = 8
-                                 ) -> Dict[pd.Timestamp, OptionChain]:
-    value_times = qis.generate_dates_schedule(time_period=time_period,
-                                              freq=freq,
-                                              hour_offset=hour_offset)
-    option_chains = {}
-    for value_time in value_times:
-        option_chains[value_time] = load_option_chain(options_data_dfs=options_data_dfs,
-                                                      value_time=value_time,
-                                                      days_map=days_map,
-                                                      delta_bounds=delta_bounds,
-                                                      is_filtered=True)
-    return option_chains
-
-
-def load_price_data(options_data_dfs: OptionsDataDFs,
-                    time_period: TimePeriod = None,
-                    data: Literal['spot', 'perp', 'funding_rate'] = 'spot',
-                    freq: Optional[str] = 'D'  # to do
-                    ) -> pd.Series:
-    #options_data_dfs = OptionsDataDFs(**ts_data_loader_wrapper(ticker=ticker, freq='D', hour_offset=8))
-    spot_price = options_data_dfs.get_spot_data()[data]
-    if freq is not None:
-        spot_price = spot_price.resample(freq).last()
-    if time_period is not None:
-        spot_price = time_period.locate(spot_price)
-    return spot_price
-
-
-class UnitTests(Enum):
-    PRINT_CHAIN_DATA = 1
-    GENERATE_VOL_CHAIN_NP = 2
-    SAMPLE_CHAIN_AT_TIMES = 3
-
-
-def run_unit_test(unit_test: UnitTests):
-
-    ticker = 'BTC'  # BTC, ETH
-    value_time = pd.Timestamp('2021-10-21 08:00:00+00:00')
-    value_time = pd.Timestamp('2023-10-06 08:00:00+00:00')
-
-    from option_chain_analytics.ts_loaders import ts_data_loader_wrapper
-    options_data_dfs = OptionsDataDFs(**ts_data_loader_wrapper(ticker=ticker))
-    options_data_dfs.get_start_end_date().print()
-    chain = create_chain_from_from_options_dfs(options_data_dfs=options_data_dfs, value_time=value_time)
-
-    if unit_test == UnitTests.PRINT_CHAIN_DATA:
-        for expiry, eslice in chain.expiry_slices.items():
-            eslice.print()
-
-    elif unit_test == UnitTests.GENERATE_VOL_CHAIN_NP:
-        option_chain = generate_vol_chain_np(chain=chain,
-                                             value_time=value_time,
-                                             days_map={'1w': 7},
-                                             delta_bounds=(-0.1, 0.1),
-                                             is_filtered=True)
-        option_chain.print()
-        skews = option_chain.get_chain_skews(delta=0.35)
-        print(skews)
-
-    elif unit_test == UnitTests.SAMPLE_CHAIN_AT_TIMES:
-        time_period = qis.TimePeriod('01Jan2023', '31Jan2023', tz='UTC')
-        option_chains = sample_option_chain_at_times(options_data_dfs=options_data_dfs,
-                                                     time_period=time_period,
-                                                     freq='W-FRI',
-                                                     hour_offset=9
-                                                     )
-        for key, chain in option_chains.items():
-            print(f"{key}")
-            print(chain)
-
-    plt.show()
-
-
-if __name__ == '__main__':
-
-    unit_test = UnitTests.SAMPLE_CHAIN_AT_TIMES
-
-    is_run_all_tests = False
-    if is_run_all_tests:
-        for unit_test in UnitTests:
-            run_unit_test(unit_test=unit_test)
-    else:
-        run_unit_test(unit_test=unit_test)

stochvolmodels-1.0.25/stochvolmodels/examples/run_gmm_fit.py

@@ -1,41 +0,0 @@
-"""
-example of fitting GMM
-see StochVolModels/examples/run_gmm_fit.py
-"""
-import matplotlib.pyplot as plt
-import seaborn as sns
-import qis as qis
-from stochvolmodels import (get_btc_test_chain_data,
-                            get_spy_test_chain_data,
-                            OptionChain, GmmPricer,
-                            plot_gmm_pdfs)
-
-# get test option chain data
-# option_chain = get_btc_test_chain_data()
-option_chain = get_spy_test_chain_data()
-
-# run GMM fit
-gmm_pricer = GmmPricer()
-fit_params = gmm_pricer.calibrate_model_params_to_chain(option_chain=option_chain, n_mixtures=4)
-
-# illustrate fitted parameters and model fit to market bid-ask
-# plot two ids
-ids = ['2m', '6m']
-n = len(ids)
-with sns.axes_style('darkgrid'):
-    fig, axs = plt.subplots(n, 2, figsize=(14, 12), tight_layout=True)
-    # axs = qis.to_flat_list(axs)
-current_ax = 0
-
-for key, params in fit_params.items():
-    print(f"{key}: {params}")
-    if key in ids:
-        option_chain0 = OptionChain.get_slices_as_chain(option_chain, ids=[key])
-        # gmm_pricer.plot_model_ivols_vs_bid_ask(option_chain=option_chain0, params=params, axs=[axs[idx]])
-        plot_gmm_pdfs(params=params, option_chain0=option_chain0, axs=axs[current_ax, :])
-        qis.set_title(ax=axs[current_ax, 0], title=f"{key}-slice: (A) State PDF and Aggregate Risk-Neutral PDF")
-        qis.set_title(ax=axs[current_ax, 1], title=f"{key}-slice: Model to Market Bid/Ask vols")
-        current_ax += 1
-
-qis.set_suptitle(fig, title='Fit of 4-state GMM to SPY implied vols @ 15_Jul_2022_10_23_09')
-plt.show()