[IMP] list_depends: allow to sort topologically

Using https://docs.python.org/3/library/graphlib.html

docs/cli.md

@@ -134,6 +134,7 @@ $ manifestoo list-depends [OPTIONS]
 * `--include-selected`: Print the selected addons along with their dependencies.
 * `--ignore-missing`: Do not fail if dependencies are not found in addons path. This only applies to top level (selected) addons and transitive dependencies.
 * `--as-pip-requirements`
+* `--sorting [alphabetical|topological]`: Sorting order for dependencies, by default: alphabetical. Topological sorting is useful when seeking a migration order.
 * `--help`: Show this message and exit.
 
 ## `manifestoo list-external-dependencies`

news/62.feature

@@ -0,0 +1 @@
+Add ``--sorting`` option on list, list-depends and list-codepends.

src/manifestoo/addon_sorter.py

@@ -0,0 +1,59 @@
+from typing import Dict, Iterable, Set
+
+import graphlib
+import typer
+
+from manifestoo_core.addons_set import AddonsSet
+
+from . import echo
+
+
+class AddonSorter:
+    @staticmethod
+    def from_name(name: str) -> "AddonSorter":
+        if name == "alphabetical":
+            return AddonSorterAlphabetical()
+        elif name == "topological":
+            try:
+                graphlib.TopologicalSorter  # noqa B018
+            except AttributeError as e:
+                echo.error(
+                    "The 'topological' sorter requires Python 3.9 or later",
+                    err=False,
+                )
+                raise typer.Exit(1) from e
+            return AddonSorterTopological()
+        else:
+            echo.error(f"Unknown sorter {name}", err=False)
+            raise typer.Exit(1)
+
+    def sort(
+        self, addons_selection: Iterable[str], addon_set: AddonsSet
+    ) -> Iterable[str]:
+        return addons_selection
+
+
+class AddonSorterAlphabetical(AddonSorter):
+    def sort(
+        self, addons_selection: Iterable[str], addon_set: AddonsSet
+    ) -> Iterable[str]:
+        return sorted(addons_selection)
+
+
+class AddonSorterTopological(AddonSorter):
+    def sort(
+        self, addons_selection: Iterable[str], addon_set: AddonsSet
+    ) -> Iterable[str]:
+        result_dict: Dict[str, Set[str]] = {}
+        for addon_name in addons_selection:
+            addon = addon_set[addon_name]
+            result_dict[addon_name] = set(addon.manifest.depends)
+        from graphlib import TopologicalSorter
+
+        topological_sorted_res = TopologicalSorter(result_dict)
+        try:
+            res = list(topological_sorted_res.static_order())
+        except graphlib.CycleError as e:
+            echo.error("Cycle detected in dependencies", err=False)
+            raise typer.Exit(1) from e
+        return res

src/manifestoo/commands/list.py

@@ -1,7 +1,16 @@
-from typing import Iterable
+from typing import Iterable, Optional
 
+from manifestoo_core.addons_set import AddonsSet
+
+from ..addon_sorter import AddonSorter, AddonSorterAlphabetical
 from ..addons_selection import AddonsSelection
 
 
-def list_command(addons_selection: AddonsSelection) -> Iterable[str]:
-    return sorted(addons_selection)
+def list_command(
+    addons_selection: AddonsSelection,
+    addons_set: AddonsSet,
+    addon_sorter: Optional[AddonSorter] = None,
+) -> Iterable[str]:
+    if not addon_sorter:
+        addon_sorter = AddonSorterAlphabetical()
+    return addon_sorter.sort(addons_selection, addons_set)

src/manifestoo/commands/list_codepends.py

@@ -1,7 +1,8 @@
-from typing import Iterable, Set
+from typing import Iterable, Optional, Set
 
 from manifestoo_core.addons_set import AddonsSet
 
+from ..addon_sorter import AddonSorter, AddonSorterAlphabetical
 from ..addons_selection import AddonsSelection
 
 
@@ -10,14 +11,18 @@ def list_codepends_command(
     addons_set: AddonsSet,
     transitive: bool = True,
     include_selected: bool = True,
+    addon_sorter: Optional[AddonSorter] = None,
 ) -> Iterable[str]:
+    if not addon_sorter:
+        addon_sorter = AddonSorterAlphabetical()
     result: Set[str] = set(addons_selection) if include_selected else set()
     codeps = direct_codependencies(addons_selection, addons_set, result)
     result |= codeps
     while transitive and codeps:
         codeps = direct_codependencies(codeps, addons_set, result)
         result |= codeps
-    return result if include_selected else result - addons_selection
+    result = set(addon_sorter.sort(result, addons_set))
+    return result if include_selected else result - set(addons_selection)
 
 
 def direct_codependencies(

src/manifestoo/commands/list_depends.py

@@ -1,7 +1,8 @@
-from typing import Iterable, Set, Tuple
+from typing import Iterable, Optional, Set, Tuple
 
 from manifestoo_core.addons_set import AddonsSet
 
+from ..addon_sorter import AddonSorter, AddonSorterAlphabetical
 from ..addons_selection import AddonsSelection
 from ..dependency_iterator import dependency_iterator
 
@@ -11,7 +12,10 @@ def list_depends_command(
     addons_set: AddonsSet,
     transitive: bool = False,
     include_selected: bool = False,
+    addon_sorter: Optional[AddonSorter] = None,
 ) -> Tuple[Iterable[str], Iterable[str]]:
+    if not addon_sorter:
+        addon_sorter = AddonSorterAlphabetical()
     result: Set[str] = set()
     missing: Set[str] = set()
     for addon_name, addon in dependency_iterator(
@@ -23,4 +27,4 @@ def list_depends_command(
             missing.add(addon_name)
         else:
             result.update(set(addon.manifest.depends) - set(addons_selection))
-    return sorted(result), missing
+    return addon_sorter.sort(result, addons_set), missing

src/manifestoo/main.py

@@ -7,6 +7,7 @@
 from manifestoo_core.odoo_series import OdooSeries, detect_from_addons_set
 
 from . import echo
+from .addon_sorter import AddonSorter
 from .commands.check_dev_status import check_dev_status_command
 from .commands.check_licenses import check_licenses_command
 from .commands.interactive_tree import interactive_tree_command
@@ -225,10 +226,23 @@ def list(
         None,
         help="Separator character to use (by default, print one item per line).",
     ),
+    sorting: str = typer.Option(
+        "alphabetical",
+        "--sorting",
+        "--sort",
+        help=(
+            "Choice between 'alphabetical' and 'topological'."
+            "Topological sorting is useful when seeking a migration order."
+        ),
+        show_default=True,
+    ),
 ) -> None:
     """Print the selected addons."""
     main_options: MainOptions = ctx.obj
-    result = list_command(main_options.addons_selection)
+    addon_sorter = AddonSorter.from_name(sorting)
+    result = list_command(
+        main_options.addons_selection, main_options.addons_set, addon_sorter
+    )
     print_list(result, separator or main_options.separator or "\n")
 
 
@@ -266,16 +280,28 @@ def list_depends(
         "--as-pip-requirements",
         show_default=False,
     ),
+    sorting: str = typer.Option(
+        "alphabetical",
+        "--sorting",
+        "--sort",
+        help=(
+            "Choice between 'alphabetical' and 'topological'."
+            "Topological sorting is useful when seeking a migration order."
+        ),
+        show_default=True,
+    ),
 ) -> None:
     """Print the dependencies of selected addons."""
     main_options: MainOptions = ctx.obj
     if as_pip_requirements:
         not_implemented("--as-pip-requirement")
+    addon_sorter = AddonSorter.from_name(sorting)
     result, missing = list_depends_command(
         main_options.addons_selection,
         main_options.addons_set,
         transitive,
         include_selected,
+        addon_sorter,
     )
     if missing and not ignore_missing:
         echo.error("not found in addons path: " + ",".join(sorted(missing)))
@@ -301,18 +327,30 @@ def list_codepends(
         True,
         help="Print the selected addons along with their co-dependencies.",
     ),
+    sorting: str = typer.Option(
+        "alphabetical",
+        "--sorting",
+        "--sort",
+        help=(
+            "Choice between 'alphabetical' and 'topological'."
+            "Topological sorting is useful when seeking a migration order."
+        ),
+        show_default=True,
+    ),
 ) -> None:
     """Print the co-dependencies of selected addons.
 
     Co-dependencies is the set of addons that depend on the selected
     addons.
     """
     main_options: MainOptions = ctx.obj
+    addon_sorter = AddonSorter.from_name(sorting)
     result = list_codepends_command(
         main_options.addons_selection,
         main_options.addons_set,
         transitive,
         include_selected,
+        addon_sorter,
     )
     print_list(result, separator or main_options.separator or "\n")
 

tests/test_cmd_list.py

@@ -5,12 +5,18 @@
 from manifestoo.commands.list import list_command
 from manifestoo.main import app
 
-from .common import mock_addons_selection, populate_addons_dir
+from .common import mock_addons_selection, mock_addons_set, populate_addons_dir
 
 
 def test_basic():
     addons_selection = mock_addons_selection("b,a")
-    assert list_command(addons_selection) == ["a", "b"]
+    addons_set = mock_addons_set(
+        {
+            "a": {},
+            "b": {},
+        }
+    )
+    assert list_command(addons_selection, addons_set) == ["a", "b"]
 
 
 def test_integration(tmp_path):

tests/test_cmd_list_codepends.py

@@ -1,5 +1,6 @@
 from typer.testing import CliRunner
 
+from manifestoo.addon_sorter import AddonSorterTopological
 from manifestoo.commands.list_codepends import list_codepends_command
 from manifestoo.main import app
 
@@ -33,6 +34,13 @@ def test_transitive():
     ) == {"b"}
     assert list_codepends_command(
         addons_selection, addons_set, transitive=True, include_selected=False
+    ) == {"a", "b"}
+    assert list_codepends_command(
+        addons_selection,
+        addons_set,
+        transitive=True,
+        include_selected=False,
+        addon_sorter=AddonSorterTopological(),
     ) == {"b", "a"}
 
 
@@ -85,6 +93,12 @@ def test_include_selected():
     assert list_codepends_command(
         addons_selection, addons_set, include_selected=True
     ) == {"a", "b"}
+    assert list_codepends_command(
+        addons_selection,
+        addons_set,
+        include_selected=True,
+        addon_sorter=AddonSorterTopological(),
+    ) == {"b", "a"}
 
 
 def test_integration(tmp_path):

tests/test_cmd_list_depends.py

@@ -1,5 +1,7 @@
+import click
 from typer.testing import CliRunner
 
+from manifestoo.addon_sorter import AddonSorterTopological
 from manifestoo.commands.list_depends import list_depends_command
 from manifestoo.main import app
 
@@ -68,6 +70,16 @@ def test_loop():
         ],
         set(),
     )
+    try:
+        list_depends_command(
+            addons_selection,
+            addons_set,
+            include_selected=True,
+            transitive=True,
+            addon_sorter=AddonSorterTopological(),
+        )
+    except click.exceptions.Exit as e:
+        assert e
 
 
 def test_missing():
@@ -106,6 +118,16 @@ def test_missing():
         ["a", "b", "c"],
         {"b", "c"},
     )
+    try:
+        list_depends_command(
+            mock_addons_selection("a,c"),
+            addons_set,
+            include_selected=True,
+            transitive=True,
+            addon_sorter=AddonSorterTopological(),
+        )
+    except KeyError as e:
+        assert e
 
 
 def test_include_selected_not_included():