Fix lint and typecheck issues.

napytau/core/chi.py

@@ -1,5 +1,7 @@
 from napytau.core.polynomials import evaluate_polynomial_at_measuring_distances
-from napytau.core.polynomials import evaluate_differentiated_polynomial_at_measuring_distances # noqa E501
+from napytau.core.polynomials import (
+    evaluate_differentiated_polynomial_at_measuring_distances,
+)  # noqa E501
 from numpy import ndarray
 from numpy import sum
 from numpy import mean
@@ -46,18 +48,20 @@ def chi_squared_fixed_t(
 
     # Compute the difference between Doppler-shifted intensities and polynomial model
     shifted_intensity_difference: ndarray = (
-                                                    doppler_shifted_intensities
-                                                    - evaluate_polynomial_at_measuring_distances(distances, coefficients)
+        doppler_shifted_intensities
+        - evaluate_polynomial_at_measuring_distances(distances, coefficients)
     ) / delta_doppler_shifted_intensities
 
     # Compute the difference between unshifted intensities and
     # scaled derivative of the polynomial model
     unshifted_intensity_difference: ndarray = (
         unshifted_intensities
-        - (t_hyp
-           * evaluate_differentiated_polynomial_at_measuring_distances(distances,
-                                                                       coefficients)
-           )
+        - (
+            t_hyp
+            * evaluate_differentiated_polynomial_at_measuring_distances(
+                distances, coefficients
+            )
+        )
     ) / delta_unshifted_intensities
 
     # combine the weighted sum of squared differences
@@ -104,14 +108,15 @@ def optimize_coefficients(
         tuple: Optimized coefficients (ndarray) and minimized chi-squared value (float).
     """
     chi_squared = lambda coefficients: chi_squared_fixed_t(
-            doppler_shifted_intensities,
-            unshifted_intensities,
-            delta_doppler_shifted_intensities,
-            delta_unshifted_intensities,
-            coefficients,
-            distances,
-            t_hyp,
-            weight_factor)
+        doppler_shifted_intensities,
+        unshifted_intensities,
+        delta_doppler_shifted_intensities,
+        delta_unshifted_intensities,
+        coefficients,
+        distances,
+        t_hyp,
+        weight_factor,
+    )
 
     result: OptimizeResult = minimize(
         chi_squared,

napytau/core/core.py

@@ -7,29 +7,33 @@
 from typing import Tuple, Optional
 
 
-def calculate_lifetime(doppler_shifted_intensities: np.ndarray,
-                       unshifted_intensities: np.ndarray,
-                       delta_doppler_shifted_intensities: np.ndarray,
-                       delta_unshifted_intensities: np.ndarray,
-                       initial_coefficients: np.ndarray,
-                       distances: np.ndarray,
-                       t_hyp_range: Tuple[float, float],
-                       weight_factor: float,
-                       custom_t_hyp_estimate: Optional[float]) -> Tuple[float, float]:
-
+def calculate_lifetime(
+    doppler_shifted_intensities: np.ndarray,
+    unshifted_intensities: np.ndarray,
+    delta_doppler_shifted_intensities: np.ndarray,
+    delta_unshifted_intensities: np.ndarray,
+    initial_coefficients: np.ndarray,
+    distances: np.ndarray,
+    t_hyp_range: Tuple[float, float],
+    weight_factor: float,
+    custom_t_hyp_estimate: Optional[float],
+) -> Tuple[float, float]:
+    t_hyp: float = 0
     # If a custom t_hyp is given, we will use it for the further calculations
     # If no custom t_hyp is given, we will use the optimal taufactor instead
     if custom_t_hyp_estimate is not None:
-        t_hyp: float = custom_t_hyp_estimate
+        t_hyp = custom_t_hyp_estimate
     else:
-        t_hyp: float = optimize_t_hyp(doppler_shifted_intensities,
-                                      unshifted_intensities,
-                                      delta_doppler_shifted_intensities,
-                                      delta_unshifted_intensities,
-                                      initial_coefficients,
-                                      distances,
-                                      t_hyp_range,
-                                      weight_factor)
+        t_hyp = optimize_t_hyp(
+            doppler_shifted_intensities,
+            unshifted_intensities,
+            delta_doppler_shifted_intensities,
+            delta_unshifted_intensities,
+            initial_coefficients,
+            distances,
+            t_hyp_range,
+            weight_factor,
+        )
 
     # Now we find the optimal coefficients for the given taufactor
     optimized_coefficients: np.ndarray = (
@@ -46,15 +50,17 @@ def calculate_lifetime(doppler_shifted_intensities: np.ndarray,
     )[0]
 
     # We now calculate the lifetimes tau_i for all measured distances
-    tau_i_values: np.ndarray = calculate_tau_i_values(doppler_shifted_intensities,
-                                                      unshifted_intensities,
-                                                      delta_doppler_shifted_intensities,
-                                                      delta_unshifted_intensities,
-                                                      initial_coefficients,
-                                                      distances,
-                                                      t_hyp_range,
-                                                      weight_factor,
-                                                      custom_t_hyp_estimate)
+    tau_i_values: np.ndarray = calculate_tau_i_values(
+        doppler_shifted_intensities,
+        unshifted_intensities,
+        delta_doppler_shifted_intensities,
+        delta_unshifted_intensities,
+        initial_coefficients,
+        distances,
+        t_hyp_range,
+        weight_factor,
+        custom_t_hyp_estimate,
+    )
 
     # And we calculate the respective errors for the lifetimes
     delta_tau_i_values: np.ndarray = calculate_error_propagation_terms(
@@ -63,10 +69,13 @@ def calculate_lifetime(doppler_shifted_intensities: np.ndarray,
         delta_unshifted_intensities,
         distances,
         optimized_coefficients,
-        t_hyp)
+        t_hyp,
+    )
 
     # From lifetimes and associated errors we can now calculate the weighted mean
     # and the uncertainty
-    tau_final: (float, float) = calculate_tau_final(tau_i_values, delta_tau_i_values)
+    tau_final: Tuple[float, float] = calculate_tau_final(
+        tau_i_values, delta_tau_i_values
+    )
 
-    return tau_final
+    return tau_final

napytau/core/delta_tau.py

@@ -1,4 +1,6 @@
-from napytau.core.polynomials import evaluate_differentiated_polynomial_at_measuring_distances # noqa E501
+from napytau.core.polynomials import (
+    evaluate_differentiated_polynomial_at_measuring_distances,
+)  # noqa E501
 from napytau.core.polynomials import evaluate_polynomial_at_measuring_distances
 from numpy import array
 from numpy import ndarray
@@ -107,7 +109,9 @@ def calculate_error_propagation_terms(
         )
     )
 
-    gaussian_error_from_unshifted_intensity: ndarray = power(delta_unshifted_intensities, 2) / power(
+    gaussian_error_from_unshifted_intensity: ndarray = power(
+        delta_unshifted_intensities, 2
+    ) / power(
         calculated_differentiated_polynomial_sum_at_measuring_distances,
         2,
     )
@@ -138,7 +142,10 @@ def calculate_error_propagation_terms(
         unshifted_intensities * taufactor * delta_p_j_i_squared
     ) / power(calculated_differentiated_polynomial_sum_at_measuring_distances, 3)
 
-    test = gaussian_error_from_unshifted_intensity + gaussian_error_from_polynomial_uncertainties
-    res = test + error_from_covariance
+    interim_result: ndarray = (
+        gaussian_error_from_unshifted_intensity
+        + gaussian_error_from_polynomial_uncertainties
+    )
+    errors: ndarray = interim_result + error_from_covariance
     # Return the sum of all three contributions
-    return res
+    return errors

napytau/core/polynomials.py

@@ -3,8 +3,9 @@
 from numpy import zeros_like
 
 
-def evaluate_polynomial_at_measuring_distances(distances: ndarray,
-                                               coefficients: ndarray) -> ndarray:
+def evaluate_polynomial_at_measuring_distances(
+    distances: ndarray, coefficients: ndarray
+) -> ndarray:
     """
     Computes the sum of a polynomial evaluated at given distance points.
 
@@ -51,6 +52,8 @@ def evaluate_differentiated_polynomial_at_measuring_distances(
     sum_of_derivative_at_measuring_distances: ndarray = zeros_like(distances)
     for exponent, coefficient in enumerate(coefficients):
         if exponent > 0:
-            sum_of_derivative_at_measuring_distances += exponent * coefficient * power(distances, (exponent - 1))
+            sum_of_derivative_at_measuring_distances += (
+                exponent * coefficient * power(distances, (exponent - 1))
+            )
 
     return sum_of_derivative_at_measuring_distances

napytau/core/tau.py

@@ -1,6 +1,8 @@
 from napytau.core.chi import optimize_t_hyp
 from napytau.core.chi import optimize_coefficients
-from napytau.core.polynomials import evaluate_differentiated_polynomial_at_measuring_distances # noqa E501
+from napytau.core.polynomials import (
+    evaluate_differentiated_polynomial_at_measuring_distances,
+)  # noqa E501
 from numpy import ndarray
 from typing import Tuple, Optional
 
@@ -14,7 +16,8 @@ def calculate_tau_i_values(
     distances: ndarray,
     t_hyp_range: Tuple[float, float],
     weight_factor: float,
-    custom_t_hyp_estimate: Optional[float]) -> ndarray:
+    custom_t_hyp_estimate: Optional[float],
+) -> ndarray:
     """
     Calculates the decay times (tau_i) based on the provided
     intensities and time points.
@@ -46,14 +49,16 @@ def calculate_tau_i_values(
     if custom_t_hyp_estimate is not None:
         t_hyp: float = custom_t_hyp_estimate
     else:
-        t_hyp = optimize_t_hyp(doppler_shifted_intensities,
-                               unshifted_intensities,
-                               delta_doppler_shifted_intensities,
-                               delta_unshifted_intensities,
-                               initial_coefficients,
-                               distances,
-                               t_hyp_range,
-                               weight_factor)
+        t_hyp = optimize_t_hyp(
+            doppler_shifted_intensities,
+            unshifted_intensities,
+            delta_doppler_shifted_intensities,
+            delta_unshifted_intensities,
+            initial_coefficients,
+            distances,
+            t_hyp_range,
+            weight_factor,
+        )
 
     # optimize the polynomial coefficients with the optimized t_hyp
     optimized_coefficients: ndarray = (
@@ -71,8 +76,8 @@ def calculate_tau_i_values(
 
     # calculate decay times using the optimized coefficients
     tau_i_values: ndarray = (
-            unshifted_intensities
-            / evaluate_differentiated_polynomial_at_measuring_distances(
+        unshifted_intensities
+        / evaluate_differentiated_polynomial_at_measuring_distances(
             distances, optimized_coefficients
         )
     )

napytau/core/tau_final.py

@@ -5,8 +5,9 @@
 from typing import Tuple
 
 
-def calculate_tau_final(tau_i_values: ndarray,
-                        delta_tau_i_values: ndarray) -> Tuple[float, float]:
+def calculate_tau_final(
+    tau_i_values: ndarray, delta_tau_i_values: ndarray
+) -> Tuple[float, float]:
     """
     Computes the final decay time (tau_final) and its associated uncertainty