ruff format

Author: siliataider

bindings/pyroot/pythonizations/python/ROOT/_pythonization/_th1.py

@@ -51,7 +51,7 @@
 myResult.Parameters()
 
 # Get the error of the first parameter
-myResult.ParError(0) 
+myResult.ParError(0)
 \endcode
 
 
@@ -80,10 +80,10 @@ def myGaussian(x, pars):
     '''
     Defines a Gaussian function
     '''
-    return pars[0]*np.exp(-0.5* pow(x[0] - pars[1], 2)) 
+    return pars[0]*np.exp(-0.5* pow(x[0] - pars[1], 2))
 
 # Initialize from the Python function with the range -5 to +5, with two parameters to fit, and a one-dimensional input x
-myTF1 = ROOT.TF1("myFunction", myGaussian, -5, 5, npar=2, ndim=1) 
+myTF1 = ROOT.TF1("myFunction", myGaussian, -5, 5, npar=2, ndim=1)
 
 # Create a 1D histogram and initialize it with the built-in ROOT Gaussian "gaus"
 myTH1D = ROOT.TH1D("th1d", "Test", 200, -5, 5)
@@ -176,6 +176,7 @@ def myGaussian(x, pars):
 
 # Multiplication by constant
 
+
 def _imul(self, c):
     # Parameters:
     # - self: histogram
@@ -185,6 +186,7 @@ def _imul(self, c):
     self.Scale(c)
     return self
 
+
 # Fill with array-like data
 def _FillWithArrayTH1(self, *args):
     """
@@ -216,12 +218,10 @@ def _FillWithArrayTH1(self, *args):
     data = np.asanyarray(args[0], dtype=np.float64)
     n = len(data)
 
-    if len(args) >=2 and args[1] is not None:
+    if len(args) >= 2 and args[1] is not None:
         weights = np.asanyarray(args[1], dtype=np.float64)
         if len(weights) != n:
-            raise ValueError(
-                f"Length mismatch: data length ({n}) != weights length ({len(weights)})"
-            )
+            raise ValueError(f"Length mismatch: data length ({n}) != weights length ({len(weights)})")
     else:
         weights = np.ones(n)
 
@@ -254,7 +254,7 @@ def _enable_numpy_fill(klass):
         klass.Fill = _FillWithArrayTH1
 
 
-@pythonization('TH1')
+@pythonization("TH1")
 def pythonize_th1(klass):
     # Parameters:
     # klass: class to be pythonized

bindings/pyroot/pythonizations/python/ROOT/_pythonization/_th2.py

@@ -8,9 +8,10 @@
 # For the list of contributors see $ROOTSYS/README/CREDITS.                    #
 ################################################################################
 
-from . import pythonization
 from ROOT._pythonization._memory_utils import inject_constructor_releasing_ownership
 
+from . import pythonization
+
 
 # Fill with array-like data
 def _FillWithArrayTH2(self, *args):
@@ -47,23 +48,20 @@ def _FillWithArrayTH2(self, *args):
     y = np.asanyarray(args[1], dtype=np.float64)
 
     if len(x) != len(y):
-        raise ValueError(
-            f"Length mismatch: x length ({len(x)}) != y length ({len(y)})"
-        )
+        raise ValueError(f"Length mismatch: x length ({len(x)}) != y length ({len(y)})")
 
     n = len(x)
 
-    if len(args) >=3 and args[2] is not None:
+    if len(args) >= 3 and args[2] is not None:
         weights = np.asanyarray(args[2], dtype=np.float64)
         if len(weights) != n:
-            raise ValueError(
-                f"Length mismatch: data length ({n}) != weights length ({len(weights)})"
-            )
+            raise ValueError(f"Length mismatch: data length ({n}) != weights length ({len(weights)})")
     else:
         weights = np.ones(n)
 
     return self.FillN(n, x, y, weights)
 
+
 # The constructors need to be pythonized for each derived class separately:
 _th2_derived_classes_to_pythonize = [
     "TH2C",

bindings/pyroot/pythonizations/test/th2_fillN.py

@@ -28,10 +28,7 @@ def _run_fill_test(self, x_data, y_data):
 
         for i in range(nbins):
             for j in range(nbins):
-                self.assertAlmostEqual(
-                    verbose_hist.GetBinContent(i, j),
-                    simple_hist.GetBinContent(i, j)
-                )
+                self.assertAlmostEqual(verbose_hist.GetBinContent(i, j), simple_hist.GetBinContent(i, j))
 
         # Test filling with weights
         weights_np = np.linspace(0.1, 0.9, n)
@@ -42,10 +39,7 @@ def _run_fill_test(self, x_data, y_data):
 
         for i in range(nbins):
             for j in range(nbins):
-                self.assertAlmostEqual(
-                    verbose_hist.GetBinContent(i, j),
-                    simple_hist.GetBinContent(i, j)
-                )
+                self.assertAlmostEqual(verbose_hist.GetBinContent(i, j), simple_hist.GetBinContent(i, j))
 
         # Test mismatched weight size
         with self.assertRaises(ValueError):
@@ -56,10 +50,10 @@ def test_fill_arraylike(self):
         import numpy as np
 
         inputs = [
-            (np.array([1., 2, 3, 4, 5]), np.array([5., 4, 3, 2, 1])),
-            ([1., 2, 3, 4, 5], [5., 4, 3, 2, 1]),
+            (np.array([1.0, 2, 3, 4, 5]), np.array([5.0, 4, 3, 2, 1])),
+            ([1.0, 2, 3, 4, 5], [5.0, 4, 3, 2, 1]),
             (range(1, 6), range(5, 0, -1)),
-            ([1., 2, 3, 4, 5], np.array([5., 4, 3, 2, 1])),
+            ([1.0, 2, 3, 4, 5], np.array([5.0, 4, 3, 2, 1])),
         ]
 
         for x_data, y_data in inputs: