gh-36922: using less isinstance(..., Ring)
    
in favour of the more categorical `... in Rings()`

also fixing a few pep8 details in passing but not too much

### 📝 Checklist

- [x] The title is concise, informative, and self-explanatory.
- [x] The description explains in detail what this PR is about.
    
URL: #36922
Reported by: Frédéric Chapoton
Reviewer(s): Frédéric Chapoton, Matthias Köppe, Travis Scrimshaw

Author: Release Manager

src/sage/algebras/affine_nil_temperley_lieb.py

@@ -11,7 +11,7 @@
 from sage.categories.algebras_with_basis import AlgebrasWithBasis
 from sage.combinat.root_system.cartan_type import CartanType
 from sage.combinat.root_system.weyl_group import WeylGroup
-from sage.rings.ring import Ring
+from sage.categories.rings import Rings
 from sage.rings.integer_ring import ZZ
 from sage.combinat.free_module import CombinatorialFreeModule
 from sage.misc.cachefunc import cached_method
@@ -54,7 +54,7 @@ def __init__(self, n, R=ZZ, prefix='a'):
             sage: A = AffineNilTemperleyLiebTypeA(3, QQ); A
             The affine nilTemperley Lieb algebra A3 over the ring Rational Field
         """
-        if not isinstance(R, Ring):
+        if R not in Rings():
             raise TypeError("argument R must be a ring")
         self._cartan_type = CartanType(['A', n - 1, 1])
         self._n = n
@@ -234,15 +234,16 @@ def has_no_braid_relation(self, w, i):
         if i in w.descents():
             return False
         s = w.parent().simple_reflections()
-        wi = w*s[i]
-        adjacent = [(i-1) % w.parent().n, (i+1) % w.parent().n]
+        wi = w * s[i]
+        adjacent = [(i - 1) % w.parent().n,
+                    (i + 1) % w.parent().n]
         for j in adjacent:
             if j in w.descents():
                 if j in wi.descents():
                     return False
                 else:
                     return True
-        return self.has_no_braid_relation(w*s[w.first_descent()],i)
+        return self.has_no_braid_relation(w * s[w.first_descent()], i)
 
     def _repr_term(self, t, short_display=True):
         """

src/sage/algebras/lie_algebras/lie_algebra.py

@@ -30,7 +30,6 @@
 from sage.algebras.lie_algebras.lie_algebra_element import (LieAlgebraElementWrapper,
                                                             LieAlgebraMatrixWrapper)
 from sage.rings.integer_ring import ZZ
-from sage.rings.ring import Ring
 from sage.matrix.matrix_space import MatrixSpace
 from sage.sets.family import Family, AbstractFamily
 
@@ -419,7 +418,7 @@ def __classcall_private__(cls, R=None, arg0=None, arg1=None, names=None,
             raise ValueError("invalid arguments")
 
         def check_assoc(A):
-            return (isinstance(A, (Ring, MatrixSpace))
+            return (isinstance(A, MatrixSpace)
                     or A in Rings()
                     or A in Algebras(R).Associative())
         if arg0 in ZZ or check_assoc(arg1):

src/sage/algebras/splitting_algebra.py

@@ -229,11 +229,11 @@ def __init__(self, monic_polynomial, names='X', iterate=True, warning=True):
             if not base_ring.is_integral_domain():
                 raise TypeError("base_ring must be an integral domain")
         except NotImplementedError:
-            from sage.rings.ring import Ring
-            if not isinstance(base_ring, Ring):
-                raise TypeError("base_ring must be an instance of ring")
+            from sage.categories.rings import Rings
+            if base_ring not in Rings():
+                raise TypeError("base_ring must be a ring")
             if warning:
-                warn('Assuming %s to be an integral domain!' % (base_ring))
+                warn('Assuming %s to be an integral domain!' % base_ring)
 
         if deg < 1:
             raise ValueError("the degree of the polynomial must positive")

src/sage/modular/abvar/homspace.py

@@ -183,14 +183,14 @@
 
 from sage.categories.homset import HomsetWithBase
 from sage.structure.all import parent
+from sage.structure.parent import Parent
 from sage.misc.lazy_attribute import lazy_attribute
 
 
 from . import morphism
 
 from sage.rings.infinity import Infinity
 
-from sage.rings.ring import Ring
 from sage.matrix.matrix_space import MatrixSpace
 from sage.matrix.constructor import Matrix, identity_matrix
 from sage.structure.element import is_Matrix
@@ -482,13 +482,11 @@ def free_module(self):
 
     def gen(self, i=0):
         """
-        Return i-th generator of self.
+        Return i-th generator of ``self``.
 
         INPUT:
 
-
-        -  ``i`` - an integer
-
+        -  ``i`` -- an integer
 
         OUTPUT: a morphism
 
@@ -508,7 +506,7 @@ def gen(self, i=0):
 
     def ngens(self):
         """
-        Return number of generators of self.
+        Return number of generators of ``self``.
 
         OUTPUT: integer
 
@@ -661,10 +659,12 @@ def _calculate_product_gens(self):
 
     def _calculate_simple_gens(self):
         """
-        Calculate generators for self, where both the domain and codomain
-        for self are assumed to be simple abelian varieties. The saturation
-        of the span of these generators in self will be the full space of
-        homomorphisms from the domain of self to its codomain.
+        Calculate generators for ``self``, where both the domain and codomain
+        for ``self`` are assumed to be simple abelian varieties.
+
+        The saturation of the span of these generators in ``self``
+        will be the full space of homomorphisms from the domain of
+        ``self`` to its codomain.
 
         EXAMPLES::
 
@@ -749,23 +749,21 @@ def _calculate_simple_gens(self):
 
 
 # NOTE/WARNING/TODO:  Below in the __init__, etc. we do *not* check
-# that the input gens are give something that spans a sub*ring*, as apposed
+# that the input gens are give something that spans a sub*ring*, as opposed
 # to just a subgroup.
-class EndomorphismSubring(Homspace, Ring):
+class EndomorphismSubring(Homspace):
 
     def __init__(self, A, gens=None, category=None):
         """
         A subring of the endomorphism ring.
 
         INPUT:
 
+        -  ``A`` -- an abelian variety
 
-        -  ``A`` - an abelian variety
-
-        -  ``gens`` - (default: None); optional; if given
+        -  ``gens`` -- (default: ``None``); optional; if given
            should be a tuple of the generators as matrices
 
-
         EXAMPLES::
 
             sage: J0(23).endomorphism_ring()
@@ -808,14 +806,13 @@ def __init__(self, A, gens=None, category=None):
         self._A = A
 
         # Initialise self with the correct category.
-        # We need to initialise it as a ring first
         if category is None:
             homset_cat = A.category()
         else:
             homset_cat = category
-        # Remark: Ring.__init__ will automatically form the join
+        # Remark: Parent.__init__ will automatically form the join
         # of the category of rings and of homset_cat
-        Ring.__init__(self, A.base_ring(), category=homset_cat.Endsets())
+        Parent.__init__(self, A.base_ring(), category=homset_cat.Endsets())
         Homspace.__init__(self, A, A, cat=homset_cat)
         if gens is None:
             self._gens = None
@@ -825,7 +822,7 @@ def __init__(self, A, gens=None, category=None):
 
     def _repr_(self):
         """
-        Return the string representation of self.
+        Return the string representation of ``self``.
 
         EXAMPLES::
 
@@ -853,18 +850,16 @@ def abelian_variety(self):
 
     def index_in(self, other, check=True):
         """
-        Return the index of self in other.
+        Return the index of ``self`` in ``other``.
 
         INPUT:
 
-
-        -  ``other`` - another endomorphism subring of the
+        -  ``other`` -- another endomorphism subring of the
            same abelian variety
 
-        -  ``check`` - bool (default: True); whether to do some
+        -  ``check`` -- bool (default: ``True``); whether to do some
            type and other consistency checks
 
-
         EXAMPLES::
 
             sage: R = J0(33).endomorphism_ring()

src/sage/modular/modform/space.py

@@ -72,7 +72,7 @@
 from sage.rings.power_series_ring import PowerSeriesRing
 from sage.rings.power_series_ring_element import is_PowerSeries
 from sage.rings.rational_field import QQ
-from sage.rings.ring import Ring
+from sage.categories.rings import Rings
 
 from sage.structure.all import Sequence
 from sage.structure.richcmp import (richcmp_method, richcmp, rich_to_bool,
@@ -145,7 +145,7 @@ def __init__(self, group, weight, character, base_ring, category=None):
         weight = Integer(weight)
         if not ((character is None) or isinstance(character, dirichlet.DirichletCharacter)):
             raise TypeError("character must be a Dirichlet character")
-        if not isinstance(base_ring, Ring):
+        if base_ring not in Rings():
             raise TypeError("base_ring must be a ring")
         self.__sturm_bound = None
         self.__weight, self.__group, self.__character = weight, group, character
@@ -608,7 +608,7 @@ def integral_basis(self):
         pr = W.degree()
         B = self.q_integral_basis(pr)
         I = [self.linear_combination_of_basis(
-                  W.coordinates(f.padded_list(pr))) for f in B]
+            W.coordinates(f.padded_list(pr))) for f in B]
         return Sequence(I, cr=True, immutable=True)
 
     @cached_method
@@ -688,7 +688,7 @@ def q_expansion_basis(self, prec=None):
             ]
         """
         if prec is None:
-            try: # don't care about precision -- just must be big enough to determine forms
+            try:  # don't care about precision -- just must be big enough to determine forms
                 return self.__q_expansion_basis[1]
             except AttributeError:
                 pass
@@ -697,8 +697,8 @@ def q_expansion_basis(self, prec=None):
             prec = Integer(self.__normalize_prec(prec))
 
         if prec == 0:
-            z = self._q_expansion_ring()(0,prec)
-            return Sequence([z]*int(self.dimension()), immutable=True, cr=True)
+            z = self._q_expansion_ring()(0, prec)
+            return Sequence([z] * int(self.dimension()), immutable=True, cr=True)
         elif prec != -1:
             try:
                 current_prec, B = self.__q_expansion_basis
@@ -710,7 +710,7 @@ def q_expansion_basis(self, prec=None):
                 pass
 
         d = self.dimension()
-        current_prec = max(prec, self.prec(), int(1.2*d) + 3)         # +3 for luck.
+        current_prec = max(prec, self.prec(), int(1.2 * d) + 3)  # +3 for luck.
         tries = 0
         while True:
             B = [f for f in self._compute_q_expansion_basis(current_prec) if f != 0]
@@ -769,8 +769,8 @@ def q_echelon_basis(self, prec=None):
         """
         prec = self.__normalize_prec(prec)
         if prec == 0:
-            z = self._q_expansion_ring()(0,0)
-            return Sequence([z]*int(self.dimension()), cr=True)
+            z = self._q_expansion_ring()(0, 0)
+            return Sequence([z] * int(self.dimension()), cr=True)
         try:
             current_prec, B = self.__q_echelon_basis
         except AttributeError:
@@ -789,7 +789,7 @@ def q_echelon_basis(self, prec=None):
         T = self._q_expansion_ring()
         S = [T(f.list(), prec) for f in C.basis()]
         for _ in range(self.dimension() - len(S)):
-            S.append(T(0,prec))
+            S.append(T(0, prec))
         S = Sequence(S, immutable=True, cr=True)
         self.__q_echelon_basis = (prec, S)
         return S
@@ -818,8 +818,8 @@ def q_integral_basis(self, prec=None):
         prec = self.__normalize_prec(prec)
         R = PowerSeriesRing(ZZ, name=defaults.DEFAULT_VARIABLE)
         if prec == 0:
-            z = R(0,prec)
-            return Sequence([z]*int(self.dimension()), cr=True)
+            z = R(0, prec)
+            return Sequence([z] * int(self.dimension()), cr=True)
         try:
             current_prec, B = self.__q_integral_basis
         except AttributeError:

src/sage/modular/modsym/ambient.py

@@ -94,7 +94,7 @@ class ``ModularSymbolsAmbient``, derived from
 from sage.rings.integer_ring import ZZ
 from sage.rings.polynomial.multi_polynomial import MPolynomial
 from sage.rings.rational_field import QQ
-from sage.rings.ring import Ring
+from sage.categories.fields import Fields
 from sage.structure.factorization import Factorization
 from sage.structure.formal_sum import FormalSum
 
@@ -168,8 +168,8 @@ def __init__(self, group, weight, sign, base_ring,
             raise TypeError("group must be a congruence subgroup")
 
         sign = int(sign)
-        if not isinstance(base_ring, Ring) and base_ring.is_field():
-            raise TypeError("base_ring must be a commutative ring")
+        if base_ring not in Fields():
+            raise TypeError("base_ring must be a field")
 
         if character is None and arithgroup.is_Gamma0(group):
             character = TrivialCharacter(group.level(), base_ring)
@@ -2983,7 +2983,7 @@ def _compute_hecke_matrix_prime(self, p, rows=None):
             self._hecke_matrices = {}
         except KeyError:
             pass
-        tm = verbose("Computing Hecke operator T_%s" % p)
+        tm = verbose(f"Computing Hecke operator T_{p}")
 
         H = heilbronn.HeilbronnCremona(p)
         # H = heilbronn.HeilbronnMerel(p)

src/sage/modular/modsym/boundary.py

@@ -102,7 +102,7 @@
 from sage.modular.modsym.manin_symbol import ManinSymbol
 
 from sage.rings.rational_field import Q as QQ
-from sage.rings.ring import Ring
+from sage.categories.rings import Rings
 
 from . import element
 
@@ -320,7 +320,7 @@ def __init__(self,
         if not arithgroup.is_CongruenceSubgroup(group):
             raise TypeError("group must be a congruence subgroup")
         sign = int(sign)
-        if not isinstance(base_ring, Ring):
+        if base_ring not in Rings().Commutative():
             raise TypeError("base_ring must be a commutative ring")
         if character is None and arithgroup.is_Gamma0(group):
             character = dirichlet.TrivialCharacter(group.level(), base_ring)

src/sage/modular/modsym/relation_matrix.py

@@ -28,7 +28,7 @@
 from sage.misc.verbose import verbose
 from sage.modular.modsym.manin_symbol_list import ManinSymbolList
 from sage.rings.rational_field import is_RationalField
-from sage.rings.ring import Ring
+from sage.categories.rings import Rings
 
 
 SPARSE = True
@@ -551,8 +551,8 @@ def sparse_2term_quotient(rels, n, F):
         [(3, -1/3), (3, -1), (3, -1), (3, 1), (5, 1), (5, 1)]
     """
     n = int(n)
-    if not isinstance(F, Ring):
-        raise TypeError("F must be a ring.")
+    if F not in Rings():
+        raise TypeError("F must be a ring")
 
     tm = verbose("Starting sparse 2-term quotient...")
     free = list(range(n))