Trac #34142: modernize super in algebras/

using the short syntax `super()`

URL: https://trac.sagemath.org/34142
Reported by: chapoton
Ticket author(s): Frédéric Chapoton
Reviewer(s): Matthias Koeppe

Author: Release Manager

src/sage/algebras/askey_wilson.py

@@ -237,7 +237,7 @@ def __classcall_private__(cls, R, q=None):
             raise ValueError("q={} is not invertible in {}".format(q, R))
         if R not in Rings().Commutative():
             raise ValueError("{} is not a commutative ring".format(R))
-        return super(AskeyWilsonAlgebra, cls).__classcall__(cls, R, q)
+        return super().__classcall__(cls, R, q)
 
     def __init__(self, R, q):
         r"""
@@ -932,4 +932,4 @@ def _composition_(self, right, homset):
             return AlgebraMorphism(homset.domain(),
                                    [right(g) for g in self._on_generators],
                                    codomain=homset.codomain(), category=cat)
-        return super(self, AlgebraMorphism)._composition_(right, homset)
+        return super()._composition_(right, homset)

src/sage/algebras/associated_graded.py

@@ -249,7 +249,7 @@ def _element_constructor_(self, x):
         if isinstance(x, CombinatorialFreeModule.Element):
             if x.parent() is self._A:
                 return self._from_dict(dict(x))
-        return super(AssociatedGradedAlgebra, self)._element_constructor_(x)
+        return super()._element_constructor_(x)
 
     def gen(self, *args, **kwds):
         """

src/sage/algebras/clifford_algebra.py

@@ -463,7 +463,7 @@ def __classcall_private__(cls, Q, names=None):
                 names = tuple( '{}{}'.format(names[0], i) for i in range(Q.dim()) )
             else:
                 raise ValueError("the number of variables does not match the number of generators")
-        return super(CliffordAlgebra, cls).__classcall__(cls, Q, names)
+        return super().__classcall__(cls, Q, names)
 
     def __init__(self, Q, names, category=None):
         r"""
@@ -637,7 +637,7 @@ def _coerce_map_from_(self, V):
         if self.free_module().has_coerce_map_from(V):
             return True
 
-        return super(CliffordAlgebra, self)._coerce_map_from_(V)
+        return super()._coerce_map_from_(V)
 
     def _element_constructor_(self, x):
         """
@@ -682,7 +682,7 @@ def _element_constructor_(self, x):
             R = self.base_ring()
             return self.element_class(self, {i: R(c) for i,c in x if R(c) != R.zero()})
 
-        return super(CliffordAlgebra, self)._element_constructor_(x)
+        return super()._element_constructor_(x)
 
     def gen(self, i):
         """
@@ -1369,7 +1369,7 @@ def __classcall_private__(cls, R, names=None, n=None):
                 names = tuple( '{}{}'.format(names[0], i) for i in range(n) )
             else:
                 raise ValueError("the number of variables does not match the number of generators")
-        return super(ExteriorAlgebra, cls).__classcall__(cls, R, names)
+        return super().__classcall__(cls, R, names)
 
     def __init__(self, R, names):
         """
@@ -2211,7 +2211,7 @@ def __classcall__(cls, E, s_coeff):
 
             if isinstance(v, dict):
                 R = E.base_ring()
-                v = E._from_dict({(i,): R(c) for i,c in v.items()})
+                v = E._from_dict({(i,): R(c) for i, c in v.items()})
             else:
                 # Make sure v is in ``E``
                 v = E(v)
@@ -2227,7 +2227,7 @@ def __classcall__(cls, E, s_coeff):
                 d[(k[1], k[0])] = -v
 
         from sage.sets.family import Family
-        return super(ExteriorAlgebraDifferential, cls).__classcall__(cls, E, Family(d))
+        return super().__classcall__(cls, E, Family(d))
 
     def __init__(self, E, s_coeff):
         """

src/sage/algebras/cluster_algebra.py

@@ -1338,7 +1338,7 @@ def __classcall__(self, data, **kwargs):
         # Determine scalars
         kwargs.setdefault('scalars', ZZ)
 
-        return super(ClusterAlgebra, self).__classcall__(self, B0, **kwargs)
+        return super().__classcall__(self, B0, **kwargs)
 
     def __init__(self, B, **kwargs):
         """

src/sage/algebras/finite_dimensional_algebras/finite_dimensional_algebra.py

@@ -140,8 +140,8 @@ def __classcall_private__(cls, k, table, names='e', assume_associative=False,
 
         names = normalize_names(n, names)
 
-        return super(FiniteDimensionalAlgebra, cls).__classcall__(cls, k, table,
-                             names, category=cat)
+        return super().__classcall__(cls, k, table,
+                                     names, category=cat)
 
     def __init__(self, k, table, names='e', category=None):
         """
@@ -249,7 +249,7 @@ def _Hom_(self, B, category):
         if category.is_subcategory(cat):
             from sage.algebras.finite_dimensional_algebras.finite_dimensional_algebra_morphism import FiniteDimensionalAlgebraHomset
             return FiniteDimensionalAlgebraHomset(self, B, category=category)
-        return super(FiniteDimensionalAlgebra, self)._Hom_(B, category)
+        return super()._Hom_(B, category)
 
     def ngens(self):
         """

src/sage/algebras/free_algebra.py

@@ -783,7 +783,7 @@ def quotient(self, mons, mats=None, names=None, **args):
             Free algebra quotient on 3 generators ('i', 'j', 'k') and dimension 4 over Rational Field
         """
         if mats is None:
-            return super(FreeAlgebra_generic, self).quotient(mons, names)
+            return super().quotient(mons, names)
         from . import free_algebra_quotient
         return free_algebra_quotient.FreeAlgebraQuotient(self, mons, mats, names)
 
@@ -1088,7 +1088,7 @@ def __classcall_private__(cls, R, n=None, names=None):
             if n is None:
                 n = len(names)
             alg = FreeAlgebra(R, n, names)
-        return super(PBWBasisOfFreeAlgebra, cls).__classcall__(cls, alg)
+        return super().__classcall__(cls, alg)
 
     def __init__(self, alg):
         """
@@ -1137,7 +1137,7 @@ def _repr_term(self, w):
             3*PBW[1]
         """
         if len(w) == 0:
-            return super(PBWBasisOfFreeAlgebra, self)._repr_term(w)
+            return super()._repr_term(w)
         ret = ''
         p = 1
         cur = None
@@ -1149,7 +1149,7 @@ def _repr_term(self, w):
                     if p != 1:
                         ret += "^{}".format(p)
                     ret += "*"
-                ret += super(PBWBasisOfFreeAlgebra, self)._repr_term(x.to_monoid_element())
+                ret += super()._repr_term(x.to_monoid_element())
                 cur = x
                 p = 1
         if p != 1:

src/sage/algebras/free_algebra_element.py

@@ -224,11 +224,11 @@ def _acted_upon_(self, scalar, self_on_left=False):
             if self_on_left:
                 return Factorization([(self, 1)]) * scalar
             return scalar * Factorization([(self, 1)])
-        return super(FreeAlgebraElement, self)._acted_upon_(scalar, self_on_left)
+        return super()._acted_upon_(scalar, self_on_left)
 
     # For backward compatibility
-    #_lmul_ = _acted_upon_
-    #_rmul_ = _acted_upon_
+    # _lmul_ = _acted_upon_
+    # _rmul_ = _acted_upon_
 
     def variables(self):
         """

src/sage/algebras/free_algebra_quotient.py

@@ -83,10 +83,11 @@ def __classcall__(cls, A, mons, mats, names):
             M = M.parent()(M)
             M.set_immutable()
             new_mats.append(M)
-        return super(FreeAlgebraQuotient, cls).__classcall__(cls, A, tuple(mons),
-                                                  tuple(new_mats), tuple(names))
+        return super().__classcall__(cls, A, tuple(mons),
+                                     tuple(new_mats), tuple(names))
 
     Element = FreeAlgebraQuotientElement
+
     def __init__(self, A, mons, mats, names):
         """
         Return a quotient algebra defined via the action of a free algebra

src/sage/algebras/free_zinbiel_algebra.py

@@ -211,10 +211,9 @@ def __classcall_private__(cls, R, n=None, names=None,
             side = '<'
         if side not in ['<', '>']:
             raise ValueError("side must be either '<' or '>'")
-        superclass = super(FreeZinbielAlgebra, cls)
         if names is None:
-            return superclass.__classcall__(cls, R, n, None, prefix, side)
-        return superclass.__classcall__(cls, R, n, tuple(names), prefix, side)
+            return super().__classcall__(cls, R, n, None, prefix, side)
+        return super().__classcall__(cls, R, n, tuple(names), prefix, side)
 
     def __init__(self, R, n, names, prefix, side):
         """
@@ -603,7 +602,7 @@ def _coerce_map_from_(self, R):
             return (all(x in self.variable_names()
                         for x in R.variable_names()) and
                     self.base_ring().has_coerce_map_from(R.base_ring()))
-        return super(FreeZinbielAlgebra, self)._coerce_map_from_(R)
+        return super()._coerce_map_from_(R)
 
     def construction(self):
         """

src/sage/algebras/hecke_algebras/ariki_koike_algebra.py

@@ -311,7 +311,7 @@ def __classcall_private__(cls, r, n, q=None, u=None, R=None):
             raise TypeError("base ring must be a commutative ring")
         q = R(q)
         u = tuple(u)
-        return super(ArikiKoikeAlgebra, cls).__classcall__(cls, r, n, q, u, R)
+        return super().__classcall__(cls, r, n, q, u, R)
 
     def __init__(self, r, n, q, u, R):
         r"""