gh-35687: some fixes for pycodestyle E275
    
<!-- Please provide a concise, informative and self-explanatory title.
-->
<!-- Don't put issue numbers in the title. Put it in the Description
below. -->
<!-- For example, instead of "Fixes #12345", use "Add a new method to
multiply two integers" -->

### 📚 Description

This fixes some E275 warnings (E275 missing whitespace after keyword)
plus a few other things

outside of `graphs`, `rings`, `misc`, `coding`  and `combinat` for now

<!-- Describe your changes here in detail. -->
<!-- Why is this change required? What problem does it solve? -->
<!-- If this PR resolves an open issue, please link to it here. For
example "Fixes #12345". -->
<!-- If your change requires a documentation PR, please link it
appropriately. -->

### 📝 Checklist

<!-- Put an `x` in all the boxes that apply. It should be `[x]` not `[x
]`. -->

- [ ] The title is concise, informative, and self-explanatory.
- [ ] The description explains in detail what this PR is about.
- [ ] I have linked a relevant issue or discussion.
- [ ] I have created tests covering the changes.
- [ ] I have updated the documentation accordingly.

### ⌛ Dependencies

<!-- List all open PRs that this PR logically depends on
- #12345: short description why this is a dependency
- #34567: ...
-->

<!-- If you're unsure about any of these, don't hesitate to ask. We're
here to help! -->
    
URL: #35687
Reported by: Frédéric Chapoton
Reviewer(s): Frédéric Chapoton, Matthias Köppe

Author: Release Manager

src/sage/algebras/lie_conformal_algebras/weyl_lie_conformal_algebra.py

@@ -23,21 +23,22 @@
 - Reimundo Heluani (2019-08-09): Initial implementation.
 """
 
-#******************************************************************************
+# *****************************************************************************
 #       Copyright (C) 2019 Reimundo Heluani <[email protected]>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 2 of the License, or
 # (at your option) any later version.
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
 
 from .lie_conformal_algebra_with_structure_coefs import \
-                                LieConformalAlgebraWithStructureCoefficients
+    LieConformalAlgebraWithStructureCoefficients
 from sage.matrix.special import identity_matrix
 from sage.structure.indexed_generators import standardize_names_index_set
 
+
 class WeylLieConformalAlgebra(LieConformalAlgebraWithStructureCoefficients):
     r"""
     The Weyl Lie conformal algebra.
@@ -132,7 +133,7 @@ def __init__(self, R, ngens=None, gram_matrix=None, names=None,
         from sage.matrix.matrix_space import MatrixSpace
         if ngens:
             from sage.rings.integer_ring import ZZ
-            if not(ngens in ZZ and not ngens % 2):
+            if not (ngens in ZZ and not ngens % 2):
                 raise ValueError("ngens needs to be an even positive Integer, "
                                  f"got {ngens}")
         if gram_matrix is not None:
@@ -163,8 +164,9 @@ def __init__(self, R, ngens=None, gram_matrix=None, names=None,
         names, index_set = standardize_names_index_set(names=names,
                                                       index_set=index_set,
                                                       ngens=ngens)
-        weyldict = { (i,j): {0: {('K',0): gram_matrix[index_set.rank(i),
-                    index_set.rank(j)]}} for i in index_set for j in index_set}
+        weyldict = {(i, j): {0: {('K', 0): gram_matrix[index_set.rank(i),
+                                                       index_set.rank(j)]}}
+                    for i in index_set for j in index_set}
 
         super().__init__(R, weyldict, names=names,
                          latex_names=latex_names,
@@ -182,7 +184,7 @@ def _repr_(self):
             The Weyl Lie conformal algebra with generators (alpha0, alpha1, K) over Integer Ring
         """
         return "The Weyl Lie conformal algebra with generators {} over {}"\
-                .format(self.gens(),self.base_ring())
+            .format(self.gens(), self.base_ring())
 
     def gram_matrix(self):
         r"""

src/sage/crypto/block_cipher/des.py

@@ -472,8 +472,8 @@ def __repr__(self):
             DES block cipher with 16 rounds and the following key schedule:
             Original DES key schedule with 16 rounds
         """
-        return('DES block cipher with %s rounds and the following key '
-               'schedule:\n%s' % (self._rounds, self.keySchedule.__repr__()))
+        return ('DES block cipher with %s rounds and the following key '
+                'schedule:\n%s' % (self._rounds, self.keySchedule.__repr__()))
 
     def encrypt(self, plaintext, key):
         r"""

src/sage/crypto/mq/sr.py

@@ -665,7 +665,7 @@ def __ne__(self, other):
             sage: sr1 != sr2
             True
         """
-        return not(self == other)
+        return not (self == other)
 
     def sub_bytes(self, d):
         r"""

src/sage/games/quantumino.py

@@ -424,8 +424,8 @@ def __init__(self, aside, box=(5, 8, 2)):
             Quantumino solver for the box (5, 8, 2)
             Aside pentamino number: 9
         """
-        if not(0 <= aside < 17):
-            raise ValueError("aside (=%s) must be between 0 and 16" % aside)
+        if not (0 <= aside < 17):
+            raise ValueError(f"aside (={aside}) must be between 0 and 16")
         self._aside = aside
         self._box = box
 

src/sage/geometry/polyhedron/parent.py

@@ -2,12 +2,12 @@
 Parents for Polyhedra
 """
 
-#*****************************************************************************
+# ****************************************************************************
 #       Copyright (C) 2014 Volker Braun <[email protected]>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
-#                  http://www.gnu.org/licenses/
-#******************************************************************************
+#                  https://www.gnu.org/licenses/
+# *****************************************************************************
 
 from sage.structure.parent import Parent
 from sage.structure.element import get_coercion_model
@@ -193,7 +193,7 @@ def Polyhedra(ambient_space_or_base_ring=None, ambient_dim=None, backend=None, *
         return Polyhedra_field(base_ring.fraction_field(), ambient_dim, backend)
     else:
         raise ValueError('No such backend (=' + str(backend) +
-                         ') implemented for given basering (=' + str(base_ring)+').')
+                         ') implemented for given basering (=' + str(base_ring) + ').')
 
 
 class Polyhedra_base(UniqueRepresentation, Parent):
@@ -400,10 +400,10 @@ def some_elements(self):
         points = []
         R = self.base_ring()
         for i in range(self.ambient_dim() + 5):
-            points.append([R(i*j^2) for j in range(self.ambient_dim())])
+            points.append([R(i*j ^ 2) for j in range(self.ambient_dim())])
         return [
-            self.element_class(self, [points[0:self.ambient_dim()+1], [], []], None),
-            self.element_class(self, [points[0:1], points[1:self.ambient_dim()+1], []], None),
+            self.element_class(self, [points[0:self.ambient_dim() + 1], [], []], None),
+            self.element_class(self, [points[0:1], points[1:self.ambient_dim() + 1], []], None),
             self.element_class(self, [points[0:3], points[4:5], []], None),
             self.element_class(self, None, None)]
 
@@ -421,7 +421,7 @@ def zero(self):
             sage: p + p == p
             True
         """
-        Vrep = [[[self.base_ring().zero()]*self.ambient_dim()], [], []]
+        Vrep = [[[self.base_ring().zero()] * self.ambient_dim()], [], []]
         return self.element_class(self, Vrep, None)
 
     def empty(self):
@@ -454,7 +454,7 @@ def universe(self):
             True
         """
         R = self.base_ring()
-        return self(None, [[[R.one()]+[R.zero()]*self.ambient_dim()], []], convert=True)
+        return self(None, [[[R.one()] + [R.zero()] * self.ambient_dim()], []], convert=True)
 
     @cached_method
     def Vrepresentation_space(self):
@@ -502,10 +502,9 @@ def Hrepresentation_space(self):
         """
         if self.base_ring() in Fields():
             from sage.modules.free_module import VectorSpace
-            return VectorSpace(self.base_ring(), self.ambient_dim()+1)
-        else:
-            from sage.modules.free_module import FreeModule
-            return FreeModule(self.base_ring(), self.ambient_dim()+1)
+            return VectorSpace(self.base_ring(), self.ambient_dim() + 1)
+        from sage.modules.free_module import FreeModule
+        return FreeModule(self.base_ring(), self.ambient_dim() + 1)
 
     def _repr_base_ring(self):
         """
@@ -576,7 +575,7 @@ def _repr_(self):
             sage: Polyhedra(QQ, 3)._repr_()
             'Polyhedra in QQ^3'
         """
-        return 'Polyhedra in '+self._repr_ambient_module()
+        return 'Polyhedra in ' + self._repr_ambient_module()
 
     def _element_constructor_(self, *args, **kwds):
         """
@@ -677,7 +676,7 @@ def convert_base_ring_Hrep(lstlst):
                     if m == 0:
                         newlstlst.append(lst)
                     else:
-                        newlstlst.append([q/m for q in lst])
+                        newlstlst.append([q / m for q in lst])
                 else:
                     newlstlst.append(lst)
             return convert_base_ring(newlstlst)
@@ -902,14 +901,14 @@ def _coerce_base_ring(self, other):
                         except TypeError:
                             pass
                     if other_ring is None:
-                        raise TypeError('Could not coerce '+str(other)+' into ZZ, QQ, or RDF.')
+                        raise TypeError(f'Could not coerce {other} into ZZ, QQ, or RDF.')
 
         if not other_ring.is_exact():
             other_ring = RDF  # the only supported floating-point numbers for now
 
         cm_map, cm_ring = get_coercion_model().analyse(self.base_ring(), other_ring)
         if cm_ring is None:
-            raise TypeError('Could not coerce type '+str(other)+' into ZZ, QQ, or RDF.')
+            raise TypeError(f'Could not coerce type {other} into ZZ, QQ, or RDF.')
         return cm_ring
 
     def _coerce_map_from_(self, X):
@@ -1214,9 +1213,11 @@ def _element_constructor_polyhedron(self, polyhedron, **kwds):
         else:
             return Polyhedra_base._element_constructor_polyhedron(self, polyhedron, **kwds)
 
+
 class Polyhedra_ZZ_normaliz(Polyhedra_base):
     Element = Polyhedron_ZZ_normaliz
 
+
 class Polyhedra_QQ_ppl(Polyhedra_base):
     Element = Polyhedron_QQ_ppl
 
@@ -1246,27 +1247,35 @@ def _element_constructor_polyhedron(self, polyhedron, **kwds):
         else:
             return Polyhedra_base._element_constructor_polyhedron(self, polyhedron, **kwds)
 
+
 class Polyhedra_QQ_normaliz(Polyhedra_base):
     Element = Polyhedron_QQ_normaliz
 
+
 class Polyhedra_QQ_cdd(Polyhedra_base):
     Element = Polyhedron_QQ_cdd
 
+
 class Polyhedra_RDF_cdd(Polyhedra_base):
     Element = Polyhedron_RDF_cdd
 
+
 class Polyhedra_normaliz(Polyhedra_base):
     Element = Polyhedron_normaliz
 
+
 class Polyhedra_polymake(Polyhedra_base):
     Element = Polyhedron_polymake
 
+
 class Polyhedra_field(Polyhedra_base):
     Element = Polyhedron_field
 
+
 class Polyhedra_number_field(Polyhedra_base):
     Element = Polyhedron_number_field
 
+
 @cached_function
 def does_backend_handle_base_ring(base_ring, backend):
     r"""

src/sage/interfaces/qepcad.py

@@ -2427,7 +2427,7 @@ def __init__(self, parent, lines):
                         index = (index,)
                 self._index = index
 
-                self._dimension = sum([r&1 for r in index])
+                self._dimension = sum([r & 1 for r in index])
             if 'Level        ' in line:
                 self._level = int(line.split(':')[1].strip())
             if 'Number of children' in line:

src/sage/logic/boolformula.py

@@ -1167,7 +1167,7 @@ def convert_opt(self, tree):
             lval = ('prop', tree[1])
         else:
             lval = tree[1]
-        if not isinstance(tree[2], tuple) and not(tree[2] is None):
+        if not isinstance(tree[2], tuple) and tree[2] is not None:
             rval = ('prop', tree[2])
         else:
             rval = tree[2]
@@ -1557,5 +1557,6 @@ def length(self):
     # `len(self)`, but this may be deprecated in the future (see :trac:`32148`):
     __len__ = length
 
+
 # allow is_consequence to be called as a function (not only as a method of BooleanFormula)
 is_consequence = BooleanFormula.is_consequence

src/sage/modular/arithgroup/congroup_gamma0.py

@@ -596,7 +596,7 @@ def dimension_new_cusp_forms(self, k=2, p=0):
         N = self.level()
         k = ZZ(k)
 
-        if not(p == 0 or N % p):
+        if not (p == 0 or N % p):
             return (self.dimension_cusp_forms(k) -
                     2 * self.restrict(N // p).dimension_new_cusp_forms(k))
 

src/sage/modular/btquotients/btquotient.py

@@ -412,7 +412,7 @@ class BruhatTitsTree(SageObject, UniqueRepresentation):
         sage: T = BruhatTitsTree(4)
         Traceback (most recent call last):
         ...
-        ValueError: Input (4) must be prime
+        ValueError: input (4) must be prime
 
     AUTHORS:
 
@@ -428,8 +428,8 @@ def __init__(self, p):
             sage: T = BruhatTitsTree(17)
             sage: TestSuite(T).run()
         """
-        if not(ZZ(p).is_prime()):
-            raise ValueError('Input (%s) must be prime' % p)
+        if not ZZ(p).is_prime():
+            raise ValueError(f'input ({p}) must be prime')
         self._p = ZZ(p)
         self._Mat_22 = MatrixSpace(ZZ, 2, 2)
         self._mat_p001 = self._Mat_22([self._p, 0, 0, 1])
@@ -2283,7 +2283,7 @@ def _local_splitting(self, prec):
             self._II = M([0, a, 1, 0])
             z = 0
             self._JJ = 0
-            while(self._JJ == 0):
+            while self._JJ == 0:
                 c = a * z * z + b
                 if c.is_square():
                     x = c.sqrt()

src/sage/modular/hypergeometric_motive.py

@@ -688,11 +688,10 @@ def zigzag(self, x, flip_beta=False):
         alpha = self._alpha
         beta = self._beta
         if flip_beta:
-            return(sum(1 for a in alpha if a <= x) -
-                   sum(1 for b in beta if 1 - b <= x))
-        else:
-            return(sum(1 for a in alpha if a <= x) -
-                   sum(1 for b in beta if b <= x))
+            return (sum(1 for a in alpha if a <= x) -
+                    sum(1 for b in beta if 1 - b <= x))
+        return (sum(1 for a in alpha if a <= x) -
+                sum(1 for b in beta if b <= x))
 
     def weight(self):
         """