Repository: conan-io/conan
Pull request #18079 (2025-04-04 11:35:39)

Refactor/api
Changelog: Feature: Moving functionality from ``Command`` layer to the ``ConanAPI`` for clearing old private imports ``from conans``.
Changelog: Fix: Making some ``Command`` formatter helpers private (only the ones in ``printers`` are common for reusage), and making some ConanAPI attributes private.
Docs: Omit



Patch:
diff --git a/conan/api/output.py b/conan/api/output.py
index 6989abc07..cf291ec98 100644
--- a/conan/api/output.py
+++ b/conan/api/output.py
@@ -207,9 +207,9 @@ class ConanOutput:
             self._write_message(msg, fg=Color.BLUE)
         return self
 
-    def debug(self, msg):
+    def debug(self, msg, fg=Color.MAGENTA, bg=None):
         if self._conan_output_level <= LEVEL_DEBUG:
-            self._write_message(msg, fg=Color.MAGENTA)
+            self._write_message(msg, fg=fg, bg=bg)
         return self
 
     def verbose(self, msg, fg=None, bg=None):
diff --git a/conan/api/subapi/cache.py b/conan/api/subapi/cache.py
index b42715070..c188f5fad 100644
--- a/conan/api/subapi/cache.py
+++ b/conan/api/subapi/cache.py
@@ -24,7 +24,7 @@ class CacheAPI:
 
     def export_path(self, ref: RecipeReference):
         cache = PkgCache(self.conan_api.cache_folder, self.conan_api.config.global_conf)
-        ref.revision = None if ref.revision == "latest" else ref.revision
+        ref = _resolve_latest_ref(cache, ref)
         ref_layout = cache.recipe_layout(ref)
         return _check_folder_existence(ref, "export", ref_layout.export())
 
@@ -36,13 +36,13 @@ class CacheAPI:
 
     def export_source_path(self, ref: RecipeReference):
         cache = PkgCache(self.conan_api.cache_folder, self.conan_api.config.global_conf)
-        ref.revision = None if ref.revision == "latest" else ref.revision
+        ref = _resolve_latest_ref(cache, ref)
         ref_layout = cache.recipe_layout(ref)
         return _check_folder_existence(ref, "export_sources", ref_layout.export_sources())
 
     def source_path(self, ref: RecipeReference):
         cache = PkgCache(self.conan_api.cache_folder, self.conan_api.config.global_conf)
-        ref.revision = None if ref.revision == "latest" else ref.revision
+        ref = _resolve_latest_ref(cache, ref)
         ref_layout = cache.recipe_layout(ref)
         return _check_folder_existence(ref, "source", ref_layout.source())
 
diff --git a/conan/api/subapi/graph.py b/conan/api/subapi/graph.py
index d3998e9fd..007bae969 100644
--- a/conan/api/subapi/graph.py
+++ b/conan/api/subapi/graph.py
@@ -5,6 +5,7 @@ from conans.client.graph.graph import Node, RECIPE_CONSUMER, CONTEXT_HOST, RECIP
     CONTEXT_BUILD, BINARY_MISSING
 from conans.client.graph.graph_binaries import GraphBinariesAnalyzer
 from conans.client.graph.graph_builder import DepsGraphBuilder
+from conans.client.graph.install_graph import InstallGraph, ProfileArgs
 from conans.client.graph.profile_node_definer import initialize_conanfile_profile, consumer_definer
 from conan.errors import ConanException
 from conan.api.model import RecipeReference
@@ -212,3 +213,27 @@ class GraphAPI:
                     or (missing and ref_matches(node.ref, missing, is_consumer=None))):
                 return node.ref, node.conanfile.info
         raise ConanException("There is no missing binary")
+
+    @staticmethod
+    def build_order(deps_graph, order_by="recipe", reduce=False, profile_args=None):
+        install_graph = InstallGraph(deps_graph, order_by=order_by,
+                                     profile_args=ProfileArgs.from_args(profile_args))
+        if reduce:
+            if order_by is None:
+                raise ConanException("--reduce needs --order-by argument defined")
+            install_graph.reduce()
+        return install_graph
+
+    @staticmethod
+    def build_order_merge(files, reduce=False):
+        result = InstallGraph.load(files[0])
+        if result.reduced:
+            raise ConanException(f"Reduced build-order file cannot be merged: {files[0]}")
+        for f in files[1:]:
+            install_graph = InstallGraph.load(f)
+            if install_graph.reduced:
+                raise ConanException(f"Reduced build-order file cannot be merged: {f}")
+            result.merge(install_graph)
+        if reduce:
+            result.reduce()
+        return result
diff --git a/conan/api/subapi/remotes.py b/conan/api/subapi/remotes.py
index 1bb55664a..65409cc63 100644
--- a/conan/api/subapi/remotes.py
+++ b/conan/api/subapi/remotes.py
@@ -1,6 +1,7 @@
 import fnmatch
 import json
 import os
+from collections import OrderedDict
 from urllib.parse import urlparse
 
 from conan.api.model import Remote, LOCAL_RECIPES_INDEX
@@ -8,6 +9,7 @@ from conan.api.output import ConanOutput
 from conan.internal.cache.home_paths import HomePaths
 from conan.internal.conan_app import ConanBasicApp
 from conans.client.rest.conan_requester import ConanRequester
+from conans.client.rest.remote_credentials import RemoteCredentials
 from conans.client.rest_client_local_recipe_index import add_local_recipes_index_remote, \
     remove_local_recipes_index_remote
 from conan.internal.api.remotes.localdb import LocalDB
@@ -29,14 +31,14 @@ class RemotesAPI:
 
     def __init__(self, conan_api):
         # This method is private, the subapi is not instantiated by users
-        self.conan_api = conan_api
+        self._conan_api = conan_api
         self._home_folder = conan_api.home_folder
         self._remotes_file = HomePaths(self._home_folder).remotes_path
         # Wraps an http_requester to inject proxies, certs, etc
-        self._requester = ConanRequester(self.conan_api.config.global_conf, self.conan_api.cache_folder)
+        self._requester = ConanRequester(self._conan_api.config.global_conf, self._conan_api.cache_folder)
 
     def reinit(self):
-        self._requester = ConanRequester(self.conan_api.config.global_conf, self.conan_api.cache_folder)
+        self._requester = ConanRequester(self._conan_api.config.global_conf, self._conan_api.cache_folder)
 
     def list(self, pattern=None, only_enabled=True):
         """
@@ -224,9 +226,29 @@ class RemotesAPI:
         :param username: the user login as ``str``
         :param password: password ``str``
         """
-        app = ConanBasicApp(self.conan_api)
+        app = ConanBasicApp(self._conan_api)
         app.remote_manager.authenticate(remote, username, password)
 
+    def login(self, remotes, username=None, password=None):
+        creds = RemoteCredentials(self._conan_api.cache_folder, self._conan_api.config.global_conf)
+
+        ret = OrderedDict()
+        for r in remotes:
+            previous_info = self.user_info(r)
+
+            if username is not None and password is not None:
+                user, password = username, password
+            else:
+                user, password, _ = creds.auth(r, username)
+                if username is not None and username != user:
+                    raise ConanException(f"User '{username}' doesn't match user '{user}' in "
+                                         f"credentials.json or environment variables")
+
+            self.user_login(r, user, password)
+            info = self.user_info(r)
+            ret[r.name] = {"previous_info": previous_info, "info": info}
+        return ret
+
     def user_logout(self, remote: Remote):
         """
         Logout from the given :ref:`Remote <conan.api.model.Remote>`
@@ -247,7 +269,7 @@ class RemotesAPI:
     def user_auth(self, remote: Remote, with_user=False, force=False):
         # TODO: Review
         localdb = LocalDB(self._home_folder)
-        app = ConanBasicApp(self.conan_api)
+        app = ConanBasicApp(self._conan_api)
         if with_user:
             user, token, _ = localdb.get_login(remote.url)
             if not user:
diff --git a/conan/cli/cli.py b/conan/cli/cli.py
index 6c94be4c4..4a9ed3ece 100644
--- a/conan/cli/cli.py
+++ b/conan/cli/cli.py
@@ -45,6 +45,7 @@ class Cli:
             Cli._builtin_commands = self._commands.copy()
         else:
             self._commands = Cli._builtin_commands.copy()
+            self._groups = defaultdict(list)
             for k, v in self._commands.items():  # Fill groups data too
                 self._groups[v.group].append(k)
 
diff --git a/conan/cli/commands/graph.py b/conan/cli/commands/graph.py
index 40b27cc1b..290bac5bd 100644
--- a/conan/cli/commands/graph.py
+++ b/conan/cli/commands/graph.py
@@ -12,7 +12,6 @@ from conan.cli.formatters.graph.graph_info_text import format_graph_info
 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
 
 
 def explain_formatter_text(data):
@@ -111,13 +110,8 @@ def graph_build_order(conan_api, parser, subparser, *args):
 
     out = ConanOutput()
     out.title("Computing the build order")
-
-    install_graph = InstallGraph(deps_graph, order_by=args.order_by,
-                                 profile_args=ProfileArgs.from_args(args))
-    if args.reduce:
-        if args.order_by is None:
-            raise ConanException("--reduce needs --order-by argument defined")
-        install_graph.reduce()
+    install_graph = conan_api.graph.build_order(deps_graph, args.order_by, args.reduce,
+                                                profile_args=args)
     install_order_serialized = install_graph.install_build_order()
     if args.order_by is None:  # legacy
         install_order_serialized = install_order_serialized["order"]
@@ -144,21 +138,12 @@ def graph_build_order_merge(conan_api, parser, subparser, *args):  # noqa
     if not args.file or len(args.file) < 2:
         raise ConanException("At least 2 files are needed to be merged")
 
-    result = InstallGraph.load(make_abs_path(args.file[0]))
-    if result.reduced:
-        raise ConanException(f"Reduced build-order file cannot be merged: {args.file[0]}")
-    for f in args.file[1:]:
-        install_graph = InstallGraph.load(make_abs_path(f))
-        if install_graph.reduced:
-            raise ConanException(f"Reduced build-order file cannot be merged: {f}")
-        result.merge(install_graph)
-
-    if args.reduce:
-        result.reduce()
+    files = [make_abs_path(f) for f in args.file]
+    result = conan_api.graph.build_order_merge(files, args.reduce)
+
     install_order_serialized = result.install_build_order()
     if getattr(result, "legacy"):
         install_order_serialized = install_order_serialized["order"]
-
     return {"build_order": install_order_serialized,
             "conan_error": result.get_errors()}
 
@@ -236,13 +221,22 @@ def graph_info(conan_api, parser, subparser, *args):
             base_folder = args.deployer_folder or os.getcwd()
             conan_api.install.deploy(deps_graph, args.deployer, None, base_folder)
 
+    warn_msg = None
+    missing = set(str(n.ref.name) for n in deps_graph.nodes if n.binary == "Missing")
+    invalid = set(str(n.ref.name) for n in deps_graph.nodes if n.binary == "Invalid")
+    if missing or invalid:
+        warn_msg = "There are some error(s) in the graph:"
+        if missing:
+            warn_msg += f"\n    - Missing packages: {', '.join(missing)}"
+        if invalid:
+            warn_msg += f"\n    - Invalid packages: {', '.join(invalid)}"
+
     return {"graph": deps_graph,
             "field_filter": args.filter,
             "package_filter": args.package_filter,
             "conan_api": conan_api,
             "conan_error": str(deps_graph.error) if deps_graph.error else None,
-            # Do not compute graph errors if there are dependency errors
-            "conan_warning": InstallGraph(deps_graph).get_errors() if not deps_graph.error else None}
+            "conan_warning": warn_msg}
 
 
 @conan_subcommand(formatters={"text": explain_formatter_text,
diff --git a/conan/cli/commands/remote.py b/conan/cli/commands/remote.py
index a22529f54..83eec7f5c 100644
--- a/conan/cli/commands/remote.py
+++ b/conan/cli/commands/remote.py
@@ -10,22 +10,21 @@ from conan.cli.command import conan_command, conan_subcommand, OnceArgument
 from conan.cli.commands.list import remote_color, error_color, recipe_color, \
     reference_color
 from conan.errors import ConanException
-from conans.client.rest.remote_credentials import RemoteCredentials
 
 
-def formatter_remote_list_json(remotes):
+def _print_remotes_json(remotes):
     info = [{"name": r.name, "url": r.url, "verify_ssl": r.verify_ssl, "enabled": not r.disabled}
             for r in remotes]
     cli_out_write(json.dumps(info, indent=4))
 
 
-def print_remote_list(remotes):
+def _print_remote_list(remotes):
     for r in remotes:
         output_str = str(r)
         cli_out_write(output_str)
 
 
-def print_remote_user_list(results):
+def _print_remote_user_list(results):
     for remote_name, result in results.items():
         cli_out_write(f"{remote_name}:", fg=remote_color)
         if result["user_name"] is None:
@@ -37,7 +36,7 @@ def print_remote_user_list(results):
             cli_out_write(result["authenticated"], fg=reference_color)
 
 
-def print_remote_user_set(results):
+def _print_remote_user_set(results):
     for remote_name, result in results.items():
         from_user = "'{}'".format(result["previous_info"]["user_name"])
         from_user += " (anonymous)" \
@@ -49,12 +48,12 @@ def print_remote_user_set(results):
         cli_out_write(message)
 
 
-def output_remotes_json(results):
+def _print_remotes_users_json(results):
     cli_out_write(json.dumps(list(results.values())))
 
 
-@conan_subcommand(formatters={"text": print_remote_list, "json": formatter_remote_list_json})
-def remote_list(conan_api: ConanAPI, parser, subparser, *args):
+@conan_subcommand(formatters={"text": _print_remote_list, "json": _print_remotes_json})
+def remote_list(conan_api: ConanAPI, parser, subparser, *args):  # noqa
     """
     List current remotes.
     """
@@ -92,7 +91,7 @@ def remote_add(conan_api, parser, subparser, *args):
     conan_api.remotes.add(r, force=args.force, index=args.index)
 
 
-@conan_subcommand(formatters={"text": print_remote_list})
+@conan_subcommand(formatters={"text": _print_remote_list})
 def remote_remove(conan_api, parser, subparser, *args):
     """
     Remove remotes.
@@ -138,7 +137,7 @@ def remote_rename(conan_api, parser, subparser, *args):
     conan_api.remotes.rename(args.remote, args.new_name)
 
 
-@conan_subcommand(formatters={"text": print_remote_list, "json": formatter_remote_list_json})
+@conan_subcommand(formatters={"text": _print_remote_list, "json": _print_remotes_json})
 def remote_enable(conan_api, parser, subparser, *args):
     """
     Enable all the remotes matching a pattern.
@@ -149,7 +148,7 @@ def remote_enable(conan_api, parser, subparser, *args):
     return conan_api.remotes.enable(args.remote)
 
 
-@conan_subcommand(formatters={"text": print_remote_list, "json": formatter_remote_list_json})
+@conan_subcommand(formatters={"text": _print_remote_list, "json": _print_remotes_json})
 def remote_disable(conan_api, parser, subparser, *args):
     """
     Disable all the remotes matching a pattern.
@@ -162,8 +161,8 @@ def remote_disable(conan_api, parser, subparser, *args):
 
 # ### User related commands
 
-@conan_subcommand(formatters={"text": print_remote_user_list, "json": output_remotes_json})
-def remote_list_users(conan_api, parser, subparser, *args):
+@conan_subcommand(formatters={"text": _print_remote_user_list, "json": _print_remotes_users_json})
+def remote_list_users(conan_api, parser, subparser, *args):  # noqa
     """
     List the users logged into all the remotes.
     """
@@ -177,7 +176,7 @@ def remote_list_users(conan_api, parser, subparser, *args):
     return ret
 
 
-@conan_subcommand(formatters={"text": print_remote_user_set, "json": output_remotes_json})
+@conan_subcommand(formatters={"text": _print_remote_user_set, "json": _print_remotes_users_json})
 def remote_login(conan_api, parser, subparser, *args):
     """
     Login into the specified remotes matching a pattern.
@@ -194,29 +193,10 @@ def remote_login(conan_api, parser, subparser, *args):
     remotes = conan_api.remotes.list(pattern=args.remote, only_enabled=False)
     if not remotes:
         raise ConanException("There are no remotes matching the '{}' pattern".format(args.remote))
+    return conan_api.remotes.login(remotes, args.username, args.password)
 
-    creds = RemoteCredentials(conan_api.cache_folder, conan_api.config.global_conf)
 
-    ret = OrderedDict()
-    for r in remotes:
-        previous_info = conan_api.remotes.user_info(r)
-
-        if args.username is not None and args.password is not None:
-            user, password = args.username, args.password
-        else:
-            user, password, _ = creds.auth(r, args.username)
-            if args.username is not None and args.username != user:
-                raise ConanException(f"User '{args.username}' doesn't match user '{user}' in "
-                                     f"credentials.json or environment variables")
-
-        conan_api.remotes.user_login(r, user, password)
-        info = conan_api.remotes.user_info(r)
-        ret[r.name] = {"previous_info": previous_info, "info": info}
-
-    return ret
-
-
-@conan_subcommand(formatters={"text": print_remote_user_set, "json": output_remotes_json})
+@conan_subcommand(formatters={"text": _print_remote_user_set, "json": _print_remotes_users_json})
 def remote_set_user(conan_api, parser, subparser, *args):
     """
     Associate a username with a remote matching a pattern without performing the authentication.
@@ -240,7 +220,7 @@ def remote_set_user(conan_api, parser, subparser, *args):
     return ret
 
 
-@conan_subcommand(formatters={"text": print_remote_user_set, "json": output_remotes_json})
+@conan_subcommand(formatters={"text": _print_remote_user_set, "json": _print_remotes_users_json})
 def remote_logout(conan_api, parser, subparser, *args):
     """
     Clear the existing credentials for the specified remotes matching a pattern.
@@ -261,7 +241,7 @@ def remote_logout(conan_api, parser, subparser, *args):
     return ret
 
 
-def print_auth(remotes):
+def _print_auth(remotes):
     for remote_name, msg in remotes.items():
         if msg is None:
             cli_out_write(f"{remote_name}: No user defined")
@@ -271,11 +251,11 @@ def print_auth(remotes):
                 cli_out_write(f"    {k}: {v}", fg=Color.BRIGHT_RED if k == "error" else Color.WHITE)
 
 
-def print_auth_json(results):
+def _print_auth_json(results):
     cli_out_write(json.dumps(results))
 
 
-@conan_subcommand(formatters={"text": print_auth, "json": print_auth_json})
+@conan_subcommand(formatters={"text": _print_auth, "json": _print_auth_json})
 def remote_auth(conan_api, parser, subparser, *args):
     """
     Authenticate in the defined remotes. Use CONAN_LOGIN_USERNAME* and CONAN_PASSWORD* variables if available.
@@ -310,7 +290,7 @@ def remote_auth(conan_api, parser, subparser, *args):
 
 
 @conan_command(group="Consumer")
-def remote(conan_api, parser, *args):
+def remote(conan_api, parser, *args):  # noqa
     """
     Manage the remote list and the users authenticated on them.
     """
diff --git a/conan/cli/printers/graph.py b/conan/cli/printers/graph.py
index e0bd79e16..84c671f4a 100644
--- a/conan/cli/printers/graph.py
+++ b/conan/cli/printers/graph.py
@@ -1,4 +1,4 @@
-from conan.api.output import ConanOutput, Color, LEVEL_VERBOSE
+from conan.api.output import ConanOutput, Color, LEVEL_VERBOSE, LEVEL_DEBUG
 from conans.client.graph.graph import BINARY_INVALID, BINARY_MISSING, RECIPE_CONSUMER, \
     RECIPE_VIRTUAL, CONTEXT_BUILD, BINARY_SKIP, \
     BINARY_PLATFORM, BINARY_BUILD
@@ -115,13 +115,14 @@ def print_graph_packages(graph):
     for node in graph.nodes:
         if node.recipe in (RECIPE_CONSUMER, RECIPE_VIRTUAL):
             continue
+        node_info = node.conanfile.info
         if node.context == CONTEXT_BUILD:
-            existing = build_requires.setdefault(node.pref, [node.binary, node.binary_remote])
+            existing = build_requires.setdefault(node.pref, [node.binary, node.binary_remote, node_info])
         else:
             if node.test:
-                existing = test_requires.setdefault(node.pref, [node.binary, node.binary_remote])
+                existing = test_requires.setdefault(node.pref, [node.binary, node.binary_remote, node_info])
             else:
-                existing = requires.setdefault(node.pref, [node.binary, node.binary_remote])
+                existing = requires.setdefault(node.pref, [node.binary, node.binary_remote, node_info])
         # TO avoid showing as "skip" something that is used in other node of the graph
         if existing[0] == BINARY_SKIP:
             existing[0] = node.binary
@@ -130,7 +131,7 @@ def print_graph_packages(graph):
         if not reqs_to_print:
             return
         output.info(title, Color.BRIGHT_YELLOW)
-        for pref, (status, remote) in sorted(reqs_to_print.items(), key=repr):
+        for pref, (status, remote, info) in sorted(reqs_to_print.items(), key=repr):
             name = pref.repr_notime() if status != BINARY_PLATFORM else str(pref.ref)
             msg = f"{tab}{name} - "
             if status == BINARY_SKIP:
@@ -148,6 +149,10 @@ def print_graph_packages(graph):
                 if remote:
                     msg += f" ({remote.name})"
                 output.info(msg, Color.BRIGHT_CYAN)
+            if output.level_allowed(LEVEL_DEBUG):
+                compact_dumps = info.summarize_compact()
+                for line in compact_dumps:
+                    output.debug(f"{tab}{tab}{line}", Color.BRIGHT_GREEN)
 
     _format_requires("Requirements", requires)
     _format_requires("Test requirements", test_requires)
diff --git a/conan/internal/api/audit/providers.py b/conan/internal/api/audit/providers.py
index aa19b66c0..5e83913f4 100644
--- a/conan/internal/api/audit/providers.py
+++ b/conan/internal/api/audit/providers.py
@@ -121,7 +121,7 @@ class PrivateProvider:
         for ref in refs:
             response = self._get(ref)
             if "error" in response:
-                ConanOutput().error(f"Error: {response['error']['details']}")
+                ConanOutput().error(response['error']['details'])
                 result["error"] = response["error"]
                 return result, True
             result["data"].setdefault(str(ref), {}).update(response["data"]["query"])
@@ -191,10 +191,19 @@ class PrivateProvider:
                     "query": textwrap.dedent(full_query)
                 }
             )
+
+            if response.status_code == 404:
+                ConanOutput().write("\n")
+                ConanOutput().warning(
+                    f"An error occurred while connecting to the '{self.name}' provider.\n"
+                    "This is likely because your JFrog Platform instance does not have JFrog Curation.\n"
+                    "For more information, visit: https://audit.conan.io/missing-curation\n"
+                )
+
             # Raises if some HTTP error was found
             response.raise_for_status()
         except Exception as e:
-            return {"error": {"details": f"Something went wrong: {e}"}}
+            return {"error": {"details": str(e)}}
 
         response_json = response.json()
         # filter the extensions key with graphql data
diff --git a/conan/internal/api/uploader.py b/conan/internal/api/uploader.py
index ce057893e..8a014732e 100644
--- a/conan/internal/api/uploader.py
+++ b/conan/internal/api/uploader.py
@@ -82,9 +82,9 @@ class PackagePreparator:
         self._app = app
         self._global_conf = global_conf
 
-    def prepare(self, upload_bundle, enabled_remotes):
+    def prepare(self, pkg_list, enabled_remotes):
         local_url = self._global_conf.get("core.scm:local_url", choices=["allow", "block"])
-        for ref, bundle in upload_bundle.refs().items():
+        for ref, bundle in pkg_list.refs().items():
             layout = self._app.cache.recipe_layout(ref)
             conanfile_path = layout.conanfile()
             conanfile = self._app.loader.load_basic(conanfile_path)
@@ -97,7 +97,7 @@ class PackagePreparator:
 
             if bundle.get("upload"):
                 self._prepare_recipe(ref, bundle, conanfile, enabled_remotes)
-            for pref, prev_bundle in upload_bundle.prefs(ref, bundle).items():
+            for pref, prev_bundle in pkg_list.prefs(ref, bundle).items():
                 if prev_bundle.get("upload"):
                     self._prepare_package(pref, prev_bundle)
 
diff --git a/conan/internal/cache/cache.py b/conan/internal/cache/cache.py
index 8363cc4f5..bf7d64d2b 100644
--- a/conan/internal/cache/cache.py
+++ b/conan/internal/cache/cache.py
@@ -111,10 +111,8 @@ class PkgCache:
     def recipe_layout(self, ref: RecipeReference):
         """ the revision must exists, the folder must exist
         """
-        if ref.revision is None:  # Latest one
-            ref_data = self._db.get_latest_recipe(ref)
-        else:
-            ref_data = self._db.get_recipe(ref)
+        assert ref.revision is not None
+        ref_data = self._db.get_recipe(ref)
         ref_path = ref_data.get("path")
         ref = ref_data.get("ref")  # new revision with timestamp
         return RecipeLayout(ref, os.path.join(self._base_folder, ref_path))
diff --git a/conan/internal/cache/integrity_check.py b/conan/internal/cache/integrity_check.py
index 58dec88ea..b1148e612 100644
--- a/conan/internal/cache/integrity_check.py
+++ b/conan/internal/cache/integrity_check.py
@@ -20,11 +20,11 @@ class IntegrityChecker:
     def __init__(self, cache):
         self._cache = cache
 
-    def check(self, upload_data):
+    def check(self, pkg_list):
         corrupted = False
-        for ref, recipe_bundle in upload_data.refs().items():
+        for ref, recipe_bundle in pkg_list.refs().items():
             corrupted = self._recipe_corrupted(ref) or corrupted
-            for pref, prev_bundle in upload_data.prefs(ref, recipe_bundle).items():
+            for pref, prev_bundle in pkg_list.prefs(ref, recipe_bundle).items():
                 corrupted = self._package_corrupted(pref) or corrupted
         if corrupted:
             raise ConanException("There are corrupted artifacts, check the error logs")
diff --git a/conan/internal/default_settings.py b/conan/internal/default_settings.py
index 51b2b5d55..0be97dce2 100644
--- a/conan/internal/default_settings.py
+++ b/conan/internal/default_settings.py
@@ -146,7 +146,8 @@ compiler:
         cstd: [null, 99, gnu99, 11, gnu11, 17, gnu17, 23, gnu23]
     intel-cc:
         version: ["2021.1", "2021.2", "2021.3", "2021.4", "2022.1", "2022.2",
-                  "2022.3", "2023.0", "2023.1", "2023.2", "2024.0",]
+                  "2022.3", "2023.0", "2023.1", "2023.2", "2024.0", "2024.1",
+                  "2025.0", "2025.1"]
         update: [null, ANY]
         mode: ["icx", "classic", "dpcpp"]
         libcxx: [null, libstdc++, libstdc++11, libc++]
diff --git a/conan/internal/model/conf.py b/conan/internal/model/conf.py
index 3e3e95959..4cb9d7c29 100644
--- a/conan/internal/model/conf.py
+++ b/conan/internal/model/conf.py
@@ -7,7 +7,9 @@ import fnmatch
 from collections import OrderedDict
 
 from conan.errors import ConanException
+from conan.internal.model.options import _PackageOption
 from conan.internal.model.recipe_ref import ref_matches
+from conan.internal.model.settings import SettingsItem
 
 BUILT_IN_CONFS = {
     "core:required_conan_version": "Raise if current version does not match the defined range.",
@@ -155,7 +157,7 @@ class _ConfVarPlaceHolder:
     pass
 
 
-class _ConfValue(object):
+class _ConfValue:
 
     def __init__(self, name, value, path=False, update=None):
         if name != name.lower():
@@ -163,6 +165,8 @@ class _ConfValue(object):
         self._name = name
         self._value = value
         self._value_type = type(value)
+        if isinstance(value, (_PackageOption, SettingsItem)):
+            raise ConanException(f"Invalid 'conf' type, please use Python types (int, str, ...)")
         self._path = path
         self._update = update
 
@@ -220,6 +224,8 @@ class _ConfValue(object):
         if isinstance(value, list):
             self._value.extend(value)
         else:
+            if isinstance(value, (_PackageOption, SettingsItem)):
+                raise ConanException(f"Invalid 'conf' type, please use Python types (int, str, ...)")
             self._value.append(value)
 
     def prepend(self, value):
@@ -229,6 +235,8 @@ class _ConfValue(object):
         if isinstance(value, list):
             self._value = value + self._value
         else:
+            if isinstance(value, (_PackageOption, SettingsItem)):
+                raise ConanException(f"Invalid 'conf' type, please use Python types (int, str, ...)")
             self._value.insert(0, value)
 
     def compose_conf_value(self, other):
diff --git a/conan/internal/model/info.py b/conan/internal/model/info.py
index 2319ba777..2cadf1e8d 100644
--- a/conan/internal/model/info.py
+++ b/conan/internal/model/info.py
@@ -432,6 +432,18 @@ class ConanInfo:
         result.append("")  # Append endline so file ends with LF
         return '\n'.join(result)
 
+    def summarize_compact(self):
+        result = []
+        serialized = self.serialize()
+
+        for key, values in serialized.items():
+            if isinstance(values, dict):
+                result.append(f"{key}: " + " ".join(f"{k}={v}" for k, v in values.items()))
+            elif isinstance(values, type([])):
+                result.append(f"{key}: {' '.join(values)}")
+
+        return result
+
     def dump_diff(self, compatible):
         self_dump = self.dumps()
         compatible_dump = compatible.dumps()
diff --git a/conan/internal/model/layout.py b/conan/internal/model/layout.py
index 5ddacf543..f03c42efd 100644
--- a/conan/internal/model/layout.py
+++ b/conan/internal/model/layout.py
@@ -32,7 +32,7 @@ class Layouts(object):
         self.package = PartialLayout()
 
 
-class Folders(object):
+class Folders:
 
     def __init__(self):
         self._base_source = None
@@ -60,9 +60,6 @@ class Folders(object):
         self.subproject = None
         self.build_folder_vars = None
 
-    def __repr__(self):
-        return str(self.__dict__)
-
     def set_base_folders(self, conanfile_folder, output_folder):
         """ this methods can be used for defining all the base folders in the
         local flow (conan install, source, build), where only the current conanfile location
diff --git a/conan/tools/apple/apple.py b/conan/tools/apple/apple.py
index 4b0271891..535464990 100644
--- a/conan/tools/apple/apple.py
+++ b/conan/tools/apple/apple.py
@@ -328,3 +328,28 @@ def fix_apple_shared_install_name(conanfile):
     # there is nothing to do.
     if substitutions:
         _fix_executables(conanfile, substitutions)
+
+
+def apple_extra_flags(conanfile):
+    if not is_apple_os(conanfile):
+        return []
+    enable_bitcode = conanfile.conf.get("tools.apple:enable_bitcode", check_type=bool)
+    enable_arc = conanfile.conf.get("tools.apple:enable_arc", check_type=bool)
+    enable_visibility = conanfile.conf.get("tools.apple:enable_visibility", check_type=bool)
+    is_debug = conanfile.settings.get_safe('build_type') == "Debug"
+
+    flags = []
+    if enable_bitcode:
+        if is_debug:
+            flags.append("-fembed-bitcode-marker")
+        else:
+            flags.append("-fembed-bitcode")
+    if enable_arc:
+        flags.append("-fobjc-arc")
+    if enable_arc is False:
+        flags.append("-fno-objc-arc")
+    if enable_visibility:
+        flags.append("-fvisibility=default")
+    if enable_visibility is False:
+        flags.extend(["-fvisibility=hidden", "-fvisibility-inlines-hidden"])
+    return flags
diff --git a/conan/tools/cmake/cmakedeps2/target_configuration.py b/conan/tools/cmake/cmakedeps2/target_configuration.py
index 4e483d257..c72a13653 100644
--- a/conan/tools/cmake/cmakedeps2/target_configuration.py
+++ b/conan/tools/cmake/cmakedeps2/target_configuration.py
@@ -80,7 +80,7 @@ class TargetConfigurationTemplate2:
                         assert required_pkg == required_comp
                         comp = None
                         default_target = f"{dep.ref.name}::{dep.ref.name}"  # replace_requires
-                        link = pkg_type is not PackageType.SHARED 
+                        link = pkg_type is not PackageType.SHARED
                     else:
                         comp = required_comp
                         default_target = f"{required_pkg}::{required_comp}"
@@ -364,6 +364,8 @@ class TargetConfigurationTemplate2:
         set_property(TARGET {{lib}} APPEND PROPERTY IMPORTED_CONFIGURATIONS {{config}})
         set_target_properties({{lib}} PROPERTIES IMPORTED_LOCATION_{{config}}
                               "{{lib_info["location"]}}")
+        {% elif lib_info.get("type") == "INTERFACE" %}
+        set_property(TARGET {{lib}} APPEND PROPERTY IMPORTED_CONFIGURATIONS {{config}})
         {% endif %}
         {% if lib_info.get("link_location") %}
         set_target_properties({{lib}} PROPERTIES IMPORTED_IMPLIB_{{config}}
diff --git a/conan/tools/gnu/autotoolstoolchain.py b/conan/tools/gnu/autotoolstoolchain.py
index e2daf568f..89c395ed1 100644
--- a/conan/tools/gnu/autotoolstoolchain.py
+++ b/conan/tools/gnu/autotoolstoolchain.py
@@ -3,7 +3,7 @@ import os
 from conan.errors import ConanException
 from conan.internal import check_duplicated_generator
 from conan.internal.internal_tools import raise_on_universal_arch
-from conan.tools.apple.apple import is_apple_os, resolve_apple_flags
+from conan.tools.apple.apple import is_apple_os, resolve_apple_flags, apple_extra_flags
 from conan.tools.build import cmd_args_to_string, save_toolchain_args
 from conan.tools.build.cross_building import cross_building
 from conan.tools.build.flags import architecture_flag, build_type_flags, cppstd_flag, \
@@ -84,9 +84,9 @@ class AutotoolsToolchain:
         sysroot = sysroot.replace("\\", "/") if sysroot is not None else None
         self.sysroot_flag = "--sysroot {}".format(sysroot) if sysroot else None
 
-        self.configure_args = self._default_configure_shared_flags() + \
-                              self._default_configure_install_flags() + \
-                              self._get_triplets()
+        self.configure_args = (self._default_configure_shared_flags() +
+                               self._default_configure_install_flags() +
+                               self._get_triplets())
         self.autoreconf_args = self._default_autoreconf_flags()
         self.make_args = []
         # Apple stuff
@@ -101,6 +101,7 @@ class AutotoolsToolchain:
         # -isysroot makes all includes for your library relative to the build directory
         self.apple_isysroot_flag = isysroot_flag
         self.apple_min_version_flag = min_flag
+        self.apple_extra_flags = apple_extra_flags(self._conanfile)
 
     def _resolve_android_cross_compilation(self):
         # Issue related: https://github.com/conan-io/conan/issues/13443
@@ -188,6 +189,7 @@ class AutotoolsToolchain:
         ret = [self.libcxx, self.cppstd, self.arch_flag, fpic, self.msvc_runtime_flag,
                self.sysroot_flag]
         apple_flags = [self.apple_isysroot_flag, self.apple_arch_flag, self.apple_min_version_flag]
+        apple_flags += self.apple_extra_flags
         conf_flags = self._conanfile.conf.get("tools.build:cxxflags", default=[], check_type=list)
         vs_flag = self._add_msvc_flags(self.extra_cxxflags)
         ret = ret + self.build_type_flags + apple_flags + self.extra_cxxflags + vs_flag + conf_flags
@@ -198,6 +200,7 @@ class AutotoolsToolchain:
         fpic = "-fPIC" if self.fpic else None
         ret = [self.cstd, self.arch_flag, fpic, self.msvc_runtime_flag, self.sysroot_flag]
         apple_flags = [self.apple_isysroot_flag, self.apple_arch_flag, self.apple_min_version_flag]
+        apple_flags += self.apple_extra_flags
         conf_flags = self._conanfile.conf.get("tools.build:cflags", default=[], check_type=list)
         vs_flag = self._add_msvc_flags(self.extra_cflags)
         ret = ret + self.build_type_flags + apple_flags + self.extra_cflags + vs_flag + conf_flags
@@ -207,6 +210,7 @@ class AutotoolsToolchain:
     def ldflags(self):
         ret = [self.arch_flag, self.sysroot_flag]
         apple_flags = [self.apple_isysroot_flag, self.apple_arch_flag, self.apple_min_version_flag]
+        apple_flags += self.apple_extra_flags
         conf_flags = self._conanfile.conf.get("tools.build:sharedlinkflags", default=[],
                                               check_type=list)
         conf_flags.extend(self._conanfile.conf.get("tools.build:exelinkflags", default=[],
diff --git a/conan/tools/gnu/gnutoolchain.py b/conan/tools/gnu/gnutoolchain.py
index 1b22240e8..c5245e1e5 100644
--- a/conan/tools/gnu/gnutoolchain.py
+++ b/conan/tools/gnu/gnutoolchain.py
@@ -2,7 +2,7 @@ import os
 
 from conan.internal import check_duplicated_generator
 from conan.internal.internal_tools import raise_on_universal_arch
-from conan.tools.apple.apple import is_apple_os, resolve_apple_flags
+from conan.tools.apple.apple import is_apple_os, resolve_apple_flags, apple_extra_flags
 from conan.tools.build import cmd_args_to_string, save_toolchain_args
 from conan.tools.build.cross_building import cross_building
 from conan.tools.build.flags import architecture_flag, build_type_flags, cppstd_flag, \
@@ -104,6 +104,7 @@ class GnuToolchain:
         # -isysroot makes all includes for your library relative to the build directory
         self.apple_isysroot_flag = isysroot_flag
         self.apple_min_version_flag = min_flag
+        self.apple_extra_flags = apple_extra_flags(conanfile)
         # Default initial environment flags
         self._initialize_default_extra_env()
 
@@ -245,6 +246,7 @@ class GnuToolchain:
         ret = [self.libcxx, self.cppstd, self.arch_flag, fpic, self.msvc_runtime_flag,
                self.sysroot_flag]
         apple_flags = [self.apple_isysroot_flag, self.apple_arch_flag, self.apple_min_version_flag]
+        apple_flags += self.apple_extra_flags
         conf_flags = self._conanfile.conf.get("tools.build:cxxflags", default=[], check_type=list)
         vs_flag = self._add_msvc_flags(self.extra_cxxflags)
         ret = ret + self.build_type_flags + apple_flags + self.extra_cxxflags + vs_flag + conf_flags
@@ -255,6 +257,7 @@ class GnuToolchain:
         fpic = "-fPIC" if self.fpic else None
         ret = [self.arch_flag, fpic, self.msvc_runtime_flag, self.sysroot_flag]
         apple_flags = [self.apple_isysroot_flag, self.apple_arch_flag, self.apple_min_version_flag]
+        apple_flags += self.apple_extra_flags
         conf_flags = self._conanfile.conf.get("tools.build:cflags", default=[], check_type=list)
         vs_flag = self._add_msvc_flags(self.extra_cflags)
         ret = ret + self.build_type_flags + apple_flags + self.extra_cflags + vs_flag + conf_flags
@@ -264,6 +267,7 @@ class GnuToolchain:
     def ldflags(self):
         ret = [self.arch_flag, self.sysroot_flag]
         apple_flags = [self.apple_isysroot_flag, self.apple_arch_flag, self.apple_min_version_flag]
+        apple_flags += self.apple_extra_flags
         conf_flags = self._conanfile.conf.get("tools.build:sharedlinkflags", default=[],
                                               check_type=list)
         conf_flags.extend(self._conanfile.conf.get("tools.build:exelinkflags", default=[],
diff --git a/conan/tools/meson/toolchain.py b/conan/tools/meson/toolchain.py
index 88bbc9b73..d923d066d 100644
--- a/conan/tools/meson/toolchain.py
+++ b/conan/tools/meson/toolchain.py
@@ -7,7 +7,7 @@ from conan.errors import ConanException
 from conan.internal import check_duplicated_generator
 from conan.internal.internal_tools import raise_on_universal_arch
 from conan.tools.apple.apple import is_apple_os, apple_min_version_flag, \
-    resolve_apple_flags
+    resolve_apple_flags, apple_extra_flags
 from conan.tools.build.cross_building import cross_building
 from conan.tools.build.flags import libcxx_flags, architecture_flag
 from conan.tools.env import VirtualBuildEnv
@@ -338,6 +338,8 @@ class MesonToolchain:
         self.apple_isysroot_flag = []
         #: Apple minimum binary version flag as a list, e.g., ``["-mios-version-min", "10.8"]``
         self.apple_min_version_flag = []
+        #: Apple bitcode, visibility and arc flags
+        self.apple_extra_flags = apple_extra_flags(self._conanfile)
         #: Defines the Meson ``objc`` variable. Defaulted to ``None``, if if any Apple OS ``clang``
         self.objc = None
         #: Defines the Meson ``objcpp`` variable. Defaulted to ``None``, if if any Apple OS ``clang++``
@@ -443,6 +445,10 @@ class MesonToolchain:
         defines = self._conanfile_conf.get("tools.build:defines", default=[], check_type=list)
         sys_root = [f"--sysroot={self._sys_root}"] if self._sys_root else [""]
         ld = sharedlinkflags + exelinkflags + linker_script_flags + sys_root + self.extra_ldflags
+        # Apple extra flags from confs (visibilty, bitcode, arc)
+        cxxflags += self.apple_extra_flags
+        cflags += self.apple_extra_flags
+        ld += self.apple_extra_flags
         return {
             "cxxflags": [self.arch_flag] + cxxflags + sys_root + self.extra_cxxflags,
             "cflags": [self.arch_flag] + cflags + sys_root + self.extra_cflags,
diff --git a/conan/tools/microsoft/layout.py b/conan/tools/microsoft/layout.py
index 6ac491f47..6a4c73133 100644
--- a/conan/tools/microsoft/layout.py
+++ b/conan/tools/microsoft/layout.py
@@ -26,11 +26,11 @@ def vs_layout(conanfile):
         raise ConanException("The 'vs_layout' requires the 'arch' setting")
 
     if arch != "None" and arch != "x86":
-        arch = msbuild_arch(arch)
-        if not arch:
-            raise ConanException("The 'vs_layout' doesn't "
-                                 "work with the arch '{}'".format(arch))
-        bindirs = os.path.join(arch, build_type)
+        msvc_arch = msbuild_arch(arch)
+        if not msvc_arch:
+            raise ConanException(f"The 'vs_layout' doesn't work with the arch '{arch}'. "
+                                 "Accepted architectures: 'x86', 'x86_64', 'armv7', 'armv8'")
+        bindirs = os.path.join(msvc_arch, build_type)
     else:
         bindirs = build_type
 
diff --git a/conan/tools/microsoft/msbuilddeps.py b/conan/tools/microsoft/msbuilddeps.py
index ad2c89c84..258a56b97 100644
--- a/conan/tools/microsoft/msbuilddeps.py
+++ b/conan/tools/microsoft/msbuilddeps.py
@@ -94,9 +94,10 @@ class MSBuildDeps:
         :param conanfile: ``< ConanFile object >`` The current recipe object. Always use ``self``.
         """
         self._conanfile = conanfile
-        #: Defines the build type. By default, ``settings.build_type``.
+        #: Defines the build type. By default, the value of ``settings.build_type``.
         self.configuration = conanfile.settings.build_type
-        #: Defines the configuration key used to conditionate on which property sheet to import.
+        #: Defines the configuration key used to conditionally select which property sheet to
+        #: import (defaults to ``"Configuration"``).
         self.configuration_key = "Configuration"
         # TODO: This platform is not exactly the same as ``msbuild_arch``, because it differs
         # in x86=>Win32
@@ -105,7 +106,8 @@ class MSBuildDeps:
                          'x86_64': 'x64',
                          'armv7': 'ARM',
                          'armv8': 'ARM64'}.get(str(conanfile.settings.arch))
-        #: Defines the platform key used to conditionate on which property sheet to import.
+        #: Defines the platform key used to conditionally select which property sheet to
+        #: import (defaults to ``"Platform"``).
         self.platform_key = "Platform"
         ca_exclude = "tools.microsoft.msbuilddeps:exclude_code_analysis"
         #: List of packages names patterns to add Visual Studio ``CAExcludePath`` property
diff --git a/conans/client/graph/install_graph.py b/conans/client/graph/install_graph.py
index 4a0fdaf9e..b68dec9f2 100644
--- a/conans/client/graph/install_graph.py
+++ b/conans/client/graph/install_graph.py
@@ -66,7 +66,7 @@ class _InstallPackageReference:
         self.nodes.append(node)
 
     def _build_args(self):
-        if self.binary != BINARY_BUILD:
+        if self.binary not in (BINARY_BUILD, BINARY_EDITABLE_BUILD):
             return None
         cmd = f"--requires={self.ref}" if self.context == "host" else f"--tool-requires={self.ref}"
         compatible = "compatible:" if self.info and self.info.get("compatibility_delta") else ""
@@ -290,7 +290,7 @@ class _InstallConfiguration:
                     self.depends.append(dep.dst.pref)
 
     def _build_args(self):
-        if self.binary != BINARY_BUILD:
+        if self.binary not in (BINARY_BUILD, BINARY_EDITABLE_BUILD):
             return None
         cmd = f"--requires={self.ref}" if self.context == "host" else f"--tool-requires={self.ref}"
         compatible = "compatible:" if self.info and self.info.get("compatibility_delta") else ""
diff --git a/conans/client/graph/proxy.py b/conans/client/graph/proxy.py
index 72b927516..c2d416437 100644
--- a/conans/client/graph/proxy.py
+++ b/conans/client/graph/proxy.py
@@ -38,7 +38,9 @@ class ConanProxy:
 
         # check if it there's any revision of this recipe in the local cache
         try:
-            recipe_layout = self._cache.recipe_layout(reference)
+            cache_ref = self._cache.get_latest_recipe_reference(reference) \
+                if reference.revision is None else reference
+            recipe_layout = self._cache.recipe_layout(cache_ref)
             ref = recipe_layout.reference  # latest revision if it was not defined
         except ConanException:
             # NOT in disk, must be retrieved from remotes
diff --git a/conans/client/installer.py b/conans/client/installer.py
index d661ac53c..51197962e 100644
--- a/conans/client/installer.py
+++ b/conans/client/installer.py
@@ -2,7 +2,7 @@ import os
 import shutil
 from multiprocessing.pool import ThreadPool
 
-from conan.api.output import ConanOutput
+from conan.api.output import ConanOutput, Color
 from conan.internal.methods import run_build_method, run_package_method
 from conan.internal.api.install.generators import write_generators
 from conans.client.graph.graph import BINARY_BUILD, BINARY_CACHE, BINARY_DOWNLOAD, BINARY_EDITABLE, \
@@ -309,6 +309,9 @@ class BinaryInstaller:
             ConanOutput(scope=str(pref.ref))\
                 .highlight("Building from source")\
                 .info(f"Package {pref}")
+            compact_dumps = package.nodes[0].conanfile.info.summarize_compact()
+            for line in compact_dumps:
+                ConanOutput(scope=str(pref.ref)).info(line, fg=Color.BRIGHT_GREEN)
             package_layout = self._cache.create_build_pkg_layout(pref)
             self._handle_node_build(package, package_layout)
             # Just in case it was recomputed
diff --git a/conans/client/rest/auth_manager.py b/conans/client/rest/auth_manager.py
index e79fd4040..bb1b4cf1f 100644
--- a/conans/client/rest/auth_manager.py
+++ b/conans/client/rest/auth_manager.py
@@ -23,13 +23,14 @@ class _RemoteCreds:
     def __init__(self, localdb):
         self._localdb = localdb
 
-    def get(self, remote):
+    def get(self, remote, msg=True):
         creds = getattr(remote, "_creds", None)
         if creds is None:
             user, token, _ = self._localdb.get_login(remote.url)
             creds = user, token
-            usermsg = f"with user '{user}'" if user else "anonymously"
-            ConanOutput().info(f"Connecting to remote '{remote.name}' {usermsg}")
+            if msg:
+                usermsg = f"with user '{user}'" if user else "anonymously"
+                ConanOutput().info(f"Connecting to remote '{remote.name}' {usermsg}")
             setattr(remote, "_creds", creds)
         return creds
 
@@ -49,7 +50,7 @@ class ConanApiAuthManager:
 
     def call_rest_api_method(self, remote, method_name, *args, **kwargs):
         """Handles AuthenticationException and request user to input a user and a password"""
-        user, token = self._creds.get(remote)
+        user, token = self._creds.get(remote, msg=(method_name != "authenticate"))
         rest_client = RestApiClient(remote, token, self._requester, self._global_conf)
 
         if method_name == "authenticate":
diff --git a/conans/model/package_ref.py b/conans/model/package_ref.py
index 0669fc435..55fe086f3 100644
--- a/conans/model/package_ref.py
+++ b/conans/model/package_ref.py
@@ -17,7 +17,8 @@ class PkgReference(_PkgReference):
 
     def __init__(self, *args, **kwargs):
         if PkgReference.usage_counter == 0:
-            ConanOutput().warning(_msg.format("from conans.model.package_ref import PkgReference"))
+            ConanOutput().warning(_msg.format("from conans.model.package_ref import PkgReference"),
+                                  warn_tag="deprecated")
         PkgReference.usage_counter += 1
         super(PkgReference, self).__init__(*args, **kwargs)
 


Test patch:
diff --git a/conan/test/utils/tools.py b/conan/test/utils/tools.py
index 27fdb204c..ac819dcf5 100644
--- a/conan/test/utils/tools.py
+++ b/conan/test/utils/tools.py
@@ -700,6 +700,8 @@ class TestClient:
 
     def get_latest_ref_layout(self, ref) -> RecipeLayout:
         """Get the latest RecipeLayout given a file reference"""
+        if not ref.revision:
+            ref = self.cache.get_latest_recipe_reference(ref)
         ref_layout = self.cache.recipe_layout(ref)
         return ref_layout
 
diff --git a/test/functional/toolchains/cmake/cmakedeps/test_link_order.py b/test/functional/toolchains/cmake/cmakedeps/test_link_order.py
index 61f7332e9..16f1cb4f1 100644
--- a/test/functional/toolchains/cmake/cmakedeps/test_link_order.py
+++ b/test/functional/toolchains/cmake/cmakedeps/test_link_order.py
@@ -216,8 +216,8 @@ def _validate_link_order(libs):
     assert libs.index(prefix + 'Z2' + ext) < libs.index('system_lib' + ext_system)
 
     if platform.system() == "Darwin":
-       assert libs.index('liblibz.a') < libs.index('Carbon')
-       assert libs.index('libZ2.a') < libs.index('Carbon')
+        assert libs.index('liblibz.a') < libs.index('Carbon')
+        assert libs.index('libZ2.a') < libs.index('Carbon')
 
 
 def _get_link_order_from_cmake(content):
@@ -263,12 +263,13 @@ def _get_link_order_from_xcode(content):
 
     # Find the right Release block in the XCode file
     results = re.finditer(r'/\* Release \*/ = {', content)
+    header_found = False
     for r in results:
         release_section = content[r.start():].split("name = Release;", 1)[0]
         if "-headerpad_max_install_names" in release_section:
+            header_found = True
             break
-    else:
-        raise Exception("Cannot find the Release block linking the expected libraries")
+    assert header_found, "Cannot find the Release block linking the expected libraries"
 
     start_key = '-Wl,-headerpad_max_install_names'
     end_key = ');'
diff --git a/test/functional/toolchains/cmake/cmakedeps2/test_cmakeconfigdeps_new.py b/test/functional/toolchains/cmake/cmakedeps2/test_cmakeconfigdeps_new.py
index 27a7184cb..11a5be4bc 100644
--- a/test/functional/toolchains/cmake/cmakedeps2/test_cmakeconfigdeps_new.py
+++ b/test/functional/toolchains/cmake/cmakedeps2/test_cmakeconfigdeps_new.py
@@ -1108,7 +1108,7 @@ class TestProtobuf:
         assert "protobuf: Release!" in c.out
 
 
-@pytest.mark.tool("cmake", "3.23")
+@pytest.mark.tool("cmake", "3.27")
 class TestConfigs:
     @pytest.mark.skipif(platform.system() != "Windows", reason="Only MSVC multi-conf")
     def test_multi_config(self, matrix_client):
@@ -1137,9 +1137,9 @@ class TestConfigs:
 
         # With modern CMake > 3.26 not necessary set(CMAKE_MAP_IMPORTED_CONFIG_DEBUG Release)
         cmake = textwrap.dedent("""
-            cmake_minimum_required(VERSION 3.15)
+            cmake_minimum_required(VERSION 3.27)
             project(app CXX)
-            set(CMAKE_MAP_IMPORTED_CONFIG_DEBUG Release)
+            # set(CMAKE_MAP_IMPORTED_CONFIG_DEBUG Release)
             find_package(matrix CONFIG REQUIRED)
 
             add_executable(app src/app.cpp src/main.cpp)
@@ -1155,6 +1155,41 @@ class TestConfigs:
         assert "matrix/1.0: Hello World Release!" in c.out
         assert "app/0.1: Hello World Debug!" in c.out
 
+    def test_cross_config_components(self, matrix_client_components):
+        # Release dependencies, but compiling app in Debug
+        c = matrix_client_components
+        c.run("new cmake_exe -d name=app -d version=0.1 -d requires=matrix/1.0")
+        app_cpp = textwrap.dedent("""
+            #include "app.h"
+            #include "module.h"
+            void app(){
+               module();
+            }""")
+        c.save({"src/app.cpp": app_cpp,
+                "src/main.cpp": gen_function_cpp(name="main", includes=["app"], calls=["app"])})
+
+        c.run(f"install . -s &:build_type=Debug -c tools.cmake.cmakedeps:new={new_value}")
+        # With modern CMake > 3.26 not necessary set(CMAKE_MAP_IMPORTED_CONFIG_DEBUG Release)
+        cmake = textwrap.dedent("""
+            cmake_minimum_required(VERSION 3.27)
+            project(app CXX)
+            # set(CMAKE_MAP_IMPORTED_CONFIG_DEBUG Release)
+            find_package(matrix CONFIG REQUIRED)
+
+            add_executable(app src/app.cpp src/main.cpp)
+            target_link_libraries(app PRIVATE matrix::matrix)
+            """)
+        c.save({"CMakeLists.txt": cmake})
+
+        preset = "conan-default" if platform.system() == "Windows" else "conan-debug"
+        c.run_command(f"cmake --preset {preset}")
+        c.run_command("cmake --build --preset conan-debug")
+
+        c.run_command(os.path.join("build", "Debug", "app"))
+        assert "main: Debug!" in c.out
+        assert "module: Release!" in c.out
+        assert "vector: Release!" in c.out
+
     @pytest.mark.skipif(platform.system() == "Windows", reason="This doesn't work in MSVC")
     def test_cross_config_implicit(self, matrix_client):
         # Release dependencies, but compiling app in Debug, without specifying it
@@ -1164,9 +1199,9 @@ class TestConfigs:
 
         # With modern CMake > 3.26 not necessary set(CMAKE_MAP_IMPORTED_CONFIG_DEBUG Release)
         cmake = textwrap.dedent("""
-            cmake_minimum_required(VERSION 3.15)
+            cmake_minimum_required(VERSION 3.27)
             project(app CXX)
-            set(CMAKE_MAP_IMPORTED_CONFIG_DEBUG Release)
+            # set(CMAKE_MAP_IMPORTED_CONFIG_DEBUG Release)
             find_package(matrix CONFIG REQUIRED)
 
             add_executable(app src/app.cpp src/main.cpp)
diff --git a/test/integration/command/create_test.py b/test/integration/command/create_test.py
index 81d75486d..798230c7b 100644
--- a/test/integration/command/create_test.py
+++ b/test/integration/command/create_test.py
@@ -160,7 +160,7 @@ def test_create_package_requires():
     client.save({"conanfile.py": conanfile,
                  "test_package/conanfile.py": test_conanfile})
 
-    client.run("create . --name=pkg --version=0.1 --user=lasote --channel=testing")
+    client.run("create . --name=pkg --version=0.1 --user=lasote --channel=testing -vv")
 
     assert "pkg/0.1@lasote/testing (test package): build() " \
            "Requires: other/1.0@user/channel" in client.out
@@ -170,6 +170,10 @@ def test_create_package_requires():
     assert "pkg/0.1@lasote/testing (test package): build() cpp_info dep: dep" in client.out
     assert "pkg/0.1@lasote/testing (test package): build() cpp_info dep: pkg" in client.out
 
+    # Check that the additional info shows up when creating pkg
+    # Graph info, package creation, and test package graph info
+    assert client.out.count("requires: dep/0.1@user/channel") == 3
+
 
 def test_package_folder_build_error():
     """
diff --git a/test/integration/command/custom_commands_test.py b/test/integration/command/custom_commands_test.py
index cea9c844b..a8824f3e1 100644
--- a/test/integration/command/custom_commands_test.py
+++ b/test/integration/command/custom_commands_test.py
@@ -10,7 +10,7 @@ from conan.test.utils.tools import TestClient
 from conan.test.utils.env import environment_update
 
 
-class TestCustomCommands:
+class TestCustomCommandsErrors:
 
     def test_import_error_custom_command(self):
         mycommand = textwrap.dedent("""
@@ -48,6 +48,25 @@ class TestCustomCommands:
         client.run("config home")
         assert client.cache_folder in client.out
 
+    def test_import_error_bad_name(self):
+        mycommand = textwrap.dedent("""
+            from conan.cli.command import conan_command, conan_subcommand
+            @conan_command(group="custom commands")
+            def mycommand(conan_api, parser, *args, **kwargs):
+                \""" custom \"""
+            @conan_subcommand()
+            def mysubcmd(conan_api, parser, *args, **kwargs):
+                \""" mysubcmd \"""
+            """)
+
+        c = TestClient()
+        c.save_home({"extensions/commands/cmd_mycommand.py": mycommand})
+        # Call to any other command, it will fail loading the custom command
+        c.run("list *")
+        assert "The name for the subcommand method should begin with the main command name" in c.out
+
+
+class TestCustomCommands:
     def test_simple_custom_command(self):
         mycommand = textwrap.dedent("""
             import json
diff --git a/test/integration/command/help_test.py b/test/integration/command/help_test.py
index 6003a8cda..2af1c84a0 100644
--- a/test/integration/command/help_test.py
+++ b/test/integration/command/help_test.py
@@ -20,6 +20,11 @@ class TestHelp:
         assert "The most similar command is" in c.out
         assert "install" in c.out
 
+        c.run("remole", assert_error=True)
+        assert "The most similar commands are" in c.out
+        assert "remove" in c.out
+        assert "remote" in c.out
+
     def test_help(self):
         c = TestClient()
         c.run("-h")
diff --git a/test/integration/command/info/info_test.py b/test/integration/command/info/info_test.py
index 59765ee41..9ef293701 100644
--- a/test/integration/command/info/info_test.py
+++ b/test/integration/command/info/info_test.py
@@ -357,6 +357,37 @@ class TestErrorsInGraph:
         assert "ERROR: Package 'dep/0.1' not resolved: dep/0.1: Cannot load" in c.out
         assert exit_code == ERROR_GENERAL
 
+    def test_missing_invalid(self):
+        c = TestClient()
+        dep_invalid = textwrap.dedent(
+            """
+           from conan import ConanFile
+           from conan.errors import ConanInvalidConfiguration
+           class Pkg(ConanFile):
+               name = "dep_invalid"
+               settings = "os", "build_type"
+               version = "0.1"
+               def validate(self):
+                   raise ConanInvalidConfiguration("Invalid package")
+        """
+        )
+
+        c.save({
+                "dep/conanfile.py": GenConanfile("dep").with_version("0.1"),
+                "dep_invalid/conanfile.py": dep_invalid,
+                "consumer/conanfile.py": GenConanfile("consumer")
+                                        .with_requires("dep/0.1")
+                                        .with_requires("dep_invalid/0.1"),
+            })
+        c.run("export dep")
+        c.run("export dep_invalid")
+        exit_code = c.run("graph info consumer")
+        assert "WARN: There are some error(s) in the graph:" in c.out
+        assert "- Missing packages: dep" in c.out
+        assert "- Invalid packages: dep_invalid" in c.out
+        assert exit_code == 0
+
+
 
 class TestInfoUpdate:
 
diff --git a/test/integration/command/info/test_info_build_order.py b/test/integration/command/info/test_info_build_order.py
index a9605cea5..4a39b80e6 100644
--- a/test/integration/command/info/test_info_build_order.py
+++ b/test/integration/command/info/test_info_build_order.py
@@ -804,9 +804,8 @@ def test_multi_configuration_profile_args():
 
 def test_build_order_space_in_options():
     tc = TestClient(light=True)
-    tc.save({"dep/conanfile.py": GenConanfile("dep", "1.0")
-                .with_option("flags", ["ANY", None])
-                .with_option("extras", ["ANY", None]),
+    tc.save({"dep/conanfile.py": GenConanfile("dep", "1.0").with_option("flags", ["ANY", None])
+                                                           .with_option("extras", ["ANY", None]),
              "conanfile.txt": textwrap.dedent("""
              [requires]
              dep/1.0
@@ -879,3 +878,25 @@ def test_build_order_build_context_compatible():
                                 "bar/1.0": ["5e4ffcc1ff33697a4ee96f66f0d2228ec458f25c", "Build"]})
         c.assert_listed_binary({"foo/1.0": ["4e2ae338231ae18d0d43b9e119404d2b2c416758", "Build"]},
                                build=True)
+
+
+def test_info_build_order_editable():
+    c = TestClient()
+    c.save({"dep/conanfile.py": GenConanfile("dep", "0.1"),
+            "pkg/conanfile.py": GenConanfile("pkg", "0.1").with_requires("dep/0.1"),
+            "consumer/conanfile.txt": "[requires]\npkg/0.1"})
+    c.run("editable add dep")
+    c.run("export pkg")
+    
+    c.run("graph build-order consumer --build=missing --build=editable -f=json --order-by=recipe")
+    bo_json = json.loads(c.stdout)
+    pkg = bo_json["order"][0][0]["packages"][0][0]
+    assert pkg["binary"] == "EditableBuild"
+    assert pkg["build_args"] == "--requires=dep/0.1 --build=dep/0.1"
+
+    c.run("graph build-order consumer --build=missing --build=editable -f=json "
+          "--order-by=configuration")
+    bo_json = json.loads(c.stdout)
+    pkg = bo_json["order"][0][0]
+    assert pkg["binary"] == "EditableBuild"
+    assert pkg["build_args"] == "--requires=dep/0.1 --build=dep/0.1"
diff --git a/test/integration/command/test_profile.py b/test/integration/command/test_profile.py
index b71bbd6ac..a926b7629 100644
--- a/test/integration/command/test_profile.py
+++ b/test/integration/command/test_profile.py
@@ -2,7 +2,11 @@ import json
 import os
 import textwrap
 
+import pytest
+
+from conan.test.assets.genconanfile import GenConanfile
 from conan.test.utils.tools import TestClient
+from conans.util.files import save
 
 
 def test_profile_path():
@@ -151,3 +155,18 @@ def test_profile_show_json():
     # Check that tool_requires are properly serialized in json format
     # https://github.com/conan-io/conan/issues/15183
     assert profile["build"]["tool_requires"] == {'mytool/*': ["mytool/1.0"]}
+
+
+@pytest.mark.parametrize("new_global", [None, 0, 1, True, False, ""])
+def test_settings_serialize(new_global):
+    tc = TestClient(light=True)
+    settings_user = "new_global: [null, 0, 1, True, False, '']"
+    tc.save_home({"settings_user.yml": settings_user})
+    tc.save({"conanfile.py": GenConanfile("foo", "1.0").with_settings("new_global")})
+
+    s = f"-s new_global={new_global}" if new_global is not None else ""
+    tc.run(f"create . {s}")
+    if new_global is None:
+        assert "settings: new_global=" not in tc.out
+    else:
+        assert f"settings: new_global={new_global}" in tc.out
diff --git a/test/integration/command/test_remote_users.py b/test/integration/command/test_remote_users.py
index 46b21945c..a1f4106a1 100644
--- a/test/integration/command/test_remote_users.py
+++ b/test/integration/command/test_remote_users.py
@@ -93,6 +93,7 @@ class TestUser:
         servers = {"default": test_server}
         client = TestClient(servers=servers, inputs=["lasote", "mypass"])
         client.run(r'remote login default lasote -p="my \"password"')
+        assert "Connecting to remote" not in client.out
         assert "Changed user of remote 'default' from 'None' (anonymous) to 'lasote'" in client.out
         client.run('remote logout default')
         client.run(r'remote login default lasote -p "my \"password"')
diff --git a/test/integration/conan_api/test_cli.py b/test/integration/conan_api/test_cli.py
index f6c5877e8..ebdfcdcd8 100644
--- a/test/integration/conan_api/test_cli.py
+++ b/test/integration/conan_api/test_cli.py
@@ -1,5 +1,10 @@
+import os
+
+import pytest
+
 from conan.api.conan_api import ConanAPI
-from conan.cli.cli import Cli
+from conan.cli.cli import Cli, main
+from conan.test.utils.env import environment_update
 from conan.test.utils.mocks import RedirectedTestOutput
 from conan.test.utils.test_files import temp_folder
 from conan.test.utils.tools import redirect_output
@@ -22,6 +27,13 @@ def test_cli():
         cli2.run(["list", "*"])
         cli.run(["list", "*"])
 
+    stdout = RedirectedTestOutput()
+    stderr = RedirectedTestOutput()
+    with redirect_output(stderr, stdout):
+        cli.run()
+    # Running without args shows help, but doesn't error
+    assert "Consumer commands" in stdout.getvalue()
+
 
 def test_basic_api():
     api = ConanAPI(cache_folder=temp_folder())
@@ -36,3 +48,12 @@ def test_api_command():
     cli.add_commands()
     result = api.command.run(["remote", "list"])
     assert result[0].name == "conancenter"
+
+
+def test_main():
+    cache_folder = os.path.join(temp_folder(), "custom")
+    with environment_update({"CONAN_HOME": cache_folder}):
+        with pytest.raises(SystemExit) as e:
+            main(["list", "*"])
+        assert e.type == SystemExit
+        assert e.value.code == 0  # success
diff --git a/test/integration/conanfile/test_deprecated.py b/test/integration/conanfile/test_deprecated.py
index 128cc5362..d6a2b466c 100644
--- a/test/integration/conanfile/test_deprecated.py
+++ b/test/integration/conanfile/test_deprecated.py
@@ -1,5 +1,7 @@
 import textwrap
 
+import pytest
+
 from conan.test.utils.tools import TestClient, GenConanfile
 
 
@@ -63,3 +65,18 @@ class TestDeprecated:
 
         tc.run("graph info . --version=2.0")
         assert "deprecated: None" in tc.out
+
+class TestDeprecatedIncludesMessages:
+    @pytest.mark.parametrize("import_stm,way", [
+        ["from conans.model.package_ref import PkgReference", "PkgReference()"],
+        ["from conans.model.package_ref import PkgReference", "PkgReference.loads('foo/1.0:123')"],
+        ["from conans.model.recipe_ref import RecipeReference", "RecipeReference()"],
+        ["from conans.model.recipe_ref import RecipeReference", "RecipeReference.loads('foo/1.0@user/channel')"]
+    ])
+    def test_deprecated_package_ref_include(self, import_stm, way):
+        t = TestClient(light=True)
+        t.save({"conanfile.py": GenConanfile("pkg", "0.1")
+               .with_import(import_stm)
+                .with_package_id(f"ref = {way}")})
+        t.run("create conanfile.py")
+        assert f"Private '{import_stm}'" in t.out
diff --git a/test/integration/configuration/conf/test_conf_from_br.py b/test/integration/configuration/conf/test_conf_from_br.py
index 4b9aafe9e..a0d067526 100644
--- a/test/integration/configuration/conf/test_conf_from_br.py
+++ b/test/integration/configuration/conf/test_conf_from_br.py
@@ -1,5 +1,7 @@
 import textwrap
 
+import pytest
+
 from conan.test.assets.genconanfile import GenConanfile
 from conan.test.utils.tools import TestClient
 
@@ -266,3 +268,28 @@ def test_conf_both_build_and_host():
     client.run("install app --build=missing -s:h build_type=Debug -s:b build_type=Release")
     assert "myprotobuf/0.1: MYCONF build: Release" in client.out
     assert "myprotobuf/0.1: MYCONF host: Debug" in client.out
+
+
+@pytest.mark.parametrize("conf", ['define("user.myorg:myconf", self.options.myopt)',
+                                  'define("user.myorg:myconf", self.settings.os)',
+                                  'append("user.myorg:myconf", self.settings.os)',
+                                  'prepend("user.myorg:myconf", self.settings.os)'])
+def test_error_bad_types(conf):
+    c = TestClient(light=True)
+    conanfile = textwrap.dedent(f"""
+        from conan import ConanFile
+        class Pkg(ConanFile):
+            name = "tool"
+            version = "0.1"
+            settings = "os"
+            options = {{"myopt": [True, False]}}
+            default_options = {{"myopt": True}}
+            def package_info(self):
+                self.conf_info.{conf}
+        """)
+    c.save({"conanfile.py": conanfile})
+    c.run("create .", assert_error=True)
+    assert "ERROR: tool/0.1: Error in package_info() method, line 10"
+    assert f'self.conf_info.{conf}' in c.out
+    assert "Invalid 'conf' type, please use Python types (int, str, ...)" in c.out
+
diff --git a/test/integration/graph/test_divergent_cppstd_build_host.py b/test/integration/graph/test_divergent_cppstd_build_host.py
new file mode 100644
index 000000000..637786d50
--- /dev/null
+++ b/test/integration/graph/test_divergent_cppstd_build_host.py
@@ -0,0 +1,43 @@
+import json
+import textwrap
+
+from conan.test.assets.genconanfile import GenConanfile
+from conan.test.utils.tools import TestClient
+
+
+def test_divergent_cppstd_build_host():
+
+    c = TestClient()
+    
+    conanfile = textwrap.dedent("""
+        [requires]
+        waterfall/1.0
+        [tool_requires]
+        rainbow/1.0
+        """)
+
+    c.save({"waterfall/conanfile.py": GenConanfile("waterfall", "1.0").with_settings("compiler"),
+            "rainbow/conanfile.py": GenConanfile("rainbow", "1.0").with_settings("compiler")
+                                                .with_requires("waterfall/1.0"),
+            "conanfile.txt": conanfile})
+
+
+    c.run("export waterfall")
+    c.run("export rainbow")
+    c.run(f"install . --build=missing -s compiler.cppstd=14 -s:b compiler.cppstd=17 --format=json", redirect_stdout="graph.json")
+    graph = json.loads(c.load("graph.json"))
+
+
+    # waterfall is twice in the graph: as a direct host dependency, and an indirect build dependency
+    assert graph['graph']['nodes']['1']['ref'] == "waterfall/1.0#821e924dcef2f185dd651e6d434f9f95"
+    assert graph['graph']['nodes']['1']['context'] == "host"
+
+    assert graph['graph']['nodes']['3']['ref'] == "waterfall/1.0#821e924dcef2f185dd651e6d434f9f95"
+    assert graph['graph']['nodes']['3']['context'] == "build"
+
+    # is this the right behaviour?
+    # without the compatibility plugin, we would require two different package_id in the same graph,
+    # but because of compatibility plugin, Conan graph uses a "compatible" package_id in the build context
+    # rather than the exact one
+    assert graph['graph']['nodes']['1']['package_id'] == graph['graph']['nodes']['3']['package_id']
+
diff --git a/test/integration/graph/test_subgraph_reports.py b/test/integration/graph/test_subgraph_reports.py
index 597fb6386..b01ecfe23 100644
--- a/test/integration/graph/test_subgraph_reports.py
+++ b/test/integration/graph/test_subgraph_reports.py
@@ -4,7 +4,7 @@ import textwrap
 
 from conan.test.assets.genconanfile import GenConanfile
 from conan.test.utils.tools import TestClient
-from conans.model.recipe_ref import RecipeReference
+from conan.api.model import RecipeReference
 from conans.util.files import load
 
 
diff --git a/test/integration/package_id/test_config_package_id.py b/test/integration/package_id/test_config_package_id.py
index e3a27714b..af3b7fbf7 100644
--- a/test/integration/package_id/test_config_package_id.py
+++ b/test/integration/package_id/test_config_package_id.py
@@ -20,6 +20,7 @@ def test_config_package_id(config_version, mode, result):
     save(c.paths.global_conf_path, f"core.package_id:config_mode={mode}")
     c.save({"conanfile.py": GenConanfile("pkg", "0.1")})
     c.run("create .")
+    assert f"config_version: {result}" in c.out
     c.run("list pkg/0.1:* --format=json")
     info = json.loads(c.stdout)
     rrev = info["Local Cache"]["pkg/0.1"]["revisions"]["485dad6cb11e2fa99d9afbe44a57a164"]
@@ -39,3 +40,16 @@ def test_error_config_package_id():
     c.run("create .", assert_error=True)
     assert "ERROR: core.package_id:config_mode defined, " \
            "but error while loading 'config_version.json'" in c.out
+
+@pytest.mark.parametrize("config_version, mode, result", [
+    ("myconfig/1.2.3#rev1:pid1#prev1", "minor_mode", "myconfig/1.2.Z"),
+    ("myconfig/1.2.3#rev1:pid1#prev1", "patch_mode", "myconfig/1.2.3"),
+])
+def test_config_package_id_clear(config_version, mode, result):
+    c = TestClient(light=True)
+    config_version = json.dumps({"config_version": [config_version]})
+    save(c.paths.config_version_path, config_version)
+    save(c.paths.global_conf_path, f"core.package_id:config_mode={mode}")
+    c.save({"conanfile.py": GenConanfile("pkg", "0.1").with_package_id("self.info.clear()")})
+    c.run("create .")
+    assert f"config_version: {result}" not in c.out
diff --git a/test/integration/toolchains/gnu/test_gnutoolchain.py b/test/integration/toolchains/gnu/test_gnutoolchain.py
index e47e30e05..789df2e15 100644
--- a/test/integration/toolchains/gnu/test_gnutoolchain.py
+++ b/test/integration/toolchains/gnu/test_gnutoolchain.py
@@ -456,3 +456,49 @@ def test_conf_build_does_not_exist():
     tc = c.load("conangnutoolchain.sh")
     assert 'export CC_FOR_BUILD="x86_64-linux-gnu-gcc"' in tc
     assert 'export CXX_FOR_BUILD="x86_64-linux-gnu-g++"' in tc
+
+
+@pytest.mark.parametrize("toolchain", ["GnuToolchain", "AutotoolsToolchain"])
+def test_conf_extra_apple_flags(toolchain):
+    host = textwrap.dedent("""
+    [settings]
+    arch=x86_64
+    os=Macos
+    [conf]
+    tools.apple:enable_bitcode = True
+    tools.apple:enable_arc = True
+    tools.apple:enable_visibility = True
+    """)
+
+    c = TestClient()
+    c.save({"conanfile.txt": f"[generators]\n{toolchain}",
+            "host": host})
+    c.run("install . -pr:a host")
+    f = "conanautotoolstoolchain.sh" if toolchain == "AutotoolsToolchain" else "conangnutoolchain.sh"
+    tc = c.load(f)
+    assert 'export CXXFLAGS="$CXXFLAGS -fembed-bitcode -fobjc-arc -fvisibility=default"' in tc
+    assert 'export CFLAGS="$CFLAGS -fembed-bitcode -fobjc-arc -fvisibility=default"' in tc
+    assert 'export LDFLAGS="$LDFLAGS -fembed-bitcode -fobjc-arc -fvisibility=default"' in tc
+
+    c.run("install . -pr:a host -s build_type=Debug")
+    tc = c.load(f)
+    assert 'export CXXFLAGS="$CXXFLAGS -fembed-bitcode-marker -fobjc-arc -fvisibility=default"' in tc
+    assert 'export CFLAGS="$CFLAGS -fembed-bitcode-marker -fobjc-arc -fvisibility=default"' in tc
+    assert 'export LDFLAGS="$LDFLAGS -fembed-bitcode-marker -fobjc-arc -fvisibility=default"' in tc
+
+    host = textwrap.dedent("""
+        [settings]
+        arch=x86_64
+        os=Macos
+        [conf]
+        tools.apple:enable_bitcode = False
+        tools.apple:enable_arc = False
+        tools.apple:enable_visibility = False
+        """)
+
+    c.save({"host": host})
+    c.run("install . -pr:a host")
+    tc = c.load(f)
+    assert 'CXXFLAGS="$CXXFLAGS -fno-objc-arc -fvisibility=hidden -fvisibility-inlines-hidden"' in tc
+    assert 'CFLAGS="$CFLAGS -fno-objc-arc -fvisibility=hidden -fvisibility-inlines-hidden"' in tc
+    assert 'LDFLAGS="$LDFLAGS -fno-objc-arc -fvisibility=hidden -fvisibility-inlines-hidden"' in tc
diff --git a/test/integration/toolchains/meson/test_mesontoolchain.py b/test/integration/toolchains/meson/test_mesontoolchain.py
index 06df19bd6..3b5411212 100644
--- a/test/integration/toolchains/meson/test_mesontoolchain.py
+++ b/test/integration/toolchains/meson/test_mesontoolchain.py
@@ -746,3 +746,51 @@ def test_cross_x86_64_to_x86():
     cross = c.load(MesonToolchain.cross_filename)
     assert "cpu = 'x86_64'" in cross  # This is the build machine
     assert "cpu = 'x86'" in cross  # This is the host machine
+
+
+def test_conf_extra_apple_flags():
+    host = textwrap.dedent("""
+    [settings]
+    arch=x86_64
+    os=Macos
+    compiler=apple-clang
+    compiler.version=14.0
+    [conf]
+    tools.apple:enable_bitcode = True
+    tools.apple:enable_arc = True
+    tools.apple:enable_visibility = True
+    """)
+
+    c = TestClient()
+    c.save({"conanfile.txt": f"[generators]\nMesonToolchain",
+            "host": host})
+    c.run("install . -pr:a host")
+    f = "conan_meson_native.ini"
+    tc = c.load(f)
+    for flags in ["c_args", "cpp_args", "c_link_args", "cpp_link_args"]:
+        assert f"{flags} = ['-m64', '-fembed-bitcode', '-fobjc-arc', '-fvisibility=default']" in tc
+
+    c.run("install . -pr:a host -s build_type=Debug")
+    tc = c.load(f)
+    for flags in ["c_args", "cpp_args", "c_link_args", "cpp_link_args"]:
+        assert f"{flags} = ['-m64', '-fembed-bitcode-marker'," \
+               " '-fobjc-arc', '-fvisibility=default']" in tc
+
+    host = textwrap.dedent("""
+        [settings]
+        arch=x86_64
+        os=Macos
+        compiler=apple-clang
+        compiler.version=14.0
+        [conf]
+        tools.apple:enable_bitcode = False
+        tools.apple:enable_arc = False
+        tools.apple:enable_visibility = False
+        """)
+
+    c.save({"host": host})
+    c.run("install . -pr:a host")
+    tc = c.load(f)
+    for flags in ["c_args", "cpp_args", "c_link_args", "cpp_link_args"]:
+        assert f"{flags} = ['-m64', '-fno-objc-arc', '-fvisibility=hidden', " \
+               "'-fvisibility-inlines-hidden']" in tc
diff --git a/test/integration/toolchains/microsoft/test_vs_layout.py b/test/integration/toolchains/microsoft/test_vs_layout.py
index d406440cd..196dcf25f 100644
--- a/test/integration/toolchains/microsoft/test_vs_layout.py
+++ b/test/integration/toolchains/microsoft/test_vs_layout.py
@@ -20,3 +20,41 @@ def test_vs_layout_subproject():
     c.save({"pkg/conanfile.py": conanfile})
     c.run("install pkg")
     assert os.path.isfile(os.path.join(c.current_folder, "pkg", "conan", "conantoolchain.props"))
+
+
+def test_vs_layout_error():
+    c = TestClient()
+    conanfile = textwrap.dedent("""
+        from conan import ConanFile
+        from conan.tools.microsoft import vs_layout
+        class Pkg(ConanFile):
+            settings = "os", "compiler", "arch"
+            def layout(self):
+                vs_layout(self)
+        """)
+    c.save({"conanfile.py": conanfile})
+    c.run("install .", assert_error=True)
+    assert "The 'vs_layout' requires the 'build_type' setting" in c.out
+    conanfile = textwrap.dedent("""
+            from conan import ConanFile
+            from conan.tools.microsoft import vs_layout
+            class Pkg(ConanFile):
+                settings = "os", "compiler", "build_type"
+                def layout(self):
+                    vs_layout(self)
+            """)
+    c.save({"conanfile.py": conanfile})
+    c.run("install .", assert_error=True)
+    assert "The 'vs_layout' requires the 'arch' setting" in c.out
+    conanfile = textwrap.dedent("""
+        from conan import ConanFile
+        from conan.tools.microsoft import vs_layout
+        class Pkg(ConanFile):
+            settings = "os", "compiler", "build_type", "arch"
+            def layout(self):
+                vs_layout(self)
+        """)
+    c.save({"conanfile.py": conanfile})
+    c.run("install . -s arch=riscv64", assert_error=True)
+    assert "The 'vs_layout' doesn't work with the arch 'riscv64'" in c.out
+    assert "Accepted architectures: 'x86', 'x86_64', 'armv7', 'armv8'" in c.out
diff --git a/test/unittests/client/build/cpp_std_flags_test.py b/test/unittests/client/build/cpp_std_flags_test.py
index f4f54c6d5..b90cfa8a4 100644
--- a/test/unittests/client/build/cpp_std_flags_test.py
+++ b/test/unittests/client/build/cpp_std_flags_test.py
@@ -304,11 +304,15 @@ class CompilerFlagsTest(unittest.TestCase):
         self.assertEqual(_make_cppstd_default("msvc", "193"), "14")
 
     def test_intel_cppstd_flag(self):
-        self.assertEqual(_make_cppstd_flag("intel-cc", "19.1", "gnu98"), '-std=gnu++98')
-        self.assertEqual(_make_cppstd_flag("intel-cc", "19.1", "11"), '-std=c++11')
-        self.assertEqual(_make_cppstd_flag("intel-cc", "19.1", "14"), '-std=c++14')
-        self.assertEqual(_make_cppstd_flag("intel-cc", "19.1", "17"), '-std=c++17')
-        self.assertEqual(_make_cppstd_flag("intel-cc", "19.1", "20"), '-std=c++20')
+        self.assertEqual(_make_cppstd_flag("intel-cc", "2024.1", "gnu98"), '-std=gnu++98')
+        self.assertEqual(_make_cppstd_flag("intel-cc", "2024.1", "11"), '-std=c++11')
+        self.assertEqual(_make_cppstd_flag("intel-cc", "2024.1", "14"), '-std=c++14')
+        self.assertEqual(_make_cppstd_flag("intel-cc", "2024.1", "17"), '-std=c++17')
+        self.assertEqual(_make_cppstd_flag("intel-cc", "2024.1", "20"), '-std=c++20')
+
+        self.assertEqual(_make_cppstd_flag("intel-cc", "2025.1", "17"), '-std=c++17')
+        self.assertEqual(_make_cppstd_flag("intel-cc", "2025.1", "20"), '-std=c++20')
+        self.assertEqual(_make_cppstd_flag("intel-cc", "2025.1", "23"), '-std=c++2b')
 
     def test_mcst_lcc_cppstd_defaults(self):
         self.assertEqual(_make_cppstd_default("mcst-lcc", "1.19"), "gnu98")
diff --git a/test/unittests/model/test_conf.py b/test/unittests/model/test_conf.py
index a20b132b0..9afa00248 100644
--- a/test/unittests/model/test_conf.py
+++ b/test/unittests/model/test_conf.py
@@ -298,7 +298,7 @@ def test_conf_get_check_type_and_default():
     assert c.get("user.company.cpu:jobs", check_type=str) == "5"  # smart conversion
     with pytest.raises(ConanException) as exc_info:
         c.get("user.company.cpu:jobs", check_type=list)
-        assert "[conf] user.company.cpu:jobs must be a list-like object." in str(exc_info.value)
+    assert "[conf] user.company.cpu:jobs must be a list-like object." in str(exc_info.value)
     # Check type does not affect to default value
     assert c.get("user.non:existing", default=0, check_type=dict) == 0
     assert c.get("zlib:user.company.check:shared") is None  # unset value
@@ -315,16 +315,16 @@ def test_conf_get_check_type_and_default():
             "The value 'True' introduced is a bool object") in str(exc_info.value)
     with pytest.raises(ConanException) as exc_info:
         c.get("user:bad_value_0", check_type=bool)
-    assert ("[conf] user:bad_value_0 must be a boolean-like object (true/false, 1/0, on/off) and value 'Fasle' does not match it.") in str(exc_info.value)
+    assert "[conf] user:bad_value_0 must be a boolean-like object (true/false, 1/0, on/off) and value 'Fasle' does not match it." in str(exc_info.value)
     with pytest.raises(ConanException) as exc_info:
         c.get("user:bad_value_1", check_type=bool)
-    assert ("[conf] user:bad_value_1 must be a boolean-like object (true/false, 1/0, on/off) and value 'ture' does not match it.") in str(exc_info.value)
+    assert "[conf] user:bad_value_1 must be a boolean-like object (true/false, 1/0, on/off) and value 'ture' does not match it." in str(exc_info.value)
     with pytest.raises(ConanException) as exc_info:
         c.get("user:bad_value_2", check_type=bool)
-    assert ("[conf] user:bad_value_2 must be a boolean-like object (true/false, 1/0, on/off) and value '10' does not match it.") in str(exc_info.value)
+    assert "[conf] user:bad_value_2 must be a boolean-like object (true/false, 1/0, on/off) and value '10' does not match it." in str(exc_info.value)
     with pytest.raises(ConanException) as exc_info:
         c.get("user:bad_value_3", check_type=bool)
-    assert ("[conf] user:bad_value_3 must be a boolean-like object (true/false, 1/0, on/off) and value '\'00\'' does not match it.") in str(exc_info.value)
+    assert "[conf] user:bad_value_3 must be a boolean-like object (true/false, 1/0, on/off) and value '\'00\'' does not match it." in str(exc_info.value)
 
 
 def test_conf_pop():
diff --git a/test/unittests/tools/cmake/test_cmaketoolchain.py b/test/unittests/tools/cmake/test_cmaketoolchain.py
index 26169dece..2850f1fb4 100644
--- a/test/unittests/tools/cmake/test_cmaketoolchain.py
+++ b/test/unittests/tools/cmake/test_cmaketoolchain.py
@@ -644,7 +644,7 @@ def test_apple_cmake_osx_sysroot_sdk_mandatory(os, arch, expected_sdk):
 
     with pytest.raises(ConanException) as excinfo:
         CMakeToolchain(c).content()
-        assert "Please, specify a suitable value for os.sdk." % expected_sdk in str(excinfo.value)
+    assert "Please, specify a suitable value for os.sdk." in str(excinfo.value)
 
 
 def test_compilers_block(conanfile):
diff --git a/test/unittests/util/xz_test.py b/test/unittests/util/xz_test.py
index 707293410..f6fd540b2 100644
--- a/test/unittests/util/xz_test.py
+++ b/test/unittests/util/xz_test.py
@@ -20,3 +20,16 @@ def test_unzip_can_xz():
     content = load(os.path.join(dest_folder, "a_file.txt"))
     assert content == "my content!"
 
+
+def test_unzip_can_gz():
+    tmp_dir = temp_folder()
+    file_path = os.path.join(tmp_dir, "a_file.txt")
+    save(file_path, "my content!")
+    gz = os.path.join(tmp_dir, "sample.tar.gz")
+    with tarfile.open(gz, "w:gz") as tar:
+        tar.add(file_path, "a_file.txt")
+
+    dest_folder = temp_folder()
+    unzip(ConanFileMock(), gz, dest_folder)
+    content = load(os.path.join(dest_folder, "a_file.txt"))
+    assert content == "my content!"