reformat with black (cta-observatory#1345)

* add pre-commit hook for black

* reformat  alll with black

.pre-commit-config.yaml

@@ -0,0 +1,5 @@
+repos:
+  - repo: https://github.com/psf/black
+    rev: 19.3b0
+    hooks:
+      - id: black

ctapipe/__init__.py

@@ -4,4 +4,5 @@
 """
 
 from . import version
+
 __version__ = version.get_version(pep440=False)

ctapipe/analysis/camera/charge_resolution.py

@@ -1,7 +1,7 @@
 import numpy as np
 import pandas as pd
 
-__all__ = ['ChargeResolutionCalculator']
+__all__ = ["ChargeResolutionCalculator"]
 
 
 class ChargeResolutionCalculator:
@@ -41,7 +41,7 @@ def __init__(self, mc_true=True):
         self._df_list = []
         self._df = pd.DataFrame()
         self._n_bytes = 0
-        self._max_bytes = 1E9
+        self._max_bytes = 1e9
 
     @staticmethod
     def rmse_abs(sum_, n):
@@ -57,8 +57,7 @@ def charge_res_abs(true, sum_, n):
 
     @staticmethod
     def charge_res(true, sum_, n):
-        return (ChargeResolutionCalculator.charge_res_abs(true, sum_, n)
-                / np.abs(true))
+        return ChargeResolutionCalculator.charge_res_abs(true, sum_, n) / np.abs(true)
 
     def add(self, pixel, true, measured):
         """
@@ -73,13 +72,8 @@ def add(self, pixel, true, measured):
         measured : ndarray
             1D array containing the measured charge for each entry
         """
-        diff2 = (measured - true)**2
-        df = pd.DataFrame(dict(
-            pixel=pixel,
-            true=true,
-            sum=diff2,
-            n=np.uint32(1)
-        ))
+        diff2 = (measured - true) ** 2
+        df = pd.DataFrame(dict(pixel=pixel, true=true, sum=diff2, n=np.uint32(1)))
         self._df_list.append(df)
         self._n_bytes += df.memory_usage(index=True, deep=True).sum()
         if self._n_bytes > self._max_bytes:
@@ -91,7 +85,7 @@ def _amalgamate(self):
         values per pixel and true charge in order to reduce memory use.
         """
         self._df = pd.concat([self._df, *self._df_list], ignore_index=True)
-        self._df = self._df.groupby(['pixel', 'true']).sum().reset_index()
+        self._df = self._df.groupby(["pixel", "true"]).sum().reset_index()
         self._n_bytes = 0
         self._df_list = []
 
@@ -109,28 +103,28 @@ def finish(self):
         """
         self._amalgamate()
 
-        self._df = self._df.loc[self._df['true'] != 0]
+        self._df = self._df.loc[self._df["true"] != 0]
 
         df_p = self._df.copy()
-        true = df_p['true'].values
-        sum_ = df_p['sum'].values
-        n = df_p['n'].values
+        true = df_p["true"].values
+        sum_ = df_p["sum"].values
+        n = df_p["n"].values
         if self._mc_true:
-            df_p['charge_resolution'] = self.charge_res(true, sum_, n)
-            df_p['charge_resolution_abs'] = self.charge_res_abs(true, sum_, n)
+            df_p["charge_resolution"] = self.charge_res(true, sum_, n)
+            df_p["charge_resolution_abs"] = self.charge_res_abs(true, sum_, n)
         else:
-            df_p['charge_resolution'] = self.rmse(true, sum_, n)
-            df_p['charge_resolution_abs'] = self.rmse_abs(sum_, n)
-        df_c = self._df.copy().groupby('true').sum().reset_index()
-        df_c = df_c.drop(columns='pixel')
-        true = df_c['true'].values
-        sum_ = df_c['sum'].values
-        n = df_c['n'].values
+            df_p["charge_resolution"] = self.rmse(true, sum_, n)
+            df_p["charge_resolution_abs"] = self.rmse_abs(sum_, n)
+        df_c = self._df.copy().groupby("true").sum().reset_index()
+        df_c = df_c.drop(columns="pixel")
+        true = df_c["true"].values
+        sum_ = df_c["sum"].values
+        n = df_c["n"].values
         if self._mc_true:
-            df_c['charge_resolution'] = self.charge_res(true, sum_, n)
-            df_c['charge_resolution_abs'] = self.charge_res_abs(true, sum_, n)
+            df_c["charge_resolution"] = self.charge_res(true, sum_, n)
+            df_c["charge_resolution_abs"] = self.charge_res_abs(true, sum_, n)
         else:
-            df_c['charge_resolution'] = self.rmse(true, sum_, n)
-            df_c['charge_resolution_abs'] = self.rmse_abs(sum_, n)
+            df_c["charge_resolution"] = self.rmse(true, sum_, n)
+            df_c["charge_resolution_abs"] = self.rmse_abs(sum_, n)
 
         return df_p, df_c

ctapipe/analysis/camera/tests/test_charge_resolution.py

@@ -1,5 +1,4 @@
-from ctapipe.analysis.camera.charge_resolution import \
-    ChargeResolutionCalculator
+from ctapipe.analysis.camera.charge_resolution import ChargeResolutionCalculator
 import numpy as np
 from numpy.testing import assert_almost_equal
 
@@ -44,12 +43,14 @@ def test_finish():
     chargeres.add(0, true_charge, measured_charge)
     chargeres.add(0, true_charge, measured_charge)
     df_p, df_c = chargeres.finish()
-    assert np.array_equal(df_p['charge_resolution'].values,
-                          df_c['charge_resolution'].values)
+    assert np.array_equal(
+        df_p["charge_resolution"].values, df_c["charge_resolution"].values
+    )
     chargeres.add(1, true_charge, measured_charge)
     df_p, df_c = chargeres.finish()
-    assert not np.array_equal(df_p['charge_resolution'].values,
-                              df_c['charge_resolution'].values)
+    assert not np.array_equal(
+        df_p["charge_resolution"].values, df_c["charge_resolution"].values
+    )
 
 
 def test_calculation():
@@ -58,43 +59,45 @@ def test_calculation():
     true = 3
     n = measured.size
 
-    sum_ = np.sum((measured - true)**2)
+    sum_ = np.sum((measured - true) ** 2)
     assert_almost_equal(sum_, 0.34, 3)
     assert_almost_equal(chargeres.rmse_abs(sum_, n), 0.412, 3)
     assert_almost_equal(chargeres.rmse(true, sum_, n), 0.137, 3)
     assert_almost_equal(chargeres.charge_res_abs(true, sum_, n), 1.780, 3)
     assert_almost_equal(chargeres.charge_res(true, sum_, n), 0.593, 3)
 
     assert chargeres.rmse_abs(sum_, n) == chargeres.rmse(true, sum_, n) * true
-    assert (chargeres.charge_res_abs(true, sum_, n) ==
-            chargeres.charge_res(true, sum_, n) * true)
+    assert (
+        chargeres.charge_res_abs(true, sum_, n)
+        == chargeres.charge_res(true, sum_, n) * true
+    )
 
 
 def test_result():
     charge_res = ChargeResolutionCalculator(mc_true=False)
     measured = np.array([3.5, 2.7])
     true = 3
     n = measured.size
-    sum_ = np.sum((measured - true)**2)
+    sum_ = np.sum((measured - true) ** 2)
 
     charge_res.add(0, true, measured)
     df_p, df_c = charge_res.finish()
-    resolution = df_p['charge_resolution'].values[0]
-    assert (resolution == charge_res.rmse(true, sum_, n))
-    resolution_abs = df_p['charge_resolution_abs'].values[0]
-    assert (resolution_abs == charge_res.rmse_abs(sum_, n))
+    resolution = df_p["charge_resolution"].values[0]
+    assert resolution == charge_res.rmse(true, sum_, n)
+    resolution_abs = df_p["charge_resolution_abs"].values[0]
+    assert resolution_abs == charge_res.rmse_abs(sum_, n)
 
 
 def test_result_mc_true():
     chargeres = ChargeResolutionCalculator()
     measured = np.array([3.5, 2.7])
     true = 3
     n = measured.size
-    sum_ = np.sum((measured - true)**2)
+    sum_ = np.sum((measured - true) ** 2)
 
     chargeres.add(0, true, measured)
     df_p, df_c = chargeres.finish()
-    assert (df_p['charge_resolution'].values[0] ==
-            chargeres.charge_res(true, sum_, n))
-    assert (df_p['charge_resolution_abs'].values[0] ==
-            chargeres.charge_res_abs(true, sum_, n))
+    assert df_p["charge_resolution"].values[0] == chargeres.charge_res(true, sum_, n)
+    assert df_p["charge_resolution_abs"].values[0] == chargeres.charge_res_abs(
+        true, sum_, n
+    )

ctapipe/calib/camera/__init__.py

@@ -6,4 +6,4 @@
 from .calibrator import CameraCalibrator
 from .gainselection import GainSelector
 
-__all__ = ['CameraCalibrator', 'GainSelector']
+__all__ = ["CameraCalibrator", "GainSelector"]

ctapipe/calib/camera/calibrator.py

@@ -25,7 +25,7 @@ def __init__(
         parent=None,
         data_volume_reducer=None,
         image_extractor=None,
-        **kwargs
+        **kwargs,
     ):
         """
         Parameters
@@ -100,7 +100,8 @@ def _calibrate_dl0(self, event, telid):
             return
 
         reduced_waveforms_mask = self.data_volume_reducer(
-            waveforms, telid=telid, selected_gain_channel=selected_gain_channel)
+            waveforms, telid=telid, selected_gain_channel=selected_gain_channel
+        )
 
         waveforms_copy = waveforms.copy()
         waveforms_copy[~reduced_waveforms_mask] = 0