sdevpy 1.0.8__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.8 → sdevpy-1.1}/PKG-INFO

@@ -1,14 +1,36 @@
 Metadata-Version: 2.4
 Name: sdevpy
-Version: 1.0.8
+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.8 → sdevpy-1.1}/pyproject.toml

@@ -4,8 +4,9 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sdevpy"
-version = "1.0.8"
-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
@@ -38,6 +43,21 @@ target-version = "py313"
 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/"
+[tool.coverage.run]
+omit = [
+    "sdevpy/**/__init__.py",
+    "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__.:",
+    "pragma: no cov"
+]

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.8 → sdevpy-1.1}/sdevpy/analytics/bachelier.py

@@ -6,32 +6,20 @@ 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.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))
 
 
 def price_straddles(expiry: npt.ArrayLike, strike: npt.ArrayLike, fwd: npt.ArrayLike,
-                    vol: npt.ArrayLike) -> npt.ArrayLike:
-    """ Straddle price under the Bachelier model.
-        Note: we could improve the speed by writing the code in-line instead of
-              calling the price() function twice """
-    expiries_ = np.asarray(expiry).reshape(-1, 1)
-    prices = []
-    for i, exp_row in enumerate(expiries_):
-        k_prices = []
-        for j, k in enumerate(strike[i]):
-            iv = vol[i, j]
-            call_price = price(exp_row, k, True, fwd, iv)
-            put_price = price(exp_row, k, False, fwd, iv)
-            k_prices.append(call_price[0] + put_price[0])
-        prices.append(k_prices)
-
-    return np.asarray(prices)
+                    vol: npt.ArrayLike) -> npt.NDArray[np.float64]:
+    """ Straddle price under the Bachelier model """
+    call = price(expiry[:, None], strike, True, fwd, vol)
+    put = price(expiry[:, None], strike, False, fwd, vol)
+    return call + put
 
 
 def implied_vol_jaeckel(expiry: float, strike: float, is_call: bool, fwd: float, fwd_price: float) -> float:

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

@@ -3,14 +3,12 @@ import numpy as np
 import numpy.typing as npt
 from scipy.stats import norm
 from scipy.optimize import minimize_scalar
-from sdevpy.thirdparty.py_vollib.black import implied_volatility as jaeckel
 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
@@ -18,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)
@@ -34,7 +45,7 @@ def implied_vol(expiry: float, strike: float, is_call: bool, fwd: float, fwd_pri
 
 
 def implied_vols(expiry: float, strike: npt.ArrayLike, is_call: bool, fwd: float,
-                 fwd_price: npt.ArrayLike) -> npt.ArrayLike:
+                 fwd_price: npt.ArrayLike) -> npt.NDArray[np.float64]:
     """ Black implied volatility for vector of strikes/prices """
     if isiterable(strike) and isiterable(fwd_price):
         ivs = [implied_vol(expiry, k, is_call, fwd, p) for k, p in zip(strike, fwd_price, strict=True)]
@@ -46,7 +57,7 @@ def implied_vols(expiry: float, strike: npt.ArrayLike, is_call: bool, fwd: float
 
 
 def implied_vol_newton(expiry: float, strike: npt.ArrayLike, is_call: bool, fwd: float,
-                       fwd_price: npt.ArrayLike, tol: float=1e-8, max_iter: int=50) -> npt.ArrayLike:
+                       fwd_price: npt.ArrayLike, tol: float=1e-8, max_iter: int=50) -> npt.NDArray[np.float64]:
     """ Using vectorized Newton-Raphson, with faster convergence than Brent.
         However, this method can struggle for very small vegas, so we may want to switch
         to another method (maybe Brent above) below a certain vega threshold.
@@ -66,22 +77,12 @@ def implied_vol_newton(expiry: float, strike: npt.ArrayLike, is_call: bool, fwd:
         if np.all(np.abs(diff) < tol):
             break
 
-    # if len(strike) == 1 and len(fwd_price) == 1 and len(vol) == 1: # Return a scalar if inputs are scalar
-    #     return vol[0]
-    # else:
-    #     return vol
-    return (vol.item() if vol.ndim == 0 or vol.size ==1 else vol)
-
-
-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
-        near ATM. """
-    flag = 'c' if is_call else 'p'
-    p = fwd_price
-    iv = jaeckel.implied_volatility_of_undiscounted_option_price(p, fwd, strike, expiry, flag)
-    return iv
+    # # if len(strike) == 1 and len(fwd_price) == 1 and len(vol) == 1: # Return a scalar if inputs are scalar
+    # #     return vol[0]
+    # # else:
+    # #     return vol
+    # return (vol.item() if vol.ndim == 0 or vol.size ==1 else vol)
+    return vol
 
 
 if __name__ == "__main__":
@@ -98,8 +99,8 @@ if __name__ == "__main__":
     k_space = np.linspace(20, 2180, NUM_POINTS)
     prices = price(EXPIRY, k_space, IS_CALL, f_space, VOL)
     # print(prices)
-    implied_vols = []
+    iv_results = []
     for i, k in enumerate(k_space):
-        implied_vols.append(implied_vol(EXPIRY, k, IS_CALL, f_space[i], prices[i]))
+        iv_results.append(implied_vol(EXPIRY, k, IS_CALL, f_space[i], prices[i]))
 
-    # print(implied_vols)
+    # print(iv_results)

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.8 → 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.8 → 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.8 → 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.8 → 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)