conan 2.17.1__tar.gz → 2.18.1__tar.gz

{conan-2.17.1/conan.egg-info → conan-2.18.1}/PKG-INFO

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

{conan-2.17.1 → conan-2.18.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.17.1'
+__version__ = '2.18.1'
 conan_version = Version(__version__)

{conan-2.17.1 → conan-2.18.1}/conan/api/conan_api.py

@@ -7,6 +7,7 @@ from conan.api.subapi.cache import CacheAPI
 from conan.api.subapi.command import CommandAPI
 from conan.api.subapi.local import LocalAPI
 from conan.api.subapi.lockfile import LockfileAPI
+from conan.api.subapi.report import ReportAPI
 from conan.api.subapi.workspace import WorkspaceAPI
 from conan.api.subapi.config import ConfigAPI
 from conan.api.subapi.download import DownloadAPI
@@ -72,6 +73,7 @@ class ConanAPI:
         self.audit = AuditAPI(self)
         # Now, lazy loading of editables
         self.workspace = WorkspaceAPI(self)
+        self.report = ReportAPI(self)
 
         _check_conan_version(self)
 

{conan-2.17.1 → conan-2.18.1}/conan/api/output.py

@@ -175,6 +175,12 @@ class ConanOutput:
 
         return self
 
+    def box(self, msg):
+        color = Color.BRIGHT_GREEN
+        self.writeln("\n**************************************************", fg=color)
+        self.writeln(f'*{msg: ^48}*', fg=color)
+        self.writeln(f"**************************************************\n", fg=color)
+
     def _write_message(self, msg, fg=None, bg=None, newline=True):
         if isinstance(msg, dict):
             # For traces we can receive a dict already, we try to transform then into more natural

{conan-2.17.1 → conan-2.18.1}/conan/api/subapi/cache.py

@@ -259,6 +259,14 @@ class CacheAPI:
         download_cache = DownloadCache(download_cache_path)
         return download_cache.get_backup_sources_files(excluded_urls, package_list, only_upload)
 
+    def path_to_ref(self, path):
+        cache = PkgCache(self.conan_api.cache_folder, self.conan_api.config.global_conf)
+        result = cache.path_to_ref(path)
+        if result is None:
+            base, folder = os.path.split(path)
+            result = cache.path_to_ref(base)
+        return result
+
 
 def _resolve_latest_ref(cache, ref):
     if ref.revision is None or ref.revision == "latest":

{conan-2.17.1 → conan-2.18.1}/conan/api/subapi/command.py

@@ -1,4 +1,5 @@
 import os
+import shlex
 
 from conan.api.output import ConanOutput
 from conan.errors import ConanException
@@ -12,7 +13,7 @@ class CommandAPI:
 
     def run(self, cmd):
         if isinstance(cmd, str):
-            cmd = cmd.split()
+            cmd = shlex.split(cmd)
         if isinstance(cmd, list):
             current_cmd = cmd[0]
             args = cmd[1:]

{conan-2.17.1 → conan-2.18.1}/conan/api/subapi/config.py

@@ -66,11 +66,11 @@ class ConfigAPI:
 
         # Basic checks of the package: correct package_type and no-dependencies
         deps_graph.report_graph_error()
-        pkg = deps_graph.root.dependencies[0].dst
+        pkg = deps_graph.root.edges[0].dst
         ConanOutput().info(f"Configuration from package: {pkg}")
         if pkg.conanfile.package_type is not PackageType.CONF:
             raise ConanException(f'{pkg.conanfile} is not of package_type="configuration"')
-        if pkg.dependencies:
+        if pkg.edges:
             raise ConanException(f"Configuration package {pkg.ref} cannot have dependencies")
 
         # The computation of the "package_id" and the download of the package is done as usual

{conan-2.17.1 → conan-2.18.1}/conan/api/subapi/local.py

@@ -82,7 +82,9 @@ class LocalAPI:
             with conanfile_exception_formatter(conanfile, "layout"):
                 conanfile.layout()
 
-        folder = conanfile.recipe_folder
+        folder = conanfile.recipe_folder if conanfile.folders.root is None else \
+            os.path.normpath(os.path.join(conanfile.recipe_folder, conanfile.folders.root))
+
         conanfile.folders.set_base_source(folder)
         conanfile.folders.set_base_export_sources(folder)
         conanfile.folders.set_base_recipe_metadata(os.path.join(folder, "metadata"))

{conan-2.17.1 → conan-2.18.1}/conan/api/subapi/new.py

@@ -96,6 +96,8 @@ class NewAPI:
         from conan.internal.api.new.bazel_7_exe import bazel_exe_files_7
         from conan.internal.api.new.autotools_lib import autotools_lib_files
         from conan.internal.api.new.autoools_exe import autotools_exe_files
+        from conan.internal.api.new.premake_lib import premake_lib_files
+        from conan.internal.api.new.premake_exe import premake_exe_files
         from conan.internal.api.new.local_recipes_index import local_recipes_index_files
         from conan.internal.api.new.qbs_lib import qbs_lib_files
         from conan.internal.api.new.workspace import workspace_files
@@ -114,6 +116,8 @@ class NewAPI:
                          "bazel_7_exe": bazel_exe_files_7,
                          "autotools_lib": autotools_lib_files,
                          "autotools_exe": autotools_exe_files,
+                         "premake_lib": premake_lib_files,
+                         "premake_exe": premake_exe_files,
                          "alias": alias_file,
                          "local_recipes_index": local_recipes_index_files,
                          "qbs_lib": qbs_lib_files,

{conan-2.17.1 → conan-2.18.1}/conan/api/subapi/profiles.py

@@ -64,12 +64,12 @@ class ProfilesAPI:
         cwd = os.getcwd()
         profile_build = self._get_profile(build_profiles, args.settings_build, args.options_build,
                                           args.conf_build, cwd, cache_settings,
-                                          profile_plugin, global_conf)
+                                          profile_plugin, global_conf, context="build")
         profile_host = self._get_profile(host_profiles, args.settings_host, args.options_host, args.conf_host,
-                                         cwd, cache_settings, profile_plugin, global_conf)
+                                         cwd, cache_settings, profile_plugin, global_conf, context="host")
         return profile_host, profile_build
 
-    def get_profile(self, profiles, settings=None, options=None, conf=None, cwd=None):
+    def get_profile(self, profiles, settings=None, options=None, conf=None, cwd=None, context=None):
         """ Computes a Profile as the result of aggregating all the user arguments, first it
         loads the "profiles", composing them in order (last profile has priority), and
         finally adding the individual settings, options (priority over the profiles)
@@ -81,13 +81,13 @@ class ProfilesAPI:
         profile_plugin = self._load_profile_plugin()
 
         profile = self._get_profile(profiles, settings, options, conf, cwd, cache_settings,
-                                    profile_plugin, global_conf)
+                                    profile_plugin, global_conf, context=context)
         return profile
 
     def _get_profile(self, profiles, settings, options, conf, cwd, cache_settings,
-                     profile_plugin, global_conf):
+                     profile_plugin, global_conf, context):
         loader = ProfileLoader(self._conan_api.cache_folder)
-        profile = loader.from_cli_args(profiles, settings, options, conf, cwd)
+        profile = loader.from_cli_args(profiles, settings, options, conf, cwd, context)
         if profile_plugin is not None:
             try:
                 profile_plugin(profile)

conan-2.18.1/conan/api/subapi/report.py

@@ -0,0 +1,144 @@
+import base64
+import os
+from io import StringIO
+
+from conan.api.output import ConanOutput
+from conan.errors import ConanException
+from conan.api.model import RecipeReference
+from conan.internal.conan_app import ConanApp
+from conan.internal.errors import conanfile_exception_formatter
+from conan.internal.graph.graph import CONTEXT_HOST
+from conan.internal.graph.profile_node_definer import initialize_conanfile_profile
+from conan.internal.source import config_source
+from conan.internal.util.runners import conan_run
+
+
+class ReportAPI:
+    def __init__(self, conan_api):
+        self.conan_api = conan_api
+
+    def diff(self, old_reference, new_reference, remotes, old_path=None, new_path=None, cwd=None):
+        """
+        Compare two recipes and return the differences.
+        :param old_reference: The reference of the old recipe.
+        :param new_reference: The reference of the new recipe.
+        :param remotes: List of remotes to search for the recipes.
+        :param old_path: Optional path to the old recipe's conanfile.py.
+        :param new_path: Optional path to the new recipe's conanfile.py.
+        :param cwd: Current working directory, used to resolve paths.
+        :return: A dictionary with the differences between the two recipes.
+        """
+
+        def _source(path_to_conanfile, reference):
+            if path_to_conanfile is None:
+                export_ref, cache_path = _get_ref_from_cache_or_remote(self.conan_api, reference, remotes)
+            else:
+                export_ref, cache_path = _export_recipe_from_path(self.conan_api, path_to_conanfile,
+                                                                  reference, remotes, cwd)
+            exported_path = self.conan_api.local.get_conanfile_path(cache_path, cwd, py=True)
+            _configure_source(self.conan_api, exported_path, export_ref, remotes)
+            return export_ref, cache_path
+
+
+        old_export_ref, old_cache_path = _source(old_path, old_reference)
+        new_export_ref, new_cache_path = _source(new_path, new_reference)
+
+        old_diff_path = os.path.abspath(os.path.join(old_cache_path, os.path.pardir)).replace("\\",
+                                                                                              "/")
+        new_diff_path = os.path.abspath(os.path.join(new_cache_path, os.path.pardir)).replace("\\",
+                                                                                              "/")
+
+        src_prefix = base64.b64encode(str(new_export_ref.repr_notime()).encode()).decode() + "/"
+        dst_prefix = base64.b64encode(str(old_export_ref.repr_notime()).encode()).decode() + "/"
+
+        command = (f'git diff --no-index --src-prefix "{src_prefix}" --dst-prefix "{dst_prefix}" '
+                   f'"{old_diff_path}" "{new_diff_path}"')
+
+        ConanOutput().info(
+            f"Generating diff from {old_export_ref.repr_notime()} to {new_export_ref.repr_notime()} (this might take a while)")
+        ConanOutput().info(command)
+
+        stdout, stderr = StringIO(), StringIO()
+        conan_run(command, stdout=stdout, stderr=stderr)
+        diff = stdout.getvalue()
+
+        if old_path:
+            self.conan_api.remove.recipe(old_export_ref)
+        if new_path:
+            self.conan_api.remove.recipe(new_export_ref)
+
+        return {
+            "diff": diff,
+            "old_export_ref": old_export_ref,
+            "new_export_ref": new_export_ref,
+            "old_cache_path": old_diff_path,
+            "new_cache_path": new_diff_path,
+            "src_prefix": src_prefix,
+            "dst_prefix": dst_prefix,
+        }
+
+def _configure_source(conan_api, conanfile_path, ref, remotes):
+    app = ConanApp(conan_api)
+    conanfile = app.loader.load_consumer(conanfile_path, name=ref.name, version=str(ref.version),
+                                         user=ref.user, channel=ref.channel, graph_lock=None,
+                                         remotes=remotes)
+    # This profile is empty, but with the conf from global.conf
+    profile = conan_api.profiles.get_profile([])
+    initialize_conanfile_profile(conanfile, profile, profile, CONTEXT_HOST, False)
+    # This is important, otherwise the ``conan source`` doesn't define layout and fails
+    if hasattr(conanfile, "layout"):
+        with conanfile_exception_formatter(conanfile, "layout"):
+            conanfile.layout()
+
+    recipe_layout = app.cache.recipe_layout(ref)
+    export_source_folder = recipe_layout.export_sources()
+    source_folder = recipe_layout.source()
+
+    conanfile.folders.set_base_source(source_folder)
+    conanfile.folders.set_base_export_sources(export_source_folder)
+    conanfile.folders.set_base_recipe_metadata(recipe_layout.metadata())
+    config_source(export_source_folder, conanfile, conan_api.config.hook_manager)
+
+def _get_ref_from_cache_or_remote(conan_api, reference, enabled_remotes):
+    ref = RecipeReference.loads(reference)
+    full_ref, matching_remote = None, False
+    # The first remote is None, which means local cache for the list subapi methods
+    for remote in [None] + enabled_remotes:
+        if ref.revision:
+            no_rrev_ref = RecipeReference.loads(reference)
+            no_rrev_ref.revision = None
+            try:
+                remote_revisions = conan_api.list.recipe_revisions(no_rrev_ref, remote)
+                if ref in remote_revisions:
+                    full_ref = ref
+                    matching_remote = remote
+                    break
+            except:
+                continue
+        else:
+            try:
+                latest_recipe_revision = conan_api.list.latest_recipe_revision(ref, remote)
+            except:
+                continue
+            if full_ref is None or (latest_recipe_revision.timestamp > full_ref.timestamp):
+                full_ref = latest_recipe_revision
+                matching_remote = remote
+    if full_ref is None or matching_remote is False:
+        raise ConanException(f"No matching reference for {reference} in remotes.\n"
+                             "If you want to check against a local recipe, add an additional --{old,new}-path arg.\n")
+    if matching_remote is not None:
+        conan_api.download.recipe(full_ref, matching_remote)
+    cache_path = conan_api.cache.export_path(full_ref)
+    return full_ref, cache_path
+
+
+def _export_recipe_from_path(conan_api, path_to_conanfile, reference, enabled_remotes, cwd=None):
+    path = conan_api.local.get_conanfile_path(path_to_conanfile, cwd, py=True)
+    ref = RecipeReference.loads(reference)
+    export_ref, conanfile = conan_api.export.export(path=path,
+                                                    name=ref.name, version=str(ref.version),
+                                                    user=ref.user, channel=ref.channel,
+                                                    lockfile=None,
+                                                    remotes=enabled_remotes)
+    cache_path = conan_api.cache.export_path(export_ref)
+    return export_ref, cache_path

{conan-2.17.1 → conan-2.18.1}/conan/api/subapi/workspace.py

@@ -8,8 +8,10 @@ from conan import ConanFile
 from conan.api.model import RecipeReference
 from conan.api.output import ConanOutput
 from conan.cli import make_abs_path
+from conan.cli.printers.graph import print_graph_basic, print_graph_packages
 from conan.errors import ConanException
 from conan.internal.conan_app import ConanApp
+from conan.internal.graph.install_graph import ProfileArgs
 from conan.internal.model.workspace import Workspace, WORKSPACE_YML, WORKSPACE_PY, WORKSPACE_FOLDER
 from conan.tools.scm import Git
 from conan.internal.graph.graph import RECIPE_EDITABLE, DepsGraph, CONTEXT_HOST, RECIPE_VIRTUAL, Node, \
@@ -74,6 +76,7 @@ class WorkspaceAPI:
     TEST_ENABLED = False
 
     def __init__(self, conan_api):
+        self._enabled = True
         self._conan_api = conan_api
         self._folder = _find_ws_folder()
         if self._folder:
@@ -85,6 +88,9 @@ class WorkspaceAPI:
                 ConanOutput().warning(f"Workspace is a dev-only feature, exclusively for testing")
                 self._ws = _load_workspace(self._folder, conan_api)  # Error if not loading
 
+    def enable(self, value):
+        self._enabled = value
+
     @property
     def name(self):
         self._check_ws()
@@ -94,41 +100,42 @@ class WorkspaceAPI:
         """
         @return: the current workspace folder where the conanws.yml or conanws.py is located
         """
+        self._check_ws()
         return self._folder
 
-    @property
-    def editable_packages(self):
+    def packages(self):
         """
         @return: Returns {RecipeReference: {"path": full abs-path, "output_folder": abs-path}}
         """
-        if not self._folder:
+        if not self._folder or not self._enabled:
             return
-        editables = self._ws.packages()
-        editables = {RecipeReference.loads(r): v.copy() for r, v in editables.items()}
-        for v in editables.values():
-            path = os.path.normpath(os.path.join(self._folder, v["path"], "conanfile.py"))
+        packages = {}
+        for editable_info in self._ws.packages():
+            rel_path = editable_info["path"]
+            path = os.path.normpath(os.path.join(self._folder, rel_path, "conanfile.py"))
             if not os.path.isfile(path):
                 raise ConanException(f"Workspace editable not found: {path}")
-            v["path"] = path
-            if v.get("output_folder"):
-                v["output_folder"] = os.path.normpath(os.path.join(self._folder,
-                                                                   v["output_folder"]))
-        return editables
-
-    def select_editables(self, paths):
-        filtered_refs = [self.editable_from_path(p) for p in paths or []]
-        editables = self.editable_packages
-        requires = [ref for ref in editables]
-        if filtered_refs:
-            ConanOutput().info(f"Filtering and installing only selected editable packages")
-            requires = [ref for ref in requires if ref in filtered_refs]
-            ConanOutput().info(f"Filtered references: {requires}")
-        return requires
-
-    @property
-    def products(self):
-        self._check_ws()
-        return self._ws.products()
+            ref = editable_info.get("ref")
+            try:
+                if ref is None:
+                    conanfile = self._ws.load_conanfile(rel_path)
+                    reference = RecipeReference(name=conanfile.name, version=conanfile.version,
+                                                user=conanfile.user, channel=conanfile.channel)
+                else:
+                    reference = RecipeReference.loads(ref)
+                reference.validate_ref(reference)
+            except:
+                raise ConanException(f"Workspace editable reference could not be deduced by"
+                                     f" {rel_path}/conanfile.py or it is not"
+                                     f" correctly defined in the conanws.yml file.")
+            if reference in packages:
+                raise ConanException(f"Workspace editable reference '{str(reference)}' already exists.")
+            packages[reference] = {"path": path}
+            if editable_info.get("output_folder"):
+                packages[reference]["output_folder"] = (
+                    os.path.normpath(os.path.join(self._folder, editable_info["output_folder"]))
+                )
+        return packages
 
     def open(self, require, remotes, cwd=None):
         app = ConanApp(self._conan_api)
@@ -167,7 +174,7 @@ class WorkspaceAPI:
                                  f"'{WORKSPACE_PY}' or '{WORKSPACE_YML}' file")
 
     def add(self, path, name=None, version=None, user=None, channel=None, cwd=None,
-            output_folder=None, remotes=None, product=False):
+            output_folder=None, remotes=None):
         """
         Add a new editable package to the current workspace (the current workspace must exist)
         @param path: The path to the folder containing the conanfile.py that defines the package
@@ -178,7 +185,6 @@ class WorkspaceAPI:
         @param cwd:
         @param output_folder:
         @param remotes:
-        @param product:
         @return: The reference of the added package
         """
         self._check_ws()
@@ -191,7 +197,7 @@ class WorkspaceAPI:
         ref.validate_ref()
         output_folder = make_abs_path(output_folder) if output_folder else None
         # Check the conanfile is there, and name/version matches
-        self._ws.add(ref, full_path, output_folder, product)
+        self._ws.add(ref, full_path, output_folder)
         return ref
 
     @staticmethod
@@ -230,17 +236,10 @@ class WorkspaceAPI:
         self._check_ws()
         return {"name": self.name,
                 "folder": self._folder,
-                "products": self.products,
                 "packages": self._ws.packages()}
 
-    def editable_from_path(self, path):
-        editables = self._ws.packages()
-        for ref, info in editables.items():
-            if info["path"].replace("\\", "/") == path:
-                return RecipeReference.loads(ref)
-
-    def collapse_editables(self, deps_graph, profile_host, profile_build):
-        ConanOutput().title("Collapsing workspace editables")
+    def super_build_graph(self, deps_graph, profile_host, profile_build):
+        ConanOutput().title("Collapsing workspace packages")
 
         root_class = self._ws.root_conanfile()
         if root_class is not None:
@@ -282,3 +281,56 @@ class WorkspaceAPI:
             result.add_edge(root, t.node, r)
 
         return result
+
+    def export(self, lockfile=None, remotes=None):
+        self._check_ws()
+        exported = []
+        for ref, info in self.packages().items():
+            exported_ref = self._conan_api.export.export(info["path"], ref.name, str(ref.version),
+                                                         ref.user, ref.channel,
+                                                         lockfile=lockfile, remotes=remotes)
+            ref, _ = exported_ref
+            exported.append(ref)
+        return exported
+
+
+    def select_packages(self, packages):
+        self._check_ws()
+        editable = self.packages()
+        packages = packages or []
+        selected_editables = {}
+        for ref, info in editable.items():
+            if packages and not any(ref.matches(p, False) for p in packages):
+                continue
+            selected_editables[ref] = info
+        if not selected_editables:
+            raise ConanException("There are no selected packages defined in the workspace")
+
+        return selected_editables
+
+    def build_order(self, packages, profile_host, profile_build, build_mode, lockfile, remotes,
+                    profile_args, update=False):
+        ConanOutput().title(f"Computing dependency graph for each package")
+        conan_api = self._conan_api
+        from conan.internal.graph.install_graph import InstallGraph
+        install_order = InstallGraph(None)
+
+        for ref, info in packages.items():
+            ConanOutput().title(f"Computing the dependency graph for package: {ref}")
+
+            deps_graph = conan_api.graph.load_graph_requires([ref], None,
+                                                             profile_host, profile_build, lockfile,
+                                                             remotes, update)
+            deps_graph.report_graph_error()
+            print_graph_basic(deps_graph)
+            conan_api.graph.analyze_binaries(deps_graph, build_mode, remotes=remotes, update=update,
+                                             lockfile=lockfile)
+            print_graph_packages(deps_graph)
+
+            ConanOutput().success(f"\nAggregating build-order for package: {ref}")
+            install_graph = InstallGraph(deps_graph, order_by="recipe",
+                                         profile_args=ProfileArgs.from_args(profile_args))
+            install_graph.raise_errors()
+            install_order.merge(install_graph)
+
+        return install_order

{conan-2.17.1 → conan-2.18.1}/conan/cli/command.py

@@ -1,4 +1,5 @@
 import argparse
+import os
 import textwrap
 from contextlib import redirect_stdout
 
@@ -96,6 +97,8 @@ class BaseConanCommand:
                 formatarg, ", ".join(self._help_formatters)))
 
         if out_file:
+            if os.path.dirname(out_file):
+                os.makedirs(os.path.dirname(out_file), exist_ok=True)
             with open(out_file, 'w') as f:
                 with redirect_stdout(f):
                     formatter(info)

{conan-2.17.1 → conan-2.18.1}/conan/cli/commands/audit.py

@@ -3,7 +3,7 @@ import os
 
 from conan.api.conan_api import ConanAPI
 from conan.api.input import UserInput
-from conan.api.model import MultiPackagesList
+from conan.api.model import MultiPackagesList, RecipeReference
 from conan.api.output import cli_out_write, ConanOutput
 from conan.api.subapi.audit import CONAN_CENTER_AUDIT_PROVIDER_NAME
 from conan.cli import make_abs_path
@@ -14,6 +14,7 @@ from conan.cli.formatters.audit.vulnerabilities import text_vuln_formatter, json
 from conan.cli.printers import print_profiles
 from conan.cli.printers.graph import print_graph_basic
 from conan.errors import ConanException
+from conan.internal.util.files import load
 
 
 def _add_provider_arg(subparser):
@@ -108,18 +109,15 @@ 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")
+    input_group = subparser.add_mutually_exclusive_group(required=True)
+    input_group.add_argument("reference", help="Reference to list vulnerabilities for", nargs="?")
+    input_group.add_argument("-l", "--list", help="pkglist file to list vulnerabilities for")
+    input_group.add_argument("-s", "--sbom", help="sbom file to list vulnerabilities for")
+    input_group.add_argument("-lock", "--lockfile", help="lockfile 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)
 
-    if not args.reference and not args.list:
-        raise ConanException("Please specify a reference or a pkglist file")
-
-    if args.reference and args.list:
-        raise ConanException("Please specify a reference or a pkglist file, not both")
-
     provider = conan_api.audit.get_provider(args.provider or CONAN_CENTER_AUDIT_PROVIDER_NAME)
 
     if args.list:
@@ -130,7 +128,19 @@ def audit_list(conan_api: ConanAPI, parser, subparser, *args):
         refs_to_list = package_list.serialize()
         references = list(refs_to_list.keys())
         if not references:  # the package list might contain only refs, no revs
-            ConanOutput().warning("Nothing to list, package list do not contain recipe revisions")
+            ConanOutput().warning("Nothing to list, package list does not contain recipe revisions")
+    elif args.sbom:
+        sbom_file = make_abs_path(args.sbom)
+        sbom = json.loads(load(sbom_file))
+        if sbom.get("bomFormat") != "CycloneDX":
+            raise ConanException(f"Unsupported SBOM format, only CycloneDX is supported.")
+        purls = [component["purl"] for component in sbom["components"]]
+        references = [purl.split("pkg:conan/")[1].replace("@", "/") for purl in purls]
+    elif args.lockfile:
+        lock_file = make_abs_path(args.lockfile)
+        lockfile = conan_api.lockfile.get_lockfile(lock_file).serialize()
+        references = [str(RecipeReference.loads(ref[0] if isinstance(ref, tuple) else ref))
+                      for ref in lockfile["requires"]]
     else:
         references = [args.reference]
     return conan_api.audit.list(references, provider)

{conan-2.17.1 → conan-2.18.1}/conan/cli/commands/cache.py

@@ -64,6 +64,19 @@ def cache_path(conan_api: ConanAPI, parser, subparser, *args):
     return path
 
 
+@conan_subcommand(formatters={"text": cli_out_write})
+def cache_ref(conan_api: ConanAPI, parser, subparser, *args):
+    """
+    Show the reference for a given Conan cache folder
+    """
+    subparser.add_argument("path", help="Path to a Conan cache folder")
+    args = parser.parse_args(*args)
+    ref = conan_api.cache.path_to_ref(args.path)
+    if ref is None:
+        raise ConanException("Reference for this path not found in cache")
+    return ref.repr_notime()
+
+
 @conan_subcommand()
 def cache_clean(conan_api: ConanAPI, parser, subparser, *args):
     """
@@ -187,5 +200,6 @@ def cache_backup_upload(conan_api: ConanAPI, parser, subparser, *args):
     """
     Upload all the source backups present in the cache
     """
+    args = parser.parse_args(*args)
     files = conan_api.cache.get_backup_sources()
     conan_api.upload.upload_backup_sources(files)

{conan-2.17.1 → conan-2.18.1}/conan/cli/commands/create.py

@@ -107,8 +107,8 @@ def create(conan_api, parser, *args):
         if args.test_folder is None else args.test_folder
     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 != "Build":
+    if args.test_missing and deps_graph.root.edges\
+            and deps_graph.root.edges[0].dst.binary != "Build":
         test_conanfile_path = None  # disable it
 
     if test_conanfile_path:

{conan-2.17.1 → conan-2.18.1}/conan/cli/commands/editable.py

@@ -77,5 +77,6 @@ def editable_list(conan_api, parser, subparser, *args):
     """
     List all the packages in editable mode.
     """
+    parser.parse_args(*args)
     editables = conan_api.local.editable_list()
     return editables

{conan-2.17.1 → conan-2.18.1}/conan/cli/commands/export_pkg.py

@@ -59,7 +59,7 @@ def export_pkg(conan_api, parser, *args):
 
     # TODO: Maybe we want to be able to export-pkg it as --build-require
     deps_graph = conan_api.graph.load_graph_consumer(path,
-                                                     ref.name, ref.version, ref.user, ref.channel,
+                                                     ref.name, str(ref.version), ref.user, ref.channel,
                                                      profile_host=profile_host,
                                                      profile_build=profile_build,
                                                      lockfile=lockfile, remotes=remotes, update=None,

{conan-2.17.1 → conan-2.18.1}/conan/cli/commands/profile.py

@@ -103,6 +103,7 @@ def profile_list(conan_api, parser, subparser, *args):  # noqa
     """
     List all profiles in the cache.
     """
+    parser.parse_args(*args)
     result = conan_api.profiles.list()
     return result
 

{conan-2.17.1 → conan-2.18.1}/conan/cli/commands/remote.py

@@ -170,6 +170,7 @@ def remote_list_users(conan_api, parser, subparser, *args):  # noqa
     """
     List the users logged into all the remotes.
     """
+    parser.parse_args(*args)
     remotes = conan_api.remotes.list()
     ret = OrderedDict()
     if not remotes: