More PEP 8 work

Author: domokane

.pylintrc

@@ -1,11 +1,8 @@
-if 1==1:
-    cr = "\n"
-
-    s = "####################################################################" + cr
-    s += "#    FINANCEPY Version " + str('1.1') + " - This build: 15 Aug 2025 at 13:47      #" + 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 += "####################################################################"
-    s += cr
-
-    print(s)
+cr = "\n"
+s = "####################################################################" + cr
+s += "#    FINANCEPY Version " + str('1.1') + " - This build: 20 Aug 2025 at 11:08      #" + 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 += "####################################################################"
+s += cr
+print(s)

financepy/__init__.py

@@ -35,8 +35,8 @@ def __init__(
     ):
         """
         Creates a discount curve using a vector of times and ON fwd rates
-        The fwd rate is right-continuous i.e. a given value in the
-        input is applied to the left of that date until the previous date exclusive
+        The fwd rate is right-continuous i.e. a given value in the input
+        is applied to the left of that date until the previous date exclusive
         The last fwd rate is extrapolated into the future
         """
 
@@ -77,7 +77,7 @@ def __init__(
         if test_monotonicity(self._times) is False:
             raise FinError("Times are not sorted in increasing order")
 
-    ###############################################################################
+    ###########################################################################
 
     @classmethod
     def brick_wall_curve(
@@ -87,13 +87,17 @@ def brick_wall_curve(
         end_dt: Date,
         level: float = 1.0 * G_BASIS_POINT,
     ):
-        """Generate a discount curve of the shape f(t) = level*1_{startdate < t <= enddate} where f(.) is the instantaneous forward rate
-            Mostly useful for applying bumps to other discount_curve's, see composite_discount_curve.py
+        """Generate a discount curve of the shape
+                    f(t) = level*1_{startdate < t <= enddate}
+                    where f(.) is the instantaneous forward rate
+           Mostly useful for applying bumps to other discount_curve's,
+           see composite_discount_curve.py
         Args:
             valuation_date (Date): valuation date for the discount_curve
             start_dt (Date): start of the non-zero ON forward rate
             end_dt (Date): end of the non-zero ON forward rate
-            level (float, optional): ON forward rate between the start and end dates. Defaults to 1.0*G_BASIS_POINT.
+            level (float, optional): ON forward rate between the
+            start and end dates. Defaults to 1.0*G_BASIS_POINT.
 
         Returns:
             DiscountCurve: discount curve of the required shape
@@ -102,7 +106,7 @@ def brick_wall_curve(
         onfwd_rates = [0.0, level, 0.0]
         return cls(valuation_date, knot_dts, onfwd_rates)
 
-    ###############################################################################
+    ###########################################################################
 
     @classmethod
     def flat_curve(
@@ -112,7 +116,7 @@ def flat_curve(
         onfwd_rates = [level]
         return cls(valuation_date, knot_dts, onfwd_rates)
 
-    ###############################################################################
+    ###########################################################################
 
     def _zero_rate(self, times: Union[float, np.ndarray, list]):
         """
@@ -129,11 +133,11 @@ def _zero_rate(self, times: Union[float, np.ndarray, list]):
         zero_rates = -ldfs / times
         return zero_rates
 
-    ###############################################################################
+    ###########################################################################
 
     def df_t(self, t: Union[float, np.ndarray]):
-        """Return discount factors given a single or vector of times in years. The
-        discount factor depends on the rate and this in turn depends on its
+        """Return discount factors given a single or vector of times in years.
+        The discount factor depends on the rate and this in turn depends on its
         compounding frequency and it defaults to continuous compounding. It
         also depends on the day count convention. This was set in the
         construction of the curve to be ACT_ACT_ISDA."""
@@ -146,7 +150,7 @@ def df_t(self, t: Union[float, np.ndarray]):
 
         return df
 
-    ###############################################################################
+    ###########################################################################
 
     def __repr__(self):
 
@@ -157,7 +161,7 @@ def __repr__(self):
         s += label_to_string("FREQUENCY", (self.freq_type))
         return s
 
-    ###############################################################################
+    ###########################################################################
 
     def _print(self):
         """Simple print function for backward compatibility."""

financepy/market/curves/discount_curve_pwf_onf.py

@@ -199,13 +199,13 @@ def _delta_fit(k, *args):
     t = args[2]
     r = args[3]
     q = args[4]
-    option_type_value = args[5]
+    opt_type_value = args[5]
     inverse_delta_target = args[6]
     params = args[7]
 
     f = s * np.exp((r - q) * t)
     v = vol_function(vol_type_value, params, f, k, t)
-    delta_out = bs_delta(s, t, k, r, q, v, option_type_value)
+    delta_out = bs_delta(s, t, k, r, q, v, opt_type_value)
     inverse_delta_out = norminvcdf(np.abs(delta_out))
     inv_obj_fn = inverse_delta_target - inverse_delta_out
 
@@ -224,7 +224,7 @@ def _solver_for_smile_strike(
     t,
     r,
     q,
-    option_type_value,
+    opt_type_value,
     vol_type_value,
     delta_target,
     initial_guess,
@@ -242,12 +242,14 @@ def _solver_for_smile_strike(
         t,
         r,
         q,
-        option_type_value,
+        opt_type_value,
         inverse_delta_target,
         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
 
 
@@ -362,11 +364,15 @@ def vol_from_strike_date(self, k, expiry_dt):
         t0 = self._t_exp[index0]
         t1 = self._t_exp[index1]
 
-        vol0 = vol_function(vol_type_value, self._parameters[index0], fwd0, k, t0)
+        vol0 = vol_function(
+            vol_type_value, self._parameters[index0], fwd0, k, t0
+        )
 
         if index1 != index0:
 
-            vol1 = vol_function(vol_type_value, self._parameters[index1], fwd1, k, t1)
+            vol1 = vol_function(
+                vol_type_value, self._parameters[index1], fwd1, k, t1
+            )
 
         else:
 
@@ -556,7 +562,9 @@ def vol_from_delta_date(self, call_delta, expiry_dt, delta_method=None):
             self._parameters[index0],
         )
 
-        vol0 = vol_function(vol_type_value, self._parameters[index0], fwd0, k_0, t0)
+        vol0 = vol_function(
+            vol_type_value, self._parameters[index0], fwd0, k_0, t0
+        )
 
         if index1 != index0:
 
@@ -572,7 +580,9 @@ def vol_from_delta_date(self, call_delta, expiry_dt, delta_method=None):
                 self._parameters[index1],
             )
 
-            vol1 = vol_function(vol_type_value, self._parameters[index1], fwd1, k_1, t1)
+            vol1 = vol_function(
+                vol_type_value, self._parameters[index1], fwd1, k_1, t1
+            )
         else:
             vol1 = vol0
 
@@ -587,7 +597,9 @@ def vol_from_delta_date(self, call_delta, expiry_dt, delta_method=None):
             kt = ((t_exp - t0) * k_1 + (t1 - t_exp) * k_0) / (t1 - t0)
 
             if vart < 0.0:
-                raise FinError("Failed interpolation due to negative variance.")
+                raise FinError(
+                    "Failed interpolation due to negative variance."
+                )
 
             volt = np.sqrt(vart / t_exp)