sage.structure: Update # needs

Author: Matthias Koeppe

src/sage/structure/coerce_actions.pyx

@@ -782,16 +782,18 @@ cdef class IntegerMulAction(IntegerAction):
 
         Check that large multiplications can be interrupted::
 
-            sage: alarm(0.001); 2^(10^7) * P                                            # needs sage.schemes
+            sage: # needs sage.schemes
+            sage: alarm(0.001); 2^(10^7) * P
             Traceback (most recent call last):
             ...
             AlarmInterrupt
 
         Verify that cysignals correctly detects that the above
         exception has been handled::
 
+            sage: # needs sage.schemes
             sage: from cysignals.tests import print_sig_occurred
-            sage: print_sig_occurred()                                                  # needs sage.schemes
+            sage: print_sig_occurred()
             No current exception
         """
         cdef int err = 0

src/sage/structure/factorization.py

@@ -1231,9 +1231,9 @@ def __call__(self, *args, **kwds):
             sage: F(t=0)
             0
 
-            sage: R.<x> = LaurentPolynomialRing(QQ, 1)
-            sage: F = ((x+2)/x**3).factor()
-            sage: F(x=4)
+            sage: R.<x> = LaurentPolynomialRing(QQ, 1)                                  # needs sage.modules
+            sage: F = ((x+2)/x**3).factor()                                             # needs sage.modules
+            sage: F(x=4)                                                                # needs sage.modules
             1/64 * 6
         """
         unit = self.__unit.subs(*args, **kwds)

src/sage/structure/parent.pyx

@@ -1083,54 +1083,56 @@ cdef class Parent(sage.structure.category_object.CategoryObject):
             True
             sage: 5 in QQ
             True
-            sage: I in RR                                                               # needs sage.rings.real_mpfr
+            sage: I in RR                                                               # needs sage.rings.real_mpfr sage.symbolic
             False
-            sage: SR(2) in ZZ                                                           # needs sage.symbolic
+            sage: RIF(1, 2) in RIF                                                      # needs sage.rings.real_interval_field
             True
-            sage: RIF(1, 2) in RIF
+
+            sage: # needs sage.symbolic
+            sage: SR(2) in ZZ
             True
-            sage: pi in RIF  # there is no element of RIF equal to pi                   # needs sage.symbolic
+            sage: pi in RIF  # there is no element of RIF equal to pi
             False
-            sage: sqrt(2) in CC                                                         # needs sage.symbolic
+            sage: sqrt(2) in CC
             True
-            sage: pi in RR                                                              # needs sage.symbolic
+            sage: pi in RR
             True
-            sage: pi in CC                                                              # needs sage.symbolic
+            sage: pi in CC
             True
-            sage: pi in RDF                                                             # needs sage.symbolic
+            sage: pi in RDF
             True
-            sage: pi in CDF                                                             # needs sage.symbolic
+            sage: pi in CDF
             True
 
         Note that we have
 
         ::
 
-            sage: 3/2 in RIF
+            sage: 3/2 in RIF                                                            # needs sage.rings.real_interval_field
             True
 
         because ``3/2`` has an exact representation in ``RIF`` (i.e. can be
         represented as an interval that contains exactly one value)::
 
-            sage: RIF(3/2).is_exact()
+            sage: RIF(3/2).is_exact()                                                   # needs sage.rings.real_interval_field
             True
 
         On the other hand, we have
 
         ::
 
-            sage: 2/3 in RIF
+            sage: 2/3 in RIF                                                            # needs sage.rings.real_interval_field
             False
 
         because ``2/3`` has no exact representation in ``RIF``. Since
         ``RIF(2/3)`` is a nontrivial interval, it cannot be equal to anything
         (not even itself)::
 
-            sage: RIF(2/3).is_exact()
+            sage: RIF(2/3).is_exact()                                                   # needs sage.rings.real_interval_field
             False
-            sage: RIF(2/3).endpoints()
+            sage: RIF(2/3).endpoints()                                                  # needs sage.rings.real_interval_field
             (0.666666666666666, 0.666666666666667)
-            sage: RIF(2/3) == RIF(2/3)
+            sage: RIF(2/3) == RIF(2/3)                                                  # needs sage.rings.real_interval_field
             False
 
         TESTS:

src/sage/structure/sequence.py

@@ -45,8 +45,8 @@
 special parent.  This is what should happen, e.g., with finite field
 elements of different characteristics::
 
-    sage: v = Sequence([GF(3)(1), GF(7)(1)])                                            # needs sage.rings.finite_rings
-    sage: v.universe()                                                                  # needs sage.rings.finite_rings
+    sage: v = Sequence([GF(3)(1), GF(7)(1)])
+    sage: v.universe()
     Category of objects
 
 You can make a list immutable with ``v.freeze()``.  Assignment is

src/sage/structure/unique_representation.py

@@ -112,9 +112,9 @@ class will by default also be used as keys for the cache::
 when comparing elements of *distinct* algebraic structures!!). Hence, we
 have::
 
-    sage: GF(5)(2) == GF(3)(2)                                                          # needs sage.rings.finite_rings
+    sage: GF(5)(2) == GF(3)(2)
     False
-    sage: C(GF(3)(2)) is C(GF(5)(2))                                                    # needs sage.rings.finite_rings
+    sage: C(GF(3)(2)) is C(GF(5)(2))
     False
 
 Normalising the arguments