More PEP8 and Discount Curve set_last_df

Author: domokane

.pylintrc

@@ -13,6 +13,7 @@ disable=
     R0903,  # too-few-public-methods
     W0511,  # fixme
     W0718,  # comparison-with-itself
+    R0801   # Duplicate code
 
 [FORMAT]
 # Match Black's defaults

docs/generate.py

@@ -1,6 +1,7 @@
 """Generate the code reference pages."""
 
 from pathlib import Path
+
 import mkdocs_gen_files
 
 root = Path(__file__).parent.parent

financepy/__init__.py

@@ -1,6 +1,6 @@
 cr = "\n"
 s = "####################################################################" + cr
-s += "#    FINANCEPY Version " + str('1.1') + " - This build: 20 Aug 2025 at 13:58      #" + cr
+s += "#    FINANCEPY Version " + str('1.1') + " - This build: 20 Aug 2025 at 18:37      #" + cr
 s += "#     This software is distributed FREE AND WITHOUT ANY WARRANTY   #" + cr
 s += "#  Report bugs as issues at https://github.com/domokane/FinancePy  #" + cr
 s += "####################################################################"

financepy/market/curves/discount_curve.py

@@ -92,28 +92,19 @@ def __init__(
     @property
     def times(self) -> np.ndarray:
         """Return the internal array of times (in years) from the anchor date."""
-        return (
-            self._times.copy()
-        )  # return a copy to prevent external modification
+        return self._times.copy()  # return a copy to prevent external modification
 
     @property
     def dfs(self) -> np.ndarray:
         """Return the internal array of discount factors corresponding to times."""
-        return (
-            self._dfs.copy()
-        )  # return a copy to prevent external modification
+        return self._dfs.copy()  # return a copy to prevent external modification
 
     ###########################################################################
 
-    def set_df(self, index, df):
-        """Set the discount factor at a specific index."""
-
+    def set_last_df(self, df):
+        """Set the discount factor at the last maturity time."""
         n_points = len(self.dfs)
-
-        if index < 0 or index >= n_points:
-            raise IndexError("Index out of bounds")
-
-        self._dfs[index] = df
+        self._dfs[n_points - 1] = df
 
     ###########################################################################
 
@@ -430,9 +421,7 @@ def bump(self, bump_size: float):
             t = times[i]
             values[i] = values[i] * np.exp(-bump_size * t)
 
-        disc_curve = DiscountCurve(
-            self.value_dt, times, values, self._interp_type
-        )
+        disc_curve = DiscountCurve(self.value_dt, times, values, self._interp_type)
 
         return disc_curve
 
@@ -492,9 +481,7 @@ def __repr__(self):
         num_points = len(self._df_dates)
         s += label_to_string("DATES", "DISCOUNT FACTORS")
         for i in range(0, num_points):
-            s += label_to_string(
-                "%12s" % self._df_dates[i], "%12.8f" % self._dfs[i]
-            )
+            s += label_to_string("%12s" % self._df_dates[i], "%12.8f" % self._dfs[i])
 
         return s
 

financepy/market/curves/interpolator.py

@@ -399,10 +399,10 @@ def interpolate(self, t: float):
                 # (not sure why we have if len(times) == 1: return in the fit(...)
                 # function but reluctant to change that)
                 # so work around this. already tested that _dfs is not None
-                if len(self._dfs) == 0 or self.times[0] == 0.0:
+                if len(self._dfs) == 0 or self._times[0] == 0.0:
                     out = [1.0] * len(tvec)
                 else:
-                    onf_rate = -np.log(self._dfs[0]) / self.times[0]
+                    onf_rate = -np.log(self._dfs[0]) / self._times[0]
                     out = np.exp(-onf_rate * tvec)
             else:
                 # apparently UnivariateSpline.integral assumes the function is

financepy/market/volatility/equity_vol_surface.py

@@ -3,11 +3,11 @@
 ##############################################################################
 
 from typing import Union
+import matplotlib.pyplot as plt
 
 import numpy as np
 from scipy.optimize import minimize
 
-import matplotlib.pyplot as plt
 from numba import njit, float64, int64
 
 from ...utils.error import FinError

financepy/market/volatility/fx_vol_surface.py

@@ -2,12 +2,13 @@
 # Copyright (C) 2018, 2019, 2020 Dominic O'Kane, Saeed Amen
 ##############################################################################
 
+import matplotlib.pyplot as plt
+
 from typing import Union
 
 import numpy as np
 from scipy.optimize import minimize
 
-import matplotlib.pyplot as plt
 from numba import njit, float64, int64
 
 from ...utils.error import FinError
@@ -340,9 +341,7 @@ def delta_fit(K, *args):
 
     f = s * np.exp((r_d - r_f) * t)
     v = vol_function(vol_type_value, params, f, K, t)
-    delta_out = fast_delta(
-        s, t, K, r_d, r_f, v, delta_type_value, opt_type_value
-    )
+    delta_out = fast_delta(s, t, K, r_d, r_f, v, delta_type_value, opt_type_value)
     inverse_delta_out = norminvcdf(np.abs(delta_out))
     inv_obj_fn = inverse_delta_target - inverse_delta_out
 
@@ -399,9 +398,7 @@ def solver_for_smile_strike_fast(
         parameters,
     )
 
-    K = newton_secant(
-        delta_fit, x0=initial_guess, args=argtuple, tol=1e-8, maxiter=50
-    )
+    K = newton_secant(delta_fit, x0=initial_guess, args=argtuple, tol=1e-8, maxiter=50)
 
     return K
 
@@ -411,9 +408,7 @@ def solver_for_smile_strike_fast(
 
 
 @njit(
-    float64(
-        float64, float64, float64, float64, int64, float64, int64, float64
-    ),
+    float64(float64, float64, float64, float64, int64, float64, int64, float64),
     fastmath=True,
 )
 def solve_for_strike(
@@ -455,9 +450,7 @@ def solve_for_strike(
         vsqrtt = volatility * np.sqrt(t_del)
         arg = delta_target * phi / for_df  # CHECK THIS !!!
         norm_inv_delta = norminvcdf(arg)
-        K = fwd_fx_rate * np.exp(
-            -vsqrtt * (phi * norm_inv_delta - vsqrtt / 2.0)
-        )
+        K = fwd_fx_rate * np.exp(-vsqrtt * (phi * norm_inv_delta - vsqrtt / 2.0))
         return K
 
     elif delta_method_value == FinFXDeltaMethod.FORWARD_DELTA.value:
@@ -474,9 +467,7 @@ def solve_for_strike(
         vsqrtt = volatility * np.sqrt(t_del)
         arg = delta_target * phi  # CHECK THIS!!!!!!!!
         norm_inv_delta = norminvcdf(arg)
-        K = fwd_fx_rate * np.exp(
-            -vsqrtt * (phi * norm_inv_delta - vsqrtt / 2.0)
-        )
+        K = fwd_fx_rate * np.exp(-vsqrtt * (phi * norm_inv_delta - vsqrtt / 2.0))
         return K
 
     elif delta_method_value == FinFXDeltaMethod.SPOT_DELTA_PREM_ADJ.value:
@@ -492,9 +483,7 @@ def solve_for_strike(
             delta_target,
         )
 
-        K = newton_secant(
-            g, x0=spot_fx_rate, args=argtuple, tol=1e-7, maxiter=50
-        )
+        K = newton_secant(g, x0=spot_fx_rate, args=argtuple, tol=1e-7, maxiter=50)
 
         return K
 
@@ -511,9 +500,7 @@ def solve_for_strike(
             delta_target,
         )
 
-        K = newton_secant(
-            g, x0=spot_fx_rate, args=argtuple, tol=1e-7, maxiter=50
-        )
+        K = newton_secant(g, x0=spot_fx_rate, args=argtuple, tol=1e-7, maxiter=50)
 
         return K
 
@@ -642,29 +629,23 @@ def volatility(self, K, expiry_dt):
             # The volatility term structure is flat if there is only one expiry
             fwd = self.fwd[0]
             t_exp = self.t_exp[0]
-            vol = vol_function(
-                vol_type_value, self.parameters[0], fwd, K, t_exp
-            )
+            vol = vol_function(vol_type_value, self.parameters[0], fwd, K, t_exp)
             return vol
 
         # If the time is below first time then assume a flat vol
         if t <= self.t_exp[0]:
 
             fwd = self.fwd[0]
             t_exp = self.t_exp[0]
-            vol = vol_function(
-                vol_type_value, self.parameters[0], fwd, K, t_exp
-            )
+            vol = vol_function(vol_type_value, self.parameters[0], fwd, K, t_exp)
             return vol
 
         # If the time is beyond the last time then extrapolate with a flat vol
         if t > self.t_exp[-1]:
 
             fwd = self.fwd[-1]
             t_exp = self.t_exp[-1]
-            vol = vol_function(
-                vol_type_value, self.parameters[-1], fwd, K, t_exp
-            )
+            vol = vol_function(vol_type_value, self.parameters[-1], fwd, K, t_exp)
             return vol
 
         for i in range(1, num_curves):
@@ -676,15 +657,11 @@ def volatility(self, K, expiry_dt):
 
         fwd0 = self.fwd[index0]
         t0 = self.t_exp[index0]
-        vol0 = vol_function(
-            vol_type_value, self.parameters[index0], fwd0, K, t0
-        )
+        vol0 = vol_function(vol_type_value, self.parameters[index0], fwd0, K, t0)
 
         fwd1 = self.fwd[index1]
         t1 = self.t_exp[index1]
-        vol1 = vol_function(
-            vol_type_value, self.parameters[index1], fwd1, K, t1
-        )
+        vol1 = vol_function(vol_type_value, self.parameters[index1], fwd1, K, t1)
 
         vart0 = vol0 * vol0 * t0
         vart1 = vol1 * vol1 * t1
@@ -1047,8 +1024,7 @@ def check_calibration(self, verbose: bool, tol: float = 1e-6):
 
                 print("======================================================")
                 print(
-                    "MKT STRANGLE VOL IN: %9.6f %%"
-                    % (100.0 * self.ms_25_delta_vols[i])
+                    "MKT STRANGLE VOL IN: %9.6f %%" % (100.0 * self.ms_25_delta_vols[i])
                 )
 
             call.strike_fx_rate = self.k_25d_c_ms[i]
@@ -1254,16 +1230,12 @@ def check_calibration(self, verbose: bool, tol: float = 1e-6):
             sigma_rr = sigma_k_25d_c - sigma_k_25d_p
 
             if verbose:
-                print(
-                    "========================================================="
-                )
+                print("=========================================================")
                 print(
                     "RR = VOL_K_25_C - VOL_K_25_P => RR_IN: %9.6f %% RR_OUT: %9.6f %%"
                     % (100.0 * self.rr_25_delta_vols[i], 100.0 * sigma_rr)
                 )
-                print(
-                    "========================================================="
-                )
+                print("=========================================================")
 
             diff = sigma_rr - self.rr_25_delta_vols[i]
 
@@ -1319,9 +1291,7 @@ def implied_dbns(self, low_fx, high_fx, num_intervals):
             k_s = np.array(k_s)
             vols = np.array(vols)
 
-            density = option_implied_dbn(
-                self.spot_fx_rate, t_exp, r_d, r_f, k_s, vols
-            )
+            density = option_implied_dbn(self.spot_fx_rate, t_exp, r_d, r_f, k_s, vols)
 
             dbn = FinDistribution(k_s, density)
             dbns.append(dbn)
@@ -1369,9 +1339,7 @@ def plot_vol_curves(self):
             plt.xlabel("Strike")
             plt.ylabel("Volatility")
 
-            title = (
-                "25d FIT:" + self.currency_pair + " " + str(self.vol_func_type)
-            )
+            title = "25d FIT:" + self.currency_pair + " " + str(self.vol_func_type)
 
             key_strikes = []
             key_strikes.append(self.k_atm[tenor_index])