Stabilize PackagesList API

conan/api/model/list.py

@@ -104,7 +104,7 @@ def load_graph(graphfile, graph_recipes=None, graph_binaries=None, context=None)
                 )
 
             mpkglist = MultiPackagesList._define_graph(graph, graph_recipes, graph_binaries,
-                                                        context=base_context)
+                                                       context=base_context)
             if context == "build-only":
                 host = MultiPackagesList._define_graph(graph, graph_recipes, graph_binaries,
                                                        context="host")
@@ -276,8 +276,29 @@ def refs(self):
                 result[recipe] = rrev_dict
         return result
 
+    def items(self) -> dict[RecipeReference, dict[PkgReference, dict]]:
+        """ Get all the recipe references in the package list."""
+        result = {}
+        for ref, ref_dict in self.recipes.items():
+            for rrev, rrev_dict in ref_dict.get("revisions", {}).items():
+                t = rrev_dict.get("timestamp")
+                recipe = RecipeReference.loads(f"{ref}#{rrev}")  # TODO: optimize this
+                if t is not None:
+                    recipe.timestamp = t
+
+                pref_dict = {}
+                for package_id, pkg_bundle in rrev_dict.get("packages", {}).items():
+                    prevs = pkg_bundle.get("revisions", {})
+                    for prev, prev_bundle in prevs.items():
+                        t = prev_bundle.pop("timestamp", None)
+                        pref = PkgReference(recipe, package_id, prev, t)
+                        pref_dict[pref] = prev_bundle
+                result[recipe] = pref_dict
+        return result.items()
+
     @staticmethod
     def prefs(ref, recipe_bundle):
+        """ Get all the package references for a given recipe reference given a bundle."""
         result = {}
         for package_id, pkg_bundle in recipe_bundle.get("packages", {}).items():
             prevs = pkg_bundle.get("revisions", {})

conan/api/subapi/cache.py

@@ -109,14 +109,14 @@ def clean(self, package_list, source=True, build=True, download=True, temp=True,
             for f in backup_files:
                 remove(f)
 
-        for ref, ref_bundle in package_list.refs().items():
+        for ref, packages in package_list.items():
             ConanOutput(ref.repr_notime()).verbose("Cleaning recipe cache contents")
             ref_layout = cache.recipe_layout(ref)
             if source:
                 rmdir(ref_layout.source())
             if download:
                 rmdir(ref_layout.download_export())
-            for pref, _ in package_list.prefs(ref, ref_bundle).items():
+            for pref, _ in packages.items():
                 ConanOutput(pref).verbose("Cleaning package cache contents")
                 pref_layout = cache.pkg_layout(pref)
                 if build:

conan/api/subapi/download.py

@@ -83,9 +83,9 @@ def download_full(self, package_list: PackagesList, remote: Remote,
         """Download the recipes and packages specified in the ``package_list`` from the remote,
         parallelized based on ``core.download:parallel``"""
         def _download_pkglist(pkglist):
-            for ref, recipe_bundle in pkglist.refs().items():
+            for ref, packages in pkglist.items():
                 self.recipe(ref, remote, metadata)
-                for pref, _ in pkglist.prefs(ref, recipe_bundle).items():
+                for pref, _ in packages.items():
                     self.package(pref, remote, metadata)
 
         t = time.time()

conan/cli/commands/remove.py

@@ -1,5 +1,5 @@
 from conan.api.conan_api import ConanAPI
-from conan.api.model import ListPattern, MultiPackagesList
+from conan.api.model import ListPattern, MultiPackagesList, RecipeReference, PkgReference
 from conan.api.output import cli_out_write, ConanOutput
 from conan.api.input import UserInput
 from conan.cli import make_abs_path
@@ -92,36 +92,36 @@ def confirmation(message):
         multi_package_list = MultiPackagesList()
         multi_package_list.add(cache_name, package_list)
 
-    # TODO: This iteration and removal of not-confirmed is ugly and complicated, improve it
-    for ref, ref_bundle in package_list.refs().items():
-        ref_dict = package_list.recipes[str(ref)]["revisions"]
-        packages = ref_bundle.get("packages")
-        if packages is None:
-            if confirmation(f"Remove the recipe and all the packages of '{ref.repr_notime()}'?"):
-                if not args.dry_run:
-                    conan_api.remove.recipe(ref, remote=remote)
-            else:
-                ref_dict.pop(ref.revision)
-                if not ref_dict:
-                    package_list.recipes.pop(str(ref))
-            continue
-        prefs = package_list.prefs(ref, ref_bundle)
-        if not prefs:
-            ConanOutput().info(f"No binaries to remove for '{ref.repr_notime()}'")
-            ref_dict.pop(ref.revision)
-            if not ref_dict:
-                package_list.recipes.pop(str(ref))
-            continue
-
-        for pref, _ in prefs.items():
-            if confirmation(f"Remove the package '{pref.repr_notime()}'?"):
-                if not args.dry_run:
-                    conan_api.remove.package(pref, remote=remote)
+    result = {}
+    for ref, ref_info in package_list.recipes.items():
+        result_ref = {}
+        for rrev, rrev_info in ref_info.get("revisions", {}).items():
+            full_ref = RecipeReference.loads(ref)
+            full_ref.revision = rrev
+            packages = rrev_info.get("packages")
+            if packages is None:
+                if confirmation(f"Remove the recipe and all the packages of '{ref}#{rrev}'?"):
+                    if not args.dry_run:
+                        conan_api.remove.recipe(full_ref, remote=remote)
+                    result_ref.setdefault("revisions", {})[rrev] = rrev_info
             else:
-                pref_dict = packages[pref.package_id]["revisions"]
-                pref_dict.pop(pref.revision)
-                if not pref_dict:
-                    packages.pop(pref.package_id)
+                result_rrev = {}
+                for pkg_id, pkg_id_info in packages.items():
+                    package_revisions = pkg_id_info.get("revisions")
+                    if package_revisions is None:
+                        ConanOutput().info(f"No binaries to remove for '{full_ref.repr_notime()}'")
+                        continue
+                    for prev, prev_info in package_revisions.items():
+                        if confirmation(f"Remove the package '{ref}#{rrev}:{pkg_id}#{prev}'?"):
+                            if not args.dry_run:
+                                pref = PkgReference(full_ref, pkg_id, prev)
+                                conan_api.remove.package(pref, remote=remote)
+                            result_rrev.setdefault("packages", {})[pkg_id] = pkg_id_info
+                if result_rrev:
+                    result_ref.setdefault("revisions", {})[rrev] = result_rrev
+        if result_ref:
+            result[ref] = result_ref
+    package_list.recipes = result
 
     return {
         "results": multi_package_list.serialize(),

conan/cli/commands/upload.py

@@ -121,20 +121,23 @@ def upload(conan_api: ConanAPI, parser, *args):
 
 def _ask_confirm_upload(conan_api, package_list):
     ui = UserInput(conan_api.config.get("core:non_interactive"))
-    for ref, bundle in package_list.refs().items():
-        msg = "Are you sure you want to upload recipe '%s'?" % ref.repr_notime()
-        ref_dict = package_list.recipes[str(ref)]["revisions"]
-        if not ui.request_boolean(msg):
-            ref_dict.pop(ref.revision)
-            # clean up empy refs
-            if not ref_dict:
-                package_list.recipes.pop(str(ref))
-        else:
-            for pref, prev_bundle in package_list.prefs(ref, bundle).items():
-                msg = "Are you sure you want to upload package '%s'?" % pref.repr_notime()
-                pkgs_dict = ref_dict[ref.revision]["packages"]
-                if not ui.request_boolean(msg):
-                    pref_dict = pkgs_dict[pref.package_id]["revisions"]
-                    pref_dict.pop(pref.revision)
-                    if not pref_dict:
-                        pkgs_dict.pop(pref.package_id)
+    result = {}
+    for ref, ref_info in package_list.recipes.items():
+        result_ref = {}
+        for rrev, rrev_info in ref_info.get("revisions", {}).items():
+            msg = f"Are you sure you want to upload recipe '{ref}#{rrev}'?"
+            if ui.request_boolean(msg):
+                result_rrev = {}
+                if rrev_info.get("timestamp"):
+                    result_rrev["timestamp"] = rrev_info["timestamp"]
+                for pkg_id, pkg_id_info in rrev_info.get("packages", {}).items():
+                    for prev, prev_info in pkg_id_info.get("revisions", {}).items():
+                        msg = (f"Are you sure you want to upload package "
+                               f"'{ref}#{rrev}:{pkg_id}#{prev}'?")
+                        if ui.request_boolean(msg):
+                            pkg_info = result_rrev.setdefault("packages", {}).setdefault(pkg_id, {})
+                            pkg_info.setdefault("revisions", {})[prev] = prev_info
+                            pkg_info["info"] = pkg_id_info["info"]
+                result_ref.setdefault("revisions", {})[rrev] = result_rrev
+        result[ref] = result_ref
+    package_list.recipes = result

test/integration/command/list/test_combined_pkglist_flows.py

@@ -351,19 +351,29 @@ def client(self):
     def test_remove_nothing_only_refs(self, client):
         # It is necessary to do *#* for actually removing something
         client.run(f"list * --format=json", redirect_stdout="pkglist.json")
-        client.run(f"remove --list=pkglist.json -c")
+        client.run(f"remove --list=pkglist.json -c --format=json")
         assert "Nothing to remove, package list do not contain recipe revisions" in client.out
+        result = json.loads(client.stdout)
+        assert result["Local Cache"] == {}  # Nothing was removed
 
     @pytest.mark.parametrize("remote", [False, True])
     def test_remove_all(self, client, remote):
         # It is necessary to do *#* for actually removing something
         remote = "-r=default" if remote else ""
         client.run(f"list *#* {remote} --format=json", redirect_stdout="pkglist.json")
-        client.run(f"remove --list=pkglist.json {remote} -c")
+        client.run(f"remove --list=pkglist.json {remote} -c --dry-run")
         assert "zli/1.0.0#f034dc90894493961d92dd32a9ee3b78:" \
                " Removed recipe and all binaries" in client.out
         assert "zlib/1.0.0@user/channel#ffd4bc45820ddb320ab224685b9ba3fb:" \
                " Removed recipe and all binaries" in client.out
+
+        client.run(f"remove --list=pkglist.json {remote} -c --format=json")
+        result = json.loads(client.stdout)
+        origin = "Local Cache" if not remote else "default"
+        assert len(result[origin]["zli/1.0.0"]["revisions"]) == 1
+        assert len(result[origin]["zlib/1.0.0@user/channel"]["revisions"]) == 1
+        assert "packages" not in client.stdout  # Packages are not listed at all
+
         client.run(f"list * {remote}")
         assert "There are no matching recipe references" in client.out
 
@@ -372,22 +382,35 @@ def test_remove_packages_no_revisions(self, client, remote):
         # It is necessary to do *#* for actually removing something
         remote = "-r=default" if remote else ""
         client.run(f"list *#*:* {remote} --format=json", redirect_stdout="pkglist.json")
-        client.run(f"remove --list=pkglist.json {remote} -c")
+        client.run(f"remove --list=pkglist.json {remote} -c --format=json")
         assert "No binaries to remove for 'zli/1.0.0#f034dc90894493961d92dd32a9ee3b78'" in client.out
         assert "No binaries to remove for 'zlib/1.0.0@user/channel" \
                "#ffd4bc45820ddb320ab224685b9ba3fb" in client.out
+        result = json.loads(client.stdout)
+        origin = "Local Cache" if not remote else "default"
+        assert result[origin] == {}  # Nothing was removed
 
     @pytest.mark.parametrize("remote", [False, True])
     def test_remove_packages(self, client, remote):
         # It is necessary to do *#* for actually removing something
         remote = "-r=default" if remote else ""
         client.run(f"list *#*:*#* {remote} --format=json", redirect_stdout="pkglist.json")
-        client.run(f"remove --list=pkglist.json {remote} -c")
-
+        client.run(f"remove --list=pkglist.json {remote} -c --dry-run")
         assert "Removed recipe and all binaries" not in client.out
         assert "zli/1.0.0#f034dc90894493961d92dd32a9ee3b78: Removed binaries" in client.out
         assert "zlib/1.0.0@user/channel#ffd4bc45820ddb320ab224685b9ba3fb: " \
                "Removed binaries" in client.out
+
+        client.run(f"remove --list=pkglist.json {remote} -c --format=json")
+        result = json.loads(client.stdout)
+        origin = "Local Cache" if not remote else "default"
+        zli_revs = result[origin]["zli/1.0.0"]["revisions"]
+        zli_uc_revs = result[origin]["zlib/1.0.0@user/channel"]["revisions"]
+        assert len(zli_revs) == 1
+        assert len(zli_uc_revs) == 1
+        assert len(zli_revs["f034dc90894493961d92dd32a9ee3b78"]["packages"]) == 1
+        assert len(zli_uc_revs["ffd4bc45820ddb320ab224685b9ba3fb"]["packages"]) == 1
+
         client.run(f"list *:* {remote}")
         assert "zli/1.0.0" in client.out
         assert "zlib/1.0.0@user/channel" in client.out