[Python] Implement ruff linter suggestions

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

@@ -8,9 +8,9 @@
 # For the list of contributors see $ROOTSYS/README/CREDITS.                    #
 ################################################################################
 
-from . import pythonization
 import cppyy
 
+from . import pythonization
 
 # Python-list-like methods
 

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

@@ -10,9 +10,6 @@
 
 from . import pythonization
 
-import sys
-
-
 # Item access
 
 def _check_type(idx, msg):
@@ -22,7 +19,7 @@ def _check_type(idx, msg):
     allowed_types = (int,)
 
     t = type(idx)
-    if not t in allowed_types:
+    if t not in allowed_types:
         raise TypeError(msg.format(t.__name__))
 
 def _check_index(self, idx):
@@ -223,10 +220,11 @@ def _sort_pyz(self, *args, **kwargs):
         self.Sort()
     else:
         # Sort in a Python list copy
-        l = list(self)
-        l.sort(*args, **kwargs)
+        pylist = list(self)
+        pylist.sort(*args, **kwargs)
         self.Clear()
-        self.extend(l)
+        self.extend(pylist)
+
 
 def _index_pyz(self, val):
     # Parameters:

bindings/pyroot/pythonizations/test/tseqcollection_itemaccess.py

@@ -87,18 +87,18 @@ def test_getitem_slice(self):
 
     def test_setitem(self):
         sc = self.create_tseqcollection()
-        l = []
+        l1 = []
 
         # Set items
         for i in range(self.num_elems):
             o = ROOT.TObject()
             sc[i] = o
-            l.append(o)
+            l1.append(o)
 
         # Check previously set items
         it = ROOT.TIter(sc)
         for i in range(self.num_elems):
-            self.assertEqual(it.Next(), l[i])
+            self.assertEqual(it.Next(), l1[i])
 
         # Set items, negative indices
         l2 = []
@@ -135,16 +135,16 @@ def test_setitem_slice(self):
 
         # Append items
         sc1 = self.create_tseqcollection()
-        l = [ elem for elem in sc1 ]
+        l1 = [elem for elem in sc1]
 
         sc1[self.num_elems:] = sc2
 
         self.assertEqual(sc1.GetEntries(), 2 * self.num_elems)
         i = 0
-        for elem in l: # first half
+        for elem in l1:  # first half
             self.assertEqual(sc1[i], elem)
             i += 1
-        for elem in sc2: # second half
+        for elem in sc2:  # second half
             self.assertEqual(sc1[i], elem)
             i += 1
 

bindings/pyroot/pythonizations/test/tseqcollection_listmethods.py

@@ -24,10 +24,10 @@ def test_insert(self):
         sc = self.create_tseqcollection()
 
         # Insert with positive index
-        o = ROOT.TObject()
-        sc.insert(1, o)
+        o1 = ROOT.TObject()
+        sc.insert(1, o1)
         self.assertEqual(sc.GetEntries(), self.num_elems + 1)
-        self.assertEqual(sc.At(1), o)
+        self.assertEqual(sc.At(1), o1)
 
         # Insert with negative index (starts from end)
         o2 = ROOT.TObject()
@@ -51,18 +51,18 @@ def test_insert(self):
 
     def test_pop(self):
         sc = self.create_tseqcollection()
-        l = [ elem for elem in sc ]
+        l1 = [elem for elem in sc]
 
         # No arguments, pop last item
-        self.assertEqual(sc.pop(), l[-1])
+        self.assertEqual(sc.pop(), l1[-1])
         self.assertEqual(sc.GetEntries(), self.num_elems - 1)
 
         # Pop first item, positive index
-        self.assertEqual(sc.pop(0), l[0])
+        self.assertEqual(sc.pop(0), l1[0])
         self.assertEqual(sc.GetEntries(), self.num_elems - 2)
 
         # Pop last item, negative index
-        self.assertEqual(sc.pop(-1), l[1])
+        self.assertEqual(sc.pop(-1), l1[1])
         self.assertEqual(sc.GetEntries(), self.num_elems - 3)
 
         # Pop from empty collection
@@ -83,19 +83,19 @@ def test_pop(self):
             sc2.pop(1.0)
 
         # Pop a repeated element
-        sc2.append(ROOT.TObjString('2'))
+        sc2.append(ROOT.TObjString("2"))
         elem = sc2.pop()
         self.assertEqual(sc2.At(0), elem)
 
     def test_reverse(self):
         sc = self.create_tseqcollection()
-        l = [ elem for elem in sc ]
+        l1 = [elem for elem in sc]
 
         sc.reverse()
 
         self.assertEqual(sc.GetEntries(), self.num_elems)
         for i,elem in zip(range(self.num_elems), sc):
-            self.assertEqual(elem, l[-(i+1)])
+            self.assertEqual(elem, l1[-(i + 1)])
 
         # Empty collection
         sc2 = ROOT.TList()
@@ -104,25 +104,27 @@ def test_reverse(self):
 
     def test_sort(self):
         sc = self.create_tseqcollection()
-        l = [ elem for elem in sc ]
+        l1 = [elem for elem in sc]
 
         # Regular sort, rely on TList::Sort
         sc.sort()
         # We need to set `key` until the pythonization to
         # make TObjString comparable is there
-        l.sort(key = lambda s: s.GetName())
+        l1.sort(key=lambda s: s.GetName())
 
         self.assertEqual(sc.GetEntries(), self.num_elems)
-        self.assertEqual(l[0], sc[0])
-        for el1, el2 in zip(sc, l):
+        self.assertEqual(l1[0], sc[0])
+        for el1, el2 in zip(sc, l1):
             self.assertEqual(el1, el2)
 
         # Python sort, key and reverse arguments.
         # Sort by hash in reverse order
         sc2 = self.create_tseqcollection()
         l2 = [ elem for elem in sc2 ]
 
-        fsort = lambda elem: elem.Hash()
+        def fsort(elem):
+            return elem.Hash()
+
         rev = True
         sc2.sort(key = fsort, reverse = rev)
         l2.sort(key = fsort, reverse = rev)
@@ -144,9 +146,9 @@ def test_index(self):
             self.assertEqual(sc.index(elem), i)
 
         # Check element not in collection
-        o = ROOT.TObjString(str(self.num_elems))
+        o1 = ROOT.TObjString(str(self.num_elems))
         with self.assertRaises(ValueError):
-            sc.index(o)
+            sc.index(o1)
 
 
 if __name__ == '__main__':