gh-40027: fix pep E228 in all cython files in rings
    
so just adding space around modulo where it was missing

as suggested by `cython-lint`

### 📝 Checklist

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

Author: Release Manager

src/sage/rings/complex_mpc.pyx

@@ -344,7 +344,7 @@ cdef class MPComplexField_class(Field):
         z.init = 1
         return z
 
-    def _repr_ (self):
+    def _repr_ (self) -> str:
         """
         Return a string representation of ``self``.
 
@@ -353,12 +353,12 @@ cdef class MPComplexField_class(Field):
             sage: MPComplexField(200, 'RNDDU') # indirect doctest
             Complex Field with 200 bits of precision and rounding RNDDU
         """
-        s = "Complex Field with %s bits of precision"%self._prec
+        s = "Complex Field with %s bits of precision" % self._prec
         if self.__rnd != MPC_RNDNN:
-            s = s + " and rounding %s"%(self.__rnd_str)
+            s = s + " and rounding %s" % (self.__rnd_str)
         return s
 
-    def _latex_(self):
+    def _latex_(self) -> str:
         r"""
         Return a latex representation of ``self``.
 
@@ -613,7 +613,7 @@ cdef class MPComplexField_class(Field):
             sage: C = MPComplexField(10, 'RNDNZ'); C.name()
             'MPComplexField10_RNDNZ'
         """
-        return "MPComplexField%s_%s"%(self._prec, self.__rnd_str)
+        return "MPComplexField%s_%s" % (self._prec, self.__rnd_str)
 
     def __hash__(self):
         """

src/sage/rings/complex_mpfr.pyx

@@ -619,7 +619,7 @@ class ComplexField_class(sage.rings.abc.ComplexField):
             return self._generic_coerce_map(S)
         return self._coerce_map_via([CLF], S)
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         """
         Return a string representation of ``self``.
 
@@ -630,9 +630,9 @@ class ComplexField_class(sage.rings.abc.ComplexField):
             sage: ComplexField(15) # indirect doctest
             Complex Field with 15 bits of precision
         """
-        return "Complex Field with %s bits of precision"%self._prec
+        return "Complex Field with %s bits of precision" % self._prec
 
-    def _latex_(self):
+    def _latex_(self) -> str:
         r"""
         Return a latex representation of ``self``.
 

src/sage/rings/factorint.pyx

@@ -91,8 +91,8 @@ cpdef aurifeuillian(n, m, F=None, bint check=True):
     cdef Py_ssize_t y = euler_phi(2*n)//2
     if F is None:
         from sage.rings.polynomial.cyclotomic import cyclotomic_value
-        if n%2:
-            if n%4 == 3:
+        if n % 2:
+            if n % 4 == 3:
                 s = -1
             else:
                 s = 1
@@ -196,7 +196,7 @@ cpdef factor_aurifeuillian(n, check=True):
             F = aurifeuillian(a, m, check=False)
             rem = prod(F)
             if check and not rem.divides(n):
-                raise RuntimeError("rem=%s, F=%s, n=%s, m=%s"%(rem, F, n, m))
+                raise RuntimeError(f"rem={rem}, F={F}, n={n}, m={m}")
             rem = n // rem
             if rem != 1:
                 return [rem] + F
@@ -207,9 +207,10 @@ cpdef factor_aurifeuillian(n, check=True):
 def factor_cunningham(m, proof=None):
     r"""
     Return factorization of ``self`` obtained using trial division
-    for all primes in the so called Cunningham table. This is
-    efficient if ``self`` has some factors of type `b^n+1` or `b^n-1`,
-    with `b` in `\{2,3,5,6,7,10,11,12\}`.
+    for all primes in the so called Cunningham table.
+
+    This is efficient if ``self`` has some factors of type `b^n+1` or
+    `b^n-1`, with `b` in `\{2,3,5,6,7,10,11,12\}`.
 
     You need to install an optional package to use this method,
     this can be done with the following command line:

src/sage/rings/finite_rings/element_ntl_gf2e.pyx

@@ -517,7 +517,7 @@ cdef class FiniteField_ntl_gf2eElement(FinitePolyExtElement):
         y._cache = self._cache
         return y
 
-    def __repr__(FiniteField_ntl_gf2eElement self):
+    def __repr__(FiniteField_ntl_gf2eElement self) -> str:
         """
         Polynomial representation of ``self``.
 
@@ -552,11 +552,11 @@ cdef class FiniteField_ntl_gf2eElement(FinitePolyExtElement):
         for i from 1 < i <= GF2X_deg(rep):
             c = GF2X_coeff(rep, i)
             if not GF2_IsZero(c):
-                _repr.append("%s^%d"%(name,i))
+                _repr.append("%s^%d" % (name, i))
 
         return " + ".join(reversed(_repr))
 
-    def __bool__(FiniteField_ntl_gf2eElement self):
+    def __bool__(FiniteField_ntl_gf2eElement self) -> bool:
         r"""
         Return ``True`` if ``self != k(0)``.
 

src/sage/rings/finite_rings/element_pari_ffelt.pyx

@@ -1412,11 +1412,11 @@ cdef class FiniteFieldElement_pari_ffelt(FinitePolyExtElement):
             raise TypeError("order must be at most 65536")
 
         if self == 0:
-            return '0*Z(%s)'%F.order()
+            return '0*Z(%s)' % F.order()
         assert F.degree() > 1
         g = F.multiplicative_generator()
         n = self.log(g)
-        return 'Z(%s)^%s'%(F.order(), n)
+        return 'Z(%s)^%s' % (F.order(), n)
 
 
 def unpickle_FiniteFieldElement_pari_ffelt(parent, elem):

src/sage/rings/finite_rings/finite_field_base.pyx

@@ -139,7 +139,7 @@ cdef class FiniteField(Field):
             else:
                 return NotImplemented
 
-    def is_perfect(self):
+    def is_perfect(self) -> bool:
         r"""
         Return whether this field is perfect, i.e., every element has a `p`-th
         root. Always returns ``True`` since finite fields are perfect.
@@ -151,7 +151,7 @@ cdef class FiniteField(Field):
         """
         return True
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         """
         String representation of this finite field.
 
@@ -174,11 +174,13 @@ cdef class FiniteField(Field):
             Finite Field in d of size 7^20
         """
         if self.degree()>1:
-            return "Finite Field in %s of size %s^%s"%(self.variable_name(),self.characteristic(),self.degree())
+            return "Finite Field in %s of size %s^%s" % (self.variable_name(),
+                                                         self.characteristic(),
+                                                         self.degree())
         else:
-            return "Finite Field of size %s"%(self.characteristic())
+            return "Finite Field of size %s" % (self.characteristic())
 
-    def _latex_(self):
+    def _latex_(self) -> str:
         r"""
         Return a string denoting the name of the field in LaTeX.
 
@@ -199,12 +201,12 @@ cdef class FiniteField(Field):
             \Bold{F}_{3}
         """
         if self.degree() > 1:
-            e = "^{%s}"%self.degree()
+            e = "^{%s}" % self.degree()
         else:
             e = ""
-        return "\\Bold{F}_{%s%s}"%(self.characteristic(), e)
+        return "\\Bold{F}_{%s%s}" % (self.characteristic(), e)
 
-    def _gap_init_(self):
+    def _gap_init_(self) -> str:
         """
         Return string that initializes the GAP version of
         this finite field.
@@ -214,7 +216,7 @@ cdef class FiniteField(Field):
             sage: GF(9,'a')._gap_init_()
             'GF(9)'
         """
-        return 'GF(%s)'%self.order()
+        return 'GF(%s)' % self.order()
 
     def _magma_init_(self, magma):
         """
@@ -234,10 +236,10 @@ cdef class FiniteField(Field):
             a
         """
         if self.degree() == 1:
-            return 'GF(%s)'%self.order()
+            return 'GF(%s)' % self.order()
         B = self.base_ring()
         p = self.polynomial()
-        s = "ext<%s|%s>"%(B._magma_init_(magma),p._magma_init_(magma))
+        s = "ext<%s|%s>" % (B._magma_init_(magma),p._magma_init_(magma))
         return magma._with_names(s, self.variable_names())
 
     def _macaulay2_init_(self, macaulay2=None):

src/sage/rings/finite_rings/integer_mod.pyx

@@ -546,7 +546,7 @@ cdef class IntegerMod_abstract(FiniteRingElement):
     # Interfaces
     #################################################################
     def _pari_init_(self):
-        return 'Mod(%s,%s)'%(str(self), self._modulus.sageInteger)
+        return 'Mod(%s,%s)' % (str(self), self._modulus.sageInteger)
 
     def __pari__(self):
         return self.lift().__pari__().Mod(self._modulus.sageInteger)
@@ -584,7 +584,7 @@ cdef class IntegerMod_abstract(FiniteRingElement):
             sage: b^2
             1
         """
-        return '%s!%s'%(self.parent()._magma_init_(magma), self)
+        return '%s!%s' % (self.parent()._magma_init_(magma), self)
 
     def _axiom_init_(self):
         """
@@ -607,7 +607,7 @@ cdef class IntegerMod_abstract(FiniteRingElement):
             sage: aa.typeOf()                   # optional - fricas
             IntegerMod(15)
         """
-        return '%s :: %s'%(self, self.parent()._axiom_init_())
+        return '%s :: %s' % (self, self.parent()._axiom_init_())
 
     _fricas_init_ = _axiom_init_
 
@@ -1784,9 +1784,9 @@ cdef class IntegerMod_abstract(FiniteRingElement):
         n = self._modulus.sageInteger
         return sage.rings.integer.Integer(n // self.lift().gcd(n))
 
-    def is_primitive_root(self):
+    def is_primitive_root(self) -> bool:
         """
-        Determines whether this element generates the group of units modulo n.
+        Determine whether this element generates the group of units modulo n.
 
         This is only possible if the group of units is cyclic, which occurs if
         n is 2, 4, a power of an odd prime or twice a power of an odd prime.
@@ -1894,7 +1894,7 @@ cdef class IntegerMod_abstract(FiniteRingElement):
         try:
             return sage.rings.integer.Integer(self.__pari__().znorder())
         except PariError:
-            raise ArithmeticError("multiplicative order of %s not defined since it is not a unit modulo %s"%(
+            raise ArithmeticError("multiplicative order of %s not defined since it is not a unit modulo %s" % (
                 self, self._modulus.sageInteger))
 
     def valuation(self, p):

src/sage/rings/finite_rings/residue_field.pyx

@@ -710,7 +710,7 @@ class ResidueField_generic(Field):
             OK = OK.ring_of_integers()
         return self.base_ring().has_coerce_map_from(R) or OK.has_coerce_map_from(R)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         """
         Return a string describing this residue field.
 
@@ -733,8 +733,8 @@ class ResidueField_generic(Field):
              Univariate Polynomial Ring in t over Finite Field of size 17
         """
         if self.p.ring() is ZZ:
-            return "Residue field of Integers modulo %s"%self.p.gen()
-        return "Residue field %sof %s"%('in %s '%self.gen() if self.degree() > 1 else '', self.p)
+            return "Residue field of Integers modulo %s" % self.p.gen()
+        return "Residue field %sof %s" % ('in %s ' % self.gen() if self.degree() > 1 else '', self.p)
 
     def lift(self, x):
         """

src/sage/rings/padics/padic_generic_element.pyx

@@ -2363,7 +2363,7 @@ cdef class pAdicGenericElement(LocalGenericElement):
                 inner_sum = R.zero()
                 for u in range(upper_u,0,-1):
                     # We want u to be a p-adic unit
-                    if u%p==0:
+                    if u % p == 0:
                         new_term = R.zero()
                     else:
                         new_term = ~R(u)
@@ -2970,8 +2970,8 @@ cdef class pAdicGenericElement(LocalGenericElement):
         # we compute the value of N! as we go through the loop
         nfactorial_unit,nfactorial_val = R.one(),0
 
-        nmodp = N%p
-        for n in range(N,0,-1):
+        nmodp = N % p
+        for n in range(N, 0, -1):
             # multiply everything by x
             series_val += x_val
             series_unit *= x_unit
@@ -4224,7 +4224,7 @@ cdef class pAdicGenericElement(LocalGenericElement):
         n = Integer(n)
 
         if z.valuation() < 0:
-            verbose("residue oo, using functional equation for reciprocal. %d %s"%(n,str(self)), level=2)
+            verbose("residue oo, using functional equation for reciprocal. %d %s" % (n, str(self)), level=2)
             return (-1)**(n+1)*(1/z).polylog(n)-(z.log(p_branch)**n)/K(n.factorial())
 
         zeta = K.teichmuller(z)
@@ -4233,7 +4233,7 @@ cdef class pAdicGenericElement(LocalGenericElement):
         if zeta == 0:
             if z.precision_absolute() == PlusInfinity():
                 return K(0)
-            verbose("residue 0, using series. %d %s"%(n,str(self)), level=2)
+            verbose("residue 0, using series. %d %s" % (n, str(self)), level=2)
             M = ceil((prec/z.valuation()).log(p).n())
             N = prec - n*M
             ret = K(0)
@@ -4247,7 +4247,7 @@ cdef class pAdicGenericElement(LocalGenericElement):
         if zeta == 1:
             if z == 1:
                 return Integer(2)**(n-1)*K(-1).polylog(n, p_branch=p_branch)/(1-Integer(2)**(n-1))
-            verbose("residue 1, using _polylog_res_1. %d %s"%(n,str(self)), level=2)
+            verbose("residue 1, using _polylog_res_1. %d %s" % (n, str(self)), level=2)
             return self._polylog_res_1(n, p_branch)
 
         # Set up precision bounds
@@ -4261,7 +4261,7 @@ cdef class pAdicGenericElement(LocalGenericElement):
         K = Qp(p, prec)
 
         # Residue disk around zeta
-        verbose("general case. %d %s"%(n, str(self)), level=2)
+        verbose("general case. %d %s" % (n, str(self)), level=2)
         Li_i_zeta = [0] + [p**i/(p**i-1)*gtr[i](1/(1-zeta)) for i in range(1,n+1)]
 
         T = PowerSeriesRing(K, default_prec=ceil(tsl), names='t')
@@ -4616,7 +4616,8 @@ cpdef gauss_table(long long p, int f, int prec, bint use_longs):
             k = r1 % p
             r1 = (r1 + k * q1) // p
             if use_longs: # Use Dwork expansion to compute p-adic Gamma
-                s1 *= -evaluate_dwork_mahler_long(vv, r1*r2%q3, p, bd, k, q3)
+                s1 *= -evaluate_dwork_mahler_long(vv, r1*r2 % q3,
+                                                  p, bd, k, q3)
                 s1 %= q3
             else:
                 s *= -evaluate_dwork_mahler(v, R1(r1)*d, p, bd, k)