simple changes in infinite polynomial rings

src/sage/rings/polynomial/infinite_polynomial_ring.py

@@ -491,7 +491,7 @@ def __getitem__(self, k):
         try:
             if len(L) == 2:
                 return self._D[L[0]][int(L[1])]
-        except Exception:
+        except (TypeError, ValueError):
             pass
         raise KeyError("%s is not a variable name" % k)
 
@@ -614,7 +614,7 @@ def __getitem__(self, k):
                 return D[k]
             except KeyError:
                 pass
-        raise KeyError("%s is not a variable name of %s or its iterated base rings" % (k, self._P))
+        raise KeyError("{} is not a variable name of {} or its iterated base rings".format(k, self._P))
 
 
 ##############################################################
@@ -739,7 +739,7 @@ def __init__(self, R, names, order):
 
         # some basic data
         self._order = order
-        self._name_dict = dict([(names[i], i) for i in range(len(names))])
+        self._name_dict = {name: i for i, name in enumerate(names)}
         from sage.categories.commutative_algebras import CommutativeAlgebras
         CommutativeRing.__init__(self, R, category=CommutativeAlgebras(R))
 
@@ -755,7 +755,7 @@ def __repr__(self):
             sage: X.<alpha,beta> = InfinitePolynomialRing(ZZ, order='deglex'); X
             Infinite polynomial ring in alpha, beta over Integer Ring
         """
-        return "Infinite polynomial ring in %s over %s" % (", ".join(self._names), self._base)
+        return "Infinite polynomial ring in {} over {}".format(", ".join(self._names), self._base)
 
     def _latex_(self):
         r"""
@@ -768,7 +768,7 @@ def _latex_(self):
         """
         from sage.misc.latex import latex
         vars = ', '.join(latex(X) for X in self.gens())
-        return "%s[%s]" % (latex(self.base_ring()), vars)
+        return f"{latex(self.base_ring())}[{vars}]"
 
     @cached_method
     def _an_element_(self):
@@ -856,7 +856,7 @@ def _coerce_map_from_(self, S):
             # We do not care about the orders. But base ring and generators
             # of the pushout should remain the same as in self.
             return P._names == self._names and P._base == self._base
-        except Exception:
+        except (TypeError, ValueError):
             return False
 
     def _element_constructor_(self, x):
@@ -896,15 +896,15 @@ def _element_constructor_(self, x):
         if isinstance(x, str):
             try:
                 x = sage_eval(x, self.gens_dict())
-            except Exception:
-                raise ValueError("cannot convert %s into an element of %s" % (x, self))
+            except (TypeError, ValueError, SyntaxError):
+                raise ValueError(f"cannot convert {x} into an element of {self}")
             P = parent(x)
             if P is self:
                 return x
             elif self._base.has_coerce_map_from(P):
                 return InfinitePolynomial(self, self._base(x))
             else:
-                raise ValueError("cannot convert %s into an element of %s" % (x, self))
+                raise ValueError(f"cannot convert {x} into an element of {self}")
 
         if isinstance(parent(x), InfinitePolynomialRing_sparse):
             # the easy case - parent == self - is already past
@@ -926,7 +926,7 @@ def _element_constructor_(self, x):
             # remark: Conversion to self._P (if applicable)
             # is done in InfinitePolynomial()
             return InfinitePolynomial(self, x)
-        except Exception:
+        except (TypeError, ValueError):
             pass
 
         # By now, we can assume that x has a parent, because
@@ -937,8 +937,8 @@ def _element_constructor_(self, x):
         if not hasattr(x, 'variables'):
             try:
                 return sage_eval(repr(x), self.gens_dict())
-            except Exception:
-                raise ValueError("cannot convert %s into an element of %s" % (x, self))
+            except (TypeError, ValueError, SyntaxError):
+                raise ValueError(f"cannot convert {x} into an element of {self}")
 
         # direct conversion will only be used if the underlying polynomials are libsingular.
         from sage.rings.polynomial.multi_polynomial import MPolynomial_libsingular
@@ -965,7 +965,7 @@ def _element_constructor_(self, x):
                             # This tests admissibility on the fly:
                             VarList.sort(key=self.varname_key, reverse=True)
                         except ValueError:
-                            raise ValueError("cannot convert %s into an element of %s - variables are not admissible" % (x, self))
+                            raise ValueError("cannot convert {} into an element of {} - variables are not admissible".format(x, self))
                         xmaxind = max([int(v.split('_')[1]) for v in VarList])
                     try:
                         # Apparently, in libsingular, the polynomial conversion is not done by
@@ -981,13 +981,13 @@ def _element_constructor_(self, x):
                         # conversion to self._P will be done in InfinitePolynomial.__init__
                         return InfinitePolynomial(self, x)
                     except (ValueError, TypeError, NameError):
-                        raise ValueError("cannot convert %s (from %s, but variables %s) into an element of %s - no conversion into underlying polynomial ring %s" % (x, x.parent(), x.variables(), self, self._P))
+                        raise ValueError("cannot convert {} (from {}, but variables {}) into an element of {} - no conversion into underlying polynomial ring {}".format(x, x.parent(), x.variables(), self, self._P))
             # By now, x or self._P are not libsingular. Since MPolynomialRing_polydict
             # is too buggy, we use string evaluation
             try:
                 return sage_eval(repr(x), self.gens_dict())
             except (ValueError, TypeError, NameError):
-                raise ValueError("cannot convert %s into an element of %s - no conversion into underlying polynomial ring" % (x, self))
+                raise ValueError("cannot convert {} into an element of {} - no conversion into underlying polynomial ring".format(x, self))
 
         # By now, we are in the sparse case.
         try:
@@ -998,7 +998,7 @@ def _element_constructor_(self, x):
             # This tests admissibility on the fly:
             VarList.sort(key=self.varname_key, reverse=True)
         except ValueError:
-            raise ValueError("cannot convert %s into an element of %s - variables are not admissible" % (x, self))
+            raise ValueError("cannot convert {} into an element of {} - variables are not admissible".format(x, self))
 
         if len(VarList) == 1:
             # univariate polynomial rings are crab. So, make up another variable.
@@ -1017,7 +1017,7 @@ def _element_constructor_(self, x):
         try:
             VarList.sort(key=self.varname_key, reverse=True)
         except ValueError:
-            raise ValueError("cannot convert %s into an element of %s; the variables are not admissible" % (x, self))
+            raise ValueError("cannot convert {} into an element of {}; the variables are not admissible".format(x, self))
 
         from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
         R = PolynomialRing(self._base, VarList, order=self._order)
@@ -1031,16 +1031,16 @@ def _element_constructor_(self, x):
                     # Hence, for being on the safe side, we coerce into a pushout ring:
                     x = R(1) * x
                     return InfinitePolynomial(self, x)
-                except Exception:
+                except (TypeError, ValueError):
                     # OK, last resort, to be on the safe side
                     try:
                         return sage_eval(repr(x), self.gens_dict())
                     except (ValueError, TypeError, NameError):
-                        raise ValueError("cannot convert %s into an element of %s; conversion of the underlying polynomial failed" % (x, self))
+                        raise ValueError("cannot convert {} into an element of {}; conversion of the underlying polynomial failed".format(x, self))
         try:
             return sage_eval(repr(x), self.gens_dict())
         except (ValueError, TypeError, NameError):
-            raise ValueError("cannot convert %s into an element of %s" % (x, self))
+            raise ValueError(f"cannot convert {x} into an element of {self}")
 
     def tensor_with_ring(self, R):
         """
@@ -1085,7 +1085,7 @@ def tensor_with_ring(self, R):
         # try to find the correct base ring in other ways:
         try:
             o = B.one() * R.one()
-        except Exception:
+        except (TypeError, ValueError):
             raise TypeError("we cannot tensor with " + repr(R))
         return InfinitePolynomialRing(o.parent(), self._names, self._order, implementation='sparse')
 
@@ -1528,7 +1528,7 @@ def __str__(self):
             sage: print(x) # indirect doctest
             Generator for the x's in Infinite polynomial ring in x, y over Rational Field
         """
-        return "Generator for the %s's in %s" % (self._name, self._parent)
+        return f"Generator for the {self._name}'s in {self._parent}"
 
 
 ##############################################################
@@ -1623,7 +1623,7 @@ def tensor_with_ring(self, R):
         # try to find the correct base ring in other ways:
         try:
             o = B.one() * R.one()
-        except Exception:
+        except (TypeError, ValueError):
             raise TypeError("we cannot tensor with " + repr(R))
         return InfinitePolynomialRing(o.parent(), self._names, self._order, implementation='dense')