gh-39575: full cython-lint cleanup in data_structure pyx files
    
This fixes most of the warning issued by `cython-lint` on this
directory.

### 📝 Checklist

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

Author: Release Manager

src/sage/data_structures/binary_matrix.pxd

@@ -86,7 +86,7 @@ cdef inline void binary_matrix_fill(binary_matrix_t m, bint bit) noexcept:
     """
     cdef mp_bitcnt_t i
 
-    if bit: # set the matrix to 1
+    if bit:  # set the matrix to 1
         for i in range(m.n_rows):
             bitset_set_first_n(m.rows[i], m.n_cols)
     else:
@@ -117,7 +117,7 @@ cdef inline void binary_matrix_set(binary_matrix_t m, mp_bitcnt_t row, mp_bitcnt
     r"""
     Set an entry
     """
-    bitset_set_to(m.rows[row],col,value)
+    bitset_set_to(m.rows[row], col, value)
 
 cdef inline bint binary_matrix_get(binary_matrix_t m, mp_bitcnt_t row, mp_bitcnt_t col) noexcept:
     r"""
@@ -129,7 +129,7 @@ cdef inline binary_matrix_print(binary_matrix_t m):
     r"""
     Print the binary matrix
     """
-    cdef mp_bitcnt_t i,j
+    cdef mp_bitcnt_t i, j
     import sys
     for i in range(m.n_rows):
         for j in range(m.n_cols):

src/sage/data_structures/binary_search.pxd

@@ -1,2 +1,2 @@
 cdef Py_ssize_t binary_search(Py_ssize_t* v, Py_ssize_t n, Py_ssize_t x, Py_ssize_t* ins) noexcept
-cdef Py_ssize_t binary_search0(Py_ssize_t* v, Py_ssize_t n, Py_ssize_t x) noexcept
+cdef Py_ssize_t binary_search0(Py_ssize_t* v, Py_ssize_t n, Py_ssize_t x) noexcept

src/sage/data_structures/bitset.pxd

@@ -1,11 +1,11 @@
-#*****************************************************************************
+# ***************************************************************************
 #     Copyright (C) 2008 Robert Bradshaw <[email protected]>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
 #  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 sage.data_structures.bitset_base cimport bitset_t
 

src/sage/data_structures/bitset.pyx

@@ -16,7 +16,7 @@ linear in ``capacity``.
     faster.
 """
 
-#*****************************************************************************
+# ****************************************************************************
 #       Copyright (C) 2009 Jason Grout <[email protected]>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
@@ -28,8 +28,8 @@ linear in ``capacity``.
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
 
 from sage.data_structures.bitset_base cimport *
 from cpython.object cimport Py_LT, Py_LE, Py_EQ, Py_NE, Py_GT, Py_GE
@@ -763,7 +763,6 @@ cdef class FrozenBitset:
             ...
             ValueError: other cannot be None
         """
-        cdef bint retval
         if other is None:
             raise ValueError("other cannot be None")
         cdef FrozenBitset left, right
@@ -778,7 +777,7 @@ cdef class FrozenBitset:
         # Assumes ``left.size <= right.size``.
         return bitset_are_disjoint(left._bitset, right._bitset)
 
-    def __contains__(self, unsigned long n):
+    def __contains__(self, unsigned long n) -> bool:
         """
         Test to see if ``n`` is in ``self``.
 
@@ -821,7 +820,7 @@ cdef class FrozenBitset:
         """
         return bitset_len(self._bitset)
 
-    def __str__(self):
+    def __str__(self) -> str:
         """
         Return a string representing the bitset as a binary vector.
 
@@ -2271,7 +2270,6 @@ def test_bitset_set_first_n(py_a, long n):
         sage: test_bitset_set_first_n('00'*64, 128)
         a.set_first_n(n)    11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
     """
-    cdef bint bit = True
     cdef bitset_t a
 
     bitset_from_str(a, py_a)

src/sage/data_structures/bitset_base.pxd

@@ -18,14 +18,14 @@ AUTHORS:
   the size of the given bitsets (:issue:`15820`)
 """
 
-#*****************************************************************************
+# ***************************************************************************
 #     Copyright (C) 2008 Robert Bradshaw <[email protected]>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
 #  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/
+# ***************************************************************************
 
 # This file declares the bitset types and the (inline functions).
 # Few functions that are not inline are in the `pyx` file.
@@ -324,7 +324,7 @@ cdef inline bint mpn_equal_bits_shifted(mp_srcptr b1, mp_srcptr b2, mp_bitcnt_t
 
     cdef mp_limb_t b1h = b1[nlimbs]
     tmp_limb = (b2[i2] >> bit_offset)
-    if (n%GMP_LIMB_BITS)+bit_offset > GMP_LIMB_BITS:
+    if (n % GMP_LIMB_BITS) + bit_offset > GMP_LIMB_BITS:
         # Need bits from the next limb of b2
         tmp_limb |= (b2[preinc(i2)] << neg_bit_offset)
     return (b1h ^ tmp_limb) & mask == 0

src/sage/data_structures/bitset_base.pyx

@@ -2,14 +2,14 @@
 Few functions from ``bitset_base.pxd`` that are not inlined.
 """
 
-#*****************************************************************************
+# ***************************************************************************
 #     Copyright (C) 2008 Robert Bradshaw <[email protected]>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
 #  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/
+# ***************************************************************************
 
 cdef char* bitset_chars(char* s, fused_bitset_t bits, char zero=c'0', char one=c'1') noexcept:
     """

src/sage/data_structures/blas_dict.pyx

@@ -23,7 +23,7 @@ nonzero (as tested with `bool(v)`).
 
 This is mostly used by :class:`CombinatorialFreeModule`.
 """
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2010 Christian Stump <[email protected]>
 #                     2016 Travis Scrimshaw <[email protected]>
 #                     2016 Nicolas M. Thiéry <nthiery at users.sf.net>
@@ -32,8 +32,8 @@ This is mostly used by :class:`CombinatorialFreeModule`.
 # 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/
+# ***************************************************************************
 
 cpdef int iaxpy(a, dict X, dict Y, bint remove_zeros=True, bint factor_on_left=True) except -1:
     r"""
@@ -112,13 +112,13 @@ cpdef int iaxpy(a, dict X, dict Y, bint remove_zeros=True, bint factor_on_left=T
         flag = -1
     elif not a:
         return 0
-    for (key, value) in X.iteritems():
+    for key, value in X.items():
         if flag == -1:
             if key in Y:
-                Y[key]  -= value
+                Y[key] -= value
             else:
-                Y[key]  = -value
-                continue # no need to check for zero
+                Y[key] = -value
+                continue  # no need to check for zero
         else:
             if flag != 1:
                 # If we had the guarantee that `a` is in the base
@@ -136,8 +136,8 @@ cpdef int iaxpy(a, dict X, dict Y, bint remove_zeros=True, bint factor_on_left=T
             if key in Y:
                 Y[key] += value
             else:
-                Y[key]  = value
-                continue # no need to check for zero
+                Y[key] = value
+                continue  # no need to check for zero
         if remove_zeros and not Y[key]:
             del Y[key]
     return 0
@@ -217,7 +217,7 @@ cpdef dict negate(dict D):
         sage: blas.negate(D1)
         {0: -1, 1: -1}
     """
-    return { key: -value for key, value in D.iteritems() }
+    return {key: -value for key, value in D.items()}
 
 cpdef dict scal(a, dict D, bint factor_on_left=True):
     r"""
@@ -345,7 +345,7 @@ cpdef dict linear_combination(dict_factor_iter, bint factor_on_left=True):
     cdef dict D
 
     for D, a in dict_factor_iter:
-        if not a: # We multiply by 0, so nothing to do
+        if not a:  # We multiply by 0, so nothing to do
             continue
         if not result and a == 1:
             result = D.copy()

src/sage/data_structures/bounded_integer_sequences.pyx

@@ -195,7 +195,7 @@ cdef bint biseq_init_list(biseq_t R, list data, size_t bound) except -1:
         sig_check()
         item_c = item
         if item_c > bound:
-            raise OverflowError("list item {!r} larger than {}".format(item, bound) )
+            raise OverflowError("list item {!r} larger than {}".format(item, bound))
         biseq_inititem(R, index, item_c)
         index += 1
 
@@ -389,7 +389,8 @@ cdef mp_size_t biseq_contains(biseq_t S1, biseq_t S2, mp_size_t start) except -2
     sig_on()
     for index from start <= index <= S1.length-S2.length:
         if mpn_equal_bits_shifted(S2.data.bits, S1.data.bits,
-                S2.length*S2.itembitsize, index*S2.itembitsize):
+                                  S2.length * S2.itembitsize,
+                                  index * S2.itembitsize):
             sig_off()
             return index
     sig_off()
@@ -424,7 +425,8 @@ cdef mp_size_t biseq_startswith_tail(biseq_t S1, biseq_t S2, mp_size_t start) ex
     sig_on()
     for index from start <= index < S2.length:
         if mpn_equal_bits_shifted(S1.data.bits, S2.data.bits,
-                (S2.length - index)*S2.itembitsize, index*S2.itembitsize):
+                                  (S2.length - index) * S2.itembitsize,
+                                  index * S2.itembitsize):
             sig_off()
             return index
     sig_off()
@@ -1381,35 +1383,35 @@ def _biseq_stresstest():
     cdef list L = [BoundedIntegerSequence(6, [randint(0, 5) for z in range(randint(4, 10))]) for y in range(100)]
     cdef BoundedIntegerSequence S, T
     while True:
-        branch = randint(0,4)
+        branch = randint(0, 4)
         if branch == 0:
-            L[randint(0,99)] = L[randint(0,99)]+L[randint(0,99)]
+            L[randint(0, 99)] = L[randint(0, 99)] + L[randint(0, 99)]
         elif branch == 1:
-            x = randint(0,99)
+            x = randint(0, 99)
             if len(L[x]):
-                y = randint(0,len(L[x])-1)
-                z = randint(y,len(L[x])-1)
-                L[randint(0,99)] = L[x][y:z]
+                y = randint(0, len(L[x]) - 1)
+                z = randint(y, len(L[x]) - 1)
+                L[randint(0, 99)] = L[x][y:z]
             else:
-                L[x] = BoundedIntegerSequence(6, [randint(0,5) for z in range(randint(4,10))])
+                L[x] = BoundedIntegerSequence(6, [randint(0, 5) for z in range(randint(4, 10))])
         elif branch == 2:
-            t = list(L[randint(0,99)])
-            t = repr(L[randint(0,99)])
-            t = L[randint(0,99)].list()
+            t = list(L[randint(0, 99)])
+            t = repr(L[randint(0, 99)])
+            t = L[randint(0, 99)].list()
         elif branch == 3:
-            x = randint(0,99)
+            x = randint(0, 99)
             if len(L[x]):
-                y = randint(0,len(L[x])-1)
+                y = randint(0, len(L[x])-1)
                 t = L[x][y]
                 try:
                     t = L[x].index(t)
                 except ValueError:
-                    raise ValueError("{} should be in {} (bound {}) at position {}".format(t,L[x],L[x].bound(),y))
+                    raise ValueError("{} should be in {} (bound {}) at position {}".format(t, L[x], L[x].bound(), y))
             else:
-                L[x] = BoundedIntegerSequence(6, [randint(0,5) for z in range(randint(4,10))])
+                L[x] = BoundedIntegerSequence(6, [randint(0, 5) for z in range(randint(4, 10))])
         elif branch == 4:
-            S = L[randint(0,99)]
-            T = L[randint(0,99)]
-            biseq_startswith(S.data,T.data)
+            S = L[randint(0, 99)]
+            T = L[randint(0, 99)]
+            biseq_startswith(S.data, T.data)
             biseq_contains(S.data, T.data, 0)
             biseq_startswith_tail(S.data, T.data, 0)