activating more cython-lint checks

Author: fchapoton

pyproject.toml

@@ -41,7 +41,7 @@ build-backend = "mesonpy"
 
 [tool.cython-lint]
 max-line-length = 120
-ignore = ['E114','E117','E127','E128','E129','E202','E221','E222','E231','E261','E262','E265','E501','E711','E722','E731','E741','E743']
+ignore = ['E128','E129','E221','E222','E261','E262','E265','E501','E731','E741','E743']
 exclude = 'src/flint/flintlib/.*'
 
 [tool.spin]

src/flint/types/acb.pyx

@@ -120,7 +120,7 @@ cdef int acb_calc_func_callback(acb_ptr out, const acb_t inp, void * param, long
             if not typecheck(y, acb):
                 raise TypeError("integrand must return an acb")
             acb_set(out, (<acb> y).val)
-        except:
+        except (TypeError, ValueError):
             import sys
             ictx.exn_type, ictx.exn_obj, ictx.exn_tb = sys.exc_info()
             acb_indeterminate(out)
@@ -1346,7 +1346,7 @@ cdef class acb(flint_scalar):
         acb_hypgeom_gamma_upper((<acb>u).val, (<acb>s).val, (<acb>self).val, regularized, getprec())
         return u
 
-    def gamma_lower(self,s, int regularized=0):
+    def gamma_lower(self, s, int regularized=0):
         r"""
         Lower incomplete gamma function `\gamma(s,z)`. The argument *z*
         is given by *self* and the order *s* is passed as an extra parameter.

src/flint/types/acb_mat.pyx

@@ -124,7 +124,7 @@ cdef class acb_mat(flint_mat):
                 acb_mat_init(self.val, m, n)
                 for i from 0 <= i < m:
                     for j from 0 <= j < n:
-                        x = acb(val[i,j])
+                        x = acb(val[i, j])
                         acb_set(acb_mat_entry(self.val, i, j), (<acb>x).val)
             else:
                 raise TypeError("cannot create acb_mat from input of type %s" % type(val))
@@ -137,7 +137,7 @@ cdef class acb_mat(flint_mat):
             if isinstance(entries, (int, float, complex, fmpz, fmpq, arb, acb)):
                 c = entries
                 entries = [0] * (m * n)
-                for i in range(min(m,n)):
+                for i in range(min(m, n)):
                     entries[i*n + i] = c
             else:
                 entries = list(entries)

src/flint/types/acb_series.pyx

@@ -685,7 +685,8 @@ cdef class acb_series(flint_series):
         cap = getcap()
         cap = min(cap, (<acb_series>s).prec)
         u = acb_series.__new__(acb_series)
-        acb_hypgeom_airy_series(NULL, NULL, NULL, (<acb_series>u).val,(<acb_series>s).val, cap, getprec())
+        acb_hypgeom_airy_series(NULL, NULL, NULL, (<acb_series>u).val,
+                                (<acb_series>s).val, cap, getprec())
         (<acb_series>u).prec = cap
         return u
 

src/flint/types/arb_mat.pyx

@@ -122,7 +122,7 @@ cdef class arb_mat(flint_mat):
                 arb_mat_init(self.val, m, n)
                 for i from 0 <= i < m:
                     for j from 0 <= j < n:
-                        x = arb(val[i,j])
+                        x = arb(val[i, j])
                         arb_set(arb_mat_entry(self.val, i, j), (<arb>x).val)
             else:
                 raise TypeError("cannot create arb_mat from input of type %s" % type(val))
@@ -135,7 +135,7 @@ cdef class arb_mat(flint_mat):
             if isinstance(entries, (int, float, fmpz, fmpq, arb)):
                 c = entries
                 entries = [0] * (m * n)
-                for i in range(min(m,n)):
+                for i in range(min(m, n)):
                     entries[i*n + i] = c
             else:
                 entries = list(entries)

src/flint/types/arb_series.pyx

@@ -668,7 +668,8 @@ cdef class arb_series(flint_series):
         cap = getcap()
         cap = min(cap, (<arb_series>s).prec)
         u = arb_series.__new__(arb_series)
-        arb_hypgeom_airy_series(NULL, NULL, NULL, (<arb_series>u).val,(<arb_series>s).val, cap, getprec())
+        arb_hypgeom_airy_series(NULL, NULL, NULL, (<arb_series>u).val,
+                                (<arb_series>s).val, cap, getprec())
         (<arb_series>u).prec = cap
         return u
 
@@ -813,7 +814,7 @@ cdef class arb_series(flint_series):
         try:
             roots = []
             ctx.cap = 1
-            queue = [(arb(a),arb(b))]
+            queue = [(arb(a), arb(b))]
             qvals = [(xsgn(f(arb_series(a))[0]), xsgn(f(arb_series(b))[0]))]
             if 0 in qvals[0]:
                 raise ValueError("unknown sign at an endpoint; try a slightly larger interval")
@@ -833,8 +834,8 @@ cdef class arb_series(flint_series):
                 #fa = xsgn(f(arb_series(a))[0])
                 #fb = xsgn(f(arb_series(b))[0])
                 ctx.cap = 2
-                if fa * fb < 0 and f(arb_series([arb(m, r),1]))[1] != 0:
-                    roots.append((a,b))
+                if fa * fb < 0 and f(arb_series([arb(m, r), 1]))[1] != 0:
+                    roots.append((a, b))
                     continue
                 ctx.cap = 1
                 fm = xsgn(f(arb_series(m))[0])
@@ -843,10 +844,10 @@ cdef class arb_series(flint_series):
                     fm = xsgn(f(arb_series(m))[0])
                     if fm == 0:
                         raise ValueError("unknown sign at a bisection point")
-                queue.append((m,b))
-                qvals.append((fm,fb))
-                queue.append((a,m))
-                qvals.append((fa,fm))
+                queue.append((m, b))
+                qvals.append((fm, fb))
+                queue.append((a, m))
+                qvals.append((fa, fm))
         finally:
             ctx.cap = orig_cap
         return roots

src/flint/types/dirichlet.pyx

@@ -105,7 +105,7 @@ cdef class dirichlet_char(object):
             _dirichlet_group_cache[q] = G
         self.G = G
         dirichlet_char_init(self.val, self.G.val)
-        assert 1 <= l <= max(q,2)-1 and n_gcd(q, l) == 1
+        assert 1 <= l <= max(q, 2)-1 and n_gcd(q, l) == 1
         dirichlet_char_log(self.val, self.G.val, l)
 
     def group(self):

src/flint/types/fmpq_mat.pyx

@@ -5,7 +5,7 @@ from flint.types.fmpq cimport any_as_fmpq
 from flint.types.fmpz cimport any_as_fmpz
 
 from flint.flintlib.fmpz_mat cimport fmpz_mat_nrows, fmpz_mat_ncols
-from flint.flintlib.fmpq cimport fmpq_set,fmpq_numref, fmpq_denref
+from flint.flintlib.fmpq cimport fmpq_set, fmpq_numref, fmpq_denref
 from flint.flintlib.fmpq_poly cimport fmpq_poly_init
 from flint.flintlib.fmpq_mat cimport *
 
@@ -48,12 +48,14 @@ cdef class fmpq_mat(flint_mat):
         if len(args) == 1:
             val = args[0]
             if typecheck(val, fmpq_mat):
-                fmpq_mat_init(self.val, fmpq_mat_nrows((<fmpq_mat>val).val),
-                                        fmpq_mat_ncols((<fmpq_mat>val).val))
+                fmpq_mat_init(self.val,
+                              fmpq_mat_nrows((<fmpq_mat>val).val),
+                              fmpq_mat_ncols((<fmpq_mat>val).val))
                 fmpq_mat_set(self.val, (<fmpq_mat>val).val)
             elif typecheck(val, fmpz_mat):
-                fmpq_mat_init(self.val, fmpz_mat_nrows((<fmpz_mat>val).val),
-                                        fmpz_mat_ncols((<fmpz_mat>val).val))
+                fmpq_mat_init(self.val,
+                              fmpz_mat_nrows((<fmpz_mat>val).val),
+                              fmpz_mat_ncols((<fmpz_mat>val).val))
                 fmpq_mat_set_fmpz_mat(self.val, (<fmpz_mat>val).val)
             elif isinstance(val, (list, tuple)):
                 m = len(val)

src/flint/types/fmpq_series.pyx

@@ -15,7 +15,7 @@ from flint.types.acb_poly cimport acb_poly
 from flint.types.acb_series cimport acb_series
 from flint.types.fmpz cimport any_as_fmpz
 
-from flint.flintlib.fmpz cimport fmpz_is_zero,fmpz_set,fmpz_equal
+from flint.flintlib.fmpz cimport fmpz_is_zero, fmpz_set, fmpz_equal
 from flint.flintlib.fmpq_poly cimport *
 
 cdef fmpq_series_coerce_operands(x, y):

src/flint/types/fmpz_mat.pyx

@@ -80,7 +80,7 @@ cdef class fmpz_mat(flint_mat):
 
     """
 
- #   cdef fmpz_mat_t val
+    #   cdef fmpz_mat_t val
 
     def __cinit__(self):
         fmpz_mat_init(self.val, 0, 0)
@@ -651,7 +651,7 @@ cdef class fmpz_mat(flint_mat):
         if transform:
             v = fmpz_mat(self.nrows(), self.nrows())
             for 0 <= i < self.nrows():
-                v[i,i] = 1
+                v[i, i] = 1
             fmpz_lll(u.val, v.val, ctx)
             return u, v
         else:

src/flint/types/fmpz_mod.pyx

@@ -400,11 +400,8 @@ cdef class fmpz_mod(flint_scalar):
             return NotImplemented
 
         res = fmpz_equal(self.val, (<fmpz_mod>other).val) and \
-                (self.ctx == (<fmpz_mod>other).ctx)
-        if op == 2:
-            return res
-        else:
-            return not res
+            (self.ctx == (<fmpz_mod>other).ctx)
+        return res if op == 2 else not res
 
     def __bool__(self):
         return not self.is_zero()

src/flint/types/fmpz_mod_poly.pyx

@@ -1186,7 +1186,7 @@ cdef class fmpz_mod_poly(flint_poly):
         # For larger exponents we need to cast e to an fmpz first
         e_fmpz = any_as_fmpz(e)
         if e_fmpz is NotImplemented:
-            raise TypeError(f"exponent cannot be cast to an fmpz type: {e = }")
+            raise TypeError(f"exponent cannot be cast to an fmpz type: {e=}")
 
         # To optimise powering, we precompute the inverse of the reverse of the modulus
         if mod_rev_inv is not None:
@@ -1716,7 +1716,7 @@ cdef class fmpz_mod_poly(flint_poly):
             self.val, self.ctx.mod.val
         )
         if n > n_max:
-            raise ValueError(f"Cannot deflate with {n = }, maximum allowed value is {n_max = }")
+            raise ValueError(f"Cannot deflate with {n=}, maximum allowed value is {n_max=}")
 
         res = self.ctx.new_ctype_poly()
         fmpz_mod_poly_deflate(

src/flint/types/fq_default.pyx

@@ -56,9 +56,9 @@ cdef class fq_default_ctx:
 
         # Now fq_type should be an int between 0, 5
         if not typecheck(fq_type, int):
-            raise TypeError(f"{fq_type = } is invalid")
+            raise TypeError(f"{fq_type=} is invalid")
         if fq_type < 0 or fq_type > 5:
-            raise ValueError(f"{fq_type = } should be between 0 and 5")
+            raise ValueError(f"{fq_type=} should be between 0 and 5")
 
         return fq_type
 
@@ -129,14 +129,14 @@ cdef class fq_default_ctx:
         # c_from_order expects the characteristic to be fmpz type
         prime = any_as_fmpz(p)
         if prime is NotImplemented:
-            raise TypeError(f"cannot coerce {p = } to type fmpz")
+            raise TypeError(f"cannot coerce {p=} to type fmpz")
 
         if check_prime and not prime.is_prime():
             raise ValueError("characteristic is not prime")
 
         # the degree must be strictly positive
         if d < 1:
-            raise ValueError(f"the degree must be positive, got {d = }")
+            raise ValueError(f"the degree must be positive, got {d=}")
 
         fq_default_ctx_init_type(self.val, (<fmpz>prime).val, d, self.var, <fq_default_type>fq_type)
         self._initialized = True

src/flint/types/fq_default_poly.pyx

@@ -47,7 +47,7 @@ cdef class fq_default_poly_ctx:
             # First coerce the list element as an fq_default type
             v = self.field.any_as_fq_default(val[i])
             if v is NotImplemented:
-                raise TypeError(f"unsupported coefficient in list: {val[i] = }, {type(val[i]) = }")
+                raise TypeError(f"unsupported coefficient in list: {val[i]=}, {type(val[i])=}")
 
             # Set the coefficient of the polynomial
             fq_default_poly_set_coeff(
@@ -1324,7 +1324,7 @@ cdef class fq_default_poly(flint_poly):
         """
         G, S, _ = self.xgcd(other)
         if not G.is_one():
-            raise ValueError(f"polynomial has no inverse modulo {other = }")
+            raise ValueError(f"polynomial has no inverse modulo {other=}")
         return S
 
     # ====================================
@@ -1638,7 +1638,7 @@ cdef class fq_default_poly(flint_poly):
             self.val, self.ctx.field.val
         )
         if n > n_max:
-            raise ValueError(f"Cannot deflate with {n = }, maximum allowed value is {n_max = }")
+            raise ValueError(f"Cannot deflate with {n=}, maximum allowed value is {n_max=}")
 
         res = self.ctx.new_ctype_poly()
         fq_default_poly_deflate(

src/flint/types/nmod_mat.pyx

@@ -62,8 +62,9 @@ cdef any_as_nmod_mat(obj, nmod_t mod):
     x = any_as_fmpz_mat(obj)
     if x is not NotImplemented:
         r = nmod_mat.__new__(nmod_mat)
-        nmod_mat_init(r.val, fmpz_mat_nrows((<fmpz_mat>x).val),
-                             fmpz_mat_ncols((<fmpz_mat>x).val), mod.n)
+        nmod_mat_init(r.val,
+                      fmpz_mat_nrows((<fmpz_mat>x).val),
+                      fmpz_mat_ncols((<fmpz_mat>x).val), mod.n)
         fmpz_mat_get_nmod_mat(r.val, (<fmpz_mat>x).val)
         return r
     return NotImplemented

src/flint/types/nmod_poly.pyx

@@ -155,7 +155,7 @@ cdef class nmod_poly(flint_poly):
         cdef mp_limb_t m
         n = self.length()
         m = self.modulus()
-        L = [nmod(0,m) for i in range(n)]   # XXX: speed up
+        L = [nmod(0, m) for i in range(n)]   # XXX: speed up
         for i from 0 <= i < n:
             (<nmod>(L[i])).val = nmod_poly_get_coeff_ui(self.val, i)
         return L
@@ -262,7 +262,7 @@ cdef class nmod_poly(flint_poly):
             45*x^4 + 23*x^3 + 159*x^2 + 151*x + 110
         """
         if n <= 0:
-            raise ValueError(f"{n = } must be positive")
+            raise ValueError(f"{n=} must be positive")
 
         if self.is_zero():
             raise ValueError("cannot invert the zero element")
@@ -315,11 +315,11 @@ cdef class nmod_poly(flint_poly):
         cdef nmod_poly res
         g = any_as_nmod_poly(other, self.val.mod)
         if g is NotImplemented:
-            raise TypeError(f"cannot convert {other = } to nmod_poly")
+            raise TypeError(f"cannot convert {other=} to nmod_poly")
 
         h = any_as_nmod_poly(modulus, self.val.mod)
         if h is NotImplemented:
-            raise TypeError(f"cannot convert {modulus = } to nmod_poly")
+            raise TypeError(f"cannot convert {modulus=} to nmod_poly")
 
         if modulus.is_zero():
             raise ZeroDivisionError("cannot reduce modulo zero")
@@ -549,7 +549,7 @@ cdef class nmod_poly(flint_poly):
         # For larger exponents we need to cast e to an fmpz first
         e_fmpz = any_as_fmpz(e)
         if e_fmpz is NotImplemented:
-            raise TypeError(f"exponent cannot be cast to an fmpz type: {e = }")
+            raise TypeError(f"exponent cannot be cast to an fmpz type: {e=}")
 
         # To optimise powering, we precompute the inverse of the reverse of the modulus
         if mod_rev_inv is not None: