set sort edges to False by default

Author: dcoudert

src/sage/graphs/digraph.py

@@ -3614,7 +3614,8 @@ def flow_polytope(self, edges=None, ends=None, backend=None):
 
         Using a different order for the edges of the graph::
 
-            sage: fl = G.flow_polytope(edges=G.edges(key=lambda x: x[0] - x[1])); fl    # needs sage.geometry.polyhedron
+            sage: ordered_edges = G.edges(sort=True, key=lambda x: x[0] - x[1])
+            sage: fl = G.flow_polytope(edges=ordered_edges); fl                         # needs sage.geometry.polyhedron
             A 1-dimensional polyhedron in QQ^4 defined as the convex hull of 2 vertices
             sage: fl.vertices()                                                         # needs sage.geometry.polyhedron
             (A vertex at (0, 1, 1, 0), A vertex at (1, 0, 0, 1))

src/sage/graphs/generic_graph.py

@@ -12371,7 +12371,7 @@ def has_edge(self, u, v=None, label=None):
                     label = None
         return self._backend.has_edge(u, v, label)
 
-    def edges(self, vertices=None, labels=True, sort=None, key=None,
+    def edges(self, vertices=None, labels=True, sort=False, key=None,
               ignore_direction=False, sort_vertices=True):
         r"""
         Return a :class:`~EdgesView` of edges.
@@ -12395,13 +12395,10 @@ def edges(self, vertices=None, labels=True, sort=None, key=None,
         - ``labels`` -- boolean (default: ``True``); if ``False``, each edge is
           simply a pair ``(u, v)`` of vertices
 
-        - ``sort`` -- boolean (default: ``None``); if ``True``, edges are sorted
-          according to the default ordering
-
-          As of :trac:`22349`, this argument must be explicitly
-          specified (unless a ``key`` is given); otherwise a warning
-          is printed and ``sort=True`` is used. The default will
-          eventually be changed to ``False``.
+        - ``sort`` -- boolean (default: ``False``); whether to sort edges
+          according the ordering specified with parameter ``key``. If ``False``
+          (default), edges are not sorted. This is the fastest and less memory
+          consuming method for iterating over edges.
 
         - ``key`` -- a function (default: ``None``); a function that takes an
           edge (a pair or a triple, according to the ``labels`` keyword) as its
@@ -12497,7 +12494,7 @@ def edges(self, vertices=None, labels=True, sort=None, key=None,
             ....:   G.set_edge_label(e[0], e[1], chr(ord('A') + e[0] + 5 * e[1]))
             sage: G.edges(sort=True)
             [(0, 1, 'F'), (0, 4, 'U'), (1, 2, 'L'), (2, 3, 'R'), (3, 4, 'X')]
-            sage: G.edges(key=lambda x: x[2])
+            sage: G.edges(sort=True, key=lambda x: x[2])
             [(0, 1, 'F'), (1, 2, 'L'), (2, 3, 'R'), (0, 4, 'U'), (3, 4, 'X')]
 
         We can restrict considered edges to those incident to a given set::
@@ -12548,20 +12545,7 @@ def edges(self, vertices=None, labels=True, sort=None, key=None,
             sage: G.edge_label(0, 1)[0] += 1
             sage: G.edges(sort=True)
             [(0, 1, [8]), (0, 2, [7])]
-
-        Deprecation warning for ``sort=None`` (:trac:`27408`)::
-
-            sage: G = graphs.HouseGraph()
-            sage: G.edges(sort=None)
-            doctest:...: DeprecationWarning: parameter 'sort' will be set to False by default in the future
-            See https://github.com/sagemath/sage/issues/27408 for details.
-            [(0, 1, None), (0, 2, None), (1, 3, None), (2, 3, None), (2, 4, None), (3, 4, None)]
         """
-        if sort is None:
-            if key is None:
-                deprecation(27408, "parameter 'sort' will be set to False by default in the future")
-            sort = True
-
         if vertices is not None and vertices in self:
             vertices = [vertices]
 

src/sage/graphs/views.pyx

@@ -64,18 +64,10 @@ cdef class EdgesView:
     - ``ignore_direction`` -- boolean (default: ``False``); only applies to
       directed graphs. If ``True``, searches across edges in either direction.
 
-    - ``sort`` -- boolean (default: ``None``); whether to sort edges
-
-      - if ``None``, sort edges according to the default ordering and give a
-        deprecation warning as sorting will be set to ``False`` by default in
-        the future
-
-      - if ``True``, edges are sorted according the ordering specified with
-        parameter ``key``
-
-      - if ``False``, edges are not sorted. This is the fastest and less memory
-        consuming method for iterating over edges. This will become the default
-        behavior in the future.
+    - ``sort`` -- boolean (default: ``False``); whether to sort edges according
+      the ordering specified with parameter ``key``. If ``False`` (default),
+      edges are not sorted. This is the fastest and less memory consuming method
+      for iterating over edges.
 
     - ``key`` -- a function (default: ``None``); a function that takes an edge
       (a pair or a triple, according to the ``labels`` keyword) as its one
@@ -350,7 +342,7 @@ cdef class EdgesView:
 
     def __init__(self, G, vertices=None, vertices2=None, labels=True,
                  ignore_direction=False,
-                 sort=None, key=None, sort_vertices=True):
+                 sort=False, key=None, sort_vertices=True):
         """
         Construction of this :class:`EdgesView`.