gh-36109: Prepare for updating Cython to 3.0.0
    
<!-- ^^^^^
Please provide a concise, informative and self-explanatory title.
Don't put issue numbers in there, do this in the PR body below.
For example, instead of "Fixes #1234" use "Introduce new method to
calculate 1+1"
-->
<!-- 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. -->

Here are the changes needed to get Sage compiled with Cython 3. This PR
contains changes that do not break compatibility with old Cython, so
they can be merged without actually upgrading Cython.

Part of #29863.

### 📝 Checklist

<!-- Put an `x` in all the boxes that apply. -->
<!-- If your change requires a documentation PR, please link it
appropriately -->
<!-- If you're unsure about any of these, don't hesitate to ask. We're
here to help! -->
<!-- Feel free to remove irrelevant items. -->

- [x] The title is concise, informative, and self-explanatory.
- [x] The description explains in detail what this PR is about.
- [x] I have linked a relevant issue or discussion.

### ⌛ 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: #36109
Reported by: Yutao Yuan
Reviewer(s): Gonzalo Tornaría, Yutao Yuan

Author: Release Manager

src/doc/en/thematic_tutorials/coercion_and_categories.rst

@@ -106,7 +106,6 @@ This base class provides a lot more methods than a general parent::
 
     sage: [p for p in dir(Field) if p not in dir(Parent)]
     ['__fraction_field',
-     '__ideal_monoid',
      '__iter__',
      '__len__',
      '__rxor__',
@@ -119,6 +118,7 @@ This base class provides a lot more methods than a general parent::
      '_default_category',
      '_gens',
      '_ideal_class_',
+     '_ideal_monoid',
      '_latex_names',
      '_list',
      '_one_element',

src/doc/en/thematic_tutorials/tutorial-objects-and-classes.rst

@@ -298,7 +298,7 @@ http://docs.python.org/library/ for a complete list. ::
         sage: el
         bla
         sage: el.__dict__
-        {'__custom_name': 'bla', 'value': 42}
+        {'_SageObject__custom_name': 'bla', 'value': 42}
 
     Lots of Sage objects are not Python objects but compiled Cython
     objects. Python sees them as builtin objects and you do not have

src/sage/algebras/letterplace/free_algebra_letterplace.pxd

@@ -20,16 +20,15 @@ cdef class FreeAlgebra_letterplace_libsingular():
     cdef ring* _lp_ring
     cdef MPolynomialRing_libsingular _commutative_ring
     cdef MPolynomialRing_libsingular _lp_ring_internal
-    cdef object __ngens
+    cdef object _ngens
 
 cdef class FreeAlgebra_letterplace(Algebra):
     cdef MPolynomialRing_libsingular _commutative_ring
     cdef MPolynomialRing_libsingular _current_ring
     cdef int _degbound
-    cdef int __ngens
+    cdef int _ngens
     cdef int _nb_slackvars
     cdef object __monoid
-    cdef public object __custom_name
     cdef str exponents_to_string(self, E)
     cdef str exponents_to_latex(self, E)
     cdef tuple _degrees

src/sage/algebras/letterplace/free_algebra_letterplace.pyx

@@ -255,7 +255,7 @@ cdef class FreeAlgebra_letterplace(Algebra):
         """
         if not isinstance(R, MPolynomialRing_libsingular):
             raise TypeError("a letterplace algebra must be provided by a polynomial ring of type %s" % MPolynomialRing_libsingular)
-        self.__ngens = R.ngens()
+        self._ngens = R.ngens()
         if degrees is None:
             varnames = R.variable_names()
             self._nb_slackvars = 0
@@ -269,12 +269,12 @@ cdef class FreeAlgebra_letterplace(Algebra):
         self._current_ring = make_letterplace_ring(R, 1)
         self._degbound = 1
         if degrees is None:
-            self._degrees = tuple([int(1)] * self.__ngens)
+            self._degrees = tuple([int(1)] * self._ngens)
         else:
             if (not isinstance(degrees, (tuple, list))) \
-                    or len(degrees) != self.__ngens - self._nb_slackvars \
+                    or len(degrees) != self._ngens - self._nb_slackvars \
                     or any(i <= 0 for i in degrees):
-                raise TypeError("the generator degrees must be given by a list or tuple of %d positive integers" % (self.__ngens - 1))
+                raise TypeError("the generator degrees must be given by a list or tuple of %d positive integers" % (self._ngens - 1))
             self._degrees = tuple([int(i) for i in degrees])
             self.set_degbound(max(self._degrees))
         self._populate_coercion_lists_(coerce_list=[base_ring])
@@ -305,7 +305,7 @@ cdef class FreeAlgebra_letterplace(Algebra):
             sage: F.ngens()
             3
         """
-        return self.__ngens - self._nb_slackvars
+        return self._ngens - self._nb_slackvars
 
     def gen(self, i):
         """
@@ -327,17 +327,17 @@ cdef class FreeAlgebra_letterplace(Algebra):
             sage: F.gen(2)
             c
         """
-        if i >= self.__ngens - self._nb_slackvars:
-            raise ValueError("this free algebra only has %d generators" % (self.__ngens - self._nb_slackvars))
+        if i >= self._ngens - self._nb_slackvars:
+            raise ValueError("this free algebra only has %d generators" % (self._ngens - self._nb_slackvars))
         if self._gens is not None:
             return self._gens[i]
         deg = self._degrees[i]
         # self.set_degbound(deg)
         p = self._current_ring.gen(i)
         cdef int n
-        cdef int j = self.__ngens - 1
+        cdef int j = self._ngens - 1
         for n in range(1, deg):
-            j += self.__ngens
+            j += self._ngens
             p *= self._current_ring.gen(j)
         return FreeAlgebraElement_letterplace(self, p)
 
@@ -413,7 +413,7 @@ cdef class FreeAlgebra_letterplace(Algebra):
             sage: FreeAlgebra(QQ, implementation='letterplace', names=['x']).is_commutative()
             True
         """
-        return self.__ngens - self._nb_slackvars <= 1
+        return self._ngens - self._nb_slackvars <= 1
 
     def is_field(self, proof=True):
         """
@@ -430,7 +430,7 @@ cdef class FreeAlgebra_letterplace(Algebra):
             sage: F.is_field()
             False
         """
-        return (not (self.__ngens - self._nb_slackvars)) and self._base.is_field(proof=proof)
+        return (not (self._ngens - self._nb_slackvars)) and self._base.is_field(proof=proof)
 
     def _repr_(self):
         """
@@ -446,7 +446,7 @@ cdef class FreeAlgebra_letterplace(Algebra):
             sage: F
             Free Associative Unital Algebra on 3 generators (x, y, z) over Rational Field
         """
-        return "Free Associative Unital Algebra on %d generators %s over %s" % (self.__ngens - self._nb_slackvars, self.gens(), self._base)
+        return "Free Associative Unital Algebra on %d generators %s over %s" % (self._ngens - self._nb_slackvars, self.gens(), self._base)
 
     def _latex_(self):
         r"""
@@ -586,7 +586,7 @@ cdef class FreeAlgebra_letterplace(Algebra):
               generated free abelian monoid.
               In principle, this is correct, but it is not implemented, yet.>
         """
-        cdef int ngens = self.__ngens
+        cdef int ngens = self._ngens
         cdef int nblocks = len(E) // ngens
         cdef int i, j, base, exp, var_ind
         cdef list out = []
@@ -618,7 +618,7 @@ cdef class FreeAlgebra_letterplace(Algebra):
             sage: latex(-(a*b*(z+1)-c)^2)     # indirect doctest
             \left(2 z + 1\right) a b a b + \left(z + 1\right) a b c + \left(z + 1\right) c a b - c c
         """
-        cdef int ngens = self.__ngens
+        cdef int ngens = self._ngens
         cdef int nblocks = len(E) // ngens
         cdef int i, j, base, exp, var_ind
         cdef list out = []
@@ -678,7 +678,7 @@ cdef class FreeAlgebra_letterplace(Algebra):
         cdef list out = []
         C = self.current_ring()
         cdef FreeAlgebraElement_letterplace x
-        ngens = self.__ngens
+        ngens = self._ngens
         cdef list G = [C(x._poly) for x in g]
         from sage.groups.perm_gps.permgroup_named import CyclicPermutationGroup
         CG = CyclicPermutationGroup(C.ngens())
@@ -811,7 +811,7 @@ cdef class FreeAlgebra_letterplace(Algebra):
             l = len(e)
             break
         cdef dict out = {}
-        self.set_degbound(l // self.__ngens)
+        self.set_degbound(l // self._ngens)
         cdef Py_ssize_t n = self._current_ring.ngens()
         for e, c in D.iteritems():
             out[tuple(e) + (0,) * (n - l)] = c
@@ -896,7 +896,7 @@ cdef class FreeAlgebra_letterplace_libsingular():
         self._commutative_ring = commutative_ring
 
     def __init__(self, commutative_ring, degbound):
-        self.__ngens = commutative_ring.ngens() * degbound
+        self._ngens = commutative_ring.ngens() * degbound
 
     def __dealloc__(self):
         r"""

src/sage/algebras/quatalg/quaternion_algebra_element.pyx

@@ -1700,15 +1700,15 @@ cdef class QuaternionAlgebraElement_number_field(QuaternionAlgebraElement_abstra
             x, y, z, w = v
         cdef NumberFieldElement a = <NumberFieldElement>(parent._base(parent._a))
         cdef NumberFieldElement b = <NumberFieldElement>(parent._base(parent._b))
-        fmpz_poly_set_ZZX(self.x, (<NumberFieldElement>x).__numerator)
-        fmpz_poly_set_ZZX(self.y, (<NumberFieldElement>y).__numerator)
-        fmpz_poly_set_ZZX(self.z, (<NumberFieldElement>z).__numerator)
-        fmpz_poly_set_ZZX(self.w, (<NumberFieldElement>w).__numerator)
+        fmpz_poly_set_ZZX(self.x, (<NumberFieldElement>x)._numerator)
+        fmpz_poly_set_ZZX(self.y, (<NumberFieldElement>y)._numerator)
+        fmpz_poly_set_ZZX(self.z, (<NumberFieldElement>z)._numerator)
+        fmpz_poly_set_ZZX(self.w, (<NumberFieldElement>w)._numerator)
 
-        ZZ_to_mpz(T1, &(<NumberFieldElement>x).__denominator)
-        ZZ_to_mpz(T2, &(<NumberFieldElement>y).__denominator)
-        ZZ_to_mpz(t3, &(<NumberFieldElement>z).__denominator)
-        ZZ_to_mpz(t4, &(<NumberFieldElement>w).__denominator)
+        ZZ_to_mpz(T1, &(<NumberFieldElement>x)._denominator)
+        ZZ_to_mpz(T2, &(<NumberFieldElement>y)._denominator)
+        ZZ_to_mpz(t3, &(<NumberFieldElement>z)._denominator)
+        ZZ_to_mpz(t4, &(<NumberFieldElement>w)._denominator)
 
         mpz_lcm(self.d, T1, T2)
         mpz_lcm(self.d, self.d, t3)
@@ -1724,10 +1724,10 @@ cdef class QuaternionAlgebraElement_number_field(QuaternionAlgebraElement_abstra
         fmpz_poly_scalar_mul_mpz(self.z, self.z, t3)
         fmpz_poly_scalar_mul_mpz(self.w, self.w, t4)
 
-        fmpz_poly_set_ZZX(self.a, a.__numerator)     # we will assume that the denominator of a and b are 1
-        fmpz_poly_set_ZZX(self.b, b.__numerator)
+        fmpz_poly_set_ZZX(self.a, a._numerator)     # we will assume that the denominator of a and b are 1
+        fmpz_poly_set_ZZX(self.b, b._numerator)
 
-        fmpz_poly_set_ZZX(self.modulus, (<NumberFieldElement>x).__fld_numerator.x)  # and same for the modulus
+        fmpz_poly_set_ZZX(self.modulus, (<NumberFieldElement>x)._fld_numerator.x)  # and same for the modulus
 
     def __getitem__(self, int i):
         """
@@ -1756,17 +1756,17 @@ cdef class QuaternionAlgebraElement_number_field(QuaternionAlgebraElement_abstra
         cdef NumberFieldElement item = el._new()
 
         if i == 0:
-            fmpz_poly_get_ZZX(item.__numerator, self.x)
+            fmpz_poly_get_ZZX(item._numerator, self.x)
         elif i == 1:
-            fmpz_poly_get_ZZX(item.__numerator, self.y)
+            fmpz_poly_get_ZZX(item._numerator, self.y)
         elif i == 2:
-            fmpz_poly_get_ZZX(item.__numerator, self.z)
+            fmpz_poly_get_ZZX(item._numerator, self.z)
         elif i == 3:
-            fmpz_poly_get_ZZX(item.__numerator, self.w)
+            fmpz_poly_get_ZZX(item._numerator, self.w)
         else:
             raise IndexError("quaternion element index out of range")
 
-        mpz_to_ZZ(&item.__denominator, self.d)
+        mpz_to_ZZ(&item._denominator, self.d)
 
         return item
 

src/sage/categories/hopf_algebras_with_basis.py

@@ -36,7 +36,7 @@ class HopfAlgebrasWithBasis(CategoryWithAxiom_over_base_ring):
         sage: A = C.example(); A                                                        # needs sage.groups
         An example of Hopf algebra with basis: the group algebra of the
          Dihedral group of order 6 as a permutation group over Rational Field
-        sage: A.__custom_name = "A"                                                     # needs sage.groups
+        sage: A.rename("A")                                                             # needs sage.groups
         sage: A.category()                                                              # needs sage.groups
         Category of finite dimensional hopf algebras with basis over Rational Field
 

src/sage/categories/modules_with_basis.py

@@ -66,8 +66,8 @@ class ModulesWithBasis(CategoryWithAxiom_over_base_ring):
 
     Let `X` and `Y` be two modules with basis. We can build `Hom(X,Y)`::
 
-        sage: X = CombinatorialFreeModule(QQ, [1,2]); X.__custom_name = "X"             # needs sage.modules
-        sage: Y = CombinatorialFreeModule(QQ, [3,4]); Y.__custom_name = "Y"             # needs sage.modules
+        sage: X = CombinatorialFreeModule(QQ, [1,2]); X.rename("X")                     # needs sage.modules
+        sage: Y = CombinatorialFreeModule(QQ, [3,4]); Y.rename("Y")                     # needs sage.modules
         sage: H = Hom(X, Y); H                                                          # needs sage.modules
         Set of Morphisms from X to Y
          in Category of finite dimensional vector spaces with basis over Rational Field

src/sage/combinat/cluster_complex.py

@@ -222,10 +222,6 @@ def __init__(self, W, k, coxeter_element, algorithm):
         self._W = W
         self._w0 = w
         self._k = k
-        if k == 1:
-            self.__custom_name = 'Cluster complex'
-        else:
-            self.__custom_name = 'Multi-cluster complex'
 
         self.set_immutable()
 
@@ -271,7 +267,10 @@ def _repr_(self):
             sage: ClusterComplex(['A', 2])._repr_()
             "Cluster complex of type ['A', 2] with 5 vertices and 5 facets"
         """
-        name = self.__custom_name
+        if self._k == 1:
+            name = 'Cluster complex'
+        else:
+            name = 'Multi-cluster complex'
         name += (' of type %s with %s vertices and %s facets'
                  % (self.cartan_type(), len(self.vertices()),
                     len(self._facets)))

src/sage/combinat/integer_lists/base.pxd

@@ -12,4 +12,4 @@ cdef class IntegerListsBackend():
     cdef readonly min_part, max_part
     cdef readonly min_slope, max_slope
     cdef readonly Envelope floor, ceiling
-    cdef public dict __cached_methods  # Support cached_method
+    cdef public dict _cached_methods  # Support cached_method

src/sage/combinat/subword_complex.py

@@ -1131,7 +1131,6 @@ def __init__(self, Q, w, algorithm="inductive"):
         SimplicialComplex.__init__(self, maximal_faces=Fs,
                                    maximality_check=False,
                                    category=cat)
-        self.__custom_name = 'Subword complex'
         self._W = W
         try:
             T = W.coxeter_matrix().coxeter_type()