conan 2.14.0__tar.gz → 2.15.1__tar.gz

{conan-2.14.0/conan.egg-info → conan-2.15.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conan
-Version: 2.14.0
+Version: 2.15.1
 Summary: Conan C/C++ package manager
 Home-page: https://conan.io
 Author: JFrog LTD

{conan-2.14.0 → conan-2.15.1}/conan/__init__.py

@@ -2,5 +2,5 @@ from conan.internal.model.conan_file import ConanFile
 from conan.internal.model.workspace import Workspace
 from conan.internal.model.version import Version
 
-__version__ = '2.14.0'
+__version__ = '2.15.1'
 conan_version = Version(__version__)

{conan-2.14.0 → conan-2.15.1}/conan/api/model/list.py

@@ -3,9 +3,10 @@ import json
 import os
 from json import JSONDecodeError
 
+from conan.api.model import RecipeReference, PkgReference
+from conan.cli import make_abs_path
 from conan.errors import ConanException
 from conan.internal.errors import NotFoundException
-from conan.api.model import RecipeReference, PkgReference
 from conan.internal.model.version_range import VersionRange
 from conans.client.graph.graph import RECIPE_EDITABLE, RECIPE_CONSUMER, RECIPE_PLATFORM, \
     RECIPE_VIRTUAL, BINARY_SKIP, BINARY_MISSING, BINARY_INVALID
@@ -36,6 +37,10 @@ class MultiPackagesList:
         for k, v in other.lists.items():
             self.lists.setdefault(k, PackagesList()).merge(v)
 
+    def keep_outer(self, other):
+        for namespace, other_pkg_list in other.lists.items():
+            self.lists.get(namespace, PackagesList()).keep_outer(other_pkg_list)
+
     @staticmethod
     def load(file):
         try:
@@ -44,6 +49,14 @@ class MultiPackagesList:
             raise ConanException(f"Package list file invalid JSON: {file}\n{e}")
         except Exception as e:
             raise ConanException(f"Package list file missing or broken: {file}\n{e}")
+        # Check if input json is not a graph file
+        if "graph" in content:
+            base_path = os.path.basename(file)
+            raise ConanException(
+                'Expected a package list file but found a graph file. You can create a "package list" JSON file by running:\n\n'
+                f"\tconan list --graph {base_path} --format=json > pkglist.json\n\n"
+                "More Info at 'https://docs.conan.io/2/examples/commands/pkglists.html"
+            )
         result = {}
         for remote, pkglist in content.items():
             if "error" in pkglist:
@@ -55,19 +68,40 @@ class MultiPackagesList:
         return pkglist
 
     @staticmethod
-    def load_graph(graphfile, graph_recipes=None, graph_binaries=None):
+    def load_graph(graphfile, graph_recipes=None, graph_binaries=None, context=None):
         if not os.path.isfile(graphfile):
             raise ConanException(f"Graph file not found: {graphfile}")
         try:
+            base_context = context.split("-")[0] if context else None
             graph = json.loads(load(graphfile))
-            return MultiPackagesList._define_graph(graph, graph_recipes, graph_binaries)
+            # Check if input json is a graph file
+            if "graph" not in graph:
+                raise ConanException(
+                    'Expected a graph file but found an unexpected JSON file format. You can create a "graph" JSON file by running:\n\n'
+                    f"\tconan [ graph-info | create | export-pkg | install | test ] --format=json > graph.json\n\n"
+                    "More Info at 'https://docs.conan.io/2/reference/commands/formatters/graph_info_json_formatter.html"
+                )
+
+            mpkglist =  MultiPackagesList._define_graph(graph, graph_recipes, graph_binaries,
+                                                        context=base_context)
+            if context == "build-only":
+                host = MultiPackagesList._define_graph(graph, graph_recipes, graph_binaries,
+                                                       context="host")
+                mpkglist.keep_outer(host)
+            elif context == "host-only":
+                build = MultiPackagesList._define_graph(graph, graph_recipes, graph_binaries,
+                                                        context="build")
+                mpkglist.keep_outer(build)
+            return mpkglist
         except JSONDecodeError as e:
             raise ConanException(f"Graph file invalid JSON: {graphfile}\n{e}")
+        except ConanException as e:
+            raise e
         except Exception as e:
             raise ConanException(f"Graph file broken: {graphfile}\n{e}")
 
     @staticmethod
-    def _define_graph(graph, graph_recipes=None, graph_binaries=None):
+    def _define_graph(graph, graph_recipes=None, graph_binaries=None, context=None):
         pkglist = MultiPackagesList()
         cache_list = PackagesList()
         if graph_recipes is None and graph_binaries is None:
@@ -79,6 +113,9 @@ class MultiPackagesList:
 
         pkglist.lists["Local Cache"] = cache_list
         for node in graph["graph"]["nodes"].values():
+            if context and node['context'] != context:
+                continue
+
             # We need to add the python_requires too
             python_requires = node.get("python_requires")
             if python_requires is not None:
@@ -142,6 +179,14 @@ class PackagesList:
             return d
         recursive_dict_update(self.recipes, other.recipes)
 
+    def keep_outer(self, other):
+        if not self.recipes:
+            return
+
+        for ref, info in other.recipes.items():
+            if self.recipes.get(ref, {}) == info:
+                self.recipes.pop(ref)
+
     def split(self):
         """
         Returns a list of PackageList, splitted one per reference.

{conan-2.14.0 → conan-2.15.1}/conan/api/subapi/audit.py

@@ -12,6 +12,7 @@ from conans.util.files import save, load
 CONAN_CENTER_AUDIT_PROVIDER_NAME = "conancenter"
 CYPHER_KEY = "private"
 
+
 class AuditAPI:
     """
     This class provides the functionality to scan references for vulnerabilities.
@@ -26,15 +27,17 @@ class AuditAPI:
             "private": PrivateProvider,
         }
 
-    def scan(self, deps_graph, provider):
+    @staticmethod
+    def scan(deps_graph, provider):
         """
         Scan a given recipe for vulnerabilities in its dependencies.
         """
         refs = sorted(set(RecipeReference.loads(f"{node.ref.name}/{node.ref.version}")
-                        for node in deps_graph.nodes[1:]), key= lambda ref: ref.name)
+                          for node in deps_graph.nodes[1:]), key=lambda ref: ref.name)
         return provider.get_cves(refs)
 
-    def list(self, references, provider):
+    @staticmethod
+    def list(references, provider):
         """
         List the vulnerabilities of the given reference.
         """

{conan-2.14.0 → conan-2.15.1}/conan/api/subapi/command.py

@@ -1,3 +1,5 @@
+import os
+
 from conan.api.output import ConanOutput
 from conan.errors import ConanException
 
@@ -25,9 +27,9 @@ class CommandAPI:
         # get redefined when running a command and leak to the calling scope
         # if running from a custom command.
         # Store the old one and restore it after the command execution as a workaround.
-        _conan_output_level = ConanOutput._conan_output_level
-        _silent_warn_tags = ConanOutput._silent_warn_tags
-        _warnings_as_errors = ConanOutput._warnings_as_errors
+        _conan_output_level = ConanOutput._conan_output_level  # noqa
+        _silent_warn_tags = ConanOutput._silent_warn_tags  # noqa
+        _warnings_as_errors = ConanOutput._warnings_as_errors  # noqa
 
         try:
             result = command.run_cli(self.conan_api, args)
@@ -36,3 +38,25 @@ class CommandAPI:
             ConanOutput._silent_warn_tags = _silent_warn_tags
             ConanOutput._warnings_as_errors = _warnings_as_errors
         return result
+
+    @staticmethod
+    def get_runner(profile_host):
+        if profile_host.runner and not os.environ.get("CONAN_RUNNER_ENVIRONMENT"):
+            from conan.internal.runner.docker import DockerRunner
+            from conan.internal.runner.ssh import SSHRunner
+            from conan.internal.runner.wsl import WSLRunner
+            try:
+                runner_type = profile_host.runner['type'].lower()
+            except KeyError:
+                raise ConanException(f"Invalid runner configuration. 'type' must be defined")
+            runner_instances_map = {
+                'docker': DockerRunner,
+                # 'ssh': SSHRunner,
+                # 'wsl': WSLRunner,
+            }
+            try:
+                runner_instance = runner_instances_map[runner_type]
+            except KeyError:
+                raise ConanException(f"Invalid runner type '{runner_type}'. "
+                                     f"Allowed values: {', '.join(runner_instances_map.keys())}")
+            return runner_instance

{conan-2.14.0 → conan-2.15.1}/conan/api/subapi/list.py

@@ -1,8 +1,9 @@
+import copy
 import os
 from collections import OrderedDict
 from typing import Dict
 
-from conan.api.model import PackagesList
+from conan.api.model import PackagesList, MultiPackagesList, ListPattern
 from conan.api.output import ConanOutput, TimedOutput
 from conan.internal.api.list.query_parse import filter_package_configs
 from conan.internal.conan_app import ConanBasicApp
@@ -242,7 +243,7 @@ class ListAPI:
                 ConanOutput().info(f"Finding binaries in remote {remote.name}")
                 pkg_configurations = self.packages_configurations(ref, remote=remote)
             except Exception as e:
-                ConanOutput(f"ERROR IN REMOTE {remote.name}: {e}")
+                ConanOutput().error(f"Error in remote '{remote.name}': {e}")
             else:
                 candidates.extend(_BinaryDistance(pref, data, conaninfo, remote)
                                   for pref, data in pkg_configurations.items())
@@ -266,6 +267,82 @@ class ListAPI:
             rev_dict["packages"][pref.package_id]["remote"] = remote
         return pkglist
 
+    def find_remotes(self, package_list, remotes):
+        """
+        (Experimental) Find the remotes where the current package lists can be found
+        """
+        result = MultiPackagesList()
+        for r in remotes:
+            result_pkg_list = PackagesList()
+            for ref, recipe_bundle in package_list.refs().items():
+                ref_no_rev = copy.copy(ref)  # TODO: Improve ugly API
+                ref_no_rev.revision = None
+                try:
+                    revs = self.recipe_revisions(ref_no_rev, remote=r)
+                except NotFoundException:
+                    continue
+                if ref not in revs:  # not found
+                    continue
+                result_pkg_list.add_refs([ref])
+                for pref, pref_bundle in package_list.prefs(ref, recipe_bundle).items():
+                    pref_no_rev = copy.copy(pref)  # TODO: Improve ugly API
+                    pref_no_rev.revision = None
+                    try:
+                        prevs = self.package_revisions(pref_no_rev, remote=r)
+                    except NotFoundException:
+                        continue
+                    if pref in prevs:
+                        result_pkg_list.add_prefs(ref, [pref])
+                        info = recipe_bundle["packages"][pref.package_id]["info"]
+                        result_pkg_list.add_configurations({pref: info})
+            if result_pkg_list.recipes:
+                result.add(r.name, result_pkg_list)
+        return result
+
+    def outdated(self, deps_graph, remotes):
+        # DO NOT USE YET
+        # Data structure to store info per library
+        dependencies = deps_graph.nodes[1:]
+        dict_nodes = {}
+
+        # When there are no dependencies command should stop
+        if len(dependencies) == 0:
+            return dict_nodes
+
+        ConanOutput().title("Checking remotes")
+
+        for node in dependencies:
+            dict_nodes.setdefault(node.name, {"cache_refs": set(), "version_ranges": [],
+                                              "latest_remote": None})["cache_refs"].add(node.ref)
+
+        for version_range in deps_graph.resolved_ranges.keys():
+            dict_nodes[version_range.name]["version_ranges"].append(version_range)
+
+        # find in remotes
+        for node_name, node_info in dict_nodes.items():
+            ref_pattern = ListPattern(node_name, rrev=None, prev=None)
+            for remote in remotes:
+                try:
+                    remote_ref_list = self.select(ref_pattern, package_query=None, remote=remote)
+                except NotFoundException:
+                    continue
+                if not remote_ref_list.recipes:
+                    continue
+                str_latest_ref = list(remote_ref_list.recipes.keys())[-1]
+                recipe_ref = RecipeReference.loads(str_latest_ref)
+                if (node_info["latest_remote"] is None
+                        or node_info["latest_remote"]["ref"] < recipe_ref):
+                    node_info["latest_remote"] = {"ref": recipe_ref, "remote": remote.name}
+
+        # Filter nodes with no outdated versions
+        filtered_nodes = {}
+        for node_name, node in dict_nodes.items():
+            if node['latest_remote'] is not None and sorted(list(node['cache_refs']))[0] < \
+                    node['latest_remote']['ref']:
+                filtered_nodes[node_name] = node
+
+        return filtered_nodes
+
 
 class _BinaryDistance:
     def __init__(self, pref, binary, expected, remote=None):

{conan-2.14.0 → conan-2.15.1}/conan/cli/cli.py

@@ -15,7 +15,6 @@ from conan.api.output import ConanOutput, Color, cli_out_write, LEVEL_TRACE
 from conan.cli.command import ConanSubCommand
 from conan.cli.exit_codes import SUCCESS, ERROR_MIGRATION, ERROR_GENERAL, USER_CTRL_C, \
     ERROR_SIGTERM, USER_CTRL_BREAK, ERROR_INVALID_CONFIGURATION, ERROR_UNEXPECTED
-from conan.internal.cache.home_paths import HomePaths
 from conan import __version__
 from conan.errors import ConanException, ConanInvalidConfiguration, ConanMigrationError
 
@@ -49,7 +48,8 @@ class Cli:
             for k, v in self._commands.items():  # Fill groups data too
                 self._groups[v.group].append(k)
 
-        conan_custom_commands_path = HomePaths(self._conan_api.cache_folder).custom_commands_path
+        conan_custom_commands_path = os.path.join(self._conan_api.cache_folder, "extensions",
+                                                  "commands")
         # Important! This variable should be only used for testing/debugging purpose
         developer_custom_commands_path = os.getenv(_CONAN_INTERNAL_CUSTOM_COMMANDS_PATH)
         # Notice that in case of having same custom commands file names, the developer one has

{conan-2.14.0 → conan-2.15.1}/conan/cli/commands/audit.py

@@ -80,8 +80,8 @@ def audit_list(conan_api: ConanAPI, parser, subparser, *args):
     List the vulnerabilities of the given reference.
     """
     subparser.add_argument("reference", help="Reference to list vulnerabilities for", nargs="?")
-    subparser.add_argument("-l", "--list", help="pkglist file to list vulnerabilities for", default=None)
-    subparser.add_argument("-r", "--remote", help="Remote to use for listing", default=None)
+    subparser.add_argument("-l", "--list", help="pkglist file to list vulnerabilities for")
+    subparser.add_argument("-r", "--remote", help="Remote to use for listing")
     _add_provider_arg(subparser)
     args = parser.parse_args(*args)
 
@@ -93,7 +93,6 @@ def audit_list(conan_api: ConanAPI, parser, subparser, *args):
 
     provider = conan_api.audit.get_provider(args.provider or CONAN_CENTER_AUDIT_PROVIDER_NAME)
 
-    references = []
     if args.list:
         listfile = make_abs_path(args.list)
         multi_package_list = MultiPackagesList.load(listfile)
@@ -107,7 +106,8 @@ def audit_list(conan_api: ConanAPI, parser, subparser, *args):
         references = [args.reference]
     return conan_api.audit.list(references, provider)
 
-def text_provider_formatter(providers_action):
+
+def _text_provider_formatter(providers_action):
     providers = providers_action[0]
     action = providers_action[1]
 
@@ -125,7 +125,8 @@ def text_provider_formatter(providers_action):
                 if provider:
                     cli_out_write(f"{provider.name} (type: {provider.type}) - {provider.url}")
 
-def json_provider_formatter(providers_action):
+
+def _json_provider_formatter(providers_action):
     ret = []
     for provider in providers_action[0]:
         if provider:
@@ -133,13 +134,14 @@ def json_provider_formatter(providers_action):
     cli_out_write(json.dumps(ret, indent=4))
 
 
-@conan_subcommand(formatters={"text": text_provider_formatter, "json": json_provider_formatter})
+@conan_subcommand(formatters={"text": _text_provider_formatter, "json": _json_provider_formatter})
 def audit_provider(conan_api, parser, subparser, *args):
     """
     Manage security providers for the 'conan audit' command.
     """
 
-    subparser.add_argument("action", choices=["add", "list", "auth", "remove"], help="Action to perform from 'add', 'list' , 'remove' or 'auth'")
+    subparser.add_argument("action", choices=["add", "list", "auth", "remove"],
+                           help="Action to perform from 'add', 'list' , 'remove' or 'auth'")
     subparser.add_argument("name", help="Provider name", nargs="?")
 
     subparser.add_argument("--url", help="Provider URL")
@@ -188,8 +190,9 @@ def audit_provider(conan_api, parser, subparser, *args):
         conan_api.audit.auth_provider(provider, token)
         return [provider], args.action
 
+
 @conan_command(group="Security")
-def audit(conan_api, parser, *args):
+def audit(conan_api, parser, *args):  # noqa
     """
     Find vulnerabilities in your dependencies.
     """

{conan-2.14.0 → conan-2.15.1}/conan/cli/commands/create.py

@@ -9,8 +9,6 @@ from conan.cli.formatters.graph import format_graph_json
 from conan.cli.printers import print_profiles
 from conan.cli.printers.graph import print_graph_packages, print_graph_basic
 from conan.errors import ConanException
-from conans.client.graph.graph import BINARY_BUILD
-from conans.util.files import mkdir
 
 
 @conan_command(group="Creator", formatters={"json": format_graph_json})
@@ -63,24 +61,9 @@ def create(conan_api, parser, *args):
     lockfile = conan_api.lockfile.update_lockfile_export(lockfile, conanfile, ref, is_build)
 
     print_profiles(profile_host, profile_build)
-    if profile_host.runner and not os.environ.get("CONAN_RUNNER_ENVIRONMENT"):
-        from conan.internal.runner.docker import DockerRunner
-        from conan.internal.runner.ssh import SSHRunner
-        from conan.internal.runner.wsl import WSLRunner
-        try:
-            runner_type = profile_host.runner['type'].lower()
-        except KeyError:
-            raise ConanException(f"Invalid runner configuration. 'type' must be defined")
-        runner_instances_map = {
-            'docker': DockerRunner,
-            # 'ssh': SSHRunner,
-            # 'wsl': WSLRunner,
-        }
-        try:
-            runner_instance = runner_instances_map[runner_type]
-        except KeyError:
-            raise ConanException(f"Invalid runner type '{runner_type}'. Allowed values: {', '.join(runner_instances_map.keys())}")
-        return runner_instance(conan_api, 'create', profile_host, profile_build, args, raw_args).run()
+    runner = conan_api.command.get_runner(profile_host)
+    if runner is not None:
+        return runner(conan_api, 'create', profile_host, profile_build, args, raw_args).run()
 
     if args.build is not None and args.build_test is None:
         args.build_test = args.build
@@ -125,7 +108,7 @@ def create(conan_api, parser, *args):
     test_conanfile_path = _get_test_conanfile_path(test_package_folder, path)
     # If the user provide --test-missing and the binary was not built from source, skip test_package
     if args.test_missing and deps_graph.root.dependencies\
-            and deps_graph.root.dependencies[0].dst.binary != BINARY_BUILD:
+            and deps_graph.root.dependencies[0].dst.binary != "Build":
         test_conanfile_path = None  # disable it
 
     if test_conanfile_path:
@@ -176,7 +159,7 @@ def test_package(conan_api, deps_graph, test_conanfile_path):
         out.info("Removing previously existing 'test_package' build folder: "
                  f"{conanfile.build_folder}")
         shutil.rmtree(conanfile.build_folder, ignore_errors=True)
-        mkdir(conanfile.build_folder)
+        os.makedirs(conanfile.build_folder, exist_ok=True)
     conanfile.output.info(f"Test package build: {conanfile.folders.build}")
     conanfile.output.info(f"Test package build folder: {conanfile.build_folder}")
     conan_api.install.install_consumer(deps_graph=deps_graph,

{conan-2.14.0 → conan-2.15.1}/conan/cli/commands/graph.py

@@ -1,7 +1,6 @@
 import json
 import os
 
-from conan.api.model import ListPattern
 from conan.api.output import ConanOutput, cli_out_write, Color
 from conan.cli import make_abs_path
 from conan.cli.args import common_graph_args, validate_common_graph_args
@@ -14,8 +13,6 @@ from conan.cli.printers import print_profiles
 from conan.cli.printers.graph import print_graph_packages, print_graph_basic
 from conan.errors import ConanException
 from conans.client.graph.install_graph import InstallGraph, ProfileArgs
-from conan.internal.errors import NotFoundException
-from conan.api.model import RecipeReference
 
 
 def explain_formatter_text(data):
@@ -38,7 +35,7 @@ def explain_formatter_json(data):
 
 
 @conan_command(group="Consumer")
-def graph(conan_api, parser, *args):
+def graph(conan_api, parser, *args):  # noqa
     """
     Compute a dependency graph, without installing or building the binaries.
     """
@@ -135,7 +132,7 @@ def graph_build_order(conan_api, parser, subparser, *args):
 
 @conan_subcommand(formatters={"text": cli_build_order, "json": json_build_order,
                               "html": format_build_order_html})
-def graph_build_order_merge(conan_api, parser, subparser, *args):
+def graph_build_order_merge(conan_api, parser, subparser, *args):  # noqa
     """
     Merge more than 1 build-order file.
     """
@@ -378,48 +375,6 @@ def graph_outdated(conan_api, parser, subparser, *args):
     print_graph_basic(deps_graph)
 
     # Data structure to store info per library
-    dependencies = deps_graph.nodes[1:]
-    dict_nodes = {}
-
-    # When there are no dependencies command should stop
-    if len(dependencies) == 0:
-        return dict_nodes
-
-    ConanOutput().title("Checking remotes")
-
-    for node in dependencies:
-        dict_nodes.setdefault(node.name, {"cache_refs": set(), "version_ranges": [],
-                                          "latest_remote": None})["cache_refs"].add(node.ref)
-
-    for version_range in deps_graph.resolved_ranges.keys():
-        dict_nodes[version_range.name]["version_ranges"].append(version_range)
-
-    # find in remotes
-    _find_in_remotes(conan_api, dict_nodes, remotes)
-
-    # Filter nodes with no outdated versions
-    filtered_nodes = {}
-    for node_name, node in dict_nodes.items():
-        if node['latest_remote'] is not None and sorted(list(node['cache_refs']))[0] < \
-            node['latest_remote']['ref']:
-            filtered_nodes[node_name] = node
-
-    return filtered_nodes
-
-
-def _find_in_remotes(conan_api, dict_nodes, remotes):
-    for node_name, node_info in dict_nodes.items():
-        ref_pattern = ListPattern(node_name, rrev=None, prev=None)
-        for remote in remotes:
-            try:
-                remote_ref_list = conan_api.list.select(ref_pattern, package_query=None,
-                                                        remote=remote)
-            except NotFoundException:
-                continue
-            if not remote_ref_list.recipes:
-                continue
-            str_latest_ref = list(remote_ref_list.recipes.keys())[-1]
-            recipe_ref = RecipeReference.loads(str_latest_ref)
-            if (node_info["latest_remote"] is None
-                    or node_info["latest_remote"]["ref"] < recipe_ref):
-                node_info["latest_remote"] = {"ref": recipe_ref, "remote": remote.name}
+    # DO NOT USE this API call yet, it is not stable
+    outdated = conan_api.list.outdated(deps_graph, remotes)
+    return outdated

{conan-2.14.0 → conan-2.15.1}/conan/cli/commands/list.py

@@ -9,7 +9,6 @@ from conan.cli.formatters.list import list_packages_html
 from conan.errors import ConanException
 from conans.util.dates import timestamp_to_str
 
-
 # Keep them so we don't break other commands that import them, but TODO: Remove later
 remote_color = Color.BRIGHT_BLUE
 recipe_name_color = Color.GREEN
@@ -225,6 +224,9 @@ def list(conan_api: ConanAPI, parser, *args):
     parser.add_argument("-g", "--graph", help="Graph json file")
     parser.add_argument("-gb", "--graph-binaries", help="Which binaries are listed", action="append")
     parser.add_argument("-gr", "--graph-recipes", help="Which recipes are listed", action="append")
+    parser.add_argument("-gc", "--graph-context", help="Filter the results by the given context",
+                        default=None, action=OnceArgument,
+                        choices=["build", "host", "build-only", "host-only"])
     parser.add_argument('--lru', default=None, action=OnceArgument,
                         help="List recipes and binaries that have not been recently used. Use a"
                              " time limit like --lru=5d (days) or --lru=4w (weeks),"
@@ -248,7 +250,8 @@ def list(conan_api: ConanAPI, parser, *args):
 
     if args.graph:
         graphfile = make_abs_path(args.graph)
-        pkglist = MultiPackagesList.load_graph(graphfile, args.graph_recipes, args.graph_binaries)
+        pkglist = MultiPackagesList.load_graph(graphfile, args.graph_recipes, args.graph_binaries,
+                                               context=args.graph_context)
     else:
         ref_pattern = ListPattern(args.pattern, rrev=None, prev=None)
         if not ref_pattern.package_id and (args.package_query or args.filter_profile or

{conan-2.14.0 → conan-2.15.1}/conan/cli/commands/pkglist.py

@@ -1,12 +1,9 @@
-import copy
-
 from conan.api.conan_api import ConanAPI
-from conan.api.model import MultiPackagesList, PackagesList
+from conan.api.model import MultiPackagesList
 from conan.cli import make_abs_path
 from conan.cli.command import conan_command, conan_subcommand
 from conan.cli.commands.list import print_list_text, print_list_json
 from conan.cli.formatters.list import list_packages_html
-from conan.internal.errors import NotFoundException
 
 
 @conan_command(group="Consumer")
@@ -33,34 +30,7 @@ def pkglist_find_remote(conan_api, parser, subparser, *args):
     multi_pkglist = MultiPackagesList.load(listfile)
     package_list = multi_pkglist["Local Cache"]
     selected_remotes = conan_api.remotes.list(args.remote)
-
-    result = MultiPackagesList()
-    for r in selected_remotes:
-        result_pkg_list = PackagesList()
-        for ref, recipe_bundle in package_list.refs().items():
-            ref_no_rev = copy.copy(ref)  # TODO: Improve ugly API
-            ref_no_rev.revision = None
-            try:
-                revs = conan_api.list.recipe_revisions(ref_no_rev, remote=r)
-            except NotFoundException:
-                continue
-            if ref not in revs:  # not found
-                continue
-            result_pkg_list.add_refs([ref])
-            for pref, pref_bundle in package_list.prefs(ref, recipe_bundle).items():
-                pref_no_rev = copy.copy(pref)  # TODO: Improve ugly API
-                pref_no_rev.revision = None
-                try:
-                    prevs = conan_api.list.package_revisions(pref_no_rev, remote=r)
-                except NotFoundException:
-                    continue
-                if pref in prevs:
-                    result_pkg_list.add_prefs(ref, [pref])
-                    info = recipe_bundle["packages"][pref.package_id]["info"]
-                    result_pkg_list.add_configurations({pref: info})
-        if result_pkg_list.recipes:
-            result.add(r.name, result_pkg_list)
-
+    result = conan_api.list.find_remotes(package_list, selected_remotes)
     return {
         "results": result.serialize(),
         "conan_api": conan_api,
@@ -80,8 +50,8 @@ def pkglist_merge(conan_api, parser, subparser, *args):
     args = parser.parse_args(*args)
 
     result = MultiPackagesList()
-    for pkglist in args.list:
-        listfile = make_abs_path(pkglist)
+    for pkg_list in args.list:
+        listfile = make_abs_path(pkg_list)
         multi_pkglist = MultiPackagesList.load(listfile)
         result.merge(multi_pkglist)