sdevpy 1.0.9__tar.gz → 1.1__tar.gz

sdevpy-1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2023] [Sebastien Gurrieri]
+
+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.

{sdevpy-1.0.9 → sdevpy-1.1}/PKG-INFO

@@ -1,14 +1,36 @@
 Metadata-Version: 2.4
 Name: sdevpy
-Version: 1.0.9
+Version: 1.1
 Summary: Python package for Finance
 Author-email: Sebastien Gurrieri <sebgur@gmail.com>
-Project-URL: Git page, https://github.com/sebgur/SDev.Python
+License: MIT License
+        
+        Copyright (c) [2023] [Sebastien Gurrieri]
+        
+        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: Git, https://github.com/sebgur/SDev.Python
 Project-URL: SDev Finance, http://sdev-finance.com/
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: pandas
 Requires-Dist: numpy
 Requires-Dist: scipy
@@ -18,6 +40,7 @@ Requires-Dist: pandas_market_calendars
 Requires-Dist: openpyxl
 Requires-Dist: colorlog
 Requires-Dist: scikit-learn
+Dynamic: license-file
 
 # SDev.Python
 

{sdevpy-1.0.9 → sdevpy-1.1}/pyproject.toml

@@ -4,8 +4,9 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sdevpy"
-version = "1.0.9"
-license-files = []
+version = "1.1"
+license = {file = "LICENSE"}
+#license-files = []
 authors = [{ name="Sebastien Gurrieri", email="sebgur@gmail.com" }]
 description = "Python package for Finance"
 readme = "README.md"
@@ -21,6 +22,10 @@ dependencies = ["pandas", "numpy", "scipy", "matplotlib", "holidays",
 #dependencies = ["pyperclip", "tensorflow", "scikit-learn",
 # "tensorflow_probability", "silence_tensorflow"]
 
+[project.urls]
+"Git" = "https://github.com/sebgur/SDev.Python"
+"SDev Finance" = "http://sdev-finance.com/"
+
 [tool.setuptools.packages.find]
 where = ["."]
 include = ["sdevpy*"] # Only include these
@@ -41,14 +46,18 @@ ignore = ["E401", "I001"]
 [tool.coverage.run]
 omit = [
     "sdevpy/**/__init__.py",
-    "sdevpy/projects/raschka/*"
+    "sdevpy/tests/test.py",
+    "sdevpy/logger.py",
+    "sdevpy/settings.py",
+    "sdevpy/utilities/constants.py",
+    "sdevpy/utilities/pydotnet.py",
+    "sdevpy/tensorflow/*",
+    "sdevpy/machinelearning/*",
+    "sdevpy/volatility/mlsurfacegen/*"
 ]
 
 [tool.coverage.report]
 exclude_lines = [
-    "if __name__ == '__main__':",
+    "if __name__ == .__main__.:",
+    "pragma: no cov"
 ]
-
-[project.urls]
-"Git page" = "https://github.com/sebgur/SDev.Python"
-"SDev Finance" = "http://sdev-finance.com/"

sdevpy-1.1/sdevpy/__init__.py

@@ -0,0 +1,26 @@
+__version__ = '1.0.5'
+
+import logging
+
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+
+
+
+# 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.9 → sdevpy-1.1}/sdevpy/analytics/bachelier.py

@@ -8,10 +8,9 @@ from scipy.optimize import minimize_scalar
 def price(expiry: npt.ArrayLike, strike: npt.ArrayLike, is_call: npt.ArrayLike, fwd: npt.ArrayLike,
           vol: npt.ArrayLike) -> npt.NDArray[np.float64]:
     """ Option price under the Bachelier model """
-    stdev = vol * expiry**0.5
+    stdev = vol * np.sqrt(expiry)
     d = (fwd - strike) / stdev
     wd = np.where(is_call, d, -d)
-    # wd = d if is_call else -d
     return stdev * (wd * norm.cdf(wd) + norm.pdf(d))
 
 
@@ -70,8 +69,6 @@ def implied_vol(expiry: npt.ArrayLike, strike: npt.ArrayLike, is_call: npt.Array
     strike = np.asarray(strike, dtype=float)
     fwd_price = np.asarray(fwd_price, dtype=float)
     is_call = np.asarray(is_call, dtype=bool)
-    # expiry = float(expiry)
-    # fwd = float(fwd)
 
     #### ATM branch ####
     m = fwd - strike

{sdevpy-1.0.9 → sdevpy-1.1}/sdevpy/analytics/black.py

@@ -9,7 +9,6 @@ from sdevpy.utilities.tools import isiterable
 def price(expiry: npt.ArrayLike, strike: npt.ArrayLike, is_call: npt.ArrayLike, fwd: npt.ArrayLike,
           vol: npt.ArrayLike) -> npt.NDArray[np.float64]:
     """ Option price under the Black-Scholes model """
-    # w = 1.0 if is_call else -1.0
     w = np.where(is_call, 1.0, -1.0)
     s = vol * np.sqrt(expiry)
     d1 = np.log(fwd / strike) / s + 0.5 * s
@@ -17,12 +16,25 @@ def price(expiry: npt.ArrayLike, strike: npt.ArrayLike, is_call: npt.ArrayLike,
     return w * (fwd * norm.cdf(w * d1) - strike * norm.cdf(w * d2))
 
 
+def price_straddles(expiry: npt.ArrayLike, strike: npt.ArrayLike, fwd: npt.ArrayLike,
+                    vol: npt.ArrayLike) -> npt.NDArray[np.float64]:
+    """ Straddle price under the Black model """
+    call = price(expiry, strike, True, fwd, vol)
+    put = price(expiry, strike, False, fwd, vol)
+    return call + put
+
+
 def implied_vol(expiry: float, strike: float, is_call: bool, fwd: float, fwd_price: float) -> float:
     """ Direct method by numerical inversion using Brent.
         Non-vectorized due to solver. """
-    options = {'xtol': 1e-4, 'maxiter': 100, 'disp': False}
+    # Trial config
+    options = {'xtol': 1e-6, 'maxiter': 100, 'disp': False}
     xmin = 1e-6
-    xmax = 1.0
+    xmax = 2.0
+    # # Original config
+    # options = {'xtol': 1e-4, 'maxiter': 100, 'disp': False}
+    # xmin = 1e-6
+    # xmax = 1.0
 
     def error(vol):
         premium = price(expiry, strike, is_call, fwd, vol)

sdevpy-1.1/sdevpy/instruments/constants.py

@@ -0,0 +1,20 @@
+from enum import Enum
+
+
+class OptionType(Enum):
+    CALL = 0
+    PUT = 1
+    STRADDLE = 2
+
+
+def string_to_optiontype(s: str) -> OptionType:
+    """ Convert string to OptionType """
+    match s.lower():
+        case 'call':
+            return OptionType.CALL
+        case 'put':
+            return OptionType.PUT
+        case 'straddle':
+            return OptionType.STRADDLE
+        case _:
+            raise ValueError(f"Invalid option type: {s}")

sdevpy-1.1/sdevpy/logger.py

@@ -0,0 +1,42 @@
+import logging, colorlog
+
+
+LOG_COLORS = {"DEBUG": "cyan", "INFO": "green", "WARNING": "yellow", "ERROR": "red",
+              "CRITICAL": "bold_red"}
+
+
+def string_to_logging_level(level_str: str):
+    level_str = level_str.lower()
+    match level_str:
+        case 'debug':
+            return logging.DEBUG
+        case 'info':
+            return logging.INFO
+        case 'warning':
+            return logging.WARNING
+        case 'error':
+            return logging.ERROR
+        case 'critical':
+            return logging.CRITICAL
+        case _:
+            raise ValueError(f"Unsupported logging level: {level_str}")
+
+
+def configure(root_level: str='warning', sdevpy_level: str='debug',
+              module_display: str='none') -> None:
+    """ Configure logger. Levels can be: debug, info, warning, error and critical. """
+    handler = colorlog.StreamHandler()
+
+    match module_display.lower():
+        case 'none':
+            module_str = "%(log_color)s%(levelname)-1s%(reset)s | %(message)s"
+        case 'partial':
+            module_str = "%(log_color)s%(levelname)-1s%(reset)s | %(module)s | %(message)s"
+        case 'full':
+            module_str = "%(log_color)s%(levelname)-1s%(reset)s | %(name)s | %(message)s"
+        case _:
+            raise ValueError(f"Unsupported module display mode: {module_display}")
+
+    handler.setFormatter(colorlog.ColoredFormatter(module_str, log_colors=LOG_COLORS))
+    logging.basicConfig(level=string_to_logging_level(root_level), handlers=[handler], force=True)
+    logging.getLogger("sdevpy").setLevel(string_to_logging_level(sdevpy_level))

{sdevpy-1.0.9 → sdevpy-1.1}/sdevpy/machinelearning/keras/learningschedules.py

@@ -1,7 +1,7 @@
 """ Custom learning schedules """
 import numpy as np
 import tensorflow as tf
-from sdevpy.utilities.constants import TWO_PI
+from sdevpy.maths.constants import TWO_PI
 
 
 # Custom learning rate scheduler, exponentially decreases between given values

{sdevpy-1.0.9 → sdevpy-1.1}/sdevpy/market/correlations.py

@@ -57,13 +57,15 @@ def add_correlations(date: dt.datetime, names1: list[str], names2: list[str], va
             f.write(f"{name1}-{name2},{value}\n")
 
 
-def data_file(date: dt.datetime, **kwargs):
+def data_file(date: dt.datetime, **kwargs) -> str:
+    """ Data file for correlations """
     folder = kwargs.get('folder', test_data_folder())
     file = Path(folder) / (date.strftime(dts.DATE_FILE_FORMAT) + ".csv")
     return file
 
 
-def test_data_folder():
+def test_data_folder() -> str:
+    """ Test data folder for correlations """
     folder = Path(__file__).parent.parent.parent / "datasets" / "marketdata" / "correlations"
     folder.mkdir(parents=True, exist_ok=True)
     return folder

{sdevpy-1.0.9 → sdevpy-1.1}/sdevpy/market/eqforward.py

@@ -2,7 +2,8 @@ import os, json
 import datetime as dt
 import numpy as np
 from pathlib import Path
-from sdevpy.utilities import dates, timegrids
+from sdevpy.utilities import dates as dts
+from sdevpy.utilities import timegrids
 from sdevpy.maths import interpolation as itp
 from sdevpy.market import yieldcurve as ycrv
 from sdevpy.market.spot import get_spots
@@ -16,17 +17,9 @@ def get_forward_curves(names, valdate, **kwargs):
         file = data_file(name, valdate, **kwargs)
         data = eqforwarddata_from_file(file)
         curve = EqForwardCurve(valdate=valdate, interp_var='forward', interp_type='cubicspline')
-        # yieldcurve = ycrv.get_yieldcurve('USD.SOFR.1D', valdate)
-        curve.calibrate(data, spot)#, yieldcurve)
+        curve.calibrate(data, spot)
         fwd_curves.append(curve)
 
-    # drifts = np.asarray([0.02, 0.05, 0.04])
-    # fwd_curves_old = []
-    # for s, mu in zip(spots, drifts):
-    #     # Use the default variable trick to circumvent late binding in python loops
-    #     # Otherwise, all the lambda functions will effectively be the same
-    #     fwd_curves_old.append(lambda t, s=s, mu=mu: s * np.exp(mu * t))
-
     return fwd_curves
 
 
@@ -51,12 +44,12 @@ class EqForwardData:
     def dump_data(self):
         pillars = []
         for expiry, forward in zip(self.expiries, self.forwards, strict=True):
-            expiry_str = expiry.strftime(dates.DATE_FORMAT)
+            expiry_str = expiry.strftime(dts.DATE_FORMAT)
             pillar = {'expiry': expiry_str, 'forward': forward}
             pillars.append(pillar)
 
-        data = {'name': self.name, 'valdate': self.valdate.strftime(dates.DATE_FORMAT),
-                'snapdate': self.snapdate.strftime(dates.DATETIME_FORMAT), 'pillars': pillars}
+        data = {'name': self.name, 'valdate': self.valdate.strftime(dts.DATE_FORMAT),
+                'snapdate': self.snapdate.strftime(dts.DATETIME_FORMAT), 'pillars': pillars}
         return data
 
 
@@ -80,7 +73,7 @@ class EqForwardCurve:
         # Check consistency
         for d in self.dates:
             if d <= self.valdate:
-                raise RuntimeError(f"Expiry before or at valuation date: {d.strftime(dates.DATE_FORMAT)}")
+                raise RuntimeError(f"Expiry before or at valuation date: {d.strftime(dts.DATE_FORMAT)}")
 
         # Calibrate
         if self.interp_var == 'yield':
@@ -133,11 +126,11 @@ def eqforwarddata_from_file(file):
     # Convert date strings into dates
     for pillar in pillars:
         date_str = pillar.get('expiry')
-        date = dt.datetime.strptime(date_str, dates.DATE_FORMAT)
+        date = dt.datetime.strptime(date_str, dts.DATE_FORMAT)
         pillar['expiry'] = date
 
-    data = EqForwardData(dt.datetime.strptime(valdate, dates.DATE_FORMAT), pillars,
-                         name=name, snapdate=dt.datetime.strptime(snapdate, dates.DATETIME_FORMAT))
+    data = EqForwardData(dt.datetime.strptime(valdate, dts.DATE_FORMAT), pillars,
+                         name=name, snapdate=dt.datetime.strptime(snapdate, dts.DATETIME_FORMAT))
     return data
 
 
@@ -145,7 +138,7 @@ def data_file(name, date, **kwargs):
     folder = kwargs.get('folder', test_data_folder())
     name_folder = os.path.join(folder, name)
     os.makedirs(name_folder, exist_ok=True)
-    file = os.path.join(name_folder, date.strftime(dates.DATE_FILE_FORMAT) + ".json")
+    file = os.path.join(name_folder, date.strftime(dts.DATE_FILE_FORMAT) + ".json")
     return file
 
 
@@ -161,7 +154,7 @@ if __name__ == "__main__":
     import matplotlib.pyplot as plt
 
     name = "ABC"
-    valdate = dt.datetime(2026, 2, 15)
+    valdate = dt.datetime(2025, 12, 15)
 
     # Generate a sample to start from
     spot = 100.0
@@ -174,7 +167,7 @@ if __name__ == "__main__":
     pillars = [{'expiry': d, 'forward': f} for d, f in zip(expiries, zfwds, strict=True)]
     data = EqForwardData(valdate, pillars, name=name)
     file = data_file(name, valdate)
-    data.dump(file)
+    # data.dump(file)
 
     # Get data from existing file
     test_data = eqforwarddata_from_file(file)
@@ -185,7 +178,7 @@ if __name__ == "__main__":
     curve.calibrate(test_data, spot, yieldcurve)
 
     # Interpolate and display
-    test_dates = [dates.advance(valdate, months=1*n) for n in range(1, 150)]
+    test_dates = [dts.advance(valdate, str(n) + 'm') for n in range(1, 150)]
     test_fwds = curve.value(test_dates)
 
     # Original data

{sdevpy-1.0.9 → sdevpy-1.1}/sdevpy/market/eqvolsurface.py

@@ -1,11 +1,13 @@
 import os, json, logging
 import datetime as dt
 import numpy as np
+import numpy.typing as npt
 from pathlib import Path
 from sdevpy.utilities import dates
 from sdevpy.utilities import timegrids
 from sdevpy.analytics import black
-log = logging.getLogger(__name__)
+from sdevpy.market.eqforward import EqForwardCurve, get_forward_curves
+log = logging.getLogger(Path(__file__).stem)
 
 
 class EqVolSurfaceData:
@@ -20,46 +22,58 @@ class EqVolSurfaceData:
 
         # Extract
         self.expiries = np.asarray([s['expiry'] for s in sections])
-        self.forwards = np.asarray([s['forward'] for s in sections])
         self.input_strikes = [np.asarray(s['strikes']) for s in sections]
         self.vols = [np.asarray(s['vols']) for s in sections]
 
         # Size checks
         n_times = len(self.expiries)
-        if any(len(x) != n_times for x in (self.forwards, self.input_strikes, self.vols)):
+        if any(len(x) != n_times for x in (self.input_strikes, self.vols)):
             raise ValueError("Incompatible size along time direction between expiries, forwards, strikes and vols")
 
-        # Calculate missing strike type
-        if self.strike_input_type == 'absolute':
-            self.abs_strikes = self.input_strikes
-        elif self.strike_input_type == 'relative':
-            # self.abs_strikes = self.forwards * self.input_strikes # Old way assuming numpy matrix
-            # The code below is a quick non-tested implementation to cater for the non-matrix case.
-            # To be tested if/when case presents itself.
-            log.warning("Relative strike conversion should be tested")
-            self.abs_strikes = []
-            for i in range(n_times):
-                self.abs_strikes.append(self.forwards[i] * self.input_strikes[i])
-        else:
-            raise ValueError(f"Strike input type not supported yet: {self.strike_input_type}")
-
-        # Calculate prices
-        self.call_prices = []
+    def get_prices(self, fwd_curve: EqForwardCurve, option_type: str='call') -> npt.ArrayLike:
+        option_type_lw = option_type.lower()
+        prices = []
+        abs_strikes = self.get_strikes(fwd_curve, to_type='absolute')
         for exp_idx, expiry in enumerate(self.expiries):
             t = timegrids.model_time(self.valdate, expiry)
-            fwd = self.forwards[exp_idx]
-            strikes = self.abs_strikes[exp_idx]
+            fwd = fwd_curve.value(expiry)
+            strikes = abs_strikes[exp_idx]
             vols = self.vols[exp_idx]
-            self.call_prices.append(black.price(t, strikes, True, fwd, vols))
-
-    def get_strikes(self, type: str='absolute'):
-        req_type = type.lower()
-        if req_type == 'absolute':
-            return self.abs_strikes
-        elif req_type == 'relative':
-            return self.abs_strikes / self.forwards.reshape(-1, 1)
-        else:
-            raise ValueError(f"Unknown strike type {req_type}: expected absolute or relative")
+            match option_type_lw:
+                case 'call':
+                    price = black.price(t, strikes, True, fwd, vols)
+                case 'put':
+                    price = black.price(t, strikes, False, fwd, vols)
+                case 'straddle':
+                    price = black.price(t, strikes, True, fwd, vols)
+                    price = price + black.price(t, strikes, False, fwd, vols)
+                case _:
+                    raise ValueError(f"Invalid option type: {option_type}")
+
+            prices.append(price)
+        return prices
+
+    def get_strikes(self, fwd_curve: EqForwardCurve=None, to_type: str='absolute') -> npt.ArrayLike:
+        """ Retrieve strikes, absolute or relative """
+        to_type_lw = to_type.lower()
+        if to_type_lw == self.strike_input_type:
+            return self.input_strikes
+        else: # Need conversion
+            if fwd_curve is None:
+                raise ValueError(f"Forward curve required for strike conversion but None given: {self.name}")
+
+            # Need to loop over expiries because not all expiries must have the same number of strikes.
+            # Therefore we cannot put the strikes into numpy arrays.
+            fwds = fwd_curve.value(self.expiries)
+            n_times = len(self.expiries)
+            if to_type_lw == 'absolute' and self.strike_input_type == 'relative':
+                conv_strikes = [self.input_strikes[i] * fwds[i] for i in range(n_times)]
+            elif to_type_lw == 'relative' and self.strike_input_type == 'absolute':
+                conv_strikes = [self.input_strikes[i] / fwds[i] for i in range(n_times)]
+            else:
+                raise ValueError(f"Unknown strike type {to_type}: expected absolute or relative")
+
+            return conv_strikes
 
     def dump(self, file, indent=2):
         data = self.dump_data()
@@ -70,7 +84,7 @@ class EqVolSurfaceData:
         sections = []
         for i, expiry in enumerate(self.expiries):
             expiry_str = expiry.strftime(dates.DATE_FORMAT)
-            section = {'expiry': expiry_str, 'forward': self.forwards[i], 'strikes': self.input_strikes[i].tolist(),
+            section = {'expiry': expiry_str, 'strikes': self.input_strikes[i].tolist(),
                        'vols': self.vols[i].tolist()}
             sections.append(section)
 
@@ -93,7 +107,6 @@ class EqVolSurfaceData:
         for i in range(n_exp):
             print(sep)
             print(f"Expiry {i+1}/{n_exp}: {self.expiries[i].strftime(dates.DATE_FORMAT)}")
-            print(f"Forward: {self.forwards[i]:,.{n_digits}f}")
             with np.printoptions(precision=n_digits):
                 print("Strikes", self.input_strikes[i])
                 print("Vols", self.vols[i])
@@ -158,9 +171,12 @@ if __name__ == "__main__":
     # file = data_file(folder, name, valdate)
     # surface_data.dump(file)
 
+    # Get forward curve
+    fwd_curve = get_forward_curves([name], valdate)[0]
+
     # Get data from existing file
-    file = data_file(folder, name, valdate)
+    file = data_file(name, valdate, folder=folder)
     surface_data = eqvolsurfacedata_from_file(file)
-    print(surface_data.get_strikes('absolute'))
-    print(surface_data.get_strikes('relative'))
+    print(surface_data.get_strikes(to_type='absolute'))
+    print(surface_data.get_strikes(fwd_curve=fwd_curve, to_type='relative'))
     surface_data.pretty_print(4)

{sdevpy-1.0.9 → sdevpy-1.1}/sdevpy/market/yieldcurve.py

@@ -4,7 +4,8 @@ import datetime as dt
 import numpy as np
 from abc import ABC, abstractmethod
 from enum import Enum
-from sdevpy.utilities import timegrids, dates
+from sdevpy.utilities import dates as dts
+from sdevpy.utilities import timegrids
 from sdevpy.maths import interpolation as itp
 
 
@@ -75,13 +76,13 @@ class InterpolatedYieldCurve(YieldCurve):
         # Set data in interpolation
         if self.interp_var == YieldCurveVariable.ZERORATE:
             times = timegrids.model_time(self.valdate, self.dates)
-            data_y = -np.log(dfs) / times
+            data_y = -np.log(self.dfs) / times
         elif self.interp_var in [YieldCurveVariable.DISCOUNT, YieldCurveVariable.LOG_DISCOUNT]:
             times = [0.0]
             times.extend(timegrids.model_time(self.valdate, self.dates))
             times = np.asarray(times)
             ext_dfs = [1.0]
-            ext_dfs.extend(dfs)
+            ext_dfs.extend(self.dfs)
             ext_dfs = np.asarray(ext_dfs)
             if self.interp_var == YieldCurveVariable.DISCOUNT:
                 data_y = ext_dfs
@@ -128,13 +129,13 @@ class InterpolatedYieldCurve(YieldCurve):
             raise RuntimeError("Failure to set curve interpolation")
 
     def dump_data(self):
-        data = {'name': self.name, 'valdate': self.valdate.strftime(dates.DATE_FORMAT),
-                'snapdate': self.snapdate.strftime(dates.DATETIME_FORMAT),
+        data = {'name': self.name, 'valdate': self.valdate.strftime(dts.DATE_FORMAT),
+                'snapdate': self.snapdate.strftime(dts.DATETIME_FORMAT),
                 'interp_var': self.interp_var_str, 'interp_type': self.interp_type}
 
         pillars = []
         for expiry, df in zip(self.dates, self.dfs, strict=True):
-            pillar = {'expiry': expiry.strftime(dates.DATE_FORMAT), 'df': df}
+            pillar = {'expiry': expiry.strftime(dts.DATE_FORMAT), 'df': df}
             pillars.append(pillar)
 
         data['pillars'] = pillars
@@ -147,26 +148,24 @@ class YieldCurveVariable(Enum):
     LOG_DISCOUNT = 2
 
 
-def get_yieldcurve(name, date, **kwargs):
+def get_yieldcurve(name: str, date: dt.datetime, **kwargs):
     file = data_file(name, date, **kwargs)
     curve = yieldcurve_from_file(file)
     return curve
 
 
-def yieldcurve_from_file(file):
+def yieldcurve_from_file(file: str):
     with open(file) as f:
         data = json.load(f)
 
     name = data.get('name')
     valdate = data.get('valdate')
-    snapdate = data.get('snapdate') # Claude says this will be wrong
-    # Claude says to do the below but this fails in UT
-    # snapdate = dt.datetime.strptime(data.get('snapdate'), dates.DATE_FILE_FORMAT)
+    snapdate = dt.datetime.strptime(data.get('snapdate'), dts.DATETIME_FORMAT)
     interp_var = data.get('interp_var')
     interp_type = data.get('interp_type')
     pillars = data.get('pillars')
 
-    valdate = dt.datetime.strptime(valdate, dates.DATE_FORMAT)
+    valdate = dt.datetime.strptime(valdate, dts.DATE_FORMAT)
     curve = InterpolatedYieldCurve(valdate=valdate, interp_var=interp_var, interp_type=interp_type,
                                    name=name, snapdate=snapdate)
 
@@ -174,7 +173,7 @@ def yieldcurve_from_file(file):
     pillar_dates, pillar_dfs = [], []
     for pillar in pillars:
         date_str = pillar.get('expiry')
-        date = dt.datetime.strptime(date_str, dates.DATE_FORMAT)
+        date = dt.datetime.strptime(date_str, dts.DATE_FORMAT)
         df = pillar.get('df')
         pillar_dates.append(date)
         pillar_dfs.append(df)
@@ -187,7 +186,7 @@ def data_file(name, date, **kwargs):
     folder = kwargs.get('folder', test_data_folder())
     name_folder = os.path.join(folder, name)
     os.makedirs(name_folder, exist_ok=True)
-    file = os.path.join(name_folder, date.strftime(dates.DATE_FILE_FORMAT) + ".json")
+    file = os.path.join(name_folder, date.strftime(dts.DATE_FILE_FORMAT) + ".json")
     return file
 
 
@@ -201,7 +200,6 @@ def test_data_folder():
 
 if __name__ == "__main__":
     import matplotlib.pyplot as plt
-    from sdevpy.utilities import dates
 
     valdate = dt.datetime(2026, 2, 15)
 
@@ -223,7 +221,7 @@ if __name__ == "__main__":
     curve.set_data(zdates, dfs)
 
     # Interpolate and display
-    test_dates = [dates.advance(valdate, months=1*n) for n in range(1, 600)]
+    test_dates = [dts.advance(valdate, str(n) + 'm') for n in range(1, 600)]
     test_dfs = curve.discount(test_dates)
     test_times = timegrids.model_time(valdate, test_dates)
     test_zrs = -np.log(test_dfs) / test_times

{sdevpy-1.0.9 → sdevpy-1.1}/sdevpy/maths/constants.py

@@ -1,4 +1,5 @@
 import sys
+import math
 
 
 FLOAT_INFTY = float('inf')
@@ -17,6 +18,8 @@ C_SQRT2PI = 2.50662827459518
 C_2_SQRTPI = 1.12837916709551257390
 k_2powneg32 = 2.3283064365387e-10 # Normalization factor for Sobol
 
+TWO_PI = 2.0 * math.pi
+
 
 if __name__ == "__main__":
     print(f"FLOAT_INFTY: {FLOAT_INFTY}")

{sdevpy-1.0.9 → sdevpy-1.1}/sdevpy/maths/integration.py

@@ -33,4 +33,3 @@ if __name__ == "__main__":
     print("In-house")
     print(sd_int)
     print(time.time() - start)
-