sdevpy 1.0.6__tar.gz → 1.0.7__tar.gz

{sdevpy-1.0.6 → sdevpy-1.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sdevpy
-Version: 1.0.6
+Version: 1.0.7
 Summary: Python package for Finance
 Author-email: Sebastien Gurrieri <sebgur@gmail.com>
 Project-URL: Git page, https://github.com/sebgur/SDev.Python
@@ -11,6 +11,12 @@ Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 Requires-Dist: pandas
 Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Requires-Dist: holidays
+Requires-Dist: pandas_market_calendars
+Requires-Dist: openpyxl
+Requires-Dist: colorlog
 
 # SDev.Python
 

{sdevpy-1.0.6 → sdevpy-1.0.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sdevpy"
-version = "1.0.6"
+version = "1.0.7"
 license-files = []
 authors = [{ name="Sebastien Gurrieri", email="sebgur@gmail.com" }]
 description = "Python package for Finance"
@@ -14,17 +14,25 @@ classifiers = [
     "Programming Language :: Python :: 3",
     "Operating System :: OS Independent",
 ]
-dependencies = ["pandas", "numpy"]
-#dependencies = [
-#	"pandas","pyperclip","numpy","tensorflow",
-#  "scikit-learn", "tensorflow_probability", "silence_tensorflow"
-#]
+dependencies = ["pandas", "numpy", "scipy", "matplotlib", "holidays",
+                "pandas_market_calendars", "openpyxl", "colorlog"
+]
+#dependencies = ["pyperclip", "tensorflow", "scikit-learn",
+# "tensorflow_probability", "silence_tensorflow"]
 
 [tool.setuptools.packages.find]
 where = ["."]
 include = ["sdevpy*", "notebooks*"]  # Only include these
 #exclude = ["notebooks*", "spreadsheets*"]      # Exclude these
 
+[tool.ruff]
+line-length = 120
+target-version = "py313"
+
+[tool.ruff.lint]
+select = ["E", "F", "N", "W", "UP", "B"]
+ignore = ["E401", "I001"]
+
 [project.urls]
 "Git page" = "https://github.com/sebgur/SDev.Python"
 "SDev Finance" = "http://sdev-finance.com/"

sdevpy-1.0.7/sdevpy/__init__.py

@@ -0,0 +1,21 @@
+__version__ = '1.0.5'
+
+import logging
+import colorlog
+
+handler = colorlog.StreamHandler()
+handler.setFormatter(colorlog.ColoredFormatter(
+    "%(log_color)s%(levelname)-8s%(reset)s %(name)s - %(message)s",
+    log_colors={
+        "DEBUG":    "cyan",
+        "INFO":     "green",
+        "WARNING":  "yellow",
+        "ERROR":    "red",
+        "CRITICAL": "bold_red",
+    }
+))
+
+root = logging.getLogger()
+root.addHandler(handler)
+root.setLevel(logging.WARNING)
+logging.getLogger("sdevpy").setLevel(logging.DEBUG)

{sdevpy-1.0.6 → sdevpy-1.0.7}/sdevpy/analytics/americantree.py

@@ -4,6 +4,7 @@ import time
 import matplotlib.pyplot as plt
 from sdevpy.analytics import black
 from sdevpy.tree import trees
+from sdevpy.tree.trees import Payoff
 
 
 def option_price(ttm, strike, is_call, is_american, spot, vol, rf_rate, div_rate, disc_rate,
@@ -93,11 +94,10 @@ if __name__ == "__main__":
     if not payoff.is_american:
         plt.plot(cf_t, cf_p, label='Vanilla CF Price')
     # # plt.plot(steps_range, trinomial_prices, label='Trinomial Tree Price')
-    # plt.hlines(bs_price, steps_range[0], steps_range[-1], colors='r', linestyles='dashed', label='Black-Scholes Price')
+    # plt.hlines(bs_price, steps_range[0], steps_range[-1], colors='r', linestyles='dashed',
+    #            label='Black-Scholes Price')
     plt.title('Convergence to Black-Scholes Price for Call Options')
     plt.xlabel('Runtime')
     plt.ylabel('Option Price')
     plt.legend()
     plt.show()
-
-

{sdevpy-1.0.6 → sdevpy-1.0.7}/sdevpy/analytics/bachelier.py

@@ -13,6 +13,7 @@ def price(expiry, strike, is_call, fwd, vol):
 
 
 def price_straddles(expiries, strikes, fwd, vols):
+    """ Straddle price under the Bachelier model """
     expiries_ = np.asarray(expiries).reshape(-1, 1)
     prices = []
     for i, expiry in enumerate(expiries_):

{sdevpy-1.0.6 → sdevpy-1.0.7}/sdevpy/analytics/black.py

@@ -1,14 +1,14 @@
 """ Utilities for Black-Scholes model """
 import numpy as np
+# import numpy.typing as npt
 import scipy.stats
 from scipy.optimize import minimize_scalar
 from sdevpy.thirdparty.py_vollib.black import implied_volatility as jaeckel
-from sdevpy import settings
 
 N = scipy.stats.norm.cdf
 
 
-def price(expiry, strike, is_call, fwd, vol):
+def price(expiry: float, strike: float, is_call: bool, fwd: float, vol: float) -> float:
     """ Option price under the Black-Scholes model """
     w = 1.0 if is_call else -1.0
     s = vol * np.sqrt(expiry)
@@ -17,7 +17,7 @@ def price(expiry, strike, is_call, fwd, vol):
     return w * (fwd * N(w * d1) - strike * N(w * d2))
 
 
-def implied_vol_jaeckel(expiry, strike, is_call, fwd, fwd_price):
+def implied_vol_jaeckel(expiry: float, strike: float, is_call: bool, fwd: float, fwd_price: float) -> float:
     """ Black-Scholes implied volatility using P. Jaeckel's 'Let's be rational' method,
         from package py_vollib. Install with pip install py_vollib or at
         https://pypi.org/project/py_vollib/. Unfortunately we found it has instabilities
@@ -28,7 +28,7 @@ def implied_vol_jaeckel(expiry, strike, is_call, fwd, fwd_price):
     return iv
 
 
-def implied_vol(expiry, strike, is_call, fwd, fwd_price):
+def implied_vol(expiry: float, strike: float, is_call: bool, fwd: float, fwd_price: float) -> float:
     """ Direct method by numerical inversion using Brent """
     options = {'xtol': 1e-4, 'maxiter': 100, 'disp': False}
     xmin = 1e-6

{sdevpy-1.0.6 → sdevpy-1.0.7}/sdevpy/analytics/fbsabr.py

@@ -1,14 +1,14 @@
 """ Monte-Carlo simulation for Free-Boundary SABR model (vanillas) """
 import numpy as np
+import numpy.typing as npt
 import matplotlib.pyplot as plt
 import scipy.stats as sp
-# from analytics.sabr import calculate_alpha
 from sdevpy.tools.timegrids import SimpleTimeGridBuilder
 from sdevpy.tools import timer
 
 
-def price(expiries, strikes, are_calls, fwd, parameters, num_mc=10000, points_per_year=10,
-          scheme='Andersen'):
+def price(expiries: npt.ArrayLike, strikes: npt.ArrayLike, are_calls: npt.ArrayLike, fwd: float,
+          parameters: list[float], num_mc: int=10000, points_per_year: int=10, scheme: str='Andersen'):
     """ Calculate vanilla prices under Free-Boundary SABR model by Monte-Carlo simulation"""
     floor = 0.00001
 
@@ -16,98 +16,96 @@ def price(expiries, strikes, are_calls, fwd, parameters, num_mc=10000, points_pe
     # the spot becomes so close to 0 that Python effectively handles it as 0. This results in
     # a warning when taking a negative power of it. However, this is not an issue as Python
     # correctly finds +infinity and since we use a floor, this case is correctly handled.
-    np.seterr(divide='ignore')
-
-    # Build time grid
-    time_grid_builder = SimpleTimeGridBuilder(points_per_year=points_per_year)
-    time_grid_builder.add_grid(expiries)
-    time_grid = time_grid_builder.complete_grid()
-    num_factors = 2
-
-    # Find payoff times
-    is_payoff = np.in1d(time_grid, expiries)
-
-    # Retrieve parameters
-    lnvol = parameters['LnVol']
-    beta = parameters['Beta']
-    nu = parameters['Nu']
-    rho = parameters['Rho']
-    alpha = calculate_fbsabr_alpha(lnvol, fwd, beta)
-    nu2 = nu**2
-    sqrtmrho2 = np.sqrt(1.0 - rho**2)
-
-    # Draw all gaussians
-    # gaussians = rand.gaussians(num_steps, num_mc, num_factors, rand_method)
-
-    # Define dimensions
-    mean = np.zeros(num_factors)
-    corr = np.zeros((num_factors, num_factors))
-    for c in range(num_factors):
-        corr[c, c] = 1.0
-
-    # Draw for each step
-    seed = 42
-    rng = np.random.RandomState(seed)
-
-    # Initialize paths
-    spot = np.ones((2 * num_mc, 1)) * fwd
-    vol = np.ones((2 * num_mc, 1)) * 1.0
-
-    # Loop over time grid
-    ts = te = 0
-    payoff_count = 0
-    mc_prices = []
-    for i, t in enumerate(time_grid):
-        # print("time iteration " + str(i))
-        ts = te
-        te = t
-        dt = te - ts
-        sqrt_dt = np.sqrt(dt)
-
-        # Evolve
-        dz = rng.multivariate_normal(mean, corr, size=num_mc) * sqrt_dt
-        dz = np.concatenate((dz, -dz), axis=0) # Antithetic paths
-        dz0 = dz[:, 0].reshape(-1, 1)
-        dz1 = dz[:, 1].reshape(-1, 1)
-
-        vols = vol
-        abs_f = np.maximum(np.abs(spot), floor)
-
-        # Evolve vol
-        vol *= np.exp(-0.5 * nu2 * dt + nu * dz1)
-
-        # Evolve spot
-        if scheme == 'Euler':
-            dw = rho * dz1 + sqrtmrho2 * dz0
-            spot = spot + alpha * abs_f**beta * dw * vols
-        elif scheme == 'Andersen':
-            vole = vol
-            spot = spot + alpha * abs_f**beta * (sqrtmrho2 * vols * dz0 + rho / nu * (vole - vols))
-        else:
-            raise ValueError("Unknown scheme in FBSABR: " + scheme)
-
-        # Calculate payoff
-        if is_payoff[i]:
-            w = [1.0 if is_call else -1.0 for is_call in are_calls[payoff_count]]
-            w = np.asarray(w).reshape(1, -1)
-            k = np.asarray(strikes[payoff_count]).reshape(1, -1)
-            payoff = np.maximum(w * (spot - k), 0.0)
-            rpayoff = np.mean(payoff, axis=0)
-            mc_prices.append(rpayoff)
-            payoff_count += 1
-
-    np.seterr(divide='warn')
+    with np.errstate(divide='ignore'):
+        # Build time grid
+        time_grid_builder = SimpleTimeGridBuilder(points_per_year=points_per_year)
+        time_grid_builder.add_grid(expiries)
+        time_grid = time_grid_builder.complete_grid()
+        num_factors = 2
+
+        # Find payoff times
+        is_payoff = np.in1d(time_grid, expiries)
+
+        # Retrieve parameters
+        lnvol = parameters['LnVol']
+        beta = parameters['Beta']
+        nu = parameters['Nu']
+        rho = parameters['Rho']
+        alpha = calculate_fbsabr_alpha(lnvol, fwd, beta)
+        nu2 = nu**2
+        sqrtmrho2 = np.sqrt(1.0 - rho**2)
+
+        # Draw all gaussians
+        # gaussians = rand.gaussians(num_steps, num_mc, num_factors, rand_method)
+
+        # Define dimensions
+        mean = np.zeros(num_factors)
+        corr = np.zeros((num_factors, num_factors))
+        for c in range(num_factors):
+            corr[c, c] = 1.0
+
+        # Draw for each step
+        seed = 42
+        rng = np.random.RandomState(seed)
+
+        # Initialize paths
+        spot = np.ones((2 * num_mc, 1)) * fwd
+        vol = np.ones((2 * num_mc, 1)) * 1.0
+
+        # Loop over time grid
+        ts = te = 0
+        payoff_count = 0
+        mc_prices = []
+        for i, t in enumerate(time_grid):
+            # print("time iteration " + str(i))
+            ts = te
+            te = t
+            dt = te - ts
+            sqrt_dt = np.sqrt(dt)
+
+            # Evolve
+            dz = rng.multivariate_normal(mean, corr, size=num_mc) * sqrt_dt
+            dz = np.concatenate((dz, -dz), axis=0) # Antithetic paths
+            dz0 = dz[:, 0].reshape(-1, 1)
+            dz1 = dz[:, 1].reshape(-1, 1)
+
+            vols = vol
+            abs_f = np.maximum(np.abs(spot), floor)
+
+            # Evolve vol
+            vol *= np.exp(-0.5 * nu2 * dt + nu * dz1)
+
+            # Evolve spot
+            if scheme == 'Euler':
+                dw = rho * dz1 + sqrtmrho2 * dz0
+                spot = spot + alpha * abs_f**beta * dw * vols
+            elif scheme == 'Andersen':
+                vole = vol
+                spot = spot + alpha * abs_f**beta * (sqrtmrho2 * vols * dz0 + rho / nu * (vole - vols))
+            else:
+                raise ValueError("Unknown scheme in FBSABR: " + scheme)
+
+            # Calculate payoff
+            if is_payoff[i]:
+                w = [1.0 if is_call else -1.0 for is_call in are_calls[payoff_count]]
+                w = np.asarray(w).reshape(1, -1)
+                k = np.asarray(strikes[payoff_count]).reshape(1, -1)
+                payoff = np.maximum(w * (spot - k), 0.0)
+                rpayoff = np.mean(payoff, axis=0)
+                mc_prices.append(rpayoff)
+                payoff_count += 1
 
     return np.asarray(mc_prices)
 
 
-def calculate_fbsabr_alpha(ln_vol, fwd, beta):
+def calculate_fbsabr_alpha(ln_vol: float, fwd: float, beta: float) -> float:
     """ Calculate parameter alpha with our definition in terms of ln_vol, i.e.
         alpha = ln_vol * fwd ^ (1.0 - beta) """
     floor = 0.00001
     abs_f = np.maximum(np.abs(fwd), floor)
     return ln_vol * abs_f ** (1.0 - beta)
 
+
 if __name__ == "__main__":
     EXPIRIES = [3.0, 8.0, 13, 19, 22, 31, 34]
     NSTRIKES = 50
@@ -151,12 +149,12 @@ if __name__ == "__main__":
     # print(MC_PRICES)
 
     # Convert to IV and compare against approximate closed-form
-    # import black
-    import bachelier
+    # import sdevpy.analytics.black as black
+    import sdevpy.analytics.bachelier as bachelier
     mc_ivs = []
     for a, expiry in enumerate(EXPIRIES):
         mc_iv = []
-        for j, sstrike in enumerate(SSTRIKES[a]):
+        for j, _ in enumerate(SSTRIKES[a]):
             # mc_iv.append(black.implied_vol(expiry, sstrike, IS_CALL, SFWD, MC_PRICES[a, j]))
             mc_iv.append(bachelier.implied_vol(expiry, STRIKES[a, j], IS_CALL, FWD,
                                                MC_PRICES[a, j]))

{sdevpy-1.0.6 → sdevpy-1.0.7}/sdevpy/analytics/mcheston.py

@@ -5,7 +5,6 @@
 import numpy as np
 import matplotlib.pyplot as plt
 import scipy.stats as sp
-# from analytics.sabr import calculate_alpha
 from sdevpy.tools.timegrids import SimpleTimeGridBuilder
 from sdevpy.tools import timer
 
@@ -20,83 +19,80 @@ def price(expiries, strikes, are_calls, fwd, parameters, num_mc=10000, points_pe
     # the spot becomes so close to 0 that Python effectively handles it as 0. This results in
     # a warning when taking a negative power of it. However, this is not an issue as Python
     # correctly finds +infinity and since we use a floor, this case is correctly handled.
-    np.seterr(divide='ignore')
-
-    # Build time grid
-    time_grid_builder = SimpleTimeGridBuilder(points_per_year=points_per_year)
-    time_grid_builder.add_grid(expiries)
-    time_grid = time_grid_builder.complete_grid()
-    num_factors = 2
-
-    # Find payoff times
-    is_payoff = np.in1d(time_grid, expiries)
-
-    # Retrieve parameters
-    lnvol = parameters['LnVol']
-    kappa = parameters['Kappa']
-    theta = parameters['Theta']
-    xi = parameters['Xi']
-    rho = parameters['Rho']
-    sqrtmrho2 = np.sqrt(1.0 - rho**2)
-    v0 = calculate_v0(lnvol)
-
-    # Draw all gaussians
-    # gaussians = rand.gaussians(num_steps, num_mc, num_factors, rand_method)
-
-    # Define dimensions
-    mean = np.zeros(num_factors)
-    corr = np.zeros((num_factors, num_factors))
-    for c in range(num_factors):
-        corr[c, c] = 1.0
-
-    # Draw for each step
-    seed = 42
-    rng = np.random.RandomState(seed)
-
-    # Initialize paths
-    spot = np.ones((2 * num_mc, 1)) * fwd
-    vol2 = np.ones((2 * num_mc, 1)) * v0
-
-    # Loop over time grid
-    ts = te = 0
-    payoff_count = 0
-    mc_prices = []
-    for i, t in enumerate(time_grid):
-        ts = te
-        te = t
-        dt = te - ts
-        sqrt_dt = np.sqrt(dt)
-
-        # Evolve
-        dz = rng.multivariate_normal(mean, corr, size=num_mc) * sqrt_dt
-        dz = np.concatenate((dz, -dz), axis=0) # Antithetic paths
-        dz0 = dz[:, 0].reshape(-1, 1)
-        dz1 = dz[:, 1].reshape(-1, 1)
-
-        # Evolve vol
-        vol2s = np.abs(vol2)
-        sqrt_vol2s = np.sqrt(vol2s)
-        vol2e = vol2s + kappa * (theta - vol2s) * dt + xi * sqrt_vol2s * dz1
-        vol2e = np.abs(vol2e)
-        vol2 = vol2e
-
-        # Evolve spot
-        intvol2 = 0.5 * (vol2s + vol2e) * dt
-        ito = 0.5 * intvol2
-        dw = rho * dz1 + sqrtmrho2 * dz0
-        spot *= np.exp(-ito + sqrt_vol2s * dw)
-
-        # Calculate payoff
-        if is_payoff[i]:
-            w = [1.0 if is_call else -1.0 for is_call in are_calls[payoff_count]]
-            w = np.asarray(w).reshape(1, -1)
-            k = np.asarray(strikes[payoff_count]).reshape(1, -1)
-            payoff = np.maximum(w * (spot - k), 0.0)
-            rpayoff = np.mean(payoff, axis=0)
-            mc_prices.append(rpayoff)
-            payoff_count += 1
-
-    np.seterr(divide='warn')
+    with np.errstate(divide='ignore'):
+        # Build time grid
+        time_grid_builder = SimpleTimeGridBuilder(points_per_year=points_per_year)
+        time_grid_builder.add_grid(expiries)
+        time_grid = time_grid_builder.complete_grid()
+        num_factors = 2
+
+        # Find payoff times
+        is_payoff = np.in1d(time_grid, expiries)
+
+        # Retrieve parameters
+        lnvol = parameters['LnVol']
+        kappa = parameters['Kappa']
+        theta = parameters['Theta']
+        xi = parameters['Xi']
+        rho = parameters['Rho']
+        sqrtmrho2 = np.sqrt(1.0 - rho**2)
+        v0 = calculate_v0(lnvol)
+
+        # Draw all gaussians
+        # gaussians = rand.gaussians(num_steps, num_mc, num_factors, rand_method)
+
+        # Define dimensions
+        mean = np.zeros(num_factors)
+        corr = np.zeros((num_factors, num_factors))
+        for c in range(num_factors):
+            corr[c, c] = 1.0
+
+        # Draw for each step
+        seed = 42
+        rng = np.random.RandomState(seed)
+
+        # Initialize paths
+        spot = np.ones((2 * num_mc, 1)) * fwd
+        vol2 = np.ones((2 * num_mc, 1)) * v0
+
+        # Loop over time grid
+        ts = te = 0
+        payoff_count = 0
+        mc_prices = []
+        for i, t in enumerate(time_grid):
+            ts = te
+            te = t
+            dt = te - ts
+            sqrt_dt = np.sqrt(dt)
+
+            # Evolve
+            dz = rng.multivariate_normal(mean, corr, size=num_mc) * sqrt_dt
+            dz = np.concatenate((dz, -dz), axis=0) # Antithetic paths
+            dz0 = dz[:, 0].reshape(-1, 1)
+            dz1 = dz[:, 1].reshape(-1, 1)
+
+            # Evolve vol
+            vol2s = np.abs(vol2)
+            sqrt_vol2s = np.sqrt(vol2s)
+            vol2e = vol2s + kappa * (theta - vol2s) * dt + xi * sqrt_vol2s * dz1
+            vol2e = np.abs(vol2e)
+            vol2 = vol2e
+
+            # Evolve spot
+            intvol2 = 0.5 * (vol2s + vol2e) * dt
+            ito = 0.5 * intvol2
+            dw = rho * dz1 + sqrtmrho2 * dz0
+            spot *= np.exp(-ito + sqrt_vol2s * dw)
+
+            # Calculate payoff
+            if is_payoff[i]:
+                w = [1.0 if is_call else -1.0 for is_call in are_calls[payoff_count]]
+                w = np.asarray(w).reshape(1, -1)
+                k = np.asarray(strikes[payoff_count]).reshape(1, -1)
+                payoff = np.maximum(w * (spot - k), 0.0)
+                rpayoff = np.mean(payoff, axis=0)
+                mc_prices.append(rpayoff)
+                payoff_count += 1
 
     return np.asarray(mc_prices)
 
@@ -147,8 +143,8 @@ if __name__ == "__main__":
     mc_timer.print()
 
     # Convert to IV and compare against approximate closed-form
-    import black
-    import bachelier
+    import sdevpy.analytics.black as black
+    import sdevpy.analytics.bachelier as bachelier
     mc_ivs = []
     n_ivs = []
     for a, expiry in enumerate(EXPIRIES):