black formatting

src/periodicity/core.py

@@ -148,7 +148,7 @@ def from_xray(self, result):
         return type(self)(result)
 
     def __array_function__(self, func, types, args, kwargs):
-        """"https://numpy.org/doc/stable/reference/arrays.classes.html#numpy.class.__array_function__"""
+        """https://numpy.org/doc/stable/reference/arrays.classes.html#numpy.class.__array_function__"""
         if func not in HANDLED_FUNCTIONS:
             return NotImplemented
         if not all(issubclass(t, Signal) for t in types):
@@ -418,14 +418,14 @@ def smooth(self, width, kernel="gaussian", **kwargs):
             xf = ndimage.gaussian_filter(self.values, sigma=width, **kwargs)
         elif kernel == "boxcar":
             if width % 2 == 0:
-                weight = np.ones((width + 1,) * self.ndim) / width ** self.ndim
+                weight = np.ones((width + 1,) * self.ndim) / width**self.ndim
                 edges = [slice(None)] * self.ndim
                 for i in range(self.ndim):
                     edges[i] = [0, -1]
                     weight[tuple(edges)] /= 2
                     edges[i] = slice(None)
             else:
-                weight = np.ones((width,) * self.ndim) / width ** self.ndim
+                weight = np.ones((width,) * self.ndim) / width**self.ndim
             xf = self.convolve(weight).values
         elif kernel == "triangle":
             half = int(width // 2)

src/periodicity/data/__init__.py

@@ -167,7 +167,7 @@ def DuffingWave():
     """
     t = np.arange(1024)
     data = np.exp(-t / 256) * np.cos(
-        (np.pi / 64) * (t ** 2 / 512 + 32)
-        + 0.3 * np.sin((np.pi / 32) * (t ** 2 / 512 + 32))
+        (np.pi / 64) * (t**2 / 512 + 32)
+        + 0.3 * np.sin((np.pi / 32) * (t**2 / 512 + 32))
     )
     return data

src/periodicity/gp.py

@@ -1,10 +1,10 @@
-import celerite2
 # import celerite2.pymc4
+# import pymc as pm
+# import pymc_ext as pmx
+import celerite2
 import emcee
 import george
 import numpy as np
-# import pymc as pm
-# import pymc_ext as pmx
 from scipy.optimize import minimize
 from scipy.stats import norm
 
@@ -361,7 +361,7 @@ def period_ppf(u):
         mean = init_params.pop("mean")
         jitter = init_params.pop("jitter")
         self.gp = celerite2.GaussianProcess(self.kernel(**init_params), mean=mean)
-        self.gp.compute(self.t, diag=self.err ** 2 + jitter)
+        self.gp.compute(self.t, diag=self.err**2 + jitter)
 
     def prior_transform(self, u):
         raise NotImplementedError("subclasses must implement this method")
@@ -370,7 +370,7 @@ def set_params(self, params, gp):
         gp.mean = params.pop("mean")
         jitter = params.pop("jitter")
         gp.kernel = self.kernel(**params)
-        gp.compute(self.t, diag=self.err ** 2 + jitter, quiet=True)
+        gp.compute(self.t, diag=self.err**2 + jitter, quiet=True)
         return gp
 
     def get_psd(self, frequency, gp):
@@ -390,7 +390,7 @@ def loocv(self, gp):
         q = gp._do_solve(r[:, np.newaxis])[:, 0]
         c = gp._do_solve(np.eye(self.signal.size)).diagonal()
         return -0.5 * (
-            np.sum(q ** 2 / c)
+            np.sum(q**2 / c)
             - np.sum(np.log(c))
             + self.signal.size * np.log(2 * np.pi)
         )
@@ -488,9 +488,9 @@ class BrownianTerm(celerite2.terms.TermSum):
     def __init__(self, sigma, tau, period, mix):
         Q = 0.01
         sigma_1 = sigma * np.sqrt(mix)
-        f = np.sqrt(1 - 4 * Q ** 2)
+        f = np.sqrt(1 - 4 * Q**2)
         w0 = 2 * Q / (tau * (1 - f))
-        S0 = (1 - mix) * sigma ** 2 / (0.5 * w0 * Q * (1 + 1 / f))
+        S0 = (1 - mix) * sigma**2 / (0.5 * w0 * Q * (1 + 1 / f))
         super().__init__(
             celerite2.terms.SHOTerm(sigma=sigma_1, tau=tau, rho=period),
             celerite2.terms.SHOTerm(S0=S0, w0=w0, Q=Q),

src/periodicity/phase.py

@@ -163,7 +163,7 @@ def __call__(self, signal):
         self.t = signal.time
         self.x = signal.values
         self.sigma = np.var(signal.values, ddof=1)
-        theta_crit = 1.0 - 11.0 / signal.size ** 0.8
+        theta_crit = 1.0 - 11.0 / signal.size**0.8
         t0 = signal.baseline
         if self.p_min is None:
             p_min = 2 * signal.median_dt

src/periodicity/spectral.py

@@ -99,7 +99,7 @@ def __call__(self, signal, err=None, fit_mean=True):
         if err is None:
             err = np.ones_like(signal.values)
         self.err = err
-        w = err ** -2.0
+        w = err**-2.0
         w /= w.sum()
         t = signal.time
         if fit_mean:
@@ -117,7 +117,7 @@ def __call__(self, signal, err=None, fit_mean=True):
         C2w = 1 / np.sqrt(1 + tan_2omega_tau * tan_2omega_tau)
         Cw = np.sqrt(0.5) * np.sqrt(1 + C2w)
         Sw = np.sqrt(0.5) * np.sign(S2w) * np.sqrt(1 - C2w)
-        YY = np.dot(w, y ** 2)
+        YY = np.dot(w, y**2)
         YC = Ch * Cw + Sh * Sw
         YS = Sh * Cw - Ch * Sw
         CC = 0.5 * (1 + C2 * C2w + S2 * S2w)
@@ -127,7 +127,7 @@ def __call__(self, signal, err=None, fit_mean=True):
             SS -= (S * Cw - C * Sw) ** 2
         power = YC * YC / CC + YS * YS / SS
         if self.psd:
-            power *= 0.5 * (err ** -2.0).sum()
+            power *= 0.5 * (err**-2.0).sum()
         else:
             power /= YY
         self.signal = signal
@@ -183,7 +183,7 @@ def model(self, tf, f0):
         """
         t = self.signal.time
         y = self.signal.values
-        w = self.err ** -2.0
+        w = self.err**-2.0
         y_mean = np.dot(y, w) / w.sum()
         y = y - y_mean
         X = (

src/periodicity/timefrequency.py

@@ -109,7 +109,7 @@ def __call__(self, signal):
                 if self.method == "DQ":
                     A, F = self._normalize(mode)
                     amp = A.values
-                    phi = np.arctan2(np.sqrt(1 - F.values ** 2), F.values)
+                    phi = np.arctan2(np.sqrt(1 - F.values**2), F.values)
                     corr = np.sign(np.gradient(phi))
                     phi = np.unwrap(phi * corr)
                     freq = np.gradient(phi, F.time)
@@ -163,7 +163,7 @@ def reconstruct(coefs, periods, dt, family):
     scales = pywt.scale2frequency(family, 1) * periods / dt
     mwf = pywt.ContinuousWavelet("morl").wavefun()
     y_0 = mwf[0][np.argmin(np.abs(mwf[1]))]
-    r_sum = np.transpose(np.sum(np.transpose(coefs) / scales ** 0.5, axis=-1))
+    r_sum = np.transpose(np.sum(np.transpose(coefs) / scales**0.5, axis=-1))
     return r_sum * (1 / y_0)
 
 

tests/test_gp.py

@@ -2,7 +2,7 @@
 
 from periodicity.core import TSeries
 from periodicity.data import SpottedStar
-from periodicity.gp import BrownianGP, HarmonicGP, QuasiPeriodicGP, make_gaussian_prior
+from periodicity.gp import BrownianGP, HarmonicGP, make_gaussian_prior
 
 
 def test_make_gaussian_prior_spotted_lc():