Trac #24103: Remove a lot of deprecated code

Remove code deprecated in #2536, #13605, #14469, #16930, #16983, #16878,
#17229, #17443, #17451, #17686, #18558, #19694, #19888, #20015, #20253,
#20318, #20442, #21141, #21145, #21148, #21376, #21435

This includes a lot of deprecations for `cmp` instead of `key` for
sorting.

URL: https://trac.sagemath.org/24103
Reported by: jdemeyer
Ticket author(s): Jeroen Demeyer
Reviewer(s): Travis Scrimshaw

Author: Release Manager

src/sage/algebras/algebra_element.py

@@ -259,9 +259,6 @@ def quit_sage(verbose=True):
     from sage.libs.all import symmetrica
     symmetrica.end()
 
-# A deprecation(20442) warning will be given when this module is
-# imported, in particular when these functions are used.
-lazy_import("sage.ext.interactive_constructors_c", ["inject_on", "inject_off"])
 
 sage.structure.sage_object.register_unpickle_override('sage.categories.category', 'Sets', Sets)
 sage.structure.sage_object.register_unpickle_override('sage.categories.category_types', 'HeckeModules', HeckeModules)
@@ -271,6 +268,7 @@ def quit_sage(verbose=True):
 sage.structure.sage_object.register_unpickle_override('sage.categories.category_types', 'VectorSpaces', VectorSpaces)
 sage.structure.sage_object.register_unpickle_override('sage.categories.category_types', 'Schemes_over_base', sage.categories.schemes.Schemes_over_base)
 sage.structure.sage_object.register_unpickle_override('sage.categories.category_types', 'ModularAbelianVarieties', ModularAbelianVarieties)
+sage.structure.sage_object.register_unpickle_override('sage.libs.pari.gen_py', 'pari', pari)
 
 # Cache the contents of star imports.
 sage.misc.lazy_import.save_cache_file()

src/sage/all.py

@@ -232,33 +232,6 @@ def indices(self):
         """
         return Subsets(self._S)
 
-    def indices_cmp(self, x, y):
-        r"""
-        A comparison function on sets which gives a linear extension
-        of the inclusion order.
-
-        INPUT:
-
-        - ``x``, ``y`` -- sets
-
-        EXAMPLES::
-
-            sage: from functools import cmp_to_key
-            sage: A = Sets().WithRealizations().example(); A
-            The subset algebra of {1, 2, 3} over Rational Field
-            sage: sorted(A.indices(), key=cmp_to_key(A.indices_cmp))
-            doctest:...: DeprecationWarning: indices_cmp is deprecated, use indices_key instead.
-            See http://trac.sagemath.org/17229 for details.
-            [{}, {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3}]
-        """
-        from sage.misc.superseded import deprecation
-        deprecation(17229, "indices_cmp is deprecated, use indices_key instead.")
-
-        s = (len(x) > len(y)) - (len(x) < len(y))
-        if s != 0:
-            return s
-        return (list(x) > list(y)) - (list(x) < list(y))
-
     def indices_key(self, x):
         r"""
         A key function on a set which gives a linear extension

src/sage/categories/examples/with_realizations.py

@@ -433,13 +433,6 @@ def __init__(self, R, basis_keys=None, element_class=None, category=None,
 
         # ignore the optional 'key' since it only affects CachedRepresentation
         kwds.pop('key', None)
-        # This needs to be first as per #10127
-        if 'monomial_cmp' in kwds:
-            from sage.misc.superseded import deprecation
-            deprecation(17229, "Option monomial_cmp is deprecated, use sorting_key and sorting_reverse instead.")
-            from functools import cmp_to_key
-            kwds['sorting_key'] = cmp_to_key(kwds['monomial_cmp'])
-            del kwds['monomial_cmp']
         if 'monomial_key' in kwds:
             kwds['sorting_key'] = kwds.pop('monomial_key')
         if 'monomial_reverse' in kwds:

src/sage/combinat/free_module.py

@@ -410,8 +410,6 @@ def iterator(n, min_length, max_length, floor, ceiling, min_slope, max_slope):
         sage: list(iterator(2, 3, 3, lambda i: 0, lambda i: 5, 0, 10))
         [[0, 1, 1], [0, 0, 2]]
     """
-    #from sage.misc.superseded import deprecation
-    #deprecation(13605, 'iterator(...) is deprecated. Use IntegerListLex(...) instead.')
     stopgap("Iterator uses the old implementation of IntegerListsLex, which does not allow for arbitrary input;"
             " non-allowed input can return wrong results,"
             " please see the documentation for IntegerListsLex for details.",

src/sage/combinat/integer_list_old.py

@@ -716,153 +716,6 @@ def normalize(self, inplace=False):
                 resl[i] = resl[i].normalize()
             resl.sort(key=lambda t: t.sort_key())
 
-    def dendrog_cmp(self, other):
-        r"""
-        Return `-1` if ``self`` is smaller than ``other`` in the
-        dendrographical order; return `0` if they are equal;
-        return `1` if ``other`` is smaller.
-
-        .. NOTE:: This is deprecated.
-
-        The dendrographical order is a total order on the set of
-        unlabelled ordered rooted trees; it is defined recursively
-        as follows: An ordered rooted tree `T` with children
-        `T_1, T_2, \ldots, T_a` is smaller than an
-        ordered rooted tree `S` with children
-        `S_1, S_2, \ldots, S_b` if either `a < b` or (`a = b`
-        and there exists a `1 \leq i \leq a` such that
-        `T_1 = S_1, T_2 = S_2, \ldots, T_{i-1} = S_{i-1}` and
-        `T_i < S_i`).
-
-        INPUT:
-
-        - ``other`` -- an ordered rooted tree
-
-        OUTPUT:
-
-        - `-1`, if ``smaller < other`` with respect to the
-          dendrographical order.
-        - `0`, if ``smaller == other`` (as unlabelled ordered
-          rooted trees).
-        - `1`, if ``smaller > other`` with respect to the
-          dendrographical order.
-
-        .. NOTE::
-
-            It is possible to provide labelled trees to this
-            method; however, their labels are ignored.
-
-        EXAMPLES::
-
-            sage: OT = OrderedTree
-            sage: ta = OT([])
-            sage: tb = OT([[], [], [[], []]])
-            sage: tc = OT([[], [[], []], []])
-            sage: td = OT([[[], []], [], []])
-            sage: te = OT([[], []])
-            sage: tf = OT([[], [], []])
-            sage: tg = OT([[[], []], [[], []]])
-            sage: l = [ta, tb, tc, td, te, tf, tg]
-            sage: [l[i].dendrog_cmp(l[j]) for i in range(7) for j in range(7)]
-            doctest:...: DeprecationWarning: Please use 'sort_key' to sort.
-            See http://trac.sagemath.org/21148 for details.
-            doctest:...: DeprecationWarning: Please use 'sort_key' to sort.
-            See http://trac.sagemath.org/21148 for details.
-            [0, -1, -1, -1, -1, -1, -1,
-             1, 0, -1, -1, 1, 1, 1,
-             1, 1, 0, -1, 1, 1, 1,
-             1, 1, 1, 0, 1, 1, 1,
-             1, -1, -1, -1, 0, -1, -1,
-             1, -1, -1, -1, 1, 0, 1,
-             1, -1, -1, -1, 1, -1, 0]
-        """
-        from sage.misc.superseded import deprecation
-        deprecation(21148, "Please use 'sort_key' to sort.")
-
-        if len(self) < len(other):
-            return -1
-        if len(self) > len(other):
-            return 1
-        for (a, b) in zip(self, other):
-            comp = a.dendrog_cmp(b)
-            if comp != 0:
-                return comp
-        return 0
-
-    @cached_method
-    def dendrog_normalize(self, inplace=False):
-        r"""
-        Return the normalized tree of the *unlabelled* ordered rooted
-        tree ``self`` with respect to the dendrographical order.
-
-        INPUT:
-
-        - ``inplace`` -- (default ``False``) boolean; if ``True``,
-          then ``self`` is modified and nothing returned; otherwise
-          the normalized tree is returned
-
-        .. NOTE:: This is deprecated.
-
-        The normalized tree of an unlabelled ordered rooted tree
-        `t` with respect to the dendrographical order is an
-        unlabelled ordered rooted tree defined recursively
-        as follows: We first replace all children of `t` by their
-        normalized trees (with respect to the dendrographical
-        order); then, we reorder these children in weakly
-        increasing order with respect to the dendrographical order
-        (:meth:`dendrog_cmp`).
-
-        This can be viewed as an alternative to :meth:`normalize`
-        for the case of unlabelled ordered rooted trees.
-
-        EXAMPLES::
-
-            sage: OT = OrderedTree
-            sage: ta = OT([[],[[]]])
-            sage: tb = OT([[[]],[]])
-            sage: ta.dendrog_normalize() == tb.dendrog_normalize()
-            doctest:...: DeprecationWarning: Please use 'sort_key' to sort.
-            See http://trac.sagemath.org/21148 for details.
-            doctest:...: DeprecationWarning: Please use 'sort_key' to sort.
-            See http://trac.sagemath.org/21148 for details.
-            doctest:...: DeprecationWarning: Please use 'sort_key' to sort.
-            See http://trac.sagemath.org/21148 for details.
-            True
-            sage: ta == tb
-            False
-            sage: ta.dendrog_normalize()
-            [[], [[]]]
-
-        An example with inplace normalization::
-
-            sage: OT = OrderedTree
-            sage: ta = OT([[],[[]]])
-            sage: tb = OT([[[]],[]])
-            sage: ta.dendrog_normalize(inplace=True); ta
-            doctest:...: DeprecationWarning: Please use 'sort_key' to sort.
-            See http://trac.sagemath.org/21148 for details.
-            [[], [[]]]
-            sage: tb.dendrog_normalize(inplace=True); tb
-            [[], [[]]]
-        """
-        from sage.misc.superseded import deprecation
-        deprecation(21148, "Please use 'sort_key' to sort.")
-        
-        def dendrog_cmp(a, b):
-            return a.dendrog_cmp(b)
-        if not inplace:
-            with self.clone() as res:
-                resl = res._get_list()
-                for i in range(len(resl)):
-                    resl[i] = resl[i].dendrog_normalize()
-                resl.sort(cmp=dendrog_cmp)
-            return res
-
-        resl = self._get_list()
-        for i in range(len(resl)):
-            resl[i] = resl[i].dendrog_normalize()
-        resl.sort(cmp=dendrog_cmp)
-
 
 # Abstract class to serve as a Factory no instance are created.
 class OrderedTrees(UniqueRepresentation, Parent):

src/sage/combinat/ordered_tree.py

@@ -7682,7 +7682,7 @@ def permutohedron_lequal(p1, p2, side="right"):
 ############
 from sage.combinat.words.finite_word import evaluation_dict
 
-def to_standard(p, cmp=None, key=None):
+def to_standard(p, key=None):
     r"""
     Return a standard permutation corresponding to the iterable ``p``.
 
@@ -7691,11 +7691,6 @@ def to_standard(p, cmp=None, key=None):
     - ``p`` -- an iterable
     - ``key`` -- (optional) a comparison key for the element
       ``x`` of ``p``
-    - ``cmp`` -- (optional, deprecated) a comparison function for the
-      two elements ``x`` and ``y`` of ``p`` (return an integer
-      according to the outcome)
-
-    Using ``cmp`` is no longer allowed in Python3 and should be avoided.
 
     EXAMPLES::
 
@@ -7738,20 +7733,9 @@ def to_standard(p, cmp=None, key=None):
         sage: p = list(Words(100, 1000).random_element())
         sage: std(p) == permutation.to_standard(p)
         True
-
-    Deprecation of ``cmp`` in favor of ``key``::
-
-        sage: permutation.to_standard([5,8,2,5], cmp=lambda x,y: (x<y)-(x>y))
-        doctest:warning...:
-        DeprecationWarning: do not use 'cmp' but rather 'key' for comparison
-        See http://trac.sagemath.org/21435 for details.
-        [2, 1, 4, 3]
     """
-    if cmp is not None:
-       from sage.misc.superseded import deprecation
-       deprecation(21435, "do not use 'cmp' but rather 'key' for comparison")
     ev_dict = evaluation_dict(p)
-    ordered_alphabet = sorted(ev_dict, cmp=cmp, key=key)
+    ordered_alphabet = sorted(ev_dict, key=key)
     offset = 0
     for k in ordered_alphabet:
         temp = ev_dict[k]

src/sage/combinat/permutation.py

@@ -18,11 +18,6 @@ class that inherits from it) and implement the following methods.
       should return something that can be readily compared by
       Python. By default, the letters themselves are used.
 
-    - cmp_letters(x,y) -- a function to compare letters in the alphabet;
-      should behave like Python's cmp function (that is, it returns -1, 0
-      or 1, if x < y, x == y, x > y, respectively). By default, this points
-      to Python's cmp function. (DEPRECATED, do not use, see :trac:`21435`)
-
 By implementing the above methods, almost anything can be used as an
 alphabet.
 

src/sage/combinat/words/notes/word_inheritance_howto.txt

@@ -316,9 +316,6 @@ def __init__(self, options, args):
 
         if isinstance(options.optional, six.string_types):
             s = options.optional.lower()
-            if s == 'true':
-                sage.misc.superseded.deprecation(18558, "Use --optional=all instead of --optional=true")
-                s = "all"
             options.optional = set(s.split(','))
             if "all" in options.optional:
                 # Special case to run all optional tests
@@ -947,11 +944,6 @@ def _optional_tags_string(self):
             sage: DC = DocTestController(DocTestDefaults(optional="all,and,some,more"), [])
             sage: DC._optional_tags_string()
             'all'
-            sage: DC = DocTestController(DocTestDefaults(optional="true"), [])
-            doctest:...: DeprecationWarning: Use --optional=all instead of --optional=true
-            See http://trac.sagemath.org/18558 for details.
-            sage: DC._optional_tags_string()
-            'all'
             sage: DC = DocTestController(DocTestDefaults(optional="sage,openssl"), [])
             sage: DC._optional_tags_string()
             'openssl,sage'