conan 2.22.2__tar.gz → 2.23.0__tar.gz

{conan-2.22.2/conan.egg-info → conan-2.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conan
-Version: 2.22.2
+Version: 2.23.0
 Summary: Conan C/C++ package manager
 Home-page: https://conan.io
 Author: JFrog LTD
@@ -23,7 +23,7 @@ Description: <picture>
         - Homepage: https://conan.io/
         - Github: https://github.com/conan-io/conan
         - Docs: https://docs.conan.io
-        - Slack: https://cpplang.slack.com (#conan channel. Please, click [here](https://join.slack.com/t/cpplang/shared_invite/zt-1snzdn6rp-rOUxF3166oz1_11Tr5H~xg) to get an invitation)
+        - Slack: https://cpplang.slack.com (#conan channel. Please, click [here](https://cppalliance.org/slack/#cpp-slack) to get an invitation)
         - Twitter: https://twitter.com/conan_io
         - Blog: https://blog.conan.io
         - Security reports: https://jfrog.com/trust/report-vulnerability

{conan-2.22.2 → conan-2.23.0}/README.md

@@ -12,7 +12,7 @@ Decentralized, open-source (MIT), C/C++ package manager.
 - Homepage: https://conan.io/
 - Github: https://github.com/conan-io/conan
 - Docs: https://docs.conan.io
-- Slack: https://cpplang.slack.com (#conan channel. Please, click [here](https://join.slack.com/t/cpplang/shared_invite/zt-1snzdn6rp-rOUxF3166oz1_11Tr5H~xg) to get an invitation)
+- Slack: https://cpplang.slack.com (#conan channel. Please, click [here](https://cppalliance.org/slack/#cpp-slack) to get an invitation)
 - Twitter: https://twitter.com/conan_io
 - Blog: https://blog.conan.io
 - Security reports: https://jfrog.com/trust/report-vulnerability

{conan-2.22.2 → conan-2.23.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.22.2'
+__version__ = '2.23.0'
 conan_version = Version(__version__)

{conan-2.22.2 → conan-2.23.0}/conan/api/conan_api.py

@@ -150,4 +150,3 @@ class ConanAPI:
         @property
         def requester(self):
             return self._requester
-

{conan-2.22.2 → conan-2.23.0}/conan/api/input.py

@@ -78,7 +78,7 @@ class UserInput:
         """Request user to input a boolean"""
         ret = None
         while ret is None:
-            if default_option is True:
+            if default_option:
                 s = self.request_string("%s (YES/no)" % msg)
             elif default_option is False:
                 s = self.request_string("%s (NO/yes)" % msg)

{conan-2.22.2 → conan-2.23.0}/conan/api/model/remote.py

@@ -3,11 +3,23 @@ LOCAL_RECIPES_INDEX = "local-recipes-index"
 
 class Remote:
     """
-    The ``Remote`` class represents a remote registry of packages. It's a read-only opaque object that
-    should not be created directly, but obtained from the relevant ``RemotesAPI`` subapi methods.
+    The ``Remote`` class represents a remote registry of packages.
     """
     def __init__(self, name, url, verify_ssl=True, disabled=False, allowed_packages=None,
                  remote_type=None, recipes_only=False):
+        """ A Remote object can be constructed to be passed as an argument to
+        RemotesAPI methods. When possible, it is better to use Remote objects returned by the API,
+        but for the ``RemotesAPI.add()`` method, for which a new constructed object is necessary.
+        It is recommended to use named arguments like ``Remote(..., verify_ssl=False)`` in
+        the constructor.
+        :param name: The name of the remote.
+        :param url: The URL of the remote repository (or local folder for "local-recipes-index").
+        :param verify_ssl: Enable SSL Certificate validation.
+        :param disabled: Disable the remote repository.
+        :param allowed_packages: List of patterns of allowed packages from this remote
+        :param remote_type: Type of the remote repository, use "local-recipes-index" or ``None``
+        :param recipes_only: If True, binaries form this remote will be ignored and never used
+        """
         self.name = name  # Read only, is the key
         self.url = url
         self.verify_ssl = verify_ssl

{conan-2.22.2 → conan-2.23.0}/conan/api/output.py

@@ -124,6 +124,14 @@ class ConanOutput:
     def set_warnings_as_errors(cls, value):
         cls._warnings_as_errors = value
 
+    @classmethod
+    def get_output_level(cls):
+        return cls._conan_output_level
+
+    @classmethod
+    def set_output_level(cls, level):
+        cls._conan_output_level = level
+
     @classmethod
     def valid_log_levels(cls):
         return {"quiet": LEVEL_QUIET,  # -vquiet 80
@@ -151,7 +159,7 @@ class ConanOutput:
             vals = "quiet, error, warning, notice, status, verbose, debug(v), trace(vv)"
             raise ConanException(f"Invalid argument '-v{v}'{msg}.\nAllowed values: {vals}")
         else:
-            cls._conan_output_level = level
+            cls.set_output_level(level)
 
     @classmethod
     def level_allowed(cls, level):
@@ -270,13 +278,13 @@ class ConanOutput:
             self._write_message(msg, fg=fg, bg=bg)
         return self
 
-    def status(self, msg: str, fg: str = None, bg: str = None):
+    def status(self, msg: str, fg: str = None, bg: str = None, newline: bool = True):
         """ Provides general information about the system or ongoing operations.
 
         Info messages are basic and used to inform about common events,
         like the start or completion of processes, without implying specific problems or achievements."""
         if self._conan_output_level <= LEVEL_STATUS:
-            self._write_message(msg, fg=fg, bg=bg)
+            self._write_message(msg, fg=fg, bg=bg, newline=newline)
         return self
 
     info = status

{conan-2.22.2 → conan-2.23.0}/conan/api/subapi/audit.py

@@ -3,7 +3,6 @@ import json
 import os
 import base64
 
-from conan.api.output import ConanOutput
 from conan.internal.api.audit.providers import ConanCenterProvider, PrivateProvider
 from conan.errors import ConanException
 from conan.internal.api.remotes.encrypt import encode, decode
@@ -69,9 +68,9 @@ class AuditAPI:
             )
 
             raise ConanException(
-                f"Provider '{provider_name}' not found. Please specify a valid provider name or add it using: "
-                f"'conan audit provider add {provider_name} {add_arguments} --token=<token>'\n"
-                f"{register_message}"
+                f"Provider '{provider_name}' not found. Please specify a valid provider name or add "
+                f"it using: 'conan audit provider add {provider_name} {add_arguments} "
+                f"--token=<token>'\n{register_message}"
             )
 
         provider_data = providers[provider_name]
@@ -83,9 +82,11 @@ class AuditAPI:
             provider_data["token"] = env_token
         elif "token" in provider_data:
             try:
-                provider_data["token"] = decode(base64.standard_b64decode(provider_data["token"]).decode(), CYPHER_KEY)
-            except binascii.Error as e:
-                raise ConanException(f"Invalid token format for provider '{provider_name}'. The token might be corrupt.")
+                enc_token = base64.standard_b64decode(provider_data["token"]).decode()
+                provider_data["token"] = decode(enc_token, CYPHER_KEY)
+            except binascii.Error:
+                raise ConanException(f"Invalid token format for provider '{provider_name}'. "
+                                     f"The token might be corrupt.")
 
         provider_cls = self._provider_cls.get(provider_data["type"])
 
@@ -143,7 +144,8 @@ class AuditAPI:
         providers = _load_providers(self._providers_path)
 
         assert provider.name in providers
-        providers[provider.name]["token"] = base64.standard_b64encode(encode(token, CYPHER_KEY).encode()).decode()
+        encode_token = encode(token, CYPHER_KEY).encode()
+        providers[provider.name]["token"] = base64.standard_b64encode(encode_token).decode()
         setattr(provider, "token", token)
         _save_providers(self._providers_path, providers)
 

{conan-2.22.2 → conan-2.23.0}/conan/api/subapi/cache.py

@@ -8,8 +8,9 @@ from conan.api.model import PackagesList
 from conan.api.output import ConanOutput
 from conan.internal.api.uploader import compress_files
 from conan.internal.cache.cache import PkgCache
-from conan.internal.cache.conan_reference_layout import EXPORT_SRC_FOLDER, EXPORT_FOLDER, SRC_FOLDER, \
-    METADATA, DOWNLOAD_EXPORT_FOLDER
+from conan.internal.cache.conan_reference_layout import (EXPORT_SRC_FOLDER, EXPORT_FOLDER,
+                                                         SRC_FOLDER, METADATA,
+                                                         DOWNLOAD_EXPORT_FOLDER)
 from conan.internal.cache.home_paths import HomePaths
 from conan.internal.cache.integrity_check import IntegrityChecker
 from conan.internal.rest.download_cache import DownloadCache
@@ -104,7 +105,8 @@ class CacheAPI:
                     if not os.path.exists(manifest) or not os.path.exists(info):
                         rmdir(folder)
         if backup_sources:
-            backup_files = self._conan_api.cache.get_backup_sources(package_list, exclude=False, only_upload=False)
+            backup_files = self._conan_api.cache.get_backup_sources(package_list, exclude=False,
+                                                                    only_upload=False)
             ConanOutput().verbose(f"Cleaning {len(backup_files)} backup sources")
             for f in backup_files:
                 remove(f)
@@ -175,7 +177,8 @@ class CacheAPI:
         pkglist_path = os.path.join(tempfile.gettempdir(), "pkglist.json")
         save(pkglist_path, serialized)
         tar_files["pkglist.json"] = pkglist_path
-        compress_files(tar_files, os.path.basename(tgz_path), os.path.dirname(tgz_path), compresslevel, recursive=True)
+        compress_files(tar_files, os.path.basename(tgz_path), os.path.dirname(tgz_path),
+                       compresslevel, recursive=True)
         remove(pkglist_path)
 
     def restore(self, path):
@@ -260,7 +263,8 @@ class CacheAPI:
         download_cache_path = config.get("core.sources:download_cache")
         download_cache_path = download_cache_path or HomePaths(
             self._conan_api.cache_folder).default_sources_backup_folder
-        excluded_urls = config.get("core.sources:exclude_urls", check_type=list, default=[]) if exclude else []
+        excluded_urls = config.get("core.sources:exclude_urls",
+                                   check_type=list, default=[]) if exclude else []
         download_cache = DownloadCache(download_cache_path)
         return download_cache.get_backup_sources_files(excluded_urls, package_list, only_upload)
 

{conan-2.22.2 → conan-2.23.0}/conan/api/subapi/graph.py

@@ -88,7 +88,8 @@ class GraphAPI:
         return root_node
 
     def _load_root_virtual_conanfile(self, profile_host, profile_build, requires, tool_requires,
-                                     lockfile, remotes, update, check_updates=False, python_requires=None):
+                                     lockfile, remotes, update, check_updates=False,
+                                     python_requires=None):
         if not python_requires and not requires and not tool_requires:
             raise ConanException("Provide requires or tool_requires")
         app = ConanApp(self._conan_api)
@@ -164,8 +165,8 @@ class GraphAPI:
         """ Compute the dependency graph, starting from a root package, evaluation the graph with
         the provided configuration in profile_build, and profile_host. The resulting graph is a
         graph of recipes, but packages are not computed yet (package_ids) will be empty in the
-        result. The result might have errors, like version or configuration conflicts, but it is still
-        possible to inspect it. Only trying to install such graph will fail
+        result. The result might have errors, like version or configuration conflicts, but it is
+        still possible to inspect it. Only trying to install such graph will fail
 
         :param root_node: the starting point, an already initialized Node structure, as
             returned by the "load_root_node" api
@@ -189,8 +190,8 @@ class GraphAPI:
         deps_graph = builder.load_graph(root_node, profile_host, profile_build, lockfile)
         return deps_graph
 
-    def analyze_binaries(self, graph, build_mode=None, remotes=None, update=None, lockfile=None,
-                         build_modes_test=None, tested_graph=None):
+    def analyze_binaries(self, graph, build_mode=None, remotes=None, update=None,
+                         lockfile=None, build_modes_test=None, tested_graph=None):
         """ Given a dependency graph, will compute the package_ids of all recipes in the graph, and
         evaluate if they should be built from sources, downloaded from a remote server, of if the
         packages are already in the local Conan cache
@@ -199,8 +200,12 @@ class GraphAPI:
         :param graph: a Conan dependency graph, as returned by "load_graph()"
         :param build_mode: TODO: Discuss if this should be a BuildMode object or list of arguments
         :param remotes: list of remotes
-        :param update: (False by default), if Conan should look for newer versions or
-            revisions for already existing recipes in the Conan cache
+        :param update: (``False`` by default), if Conan should look for newer versions or
+            revisions for already existing recipes in the Conan cache. It also accepts an array of
+            reference patterns to limit the update to those references if any of the items match.
+            Eg. ``False``, ``None`` or ``[]`` *means no update*,
+            ``True`` or ``["*"]`` *means update all*,
+            and ``["pkgA/*", "pkgB/1.0@user/channel"]`` *means to update only specific packages*.
         :param build_modes_test: the --build-test argument
         :param tested_graph: In case of a "test_package", the graph being tested
         """

{conan-2.22.2 → conan-2.23.0}/conan/api/subapi/install.py

@@ -6,7 +6,7 @@ from conan.internal.deploy import do_deploys
 
 from conan.internal.graph.install_graph import InstallGraph
 from conan.internal.graph.installer import BinaryInstaller
-from conan.errors import ConanInvalidConfiguration
+from conan.errors import ConanInvalidConfiguration, ConanException
 
 
 class InstallAPI:
@@ -15,10 +15,11 @@ class InstallAPI:
         self._conan_api = conan_api
         self._helpers = helpers
 
-    def install_binaries(self, deps_graph, remotes=None):
+    def install_binaries(self, deps_graph, remotes=None, return_install_error=False):
         """ Install binaries for dependency graph
         :param deps_graph: Dependency graph to intall packages for
         :param remotes:
+        :param return_install_error: If True, do not raise an exception, but return it
         """
         app = ConanBasicApp(self._conan_api)
         installer = BinaryInstaller(app, self._helpers.global_conf, app.editable_packages,
@@ -27,7 +28,14 @@ class InstallAPI:
         install_graph.raise_errors()
         install_order = install_graph.install_order()
         installer.install_system_requires(deps_graph, install_order=install_order)
-        installer.install(deps_graph, remotes, install_order=install_order)
+        try:  # To be able to capture the output, report or save graph.json, then raise later
+            installer.install(deps_graph, remotes, install_order=install_order)
+        except ConanException as e:
+            # If true, allows to return the exception, so progress can be reported like the
+            # already built binaries to upload them
+            if not return_install_error:
+                raise
+            return e
 
     def install_system_requires(self, graph, only_info=False):
         """ Install binaries for dependency graph
@@ -52,7 +60,8 @@ class InstallAPI:
 
     # TODO: Look for a better name
     def install_consumer(self, deps_graph, generators=None, source_folder=None, output_folder=None,
-                         deploy=False, deploy_package=None, deploy_folder=None, envs_generation=None):
+                         deploy=False, deploy_package=None, deploy_folder=None,
+                         envs_generation=None):
         """ Once a dependency graph has been installed, there are things to be done, like invoking
         generators for the root consumer.
         This is necessary for example for conanfile.txt/py, or for "conan install <ref> -g
@@ -93,5 +102,5 @@ class InstallAPI:
                          envs_generation=envs_generation)
 
     def deploy(self, graph, deployer, deploy_package=None, deploy_folder=None):
-        return do_deploys(self._conan_api.home_folder, graph, deployer, deploy_package=deploy_package,
-                          deploy_folder=deploy_folder)
+        return do_deploys(self._conan_api.home_folder, graph, deployer,
+                          deploy_package=deploy_package, deploy_folder=deploy_folder)

{conan-2.22.2 → conan-2.23.0}/conan/api/subapi/list.py

@@ -1,4 +1,3 @@
-import copy
 import os
 from collections import OrderedDict
 from typing import Dict
@@ -318,27 +317,50 @@ class ListAPI:
         (Experimental) Find the remotes where the current package lists can be found
         """
         result = MultiPackagesList()
+        app = ConanBasicApp(self._conan_api)
         for r in remotes:
             result_pkg_list = PackagesList()
-            for ref, packages in package_list.items():
-                ref_no_rev = copy.copy(ref)  # TODO: Improve ugly API
-                ref_no_rev.revision = None
+            for ref, ref_contents in package_list.serialize().items():
+                ref = RecipeReference.loads(ref)
                 try:
-                    revs = self.recipe_revisions(ref_no_rev, remote=r)
+                    remote_rrevs = app.remote_manager.get_recipe_revisions(ref, remote=r)
                 except NotFoundException:
                     continue
-                if ref not in revs:  # not found
+                revisions = ref_contents.get("revisions")
+                if revisions is None:  # This is a package list just with name/version
+                    if remote_rrevs:
+                        result_pkg_list.add_ref(ref)
                     continue
-                result_pkg_list.add_ref(ref)
-                for pref, pkg_info in packages.items():
-                    pref_no_rev = copy.copy(pref)  # TODO: Improve ugly API
-                    pref_no_rev.revision = None
-                    try:
-                        prevs = self.package_revisions(pref_no_rev, remote=r)
-                    except NotFoundException:
+
+                for revision, rev_content in revisions.items():
+                    ref.revision = revision
+                    # We look for the value of revision in server, to return timestamp too
+                    found = next((r for r in remote_rrevs if r == ref), None)
+                    if not found:
                         continue
-                    if pref in prevs:
-                        result_pkg_list.add_pref(pref, pkg_info)
+                    result_pkg_list.add_ref(found)
+                    packages = rev_content.get("packages")
+                    if packages is None:
+                        continue
+                    for pkgid, pkgcontent in packages.items():
+                        pref = PkgReference(ref, pkgid)
+                        try:
+                            remote_prefs = app.remote_manager.get_package_revisions(pref, remote=r)
+                        except NotFoundException:
+                            continue
+                        pkg_revisions = pkgcontent.get("revisions")
+                        if pkg_revisions is None:  # This is a package_id, no prevs
+                            if remote_prefs:
+                                result_pkg_list.add_pref(pref, pkgcontent.get("info"))
+                            continue
+                        for pkg_revision, prev_content in pkg_revisions.items():
+                            pref.revision = pkg_revision
+                            # We look for the value of revision in server, to return timestamp too
+                            pfound = next((r for r in remote_prefs if r == pref), None)
+                            if not pfound:
+                                continue
+                            result_pkg_list.add_pref(pfound, pkgcontent.get("info"))
+
             if result_pkg_list:
                 result.add(r.name, result_pkg_list)
         return result

{conan-2.22.2 → conan-2.23.0}/conan/api/subapi/new.py

@@ -166,7 +166,7 @@ class NewAPI:
     @staticmethod
     def render(template_files, definitions):
         result = {}
-        name = definitions.get("name", "pkg")
+        name = definitions.get("name", "mypkg")
         if isinstance(name, list):
             raise ConanException(f"name argument can't be multiple: {name}")
         if name != name.lower():

{conan-2.22.2 → conan-2.23.0}/conan/api/subapi/remotes.py

@@ -58,7 +58,8 @@ class RemotesAPI:
 
         :param pattern: single ``str`` or list of ``str``. If the pattern is an exact name without
           wildcards like "*" and no remote is found matching that exact name, it will raise an error.
-        :return: the list of disabled :ref:`Remote <conan.api.model.Remote>` objects  (even if they were already disabled)
+        :return: the list of disabled :ref:`Remote <conan.api.model.Remote>` objects  (even if they
+          were already disabled)
         """
         remotes = _load(self._remotes_file)
         disabled = _filter(remotes, pattern, only_enabled=False)
@@ -76,7 +77,8 @@ class RemotesAPI:
 
         :param pattern: single ``str`` or list of ``str``. If the pattern is an exact name without
           wildcards like "*" and no remote is found matching that exact name, it will raise an error.
-        :return: the list of enabled :ref:`Remote <conan.api.model.Remote>` objects (even if they were already enabled)
+        :return: the list of enabled :ref:`Remote <conan.api.model.Remote>` objects (even if they
+          were already enabled)
         """
         remotes = _load(self._remotes_file)
         enabled = _filter(remotes, pattern, only_enabled=False)
@@ -93,7 +95,8 @@ class RemotesAPI:
         Obtain a :ref:`Remote <conan.api.model.Remote>` object
 
         :param remote_name: the exact name of the remote to be returned
-        :return: the :ref:`Remote <conan.api.model.Remote>` object, or raise an Exception if the remote does not exist.
+        :return: the :ref:`Remote <conan.api.model.Remote>` object, or raise an Exception if the
+          remote does not exist.
         """
         remotes = _load(self._remotes_file)
         try:

{conan-2.22.2 → conan-2.23.0}/conan/api/subapi/report.py

@@ -41,7 +41,6 @@ class ReportAPI:
                               remotes)
             return export_ref, cache_path
 
-
         old_export_ref, old_cache_path = _source(old_path, old_reference)
         new_export_ref, new_cache_path = _source(new_path, new_reference)
 
@@ -79,6 +78,7 @@ class ReportAPI:
             "dst_prefix": dst_prefix,
         }
 
+
 def _configure_source(conan_api, hook_manager, conanfile_path, ref, remotes):
     app = ConanApp(conan_api)
     conanfile = app.loader.load_consumer(conanfile_path, name=ref.name, version=str(ref.version),
@@ -101,6 +101,7 @@ def _configure_source(conan_api, hook_manager, conanfile_path, ref, remotes):
     conanfile.folders.set_base_recipe_metadata(recipe_layout.metadata())
     config_source(export_source_folder, conanfile, hook_manager)
 
+
 def _get_ref_from_cache_or_remote(conan_api, reference, enabled_remotes):
     ref = RecipeReference.loads(reference)
     full_ref, matching_remote = None, False

{conan-2.22.2 → conan-2.23.0}/conan/api/subapi/workspace.py

@@ -18,8 +18,8 @@ from conan.internal.methods import auto_language, auto_shared_fpic_config_option
 from conan.internal.model.options import Options
 from conan.internal.model.workspace import Workspace, WORKSPACE_YML, WORKSPACE_PY, WORKSPACE_FOLDER
 from conan.tools.scm import Git
-from conan.internal.graph.graph import RECIPE_EDITABLE, DepsGraph, CONTEXT_HOST, RECIPE_VIRTUAL, Node, \
-    RECIPE_CONSUMER
+from conan.internal.graph.graph import (RECIPE_EDITABLE, DepsGraph, CONTEXT_HOST, RECIPE_VIRTUAL,
+                                        Node, RECIPE_CONSUMER)
 from conan.internal.graph.graph import TransitiveRequirement
 from conan.internal.graph.profile_node_definer import consumer_definer, initialize_conanfile_profile
 from conan.internal.loader import load_python_file
@@ -95,7 +95,6 @@ class WorkspaceAPI:
     def enable(self, value):
         self._enabled = value
 
-    @property
     def name(self):
         self._check_ws()
         return self._ws.name()
@@ -118,7 +117,7 @@ class WorkspaceAPI:
             rel_path = editable_info["path"]
             path = os.path.normpath(os.path.join(self._folder, rel_path, "conanfile.py"))
             if not os.path.isfile(path):
-                raise ConanException(f"Workspace editable not found: {path}")
+                raise ConanException(f"Workspace package not found: {path}")
             ref = editable_info.get("ref")
             try:
                 if ref is None:
@@ -128,12 +127,12 @@ class WorkspaceAPI:
                 else:
                     reference = RecipeReference.loads(ref)
                 reference.validate_ref(reference)
-            except:
-                raise ConanException(f"Workspace editable reference could not be deduced by"
+            except Exception as e:
+                raise ConanException(f"Workspace package reference could not be deduced by"
                                      f" {rel_path}/conanfile.py or it is not"
-                                     f" correctly defined in the conanws.yml file.")
+                                     f" correctly defined in the conanws.yml file: {e}")
             if reference in packages:
-                raise ConanException(f"Workspace editable reference '{str(reference)}' already exists.")
+                raise ConanException(f"Workspace package '{str(reference)}' already exists.")
             packages[reference] = {"path": path}
             if editable_info.get("output_folder"):
                 packages[reference]["output_folder"] = (
@@ -238,7 +237,7 @@ class WorkspaceAPI:
 
     def info(self):
         self._check_ws()
-        return {"name": self.name,
+        return {"name": self._ws.name(),
                 "folder": self._folder,
                 "packages": self._ws.packages()}
 
@@ -281,17 +280,20 @@ class WorkspaceAPI:
         root_class = self._ws.root_conanfile()
         if root_class is not None:
             conanfile = root_class(f"{WORKSPACE_PY} base project Conanfile")
+            # To inject things like cmd_wrapper to the consumer conanfile, so self.run() works
+            helpers = ConanApp(self._conan_api).loader._conanfile_helpers  # noqa
+            conanfile._conan_helpers = helpers
             initialize_conanfile_profile(conanfile, profile_build, profile_host, CONTEXT_HOST,
                                          is_build_require=False)
             # consumer_definer(conanfile, profile_host, profile_build)
             self._init_options(conanfile, profile_host.options)
-            root = Node(None, conanfile, context=CONTEXT_HOST, recipe=RECIPE_CONSUMER,
-                        path=self._folder)  # path lets use the conanws.py folder
-            root.should_build = True  # It is a consumer, this is something we are building
             for field in ("requires", "build_requires", "test_requires", "requirements", "build",
                           "source", "package"):
                 if getattr(conanfile, field, None):
                     raise ConanException(f"Conanfile in conanws.py shouldn't have '{field}'")
+            root = Node(None, conanfile, context=CONTEXT_HOST, recipe=RECIPE_CONSUMER,
+                        path=self._folder)  # path lets use the conanws.py folder
+            root.should_build = True  # It is a consumer, this is something we are building
         else:
             ConanOutput().info(f"Workspace {WORKSPACE_PY} not found in the workspace folder, "
                                "using default behavior")
@@ -301,7 +303,7 @@ class WorkspaceAPI:
 
         result = DepsGraph()  # TODO: We might need to copy more information from the original graph
         result.add_node(root)
-        conanfile.workspace_packages_options = {}
+        conanfile.workspace_packages = {}
         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
@@ -313,7 +315,9 @@ class WorkspaceAPI:
                                          f"in the workspace: {deps_edit}")
                 result.add_node(node)
                 continue
-            conanfile.workspace_packages_options[node.ref] = node.conanfile.options.serialize()
+            # At the moment we are exposing the full conanfile, docs will warn against usage of
+            # non pure functions
+            conanfile.workspace_packages[node.ref] = node.conanfile
             for r, t in node.transitive_deps.items():
                 if t.node.recipe == RECIPE_EDITABLE:
                     continue

{conan-2.22.2 → conan-2.23.0}/conan/cli/cli.py

@@ -95,6 +95,7 @@ class Cli:
             if command_wrapper.doc:
                 name = f"{package}:{command_wrapper.name}" if package else command_wrapper.name
                 self._commands[name] = command_wrapper
+                command_wrapper._prog = name  # set the program name with possible package, if any
                 # Avoiding duplicated command help messages
                 if name not in self._groups[command_wrapper.group]:
                     self._groups[command_wrapper.group].append(name)

{conan-2.22.2 → conan-2.23.0}/conan/cli/command.py

@@ -49,7 +49,7 @@ class BaseConanCommand:
     def _init_core_options(parser):
         # Define possible levels, including "" for verbose
         possible_levels = list(ConanOutput.valid_log_levels().keys())
-        possible_levels[possible_levels.index(None)] = ""
+        possible_levels.pop(possible_levels.index(None))
         parser.add_argument("-v", default="status", nargs='?',
                             help="Level of detail of the output. Valid options from less verbose "
                                  "to more verbose: -vquiet, -verror, -vwarning, -vnotice, -vstatus, "
@@ -116,7 +116,12 @@ class BaseConanCommand:
     def _dispatch_errors(info):
         if info and isinstance(info, dict):
             if info.get("conan_error"):
-                raise ConanException(info["conan_error"])
+                e = info["conan_error"]
+                # Storing and launching an exception is better than the string, as it keeps
+                # the correct backtrace for debugging.
+                if isinstance(e, Exception):
+                    raise e
+                raise ConanException(e)
             if info.get("conan_warning"):
                 ConanOutput().warning(info["conan_warning"])
 
@@ -152,6 +157,7 @@ class ConanCommand(BaseConanCommand):
         self._subcommands = {}
         self._group = group or "Other"
         self._name = method.__name__.replace("_", "-")
+        self._prog = self._name
 
     def add_subcommand(self, subcommand):
         subcommand.set_name(self.name)
@@ -159,7 +165,7 @@ class ConanCommand(BaseConanCommand):
 
     def run_cli(self, conan_api, *args):
         parser = ConanArgumentParser(conan_api, description=self._doc,
-                                     prog="conan {}".format(self._name),
+                                     prog="conan {}".format(self._prog),
                                      formatter_class=SmartFormatter)
         self._init_formatters(parser)
         self._init_core_options(parser)
@@ -182,7 +188,7 @@ class ConanCommand(BaseConanCommand):
 
     def run(self, conan_api, *args):
         parser = ConanArgumentParser(conan_api, description=self._doc,
-                                     prog="conan {}".format(self._name),
+                                     prog="conan {}".format(self._prog),
                                      formatter_class=SmartFormatter)
         self._init_formatters(parser)
         self._init_core_options(parser)

{conan-2.22.2 → conan-2.23.0}/conan/cli/commands/create.py

@@ -68,6 +68,7 @@ def create(conan_api, parser, *args):
     if args.build is not None and args.build_test is None:
         args.build_test = args.build
 
+    install_error = None
     if is_python_require:
         deps_graph = conan_api.graph.load_graph_requires([], [],
                                                          profile_host=profile_host,
@@ -98,7 +99,9 @@ def create(conan_api, parser, *args):
                                          update=args.update, lockfile=lockfile)
         print_graph_packages(deps_graph)
 
-        conan_api.install.install_binaries(deps_graph=deps_graph, remotes=remotes)
+        install_error = conan_api.install.install_binaries(deps_graph=deps_graph, remotes=remotes,
+                                                           return_install_error=True)
+
         # We update the lockfile, so it will be updated for later ``test_package``
         lockfile = conan_api.lockfile.update_lockfile(lockfile, deps_graph, args.lockfile_packages,
                                                       clean=args.lockfile_clean)
@@ -111,7 +114,7 @@ def create(conan_api, parser, *args):
             and deps_graph.root.edges[0].dst.binary != "Build":
         test_conanfile_path = None  # disable it
 
-    if test_conanfile_path:
+    if test_conanfile_path and not install_error:
         # TODO: We need arguments for:
         #  - decide update policy "--test_package_update"
         # If it is a string, it will be injected always, if it is a RecipeReference, then it will
@@ -126,7 +129,8 @@ def create(conan_api, parser, *args):
 
     conan_api.lockfile.save_lockfile(lockfile, args.lockfile_out, cwd)
     return {"graph": deps_graph,
-            "conan_api": conan_api}
+            "conan_api": conan_api,
+            "conan_error": install_error}
 
 
 def _check_tested_reference_matches(deps_graph, tested_ref, out):