conan 2.21.0__tar.gz → 2.22.0__tar.gz

{conan-2.21.0/conan.egg-info → conan-2.22.0}/PKG-INFO

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

{conan-2.21.0 → conan-2.22.0}/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.21.0'
+__version__ = '2.22.0'
 conan_version = Version(__version__)

{conan-2.21.0 → conan-2.22.0}/conan/api/conan_api.py

@@ -66,7 +66,8 @@ class ConanAPI:
         self.profiles = ProfilesAPI(self, self._api_helpers)
         self.install = InstallAPI(self, self._api_helpers)
         self.graph = GraphAPI(self, self._api_helpers)
-        self.export = ExportAPI(self, self._api_helpers)
+        #: Used to export recipes and pre-compiled package binaries to the Conan cache
+        self.export: ExportAPI = ExportAPI(self, self._api_helpers)
         self.remove = RemoveAPI(self)
         self.new = NewAPI(self)
         #: Used to upload recipes and packages to remotes
@@ -82,7 +83,7 @@ class ConanAPI:
         self.report = ReportAPI(self, self._api_helpers)
 
     @property
-    def home_folder(self):
+    def home_folder(self) -> str:
         """ Where the Conan user home is located. Read only.
         Can be modified by the ``CONAN_HOME`` environment variable or by the
         ``.conanrc`` file in the current directory or any parent directory
@@ -112,6 +113,7 @@ class ConanAPI:
             self.hook_manager = HookManager(HomePaths(self._conan_api.home_folder).hooks_path)
             # Wraps an http_requester to inject proxies, certs, etc
             self._requester = ConanRequester(self.global_conf, self._conan_api.home_folder)
+            self._settings_yml = None
 
         def set_core_confs(self, core_confs):
             confs = ConfDefinition()
@@ -137,10 +139,13 @@ class ConanAPI:
             self._init_global_conf()
             self.hook_manager.reinit()
             self._requester = ConanRequester(self.global_conf, self._conan_api.home_folder)
+            self._settings_yml = None
 
         @property
         def settings_yml(self):
-            return load_settings_yml(self._conan_api.home_folder)
+            if self._settings_yml is None:
+                self._settings_yml = load_settings_yml(self._conan_api.home_folder)
+            return self._settings_yml
 
         @property
         def requester(self):

{conan-2.21.0 → conan-2.22.0}/conan/api/output.py

@@ -124,22 +124,26 @@ class ConanOutput:
     def set_warnings_as_errors(cls, value):
         cls._warnings_as_errors = value
 
+    @classmethod
+    def valid_log_levels(cls):
+        return {"quiet": LEVEL_QUIET,  # -vquiet 80
+            "error": LEVEL_ERROR,  # -verror 70
+            "warning": LEVEL_WARNING,  # -vwaring 60
+            "notice": LEVEL_NOTICE,  # -vnotice 50
+            "status": LEVEL_STATUS,  # -vstatus 40
+            None: LEVEL_VERBOSE,  # -v 30
+            "verbose": LEVEL_VERBOSE,  # -vverbose 30
+            "debug": LEVEL_DEBUG,  # -vdebug 20
+            "v": LEVEL_DEBUG,  # -vv 20
+            "trace": LEVEL_TRACE,  # -vtrace 10
+            "vv": LEVEL_TRACE  # -vvv 10
+        }
+
     @classmethod
     def define_log_level(cls, v):
         env_level = os.getenv("CONAN_LOG_LEVEL")
         v = env_level or v
-        levels = {"quiet": LEVEL_QUIET,  # -vquiet 80
-                  "error": LEVEL_ERROR,  # -verror 70
-                  "warning": LEVEL_WARNING,  # -vwaring 60
-                  "notice": LEVEL_NOTICE,  # -vnotice 50
-                  "status": LEVEL_STATUS,  # -vstatus 40
-                  None: LEVEL_VERBOSE,  # -v 30
-                  "verbose": LEVEL_VERBOSE,  # -vverbose 30
-                  "debug": LEVEL_DEBUG,  # -vdebug 20
-                  "v": LEVEL_DEBUG,  # -vv 20
-                  "trace": LEVEL_TRACE,  # -vtrace 10
-                  "vv": LEVEL_TRACE  # -vvv 10
-                  }
+        levels = cls.valid_log_levels()
         try:
             level = levels[v]
         except KeyError:

{conan-2.21.0 → conan-2.22.0}/conan/api/subapi/cache.py

@@ -276,7 +276,7 @@ class CacheAPI:
 def _resolve_latest_ref(cache, ref):
     if ref.revision is None or ref.revision == "latest":
         ref.revision = None
-        result = cache.get_latest_recipe_reference(ref)
+        result = cache.get_latest_recipe_revision(ref)
         if result is None:
             raise ConanException(f"'{ref}' not found in cache")
         ref = result
@@ -287,7 +287,7 @@ def _resolve_latest_pref(cache, pref):
     pref.ref = _resolve_latest_ref(cache, pref.ref)
     if pref.revision is None or pref.revision == "latest":
         pref.revision = None
-        result = cache.get_latest_package_reference(pref)
+        result = cache.get_latest_package_revision(pref)
         if result is None:
             raise ConanException(f"'{pref.repr_notime()}' not found in cache")
         pref = result

{conan-2.21.0 → conan-2.22.0}/conan/api/subapi/config.py

@@ -150,3 +150,40 @@ class ConfigAPI:
         self._conan_api.reinit()
         # CHECK: This also generates a remotes.json that is not there after a conan profile show?
         self._conan_api.migrate()
+
+    @property
+    def settings_yml(self):
+        """ Get the contents of the settings.yml and user_settings.yml files,
+            which define the possible values for settings.
+
+            Note that this is different from the settings present in a conanfile,
+            which represent the actual values for a specific package, while this
+            property represents the possible values for each setting.
+
+            :returns: A read-only object representing the settings scheme, with a
+                ``possible_values()`` method that returns a dictionary with the possible values for each setting,
+                and a ``fields`` property that returns an ordered list with the fields of each setting.
+                Note that it's possible to access nested settings using attribute access,
+                such as ``settings_yml.compiler.possible_values()``.
+        """
+
+        class SettingsYmlInterface:
+            def __init__(self, settings):
+                self._settings = settings
+
+            def possible_values(self):
+                """ returns a dict with the possible values for each setting """
+                return self._settings.possible_values()
+
+            @property
+            def fields(self):
+                """ returns a dict with the fields of each setting """
+                return self._settings.fields
+
+            def __getattr__(self, item):
+                return SettingsYmlInterface(getattr(self._settings, item))
+
+            def __str__(self):
+                return str(self._settings)
+
+        return SettingsYmlInterface(self._helpers.settings_yml)

{conan-2.21.0 → conan-2.22.0}/conan/api/subapi/download.py

@@ -37,7 +37,7 @@ class DownloadAPI:
         if ref.timestamp is None:  # we didnt obtain the timestamp before (in general it should be)
             # Respect the timestamp of the server, the ``get_recipe()`` doesn't do it internally
             # Best would be that ``get_recipe()`` returns the timestamp in the same call
-            server_ref = app.remote_manager.get_recipe_revision_reference(ref, remote)
+            server_ref = app.remote_manager.get_recipe_revision(ref, remote)
             assert server_ref == ref
             ref.timestamp = server_ref.timestamp
         app.remote_manager.get_recipe(ref, remote, metadata)
@@ -70,7 +70,7 @@ class DownloadAPI:
 
         if pref.timestamp is None:  # we didn't obtain the timestamp before (in general it should be)
             # Respect the timestamp of the server
-            server_pref = app.remote_manager.get_package_revision_reference(pref, remote)
+            server_pref = app.remote_manager.get_package_revision(pref, remote)
             assert server_pref == pref
             pref.timestamp = server_pref.timestamp
 

conan-2.22.0/conan/api/subapi/export.py

@@ -0,0 +1,153 @@
+import os
+from typing import List, Tuple
+
+from conan import ConanFile
+from conan.api.output import ConanOutput
+from conan.cli.printers.graph import print_graph_basic
+from conan.internal.cache.cache import PkgCache
+from conan.internal.conan_app import ConanApp
+from conan.internal.api.export import cmd_export
+from conan.internal.methods import run_package_method
+from conan.internal.graph.graph import BINARY_BUILD, RECIPE_INCACHE
+from conan.api.model import PkgReference, Remote, RecipeReference
+from conan.internal.util.files import mkdir
+
+
+class ExportAPI:
+    """ This API provides methods to export artifacts, both recipes and pre-compiled package
+    binaries from user folders to the Conan cache, as Conan recipes and Conan package binaries
+    """
+
+    def __init__(self, conan_api, helpers):
+        self._conan_api = conan_api
+        self._helpers = helpers
+
+    def export(self, path, name: str = None, version: str = None, user: str = None,
+               channel: str = None, lockfile=None,
+               remotes: List[Remote] = None) -> Tuple[RecipeReference, ConanFile]:
+        """ Exports a ``conanfile.py`` recipe, together with its associated files to the Conan cache.
+        A "recipe-revision" will be computed and assigned.
+
+        :param path: Path to the conanfile to be exported
+        :param name: Optional package name. Typically not necessary as it is defined by the recipe
+            attribute or dynamically with the ``set_name()`` method.
+            If it is defined in recipe and as an argument, but they don't match, an error will be raised.
+        :param version: Optional version. It can be defined in the recipe with the version
+            attribute or dynamically with the 'set_version()' method.
+            If it is defined in recipe and as an argument, but they don't match, an error will be raised.
+        :param user: Optional user. Can be defined by recipe attribute.
+            If it is defined in recipe and as an argument, but they don't match, an error will be raised.
+        :param channel: Optional channel. Can be defined by recipe attribute.
+            If it is defined in recipe and as an argument, but they don't match, an error will be raised.
+        :param lockfile: Optional, only relevant if the recipe has 'python-requires' to be locked
+        :param remotes: Optional, only relevant to resolve 'python-requires' in remotes
+        :return: A tuple of the exported RecipeReference and a ConanFile object
+        """
+        ConanOutput().title("Exporting recipe to the cache")
+        app = ConanApp(self._conan_api)
+        hook_manager = self._helpers.hook_manager
+        return cmd_export(app.loader, app.cache, hook_manager, self._helpers.global_conf, path,
+                          name, version, user, channel, graph_lock=lockfile, remotes=remotes)
+
+    def export_pkg_graph(self, path, ref: RecipeReference, profile_host, profile_build,
+                         remotes: List[Remote], lockfile=None, is_build_require=False,
+                         skip_binaries=False, output_folder=None):
+        """Computes a dependency graph for a given configuration, for an already existing (previously
+        exported) recipe in the Conan cache. This method computes the full dependency graph, using
+        the profiles, lockfile and remotes information as any other install/graph/create command.
+        This is necessary in order to compute the "package_id" of the binary being exported
+        into the Conan cache.
+        The resulting dependency graph can be passed to ``export_pkg()`` method
+
+        :param path: Path to the conanfile.py in the user folder
+        :param ref: full RecipeReference, including recipe-revision
+        :param profile_host: Profile for the host context
+        :param profile_build: Profile for the build context
+        :param lockfile: Optional lockfile
+        :param remotes: List of Remotes
+        :param is_build_require: In case a package intended to be used as a tool-requires
+        :param skip_binaries:
+        :param output_folder: The folder containing output files, like potential environment scripts
+        :return: A Graph object that can be passed to ``export_pkg()`` method
+        """
+        assert ref.revision, "ref argument must have recipe-revision defined"
+        conan_api = self._conan_api
+        deps_graph = conan_api.graph.load_graph_consumer(path,
+                                                         ref.name, str(ref.version), ref.user,
+                                                         ref.channel,
+                                                         profile_host=profile_host,
+                                                         profile_build=profile_build,
+                                                         lockfile=lockfile, remotes=remotes,
+                                                         update=None,
+                                                         is_build_require=is_build_require)
+
+        print_graph_basic(deps_graph)
+        deps_graph.report_graph_error()
+        conan_api.graph.analyze_binaries(deps_graph, build_mode=[ref.name], lockfile=lockfile,
+                                         remotes=remotes)
+        deps_graph.report_graph_error()
+
+        root_node = deps_graph.root
+        root_node.ref = ref  # Make sure the root node revision is well defined
+
+        if not skip_binaries:
+            # unless the user explicitly opts-out with --skip-binaries, it is necessary to install
+            # binaries, in case there are build_requires necessary like tool-requires=cmake
+            # and package() method doing ``cmake.install()``
+            # for most cases, deps will be in cache already because of a previous "conan install"
+            # but if it is not the case, the binaries from remotes will be downloaded
+            conan_api.install.install_binaries(deps_graph=deps_graph, remotes=remotes)
+        source_folder = os.path.dirname(path)
+        conan_api.install.install_consumer(deps_graph=deps_graph, source_folder=source_folder,
+                                           output_folder=output_folder)
+        return deps_graph
+
+    def export_pkg(self, graph, output_folder=None) -> None:
+        """Executes the ``package()`` method of the exported recipe in order to copy the artifacts
+        from user folder to the Conan cache package folder
+
+        :param graph: A Graph object
+        :param output_folder: Optional folder where generated files like environment scripts
+            of dependencies have been installed
+        """
+        cache = PkgCache(self._conan_api.cache_folder, self._helpers.global_conf)
+        hook_manager = self._helpers.hook_manager
+
+        # The graph has to be loaded with build_mode=[ref.name], so that node is not tried
+        # to be downloaded from remotes
+        # passing here the create_reference=ref argument is useful so the recipe is in "develop",
+        # because the "package()" method is in develop=True already
+        pkg_node = graph.root
+        ref = pkg_node.ref
+        source_folder = os.path.dirname(pkg_node.path)
+        out = ConanOutput(scope=pkg_node.conanfile.display_name)
+        out.info("Exporting binary from user folder to Conan cache")
+        conanfile = pkg_node.conanfile
+
+        package_id = pkg_node.package_id
+        assert package_id is not None
+        out.info("Packaging to %s" % package_id)
+        pref = PkgReference(ref, package_id)
+        pkg_layout = cache.create_build_pkg_layout(pref)
+
+        conanfile.folders.set_base_folders(source_folder, output_folder)
+        dest_package_folder = pkg_layout.package()
+        conanfile.folders.set_base_package(dest_package_folder)
+        mkdir(pkg_layout.metadata())
+        conanfile.folders.set_base_pkg_metadata(pkg_layout.metadata())
+
+        with pkg_layout.set_dirty_context_manager():
+            prev = run_package_method(conanfile, package_id, hook_manager, ref)
+
+        pref = PkgReference(pref.ref, pref.package_id, prev)
+        pkg_layout.reference = pref
+        cache.assign_prev(pkg_layout)
+        pkg_node.prev = prev
+        pkg_node.pref_timestamp = pref.timestamp  # assigned by assign_prev
+        pkg_node.recipe = RECIPE_INCACHE
+        pkg_node.binary = BINARY_BUILD
+        # Make sure folder is updated
+        final_folder = pkg_layout.package()
+        conanfile.folders.set_base_package(final_folder)
+        out.info(f"Package folder {final_folder}")
+        out.success("Exported package binary")

{conan-2.21.0 → conan-2.22.0}/conan/api/subapi/list.py

@@ -57,9 +57,9 @@ class ListAPI:
         assert ref.revision is None, "latest_recipe_revision: ref already have a revision"
         app = ConanBasicApp(self._conan_api)
         if remote:
-            ret = app.remote_manager.get_latest_recipe_reference(ref, remote=remote)
+            ret = app.remote_manager.get_latest_recipe_revision(ref, remote=remote)
         else:
-            ret = app.cache.get_latest_recipe_reference(ref)
+            ret = app.cache.get_latest_recipe_revision(ref)
 
         return ret
 
@@ -69,9 +69,9 @@ class ListAPI:
         assert ref.revision is None, "recipe_revisions: ref already have a revision"
         app = ConanBasicApp(self._conan_api)
         if remote:
-            results = app.remote_manager.get_recipe_revisions_references(ref, remote=remote)
+            results = app.remote_manager.get_recipe_revisions(ref, remote=remote)
         else:
-            results = app.cache.get_recipe_revisions_references(ref)
+            results = app.cache.get_recipe_revisions(ref)
 
         return results
 
@@ -83,9 +83,9 @@ class ListAPI:
         assert pref.package_id is not None, "package_id must be defined"
         app = ConanBasicApp(self._conan_api)
         if remote:
-            ret = app.remote_manager.get_latest_package_reference(pref, remote=remote)
+            ret = app.remote_manager.get_latest_package_revision(pref, remote=remote)
         else:
-            ret = app.cache.get_latest_package_reference(pref)
+            ret = app.cache.get_latest_package_revision(pref)
         return ret
 
     def package_revisions(self, pref: PkgReference, remote=None):
@@ -93,23 +93,20 @@ class ListAPI:
                                               "check latest first if needed"
         app = ConanBasicApp(self._conan_api)
         if remote:
-            results = app.remote_manager.get_package_revisions_references(pref, remote=remote)
+            results = app.remote_manager.get_package_revisions(pref, remote=remote)
         else:
-            results = app.cache.get_package_revisions_references(pref, only_latest_prev=False)
+            results = app.cache.get_package_revisions(pref)
         return results
 
     def _packages_configurations(self, ref: RecipeReference,
                                  remote=None) -> Dict[PkgReference, dict]:
-        assert ref.revision is not None, "packages: ref should have a revision. " \
-                                         "Check latest if needed."
+        assert ref.revision is not None and ref.revision != "latest", \
+            "packages: ref should have a revision. Check latest if needed."
         app = ConanBasicApp(self._conan_api)
         if not remote:
             prefs = app.cache.get_package_references(ref)
             packages = _get_cache_packages_binary_info(app.cache, prefs)
         else:
-            if ref.revision == "latest":
-                ref.revision = None
-                ref = app.remote_manager.get_latest_recipe_reference(ref, remote=remote)
             packages = app.remote_manager.search_packages(remote, ref)
         return packages
 
@@ -120,8 +117,6 @@ class ListAPI:
         :param query: str like "os=Windows AND (arch=x86 OR compiler=gcc)"
         :return: Dict[PkgReference, PkgConfiguration]
         """
-        if query is None:
-            return pkg_configurations
         try:
             if "!" in query:
                 raise ConanException("'!' character is not allowed")
@@ -178,6 +173,7 @@ class ListAPI:
             It can be a string like ``"2d"`` (2 days) or ``"3h"`` (3 hours).
         :parameter Profile profile: Profile to filter the packages by settings and options.
         """
+        # TODO: Implement better error forwarding for "list" command that captures Exceptions
         if package_query and pattern.package_id and "*" not in pattern.package_id:
             raise ConanException("Cannot specify '-p' package queries, "
                                  "if 'package_id' is not a pattern")
@@ -513,7 +509,7 @@ def _get_cache_packages_binary_info(cache, prefs) -> Dict[PkgReference, dict]:
     result = OrderedDict()
 
     for pref in prefs:
-        latest_prev = cache.get_latest_package_reference(pref)
+        latest_prev = cache.get_latest_package_revision(pref)
         pkg_layout = cache.pkg_layout(latest_prev)
 
         # Read conaninfo

{conan-2.21.0 → conan-2.22.0}/conan/api/subapi/profiles.py

@@ -43,8 +43,11 @@ class ProfilesAPI:
         :return: the path to the default "build" profile, either in the cache or as
             defined by the user in configuration
         """
-        global_conf = self._api_helpers.global_conf
-        default_profile = global_conf.get("core:default_build_profile", default=DEFAULT_PROFILE_NAME)
+        default_profile = os.environ.get("CONAN_DEFAULT_BUILD_PROFILE")
+        if default_profile is None:
+            global_conf = self._api_helpers.global_conf
+            default_profile = global_conf.get("core:default_build_profile",
+                                              default=DEFAULT_PROFILE_NAME)
         default_profile = os.path.join(self._home_paths.profiles_path, default_profile)
         if not os.path.exists(default_profile):
             msg = ("The default build profile '{}' doesn't exist.\n"

{conan-2.21.0 → conan-2.22.0}/conan/api/subapi/workspace.py

@@ -263,10 +263,11 @@ class WorkspaceAPI:
 
     def super_build_graph(self, deps_graph, profile_host, profile_build):
         order = []
-        packages = self._ws.packages()
+        packages = self.packages()
 
         def find_folder(ref):
-            return next(p["path"] for p in packages if RecipeReference.loads(p["ref"]) == ref)
+            return next(os.path.dirname(os.path.relpath(p["path"], self._folder)) for p_ref, p in
+                        packages.items() if p_ref == ref)
 
         for level in deps_graph.by_levels():
             items = [item for item in level if item.recipe == "Editable"]
@@ -303,6 +304,13 @@ class WorkspaceAPI:
         conanfile.workspace_packages_options = {}
         for node in deps_graph.nodes[1:]:  # Exclude the current root
             if node.recipe != RECIPE_EDITABLE:
+                # sanity check, a pacakge in the cache cannot have dependencies to the workspace
+                deps_edit = [d.node for d in node.transitive_deps.values()
+                             if d.node.recipe == RECIPE_EDITABLE]
+                if deps_edit:
+                    raise ConanException(f"Workspace definition error. Package {node} in the "
+                                         f"Conan cache has dependencies to packages "
+                                         f"in the workspace: {deps_edit}")
                 result.add_node(node)
                 continue
             conanfile.workspace_packages_options[node.ref] = node.conanfile.options.serialize()

{conan-2.21.0 → conan-2.22.0}/conan/cli/args.py

@@ -27,29 +27,31 @@ _help_build_policies = '''Optional, specify which packages to build from source.
 
 
 def add_lockfile_args(parser):
-    parser.add_argument("-l", "--lockfile", action=OnceArgument,
-                        help="Path to a lockfile. Use --lockfile=\"\" to avoid automatic use of "
-                             "existing 'conan.lock' file")
-    parser.add_argument("--lockfile-partial", action="store_true",
-                        help="Do not raise an error if some dependency is not found in lockfile")
-    parser.add_argument("--lockfile-out", action=OnceArgument,
-                        help="Filename of the updated lockfile")
-    parser.add_argument("--lockfile-packages", action="store_true",
-                        help=argparse.SUPPRESS)
-    parser.add_argument("--lockfile-clean", action="store_true",
-                        help="Remove unused entries from the lockfile")
-    parser.add_argument("--lockfile-overrides",
-                        help="Overwrite lockfile overrides")
+    group = parser.add_argument_group("lockfile arguments")
+    group.add_argument("-l", "--lockfile", action=OnceArgument,
+                       help="Path to a lockfile. Use --lockfile=\"\" to avoid automatic use of "
+                            "existing 'conan.lock' file")
+    group.add_argument("--lockfile-partial", action="store_true",
+                       help="Do not raise an error if some dependency is not found in lockfile")
+    group.add_argument("--lockfile-out", action=OnceArgument,
+                       help="Filename of the updated lockfile")
+    group.add_argument("--lockfile-packages", action="store_true",
+                       help=argparse.SUPPRESS)
+    group.add_argument("--lockfile-clean", action="store_true",
+                       help="Remove unused entries from the lockfile")
+    group.add_argument("--lockfile-overrides",
+                       help="Overwrite lockfile overrides")
 
 
 def add_common_install_arguments(parser):
     parser.add_argument("-b", "--build", action="append", help=_help_build_policies)
 
-    group = parser.add_mutually_exclusive_group()
-    group.add_argument("-r", "--remote", action="append", default=None,
-                       help='Look in the specified remote or remotes server')
-    group.add_argument("-nr", "--no-remote", action="store_true",
-                       help='Do not use remote, resolve exclusively in the cache')
+    group = parser.add_argument_group("remote arguments")
+    exclusive_group = group.add_mutually_exclusive_group()
+    exclusive_group.add_argument("-r", "--remote", action="append", default=None,
+                                 help='Look in the specified remote or remotes server')
+    exclusive_group.add_argument("-nr", "--no-remote", action="store_true",
+                                 help='Do not use remote, resolve exclusively in the cache')
 
     update_help = ("Will install newer versions and/or revisions in the local cache "
                    "for the given reference name, or all references in the graph if no argument is supplied. "
@@ -57,13 +59,15 @@ def add_common_install_arguments(parser):
                    "satisfies the range. It will update to the "
                    "latest revision for the resolved version range.")
 
-    parser.add_argument("-u", "--update", action="append", nargs="?", help=update_help, const="*")
+    group.add_argument("-u", "--update", action="append", nargs="?", help=update_help, const="*")
     add_profiles_args(parser)
 
 
 def add_profiles_args(parser):
     contexts = ["build", "host"]
 
+    group = parser.add_argument_group("profile arguments")
+
     # This comes from the _AppendAction code but modified to add to the contexts
     class ContextAllAction(argparse.Action):
 
@@ -75,29 +79,29 @@ def add_profiles_args(parser):
                 setattr(namespace, self.dest + "_" + context, items)
 
     def create_config(short, long, example=None):
-        parser.add_argument(f"-{short}", f"--{long}",
-                            default=None,
-                            action="append",
-                            dest=f"{long}_host",
-                            metavar=long.upper(),
-                            help=f'Apply the specified {long}. '
-                                 f'By default, or if specifying -{short}:h (--{long}:host), it applies to the host context. '
-                                 f'Use -{short}:b (--{long}:build) to specify the build context, '
-                                 f'or -{short}:a (--{long}:all) to specify both contexts at once'
-                                   + ('' if not example else f". Example: {example}"))
+        group.add_argument(f"-{short}", f"--{long}",
+                           default=None,
+                           action="append",
+                           dest=f"{long}_host",
+                           metavar=long.upper(),
+                           help=f'Apply the specified {long}. '
+                                f'By default, or if specifying -{short}:h (--{long}:host), it applies to the host context. '
+                                f'Use -{short}:b (--{long}:build) to specify the build context, '
+                                f'or -{short}:a (--{long}:all) to specify both contexts at once'
+                                + ('' if not example else f". Example: {example}"))
         for context in contexts:
-            parser.add_argument(f"-{short}:{context[0]}", f"--{long}:{context}",
-                                default=None,
-                                action="append",
-                                dest=f"{long}_{context}",
-                                help="")
-
-        parser.add_argument(f"-{short}:a", f"--{long}:all",
-                            default=None,
-                            action=ContextAllAction,
-                            dest=long,
-                            metavar=f"{long.upper()}_ALL",
-                            help="")
+            group.add_argument(f"-{short}:{context[0]}", f"--{long}:{context}",
+                               default=None,
+                               action="append",
+                               dest=f"{long}_{context}",
+                               help="")
+
+        group.add_argument(f"-{short}:a", f"--{long}:all",
+                           default=None,
+                           action=ContextAllAction,
+                           dest=long,
+                           metavar=f"{long.upper()}_ALL",
+                           help="")
 
     create_config("pr", "profile")
     create_config("o", "options", '-o="pkg/*:with_qt=True"')
@@ -106,14 +110,15 @@ def add_profiles_args(parser):
 
 
 def add_reference_args(parser):
-    parser.add_argument("--name", action=OnceArgument,
-                        help='Provide a package name if not specified in conanfile')
-    parser.add_argument("--version", action=OnceArgument,
-                        help='Provide a package version if not specified in conanfile')
-    parser.add_argument("--user", action=OnceArgument,
-                        help='Provide a user if not specified in conanfile')
-    parser.add_argument("--channel", action=OnceArgument,
-                        help='Provide a channel if not specified in conanfile')
+    group = parser.add_argument_group("reference arguments")
+    group.add_argument("--name", action=OnceArgument,
+                       help='Provide a package name if not specified in conanfile')
+    group.add_argument("--version", action=OnceArgument,
+                       help='Provide a package version if not specified in conanfile')
+    group.add_argument("--user", action=OnceArgument,
+                       help='Provide a user if not specified in conanfile')
+    group.add_argument("--channel", action=OnceArgument,
+                       help='Provide a channel if not specified in conanfile')
 
 
 def common_graph_args(subparser):
@@ -124,12 +129,12 @@ def common_graph_args(subparser):
                                 "directory when no --requires or --tool-requires is "
                                 "given",
                            default=None)
-    add_reference_args(subparser)
+    add_common_install_arguments(subparser)
     subparser.add_argument("--requires", action="append",
                            help='Directly provide requires instead of a conanfile')
     subparser.add_argument("--tool-requires", action='append',
-                           help='Directly provide tool-requires instead of a conanfile')
-    add_common_install_arguments(subparser)
+                                                  help='Directly provide tool-requires instead of a conanfile')
+    add_reference_args(subparser)
     add_lockfile_args(subparser)