[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

light-curve/light_curve/light_curve_py/features/rainbow/_base.py

@@ -1,5 +1,4 @@
 from abc import abstractmethod
-from copy import deepcopy
 from dataclasses import dataclass
 from typing import Dict, List, Tuple
 
@@ -155,7 +154,7 @@ def _parameter_scalings(self) -> Dict[str, str]:
         if self.with_baseline:
             for band_name in self.bands.names:
                 baseline_name = self.p.baseline_parameter_name(band_name)
-                rules[baseline_name] = 'baseline'
+                rules[baseline_name] = "baseline"
 
         return rules
 
@@ -171,7 +170,7 @@ def _parameter_scale(self, name: str, t_scaler: Scaler, m_scaler: MultiBandScale
 
     def _unscale_parameters(self, params, t_scaler: Scaler, m_scaler: MultiBandScaler) -> None:
         """Unscale parameters from internal units, in-place."""
-        for name,scaling in self._parameter_scalings().items():
+        for name, scaling in self._parameter_scalings().items():
             if scaling == "time":
                 params[self.p[name]] = t_scaler.undo_shift_scale(params[self.p[name]])
 
@@ -305,12 +304,17 @@ def _eval_and_fill(self, *, t, m, sigma, band, fill_value):
         return super()._eval_and_fill(t=t, m=m, sigma=sigma, band=band, fill_value=fill_value)
 
     def _eval_and_get_errors(
-            self, *, t, m, sigma, band,
-            upper_mask=None,
-            get_initial=False,
-            return_covariance=False,
-            print_level=None,
-            debug=False
+        self,
+        *,
+        t,
+        m,
+        sigma,
+        band,
+        upper_mask=None,
+        get_initial=False,
+        return_covariance=False,
+        print_level=None,
+        debug=False,
     ):
         # Initialize data scalers
         t_scaler = Scaler.from_time(t)
@@ -352,7 +356,7 @@ def _eval_and_get_errors(
         # TODO: expose these parameters through function arguments
         if print_level is not None:
             minuit.print_level = print_level
-        minuit.strategy = 0 # We will need to manually call .hesse() on convergence anyway
+        minuit.strategy = 0  # We will need to manually call .hesse() on convergence anyway
 
         # Supposedly it is not the same as just setting iterate=10?..
         for i in range(10):
@@ -372,10 +376,17 @@ def _eval_and_get_errors(
             # Expose everything we have to outside, unscaled, for easier debugging
             self.minuit = minuit
             self.mparams = {
-                't':t, 'band_idx':band_idx, 'wave_cm':wave_cm, 'm':m, 'sigma':sigma,
-                'limits':limits, 'upper_mask':upper_mask,
-                'initial_guesses':initial_guesses, 'values':minuit.values, 'errors':minuit.errors,
-                'covariance':minuit.covariance,
+                "t": t,
+                "band_idx": band_idx,
+                "wave_cm": wave_cm,
+                "m": m,
+                "sigma": sigma,
+                "limits": limits,
+                "upper_mask": upper_mask,
+                "initial_guesses": initial_guesses,
+                "values": minuit.values,
+                "errors": minuit.errors,
+                "covariance": minuit.covariance,
             }
 
         if not minuit.valid and self.fail_on_divergence and not get_initial:

light-curve/light_curve/light_curve_py/features/rainbow/_parameters.py

@@ -14,7 +14,7 @@ def baseline_parameter_name(band: str) -> str:
 
 def baseline_band_name(name: str) -> str:
     if name.startswith("baseline_"):
-        return name[len("baseline_"):]
+        return name[len("baseline_") :]
 
     return None
 

light-curve/light_curve/light_curve_py/features/rainbow/bolometric.py

@@ -99,7 +99,7 @@ def limits(t, m, sigma, band):
         limits = {}
         limits["reference_time"] = (np.min(t) - 10 * t_amplitude, np.max(t) + 10 * t_amplitude)
         limits["amplitude"] = (0.0, 20 * m_amplitude)
-        limits["rise_time"] = (0.1*mean_dt, 10*t_amplitude)
+        limits["rise_time"] = (0.1 * mean_dt, 10 * t_amplitude)
 
         return limits
 
@@ -141,7 +141,7 @@ def value(t, t0, amplitude, rise_time, fall_time):
     def initial_guesses(t, m, sigma, band):
         A = np.ptp(m)
 
-        mc = m - np.min(m) # To avoid crashing on all-negative data
+        mc = m - np.min(m)  # To avoid crashing on all-negative data
 
         # Naive peak position from the highest point
         t0 = t[np.argmax(m)]
@@ -176,8 +176,8 @@ def limits(t, m, sigma, band):
         limits = {}
         limits["reference_time"] = (np.min(t) - 10 * t_amplitude, np.max(t) + 10 * t_amplitude)
         limits["amplitude"] = (0.0, 20 * m_amplitude)
-        limits["rise_time"] = (0.1*mean_dt, 10 * t_amplitude)
-        limits["fall_time"] = (0.1*mean_dt, 10 * t_amplitude)
+        limits["rise_time"] = (0.1 * mean_dt, 10 * t_amplitude)
+        limits["fall_time"] = (0.1 * mean_dt, 10 * t_amplitude)
 
         return limits
 

light-curve/light_curve/light_curve_py/minuit_ml.py

@@ -3,41 +3,45 @@
 from typing import Callable, Dict, Tuple
 
 import numpy as np
-from scipy.stats import norm
 from scipy.special import erf
 
-import numba as nb
 
 def logpdf(x, mu, sigma):
     # We do not need second term as it does not depend on parameters
-    return -(((x - mu)/sigma)**2)/2 # - np.log(np.sqrt(2*np.pi) * sigma)
+    return -(((x - mu) / sigma) ** 2) / 2  # - np.log(np.sqrt(2*np.pi) * sigma)
+
 
 def barrier(x):
-    res = np.where(x>0, 1/x, np.inf) # FIXME: naive barrier function
+    res = np.where(x > 0, 1 / x, np.inf)  # FIXME: naive barrier function
 
     return res
 
+
 def logcdf(x):
     # TODO: faster (maybe not so accurate, as we do not need it) implementation
     # return norm.logcdf(x)
 
     result = np.zeros(len(x))
 
     idx = x < -5
-    result[idx] = -x[idx]**2/2 - 1/x[idx]**2 - 0.9189385336 - np.log(-x[idx])
-    result[~idx] = np.log(0.5) + np.log1p(erf(x[~idx]/np.sqrt(2)))
+    result[idx] = -x[idx] ** 2 / 2 - 1 / x[idx] ** 2 - 0.9189385336 - np.log(-x[idx])
+    result[~idx] = np.log(0.5) + np.log1p(erf(x[~idx] / np.sqrt(2)))
 
     return result
 
+
 try:
     from iminuit import Minuit
 except ImportError:
     MaximumLikelihood = None
 else:
+
     class MaximumLikelihood:
         errordef = Minuit.LIKELIHOOD
 
-        def __init__(self, model: Callable, parameters: Dict[str, Tuple[float, float]], upper_mask=None, *, x, y, yerror):
+        def __init__(
+            self, model: Callable, parameters: Dict[str, Tuple[float, float]], upper_mask=None, *, x, y, yerror
+        ):
             self.model = model
             self.x = x
             self.y = y
@@ -59,22 +63,23 @@ def __call__(self, *par):
             ym = self.model(self.x, *par)
 
             if self.upper_mask is None:
-                result = -np.sum(logpdf(self.y,  ym, self.yerror))
+                result = -np.sum(logpdf(self.y, ym, self.yerror))
             else:
                 # Measurements
-                result = -np.sum(logpdf(self.y[~self.upper_mask],  ym[~self.upper_mask], self.yerror[~self.upper_mask]))
+                result = -np.sum(logpdf(self.y[~self.upper_mask], ym[~self.upper_mask], self.yerror[~self.upper_mask]))
                 # Upper limits, Tobit model
                 # https://stats.stackexchange.com/questions/49443/how-to-model-this-odd-shaped-distribution-almost-a-reverse-j
                 result += -np.sum(
-                    logcdf((self.y[self.upper_mask] - ym[self.upper_mask])/self.yerror[self.upper_mask])
+                    logcdf((self.y[self.upper_mask] - ym[self.upper_mask]) / self.yerror[self.upper_mask])
                 )
 
             # Barriers around parameter ranges
             # Scale is selected so that for the most of the range it is much smaller
             # than 0.5 which corresponds to 1-sigma errors
-            result += 0.0001 * np.sum(barrier((par - self.limits0)/self.limits_scale))
-            result += 0.0001 * np.sum(barrier((self.limits1 - par)/self.limits_scale))
+            result += 0.0001 * np.sum(barrier((par - self.limits0) / self.limits_scale))
+            result += 0.0001 * np.sum(barrier((self.limits1 - par) / self.limits_scale))
 
             return result
 
+
 __all__ = ["MaximumLikelihood"]