Trac #21475: Make __nonzero__ an alias of __bool__ (in some python files)

This is part of #16076.

URL: https://trac.sagemath.org/21475
Reported by: aapitzsch
Ticket author(s): André Apitzsch
Reviewer(s): Travis Scrimshaw

Author: Release Manager

src/sage/algebras/jordan_algebra.py

@@ -405,7 +405,7 @@ def _latex_(self):
             from sage.misc.latex import latex
             return latex(self._x)
 
-        def __nonzero__(self):
+        def __bool__(self):
             """
             Return if ``self`` is non-zero.
 
@@ -414,10 +414,12 @@ def __nonzero__(self):
                 sage: F.<x,y,z> = FreeAlgebra(QQ)
                 sage: J = JordanAlgebra(F)
                 sage: a,b,c = map(J, F.gens())
-                sage: (a + 2*b - c).__nonzero__()
+                sage: bool(a + 2*b - c)
                 True
             """
-            return self._x.__nonzero__()
+            return bool(self._x)
+
+        __nonzero__ = __bool__
 
         def __eq__(self, other):
             """
@@ -805,22 +807,24 @@ def _latex_(self):
             from sage.misc.latex import latex
             return "{} + {}".format(latex(self._s), latex(self._v))
 
-        def __nonzero__(self):
+        def __bool__(self):
             """
             Return if ``self`` is non-zero.
 
             TESTS::
 
                 sage: m = matrix([[0,1],[1,1]])
                 sage: J.<a,b,c> = JordanAlgebra(m)
-                sage: 1.__nonzero__()
+                sage: bool(1)
                 True
-                sage: b.__nonzero__()
+                sage: bool(b)
                 True
-                sage: (a + 2*b - c).__nonzero__()
+                sage: bool(a + 2*b - c)
                 True
             """
-            return self._s.__nonzero__() or self._v.__nonzero__()
+            return bool(self._s) or bool(self._v)
+
+        __nonzero__ = __bool__
 
         def __eq__(self, other):
             """

src/sage/categories/crystals.py

@@ -2059,7 +2059,7 @@ def _call_(self, x):
                 cur = cur.e_string(s)
         return cur
 
-    def __nonzero__(self):
+    def __bool__(self):
         """
         Return if ``self`` is a non-zero morphism.
 
@@ -2076,6 +2076,8 @@ def __nonzero__(self):
         """
         return any(self._on_gens(mg) is not None for mg in self._gens)
 
+    __nonzero__ = __bool__
+
     # TODO: Does this belong in the element_class of the Crystals() category?
     def to_module_generator(self, x):
         """

src/sage/categories/examples/commutative_additive_monoids.py

@@ -110,20 +110,20 @@ def zero(self):
         return self(())
 
     class Element(FreeCommutativeAdditiveSemigroup.Element):
-        def __nonzero__(self):
+        def __bool__(self):
             """
             Check if ``self`` is not the zero of the monoid
 
             EXAMPLES::
 
                 sage: M = CommutativeAdditiveMonoids().example()
-                sage: M.zero().__nonzero__()
-                False
                 sage: bool(M.zero())
                 False
                 sage: [bool(m) for m in M.additive_semigroup_generators()]
                 [True, True, True, True]
             """
             return any(x for x in self.value.values())
 
+        __nonzero__ = __bool__
+
 Example = FreeCommutativeAdditiveMonoid

src/sage/categories/homset.py

@@ -698,7 +698,7 @@ def __hash__(self):
         """
         return hash((self._domain, self._codomain, self.base()))
 
-    def __nonzero__(self):
+    def __bool__(self):
         """
         TESTS::
 
@@ -707,6 +707,8 @@ def __nonzero__(self):
         """
         return True
 
+    __nonzero__ = __bool__
+
     def _generic_convert_map(self, S):
         """
         Return a generic map from a given homset to ``self``.

src/sage/combinat/crystals/kirillov_reshetikhin.py

@@ -4115,5 +4115,6 @@ def is_isomorphism(self):
     is_surjective = is_isomorphism
     is_embedding = is_isomorphism
     is_strict = is_isomorphism
+    __bool__ = is_isomorphism
     __nonzero__ = is_isomorphism
 

src/sage/combinat/finite_state_machine.py

@@ -1975,7 +1975,7 @@ def fully_equal(left, right, compare_color=True):
                 left.initial_probability == right.initial_probability)
 
 
-    def __nonzero__(self):
+    def __bool__(self):
         """
         Returns True.
 
@@ -1990,12 +1990,15 @@ def __nonzero__(self):
         TESTS::
 
             sage: from sage.combinat.finite_state_machine import FSMState
-            sage: FSMState('A').__nonzero__()
+            sage: bool(FSMState('A'))
             True
         """
         return True  # A state cannot be zero (see __init__)
 
 
+    __nonzero__ = __bool__
+
+
     def _epsilon_successors_(self, fsm=None):
         """
         Returns the dictionary with states reachable from ``self``
@@ -2502,7 +2505,7 @@ def __ne__(left, right):
         return (not (left == right))
 
 
-    def __nonzero__(self):
+    def __bool__(self):
         """
         Returns True.
 
@@ -2517,11 +2520,13 @@ def __nonzero__(self):
         EXAMPLES::
 
             sage: from sage.combinat.finite_state_machine import FSMTransition
-            sage: FSMTransition('A', 'B', 0).__nonzero__()
+            sage: bool(FSMTransition('A', 'B', 0))
             True
         """
         return True  # A transition cannot be zero (see __init__)
 
+    __nonzero__ = __bool__
+
 
 #*****************************************************************************
 
@@ -3918,7 +3923,7 @@ def __call__(self, *args, **kwargs):
     #*************************************************************************
 
 
-    def __nonzero__(self):
+    def __bool__(self):
         """
         Returns True if the finite state machine consists of at least
         one state.
@@ -3933,12 +3938,15 @@ def __nonzero__(self):
 
         TESTS::
 
-            sage: FiniteStateMachine().__nonzero__()
+            sage: bool(FiniteStateMachine())
             False
         """
         return len(self._states_) > 0
 
 
+    __nonzero__ = __bool__
+
+
     def __eq__(left, right):
         """
         Returns ``True`` if the two finite state machines are equal,

src/sage/groups/abelian_gps/abelian_group.py

@@ -676,7 +676,7 @@ def is_trivial(self):
         """
         return self.elementary_divisors() == ()
 
-    def __nonzero__(self):
+    def __bool__(self):
         """
         Returns True if this group is nontrivial.
 
@@ -692,6 +692,8 @@ def __nonzero__(self):
         """
         return not self.is_trivial()
 
+    __nonzero__ = __bool__
+
     @cached_method
     def dual_group(self, names="X", base_ring=None):
         """

src/sage/misc/unknown.py

@@ -54,7 +54,7 @@ def _repr_(self):
         """
         return "Unknown"
 
-    def __nonzero__(self):
+    def __bool__(self):
         """
         When evaluated in a boolean context ``Unknown()`` is evalutated into
         ``False``.
@@ -68,6 +68,8 @@ def __nonzero__(self):
         """
         return False
 
+    __nonzero__ = __bool__
+
     def __and__(self, other):
         """
         The ``and`` logical connector.