gh-39892: some care for assert and not in pyx files
    
fixing some suggestions of pycodestyle for code E275

### 📝 Checklist

- [x] The title is concise and informative.
- [x] The description explains in detail what this PR is about.
    
URL: #39892
Reported by: Frédéric Chapoton
Reviewer(s): David Coudert

Author: Release Manager

src/sage/combinat/designs/orthogonal_arrays_find_recursive.pyx

@@ -292,9 +292,9 @@ cpdef find_construction_3_3(int k, int n):
         (11, 11, 16, 1)
         sage: find_construction_3_3(12,11)
     """
-    cdef int mm,nn,i
+    cdef int mm, nn, i
     for mm in range(k-1, n//2+1):
-        if not(is_available(k, mm) and is_available(k, mm + 1)):
+        if not (is_available(k, mm) and is_available(k, mm + 1)):
             continue
 
         for nn in range(2, n//mm+1):

src/sage/combinat/posets/hasse_cython.pyx

@@ -116,7 +116,7 @@ class IncreasingChains(RecursivelyEnumeratedSet_forest):
             return True
         if self._conversion is not None:
             tup = [self._from_poset[elt] for elt in tup]
-        if any(not(0 <= i < self._n) for i in tup):
+        if not all(0 <= i < self._n for i in tup):
             return False
         y = tup[0]
         for k in range(1, len(tup)):

src/sage/combinat/rigged_configurations/rigged_partition.pyx

@@ -134,7 +134,7 @@ cdef class RiggedPartition(SageObject):
         """
         # If it is empty, return saying so
         if not self._list:
-            return("(/)\n")
+            return "(/)\n"
 
         from sage.combinat.partition import Partitions
         if Partitions.options.convention == "French":
@@ -148,7 +148,7 @@ cdef class RiggedPartition(SageObject):
             ret_str += "[ ]"*val
             ret_str += str(self.rigging[i])
             ret_str += "\n"
-        return(ret_str)
+        return ret_str
 
     def _latex_(self):
         r"""
@@ -578,7 +578,7 @@ cdef class RiggedPartitionTypeB(RiggedPartition):
         """
         # If it is empty, return saying so
         if not self._list:
-            return("(/)\n")
+            return "(/)\n"
 
         from sage.combinat.partition import Partitions
         if Partitions.options.convention == "french":
@@ -599,7 +599,7 @@ cdef class RiggedPartitionTypeB(RiggedPartition):
             ret_str += box_str*val
             ret_str += str(self.rigging[i])
             ret_str += "\n"
-        return(ret_str)
+        return ret_str
 
     def _latex_(self):
         r"""

src/sage/crypto/boolean_function.pyx

@@ -100,7 +100,7 @@ cdef long yellow_code(unsigned long a) noexcept:
     cdef unsigned long s = (8*sizeof(unsigned long)) >> 1
     cdef unsigned long m = (~0UL) >> s
     cdef unsigned long r = a
-    while(s):
+    while s:
         sig_check()
         r ^= (r&m) << s
         s >>= 1

src/sage/graphs/path_enumeration.pyx

@@ -1855,7 +1855,7 @@ def all_paths_iterator(self, starting_vertices=None, ending_vertices=None,
             idx_to_path[idx] = path
             pq.push((-len(path), idx))
             idx = idx + 1
-        except(StopIteration):
+        except StopIteration:
             pass
     # Since we always extract a shortest path, using a heap
     # can speed up the algorithm
@@ -1875,7 +1875,7 @@ def all_paths_iterator(self, starting_vertices=None, ending_vertices=None,
             idx_to_path[idx] = path
             pq.push((-len(path), idx))
             idx = idx + 1
-        except(StopIteration):
+        except StopIteration:
             pass
 
 

src/sage/graphs/strongly_regular_db.pyx

@@ -2617,8 +2617,8 @@ def SRG_630_85_20_10():
     hs = HoffmanSingletonGraph()
     P = list(range(5)) + list(range(30, 35))  # a Petersen in hs
     mc = [0, 1, 5, 6, 12, 13, 16, 17, 22, 23, 29, 33, 39, 42, 47]
-    assert(hs.subgraph(mc).is_regular(k=0))  # a maximum coclique
-    assert(hs.subgraph(P).is_regular(k=3))
+    assert hs.subgraph(mc).is_regular(k=0)  # a maximum coclique
+    assert hs.subgraph(P).is_regular(k=3)
     h = hs.automorphism_group().stabilizer(mc, action='OnSets')
     l = h.orbit(tuple((x[0], x[1]) for x in hs.subgraph(P).matching()),
                 "OnSetsSets")

src/sage/groups/perm_gps/permgroup_element.pyx

@@ -565,7 +565,7 @@ cdef class PermutationGroupElement(MultiplicativeGroupElement):
             ('b','c')
         """
         cdef int i, j, vn = len(v)
-        assert(vn <= self.n)
+        assert vn <= self.n
         if convert:
             convert_dict = self._parent._domain_to_gap
             for i in range(len(v)):

src/sage/libs/singular/function.pyx

@@ -629,19 +629,19 @@ cdef class Converter(SageObject):
             3
         """
         cdef leftv * v
-        v=self.args
+        v = self.args
         cdef int l
-        l=0
+        l = 0
         while v != NULL:
-            l=l+1
-            v=v.next
+            l += 1
+            v = v.next
         return l
 
     cdef leftv* pop_front(self) except NULL:
         """
         Pop a Singular element from the front of the list.
         """
-        assert(self.args != NULL)
+        assert self.args != NULL
         cdef leftv *res = self.args
         self.args = self.args.next
         res.next = NULL

src/sage/libs/singular/ring.pyx

@@ -579,9 +579,9 @@ cdef ring *singular_ring_new(base_ring, n, names, term_order) except NULL:
     _ring.ShortOut = 0
 
     if order.is_local():
-        assert(_ring.OrdSgn == -1)
+        assert _ring.OrdSgn == -1
     if order.is_global():
-        assert(_ring.OrdSgn == 1)
+        assert _ring.OrdSgn == 1
 
     return _ring
 

src/sage/matrix/matrix0.pyx

@@ -531,7 +531,7 @@ cdef class Matrix(sage.structure.element.Matrix):
             sage: A.is_mutable()
             False
         """
-        return not(self._is_immutable)
+        return not self._is_immutable
 
     ###########################################################
     # Entry access
@@ -5140,9 +5140,9 @@ cdef class Matrix(sage.structure.element.Matrix):
             fac = o1.factor()
             S = sum((pi - 1) * pi**(ei - 1) for pi, ei in fac)
             if fac[0] == (2, 1):
-                impossible_order = not(S <= n + 1)
+                impossible_order = S > n + 1
             else:
-                impossible_order = not(S <= n)
+                impossible_order = S > n
             if impossible_order:
                 return Infinity