about error messages in categories/

Author: fchapoton

src/sage/arith/misc.py

@@ -559,7 +559,7 @@ def is_prime(n):
         if not isinstance(R, NumberField_generic):
             import warnings
             s = f'Testing primality in {R}, which is a field, ' \
-                 'hence the result will always be False. '
+                'hence the result will always be False. '
             if R is QQ:
                 s += 'To test whether n is a prime integer, use ' \
                      'is_prime(ZZ(n)) or ZZ(n).is_prime(). '
@@ -568,6 +568,7 @@ def is_prime(n):
 
     return ret
 
+
 def is_pseudoprime(n):
     r"""
     Test whether ``n`` is a pseudo-prime
@@ -2693,7 +2694,7 @@ def radical(n, *args, **kwds):
         sage: radical(0)
         Traceback (most recent call last):
         ...
-        ArithmeticError: Radical of 0 not defined.
+        ArithmeticError: radical of 0 is not defined
         sage: K.<i> = QuadraticField(-1)
         sage: radical(K(2))
         i + 1

src/sage/categories/fields.py

@@ -2,16 +2,16 @@
 r"""
 Fields
 """
-#*****************************************************************************
+# ****************************************************************************
 #  Copyright (C) 2005      David Kohel <[email protected]>
 #                          William Stein <[email protected]>
 #                2008      Teresa Gomez-Diaz (CNRS) <[email protected]>
 #                2008-2009 Nicolas M. Thiery <nthiery at users.sf.net>
 #                2012-2014 Julian Rueth <[email protected]>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
-#                  http://www.gnu.org/licenses/
-#******************************************************************************
+#                  https://www.gnu.org/licenses/
+# *****************************************************************************
 
 from sage.misc.lazy_attribute import lazy_class_attribute
 from sage.misc.lazy_import import LazyImport
@@ -22,6 +22,7 @@
 
 from sage.structure.element import coerce_binop
 
+
 class Fields(CategoryWithAxiom):
     """
     The category of (commutative) fields, i.e. commutative rings where
@@ -474,7 +475,7 @@ def _squarefree_decomposition_univariate_polynomial(self, f):
             if f.degree() == 0:
                 return Factorization([], unit=f[0])
             if self.characteristic() != 0:
-                raise NotImplementedError("square-free decomposition not implemented for this polynomial.")
+                raise NotImplementedError("square-free decomposition not implemented for this polynomial")
 
             factors = []
             cur = f

src/sage/categories/finite_posets.py

@@ -9,16 +9,17 @@
 - An *order ideal* (or *lower set*) of a poset `P` is a subset `S` of `P`
   such that if `x \leq y` and `y\in S` then `x\in S`.
 """
-#*****************************************************************************
+# ****************************************************************************
 #  Copyright (C) 2011 Nicolas M. Thiery <nthiery at users.sf.net>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
-#                  http://www.gnu.org/licenses/
-#******************************************************************************
+#                  https://www.gnu.org/licenses/
+# *****************************************************************************
 
 from sage.misc.abstract_method import abstract_method
 from sage.categories.category_with_axiom import CategoryWithAxiom
 
+
 class FinitePosets(CategoryWithAxiom):
     r"""
     The category of finite posets i.e. finite sets with a partial
@@ -1949,5 +1950,5 @@ def directed_subsets(self, direction):
                 [[]]
             """
             if direction != 'up' and direction != 'down':
-                raise ValueError("Direction must be either 'up' or 'down'.")
+                raise ValueError("direction must be either 'up' or 'down'")
             return self.antichains().map(lambda elements: self.directed_subset(elements, direction))

src/sage/categories/homset.py

@@ -81,6 +81,7 @@
 from sage.structure.coerce_dict import TripleDict
 _cache = TripleDict(weak_values=True)
 
+
 def Hom(X, Y, category=None, check=True):
     """
     Create the space of homomorphisms from X to Y in the category ``category``.
@@ -1141,16 +1142,15 @@ def identity(self):
             sage: H.identity()
             Traceback (most recent call last):
             ...
-            TypeError: Identity map only defined for endomorphisms. Try natural_map() instead.
+            TypeError: identity map only defined for endomorphisms; try natural_map() instead
             sage: H.natural_map()
             Natural morphism:
               From: Integer Ring
               To:   Rational Field
         """
         if self.is_endomorphism_set():
             return morphism.IdentityMorphism(self)
-        else:
-            raise TypeError("Identity map only defined for endomorphisms. Try natural_map() instead.")
+        raise TypeError("identity map only defined for endomorphisms; try natural_map() instead")
 
     def one(self):
         """

src/sage/categories/map.pyx

@@ -11,16 +11,15 @@ AUTHORS:
 - Sebastian Oehms   (2019-01-19): :meth:`section` added to :class:`FormalCompositeMap`.
   See :trac:`27081`.
 """
-
-#*****************************************************************************
+# ****************************************************************************
 #       Copyright (C) 2008 Robert Bradshaw <[email protected]>
 #
 # This program is free software: you can redistribute it and/or modify
 # 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/
+# ****************************************************************************
 
 from . import homset
 import weakref
@@ -52,6 +51,7 @@ def unpickle_map(_class, parent, _dict, _slots):
         mor.__dict__ = _dict
     return mor
 
+
 def is_Map(x):
     """
     Auxiliary function: Is the argument a map?
@@ -66,6 +66,7 @@ def is_Map(x):
     """
     return isinstance(x, Map)
 
+
 cdef class Map(Element):
     """
     Basic class for all maps.
@@ -1214,7 +1215,7 @@ cdef class Map(Element):
             sage: psi^2
             Traceback (most recent call last):
             ...
-            TypeError: self must be an endomorphism.
+            TypeError: self must be an endomorphism
 
             sage: K.<a> = NumberField(x^4 - 5*x + 5)
             sage: C5.<z> = CyclotomicField(5)
@@ -1230,7 +1231,7 @@ cdef class Map(Element):
               Defn: z |--> 3/11*a^3 + 4/11*a^2 + 9/11*a - 14/11
         """
         if self.domain() is not self._codomain and n != 1 and n != -1:
-            raise TypeError("self must be an endomorphism.")
+            raise TypeError("self must be an endomorphism")
         if n == 0:
             from sage.categories.morphism import IdentityMorphism
             return IdentityMorphism(self._parent)
@@ -1870,7 +1871,7 @@ cdef class FormalCompositeMap(Map):
             sage: c2.is_injective()
             Traceback (most recent call last):
             ...
-            NotImplementedError: Not enough information to deduce injectivity.
+            NotImplementedError: not enough information to deduce injectivity
 
         If the first map is surjective and the second map is not injective,
         then the composition is not injective::
@@ -1911,7 +1912,7 @@ cdef class FormalCompositeMap(Map):
         if all(f.is_surjective() for f in injectives):
             return False
 
-        raise NotImplementedError("Not enough information to deduce injectivity.")
+        raise NotImplementedError("not enough information to deduce injectivity")
 
     def is_surjective(self):
         """
@@ -1953,7 +1954,7 @@ cdef class FormalCompositeMap(Map):
             ....:     V2.hom(Matrix([[1], [1]]), V1)).is_surjective()
             Traceback (most recent call last):
             ...
-            NotImplementedError: Not enough information to deduce surjectivity.
+            NotImplementedError: not enough information to deduce surjectivity
         """
         try:
             # we try the category first
@@ -1977,7 +1978,7 @@ cdef class FormalCompositeMap(Map):
         if all(f.is_injective() for f in surjectives):
             return False
 
-        raise NotImplementedError("Not enough information to deduce surjectivity.")
+        raise NotImplementedError("not enough information to deduce surjectivity")
 
     def domains(self):
         """

src/sage/categories/posets.py

@@ -1,19 +1,19 @@
 r"""
 Posets
 """
-#*****************************************************************************
+# ****************************************************************************
 #  Copyright (C) 2011 Nicolas M. Thiery <nthiery at users.sf.net>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
-#                  http://www.gnu.org/licenses/
-#******************************************************************************
-
+#                  https://www.gnu.org/licenses/
+# *****************************************************************************
 from sage.misc.cachefunc import cached_method
 from sage.misc.abstract_method import abstract_method
 from sage.misc.lazy_import import LazyImport
 from sage.categories.category import Category
 from sage.categories.sets_cat import Sets
 
+
 class Posets(Category):
     r"""
     The category of posets i.e. sets with a partial order structure.
@@ -326,12 +326,20 @@ def directed_subset(self, elements, direction):
                 [3, 7, 8, 9, 10, 11, 12, 13, 14, 15]
                 sage: B.directed_subset([7, 10], 'down')
                 [0, 1, 2, 3, 4, 5, 6, 7, 8, 10]
+
+            TESTS::
+
+                sage: B = posets.BooleanLattice(3)
+                sage: B.directed_subset([3, 1], 'banana')
+                Traceback (most recent call last):
+                ...
+                ValueError: direction must be either 'up' or 'down'
             """
             if direction == 'up':
                 return self.order_filter(elements)
             if direction == 'down':
                 return self.order_ideal(elements)
-            raise ValueError("Direction must be either 'up' or 'down'.")
+            raise ValueError("direction must be either 'up' or 'down'")
 
         def principal_order_ideal(self, x):
             r"""

src/sage/categories/pushout.py

@@ -1,7 +1,6 @@
 """
 Coercion via construction functors
 """
-
 # ****************************************************************************
 #       Copyright (C) 2007-2014 Robert Bradshaw
 #                     2007-2018 David Roe
@@ -1293,10 +1292,9 @@ def _apply_functor_to_morphism(self, f):
             sage: R.construction()[0](f)     # indirect doctest
             Traceback (most recent call last):
             ...
-            NotImplementedError: Morphisms for infinite polynomial rings are not implemented yet.
-
+            NotImplementedError: morphisms for infinite polynomial rings are not implemented yet
         """
-        raise NotImplementedError("Morphisms for infinite polynomial rings are not implemented yet.")
+        raise NotImplementedError("morphisms for infinite polynomial rings are not implemented yet")
 
     def _apply_functor(self, R):
         """
@@ -3025,7 +3023,7 @@ def merge(self, other):
             # quotient by I would result in the trivial ring/group/...
             # Rather than create the zero ring, we claim they can't be merged
             # TODO: Perhaps this should be detected at a higher level...
-            raise TypeError("Trivial quotient intersection.")
+            raise TypeError("trivial quotient intersection")
         # GF(p) has a coercion from Integers(p). Hence, merging should
         # yield a field if either self or other yields a field.
         return QuotientFunctor(I, names=self.names, as_field=as_field,
@@ -4734,10 +4732,10 @@ def type_to_parent(P):
         sage: type_to_parent(list)
         Traceback (most recent call last):
         ...
-        TypeError: Not a scalar type.
+        TypeError: not a scalar type
     """
     from sage.structure.coerce import py_scalar_parent
     parent = py_scalar_parent(P)
     if parent is None:
-        raise TypeError("Not a scalar type.")
+        raise TypeError("not a scalar type")
     return parent

src/sage/categories/unique_factorization_domains.py

@@ -1,19 +1,20 @@
 r"""
 Unique factorization domains
 """
-#*****************************************************************************
+# ****************************************************************************
 #  Copyright (C) 2008 Teresa Gomez-Diaz (CNRS) <[email protected]>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
-#                  http://www.gnu.org/licenses/
-#******************************************************************************
+#                  https://www.gnu.org/licenses/
+# *****************************************************************************
 
 from sage.misc.lazy_attribute import lazy_class_attribute
 from sage.misc.misc_c import prod
 from sage.categories.category_singleton import Category_singleton
 from sage.categories.category_singleton import Category_contains_method_by_parent_class
 from sage.categories.gcd_domains import GcdDomains
 
+
 class UniqueFactorizationDomains(Category_singleton):
     """
     The category of (constructive) unique factorization domains.
@@ -242,7 +243,7 @@ def radical(self, *args, **kwds):
                 sage: Integer(0).radical()
                 Traceback (most recent call last):
                 ...
-                ArithmeticError: Radical of 0 not defined.
+                ArithmeticError: radical of 0 is not defined
 
             The next example shows how to compute the radical of a number,
             assuming no prime > 100000 has exponent > 1 in the factorization::
@@ -259,7 +260,7 @@ def radical(self, *args, **kwds):
                 10
             """
             if self.is_zero():
-                raise ArithmeticError("Radical of 0 not defined.")
+                raise ArithmeticError("radical of 0 is not defined")
             try:
                 decomp = self.squarefree_decomposition()
             except AttributeError: