conan 2.9.3__tar.gz → 2.10.1__tar.gz

{conan-2.9.3/conan.egg-info → conan-2.10.1}/PKG-INFO

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

{conan-2.9.3 → conan-2.10.1}/conan/__init__.py

@@ -1,6 +1,5 @@
 from conans.model.conan_file import ConanFile
 from conan.tools.scm import Version as _Version
-from conans import __version__
-
 
+__version__ = '2.10.1'
 conan_version = _Version(__version__)

{conan-2.9.3 → conan-2.10.1}/conan/api/conan_api.py

@@ -5,7 +5,8 @@ from conan.api.subapi.cache import CacheAPI
 from conan.api.subapi.command import CommandAPI
 from conan.api.subapi.local import LocalAPI
 from conan.api.subapi.lockfile import LockfileAPI
-from conans import __version__ as client_version
+from conan.api.subapi.workspace import WorkspaceAPI
+from conan import conan_version
 from conan.api.subapi.config import ConfigAPI
 from conan.api.subapi.download import DownloadAPI
 from conan.api.subapi.export import ExportAPI
@@ -20,7 +21,6 @@ from conan.api.subapi.search import SearchAPI
 from conan.api.subapi.upload import UploadAPI
 from conans.client.migrations import ClientMigrator
 from conan.errors import ConanException
-from conans.model.version import Version
 from conan.internal.paths import get_conan_user_home
 from conans.model.version_range import validate_conan_version
 
@@ -33,11 +33,12 @@ class ConanAPI:
             raise ConanException("Conan needs Python >= 3.6")
 
         init_colorama(sys.stderr)
-        self.cache_folder = cache_folder or get_conan_user_home()
+        self.workspace = WorkspaceAPI(self)
+        self.cache_folder = self.workspace.home_folder() or cache_folder or get_conan_user_home()
         self.home_folder = self.cache_folder  # Lets call it home, deprecate "cache"
 
         # Migration system
-        migrator = ClientMigrator(self.cache_folder, Version(client_version))
+        migrator = ClientMigrator(self.cache_folder, conan_version)
         migrator.migrate()
 
         self.command = CommandAPI(self)

{conan-2.9.3 → conan-2.10.1}/conan/api/output.py

@@ -4,6 +4,7 @@ import sys
 import time
 from threading import Lock
 
+import colorama
 from colorama import Fore, Style
 
 from conan.errors import ConanException
@@ -113,21 +114,26 @@ class ConanOutput:
 
         :param v: `str` or `None`, where `None` is the same as `verbose`.
         """
+        env_level = os.getenv("CONAN_LOG_LEVEL")
+        v = env_level or v
+        levels = {"quiet": LEVEL_QUIET,  # -vquiet 80
+                  "error": LEVEL_ERROR,  # -verror 70
+                  "warning": LEVEL_WARNING,  # -vwaring 60
+                  "notice": LEVEL_NOTICE,  # -vnotice 50
+                  "status": LEVEL_STATUS,  # -vstatus 40
+                  None: LEVEL_VERBOSE,  # -v 30
+                  "verbose": LEVEL_VERBOSE,  # -vverbose 30
+                  "debug": LEVEL_DEBUG,  # -vdebug 20
+                  "v": LEVEL_DEBUG,  # -vv 20
+                  "trace": LEVEL_TRACE,  # -vtrace 10
+                  "vv": LEVEL_TRACE  # -vvv 10
+                  }
         try:
-            level = {"quiet": LEVEL_QUIET,  # -vquiet 80
-                     "error": LEVEL_ERROR,  # -verror 70
-                     "warning": LEVEL_WARNING,  # -vwaring 60
-                     "notice": LEVEL_NOTICE,  # -vnotice 50
-                     "status": LEVEL_STATUS,  # -vstatus 40
-                     None: LEVEL_VERBOSE,  # -v 30
-                     "verbose": LEVEL_VERBOSE,  # -vverbose 30
-                     "debug": LEVEL_DEBUG,  # -vdebug 20
-                     "v": LEVEL_DEBUG,  # -vv 20
-                     "trace": LEVEL_TRACE,  # -vtrace 10
-                     "vv": LEVEL_TRACE  # -vvv 10
-                     }[v]
+            level = levels[v]
         except KeyError:
-            raise ConanException(f"Invalid argument '-v{v}'")
+            msg = " defined in CONAN_LOG_LEVEL environment variable" if env_level else ""
+            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
 
@@ -283,15 +289,15 @@ def cli_out_write(data, fg=None, bg=None, endline="\n", indentation=0):
     """
     Output to be used by formatters to dump information to stdout
     """
-
-    fg_ = fg or ''
-    bg_ = bg or ''
-    if (fg or bg) and _color_enabled(sys.stdout):
-        data = f"{' ' * indentation}{fg_}{bg_}{data}{Style.RESET_ALL}{endline}"
+    if (fg or bg) and _color_enabled(sys.stdout):  # need color
+        data = f"{' ' * indentation}{fg or ''}{bg or ''}{data}{Style.RESET_ALL}{endline}"
+        sys.stdout.write(data)
     else:
         data = f"{' ' * indentation}{data}{endline}"
-
-    sys.stdout.write(data)
+        # https://github.com/conan-io/conan/issues/17245 avoid colorama crash and overhead
+        colorama.deinit()
+        sys.stdout.write(data)
+        colorama.reinit()
 
 
 class TimedOutput:

{conan-2.9.3 → conan-2.10.1}/conan/api/subapi/cache.py

@@ -8,7 +8,6 @@ from conan.api.model import PackagesList
 from conan.api.output import ConanOutput
 from conan.internal.cache.cache import PkgCache
 from conan.internal.cache.home_paths import HomePaths
-from conan.internal.conan_app import ConanApp
 from conan.internal.cache.integrity_check import IntegrityChecker
 from conans.client.downloaders.download_cache import DownloadCache
 from conan.errors import ConanException
@@ -24,53 +23,53 @@ class CacheAPI:
         self.conan_api = conan_api
 
     def export_path(self, ref: RecipeReference):
-        app = ConanApp(self.conan_api)
+        cache = PkgCache(self.conan_api.cache_folder, self.conan_api.config.global_conf)
         ref.revision = None if ref.revision == "latest" else ref.revision
-        ref_layout = app.cache.recipe_layout(ref)
+        ref_layout = cache.recipe_layout(ref)
         return _check_folder_existence(ref, "export", ref_layout.export())
 
     def recipe_metadata_path(self, ref: RecipeReference):
-        app = ConanApp(self.conan_api)
-        ref = _resolve_latest_ref(app, ref)
-        ref_layout = app.cache.recipe_layout(ref)
+        cache = PkgCache(self.conan_api.cache_folder, self.conan_api.config.global_conf)
+        ref = _resolve_latest_ref(cache, ref)
+        ref_layout = cache.recipe_layout(ref)
         return _check_folder_existence(ref, "metadata", ref_layout.metadata())
 
     def export_source_path(self, ref: RecipeReference):
-        app = ConanApp(self.conan_api)
+        cache = PkgCache(self.conan_api.cache_folder, self.conan_api.config.global_conf)
         ref.revision = None if ref.revision == "latest" else ref.revision
-        ref_layout = app.cache.recipe_layout(ref)
+        ref_layout = cache.recipe_layout(ref)
         return _check_folder_existence(ref, "export_sources", ref_layout.export_sources())
 
     def source_path(self, ref: RecipeReference):
-        app = ConanApp(self.conan_api)
+        cache = PkgCache(self.conan_api.cache_folder, self.conan_api.config.global_conf)
         ref.revision = None if ref.revision == "latest" else ref.revision
-        ref_layout = app.cache.recipe_layout(ref)
+        ref_layout = cache.recipe_layout(ref)
         return _check_folder_existence(ref, "source", ref_layout.source())
 
     def build_path(self, pref: PkgReference):
-        app = ConanApp(self.conan_api)
-        pref = _resolve_latest_pref(app, pref)
-        ref_layout = app.cache.pkg_layout(pref)
+        cache = PkgCache(self.conan_api.cache_folder, self.conan_api.config.global_conf)
+        pref = _resolve_latest_pref(cache, pref)
+        ref_layout = cache.pkg_layout(pref)
         return _check_folder_existence(pref, "build", ref_layout.build())
 
     def package_metadata_path(self, pref: PkgReference):
-        app = ConanApp(self.conan_api)
-        pref = _resolve_latest_pref(app, pref)
-        ref_layout = app.cache.pkg_layout(pref)
+        cache = PkgCache(self.conan_api.cache_folder, self.conan_api.config.global_conf)
+        pref = _resolve_latest_pref(cache, pref)
+        ref_layout = cache.pkg_layout(pref)
         return _check_folder_existence(pref, "metadata", ref_layout.metadata())
 
     def package_path(self, pref: PkgReference):
-        app = ConanApp(self.conan_api)
-        pref = _resolve_latest_pref(app, pref)
-        ref_layout = app.cache.pkg_layout(pref)
+        cache = PkgCache(self.conan_api.cache_folder, self.conan_api.config.global_conf)
+        pref = _resolve_latest_pref(cache, pref)
+        ref_layout = cache.pkg_layout(pref)
         if os.path.exists(ref_layout.finalize()):
             return ref_layout.finalize()
         return _check_folder_existence(pref, "package", ref_layout.package())
 
     def check_integrity(self, package_list):
         """Check if the recipes and packages are corrupted (it will raise a ConanExcepcion)"""
-        app = ConanApp(self.conan_api)
-        checker = IntegrityChecker(app)
+        cache = PkgCache(self.conan_api.cache_folder, self.conan_api.config.global_conf)
+        checker = IntegrityChecker(cache)
         checker.check(package_list)
 
     def clean(self, package_list, source=True, build=True, download=True, temp=True,
@@ -87,11 +86,11 @@ class CacheAPI:
         :return:
         """
 
-        app = ConanApp(self.conan_api)
+        cache = PkgCache(self.conan_api.cache_folder, self.conan_api.config.global_conf)
         if temp:
-            rmdir(app.cache.temp_folder)
+            rmdir(cache.temp_folder)
             # Clean those build folders that didn't succeed to create a package and wont be in DB
-            builds_folder = app.cache.builds_folder
+            builds_folder = cache.builds_folder
             if os.path.isdir(builds_folder):
                 for subdir in os.listdir(builds_folder):
                     folder = os.path.join(builds_folder, subdir)
@@ -105,17 +104,17 @@ class CacheAPI:
                 remove(f)
 
         for ref, ref_bundle in package_list.refs().items():
-            ref_layout = app.cache.recipe_layout(ref)
+            ref_layout = cache.recipe_layout(ref)
             if source:
                 rmdir(ref_layout.source())
             if download:
                 rmdir(ref_layout.download_export())
             for pref, _ in package_list.prefs(ref, ref_bundle).items():
-                pref_layout = app.cache.pkg_layout(pref)
+                pref_layout = cache.pkg_layout(pref)
                 if build:
                     rmdir(pref_layout.build())
                     # It is important to remove the "build_id" identifier if build-folder is removed
-                    app.cache.remove_build_id(pref)
+                    cache.remove_build_id(pref)
                 if download:
                     rmdir(pref_layout.download_package())
 
@@ -244,21 +243,21 @@ class CacheAPI:
         return download_cache.get_backup_sources_files(excluded_urls, package_list, only_upload)
 
 
-def _resolve_latest_ref(app, ref):
+def _resolve_latest_ref(cache, ref):
     if ref.revision is None or ref.revision == "latest":
         ref.revision = None
-        result = app.cache.get_latest_recipe_reference(ref)
+        result = cache.get_latest_recipe_reference(ref)
         if result is None:
             raise ConanException(f"'{ref}' not found in cache")
         ref = result
     return ref
 
 
-def _resolve_latest_pref(app, pref):
-    pref.ref = _resolve_latest_ref(app, pref.ref)
+def _resolve_latest_pref(cache, pref):
+    pref.ref = _resolve_latest_ref(cache, pref.ref)
     if pref.revision is None or pref.revision == "latest":
         pref.revision = None
-        result = app.cache.get_latest_package_reference(pref)
+        result = cache.get_latest_package_reference(pref)
         if result is None:
             raise ConanException(f"'{pref.repr_notime()}' not found in cache")
         pref = result

{conan-2.9.3 → conan-2.10.1}/conan/api/subapi/config.py

@@ -40,19 +40,18 @@ class ConfigAPI:
         configuration_install(app, path_or_url, verify_ssl, config_type=config_type, args=args,
                               source_folder=source_folder, target_folder=target_folder)
 
-    def install_pkg(self, ref, lockfile=None, force=False, remotes=None):
+    def install_pkg(self, ref, lockfile=None, force=False, remotes=None, profile=None):
         ConanOutput().warning("The 'conan config install-pkg' is experimental",
                               warn_tag="experimental")
         conan_api = self.conan_api
         remotes = conan_api.remotes.list() if remotes is None else remotes
-        # Ready to use profiles as inputs, but NOT using profiles yet, empty ones
-        profile_host = profile_build = conan_api.profiles.get_profile([])
+        profile_host = profile_build = profile or conan_api.profiles.get_profile([])
 
         app = ConanApp(self.conan_api)
 
         # Computation of a very simple graph that requires "ref"
         conanfile = app.loader.load_virtual(requires=[RecipeReference.loads(ref)])
-        consumer_definer(conanfile, profile_build, profile_host)
+        consumer_definer(conanfile, profile_host, profile_build)
         root_node = Node(ref=None, conanfile=conanfile, context=CONTEXT_HOST, recipe=RECIPE_VIRTUAL)
         root_node.is_conf = True
         update = ["*"]

{conan-2.9.3 → conan-2.10.1}/conan/api/subapi/export.py

@@ -1,8 +1,11 @@
 from conan.api.output import ConanOutput
+from conan.internal.cache.cache import PkgCache
+from conan.internal.cache.home_paths import HomePaths
 from conan.internal.conan_app import ConanApp
 from conan.internal.api.export import cmd_export
-from conans.client.conanfile.package import run_package_method
+from conan.internal.methods import run_package_method
 from conans.client.graph.graph import BINARY_BUILD, RECIPE_INCACHE
+from conans.client.hook_manager import HookManager
 from conans.model.package_ref import PkgReference
 from conans.util.files import mkdir
 
@@ -15,12 +18,13 @@ class ExportAPI:
     def export(self, path, name, version, user, channel, lockfile=None, remotes=None):
         ConanOutput().title("Exporting recipe to the cache")
         app = ConanApp(self.conan_api)
-        return cmd_export(app, self.conan_api.config.global_conf, path, name, version, user, channel,
-                          graph_lock=lockfile, remotes=remotes)
+        hook_manager = HookManager(HomePaths(self.conan_api.home_folder).hooks_path)
+        return cmd_export(app, hook_manager, self.conan_api.config.global_conf, path, name, version,
+                          user, channel, graph_lock=lockfile, remotes=remotes)
 
     def export_pkg(self, deps_graph, source_folder, output_folder):
-        app = ConanApp(self.conan_api)
-        cache, hook_manager = app.cache, app.hook_manager
+        cache = PkgCache(self.conan_api.cache_folder, self.conan_api.config.global_conf)
+        hook_manager = HookManager(HomePaths(self.conan_api.home_folder).hooks_path)
 
         # The graph has to be loaded with build_mode=[ref.name], so that node is not tried
         # to be downloaded from remotes

{conan-2.9.3 → conan-2.10.1}/conan/api/subapi/install.py

@@ -1,10 +1,12 @@
 import os
 
 from conan.internal.api.install.generators import write_generators
+from conan.internal.cache.home_paths import HomePaths
 from conan.internal.conan_app import ConanApp
 from conan.internal.deploy import do_deploys
 
 from conans.client.graph.install_graph import InstallGraph
+from conans.client.hook_manager import HookManager
 from conans.client.installer import BinaryInstaller
 from conan.errors import ConanInvalidConfiguration
 
@@ -87,5 +89,6 @@ class InstallAPI:
             if gen not in final_generators:
                 final_generators.append(gen)
         conanfile.generators = final_generators
-        app = ConanApp(self.conan_api)
-        write_generators(conanfile, app, envs_generation=envs_generation)
+        hook_manager = HookManager(HomePaths(self.conan_api.home_folder).hooks_path)
+        write_generators(conanfile, hook_manager, self.conan_api.home_folder,
+                         envs_generation=envs_generation)

{conan-2.9.3 → conan-2.10.1}/conan/api/subapi/local.py

@@ -1,14 +1,15 @@
 import os
 
 from conan.cli import make_abs_path
+from conan.internal.cache.home_paths import HomePaths
 from conan.internal.conan_app import ConanApp
 from conan.internal.api.local.editable import EditablePackages
-from conans.client.conanfile.build import run_build_method
+from conan.internal.methods import run_build_method, run_source_method
 from conans.client.graph.graph import CONTEXT_HOST
 from conans.client.graph.profile_node_definer import initialize_conanfile_profile
-from conans.client.source import run_source_method
 from conan.internal.errors import conanfile_exception_formatter
 from conan.errors import ConanException
+from conans.client.hook_manager import HookManager
 from conans.model.recipe_ref import RecipeReference
 from conans.util.files import chdir
 
@@ -18,6 +19,9 @@ class LocalAPI:
     def __init__(self, conan_api):
         self._conan_api = conan_api
         self.editable_packages = EditablePackages(conan_api.home_folder)
+        editables = conan_api.workspace.editables()
+        if editables:
+            self.editable_packages.edited_refs.update(editables)
 
     @staticmethod
     def get_conanfile_path(path, cwd, py):
@@ -56,17 +60,20 @@ class LocalAPI:
         target_path = self._conan_api.local.get_conanfile_path(path=path, cwd=cwd, py=True)
         output_folder = make_abs_path(output_folder) if output_folder else None
         # Check the conanfile is there, and name/version matches
-        self.editable_packages.add(ref, target_path, output_folder=output_folder)
+        editable_packages = EditablePackages(self._conan_api.home_folder)
+        editable_packages.add(ref, target_path, output_folder=output_folder)
         return ref
 
     def editable_remove(self, path=None, requires=None, cwd=None):
         if path:
             path = make_abs_path(path, cwd)
             path = os.path.join(path, "conanfile.py")
-        return self.editable_packages.remove(path, requires)
+        editable_packages = EditablePackages(self._conan_api.home_folder)
+        return editable_packages.remove(path, requires)
 
     def editable_list(self):
-        return self.editable_packages.edited_refs
+        editable_packages = EditablePackages(self._conan_api.home_folder)
+        return editable_packages.edited_refs
 
     def source(self, path, name=None, version=None, user=None, channel=None, remotes=None):
         """ calls the 'source()' method of the current (user folder) conanfile.py
@@ -92,16 +99,16 @@ class LocalAPI:
         conanfile.folders.set_base_build(None)
         conanfile.folders.set_base_package(None)
 
-        app = ConanApp(self._conan_api)
-        run_source_method(conanfile, app.hook_manager)
+        hook_manager = HookManager(HomePaths(self._conan_api.home_folder).hooks_path)
+        run_source_method(conanfile, hook_manager)
 
     def build(self, conanfile):
         """ calls the 'build()' method of the current (user folder) conanfile.py
         """
-        app = ConanApp(self._conan_api)
+        hook_manager = HookManager(HomePaths(self._conan_api.home_folder).hooks_path)
         conanfile.folders.set_base_package(conanfile.folders.base_build)
         conanfile.folders.set_base_pkg_metadata(os.path.join(conanfile.build_folder, "metadata"))
-        run_build_method(conanfile, app.hook_manager)
+        run_build_method(conanfile, hook_manager)
 
     @staticmethod
     def test(conanfile):
@@ -117,4 +124,3 @@ class LocalAPI:
         conanfile = app.loader.load_named(conanfile_path, name=name, version=version, user=user,
                                           channel=channel, remotes=remotes, graph_lock=lockfile)
         return conanfile
-

{conan-2.9.3 → conan-2.10.1}/conan/api/subapi/new.py

@@ -5,7 +5,7 @@ from jinja2 import Template, StrictUndefined, UndefinedError, Environment, meta
 
 from conan.errors import ConanException
 from conans.util.files import load
-from conans import __version__
+from conan import __version__
 
 
 class NewAPI:
@@ -93,9 +93,11 @@ class NewAPI:
     @staticmethod
     def render(template_files, definitions):
         result = {}
-        name = definitions.get("name", "Pkg")
+        name = definitions.get("name", "pkg")
         if isinstance(name, list):
             raise ConanException(f"name argument can't be multiple: {name}")
+        if name != name.lower():
+            raise ConanException(f"name argument must be lowercase: {name}")
         definitions["conan_version"] = __version__
 
         def ensure_list(key):

{conan-2.9.3 → conan-2.10.1}/conan/api/subapi/remotes.py

@@ -237,7 +237,7 @@ class RemotesAPI:
             username = None
         localdb.store(username, token=None, refresh_token=None, remote_url=remote.url)
 
-    def user_auth(self, remote: Remote, with_user=False):
+    def user_auth(self, remote: Remote, with_user=False, force=False):
         # TODO: Review
         app = ConanApp(self.conan_api)
         if with_user:
@@ -247,7 +247,7 @@ class RemotesAPI:
                 user = os.getenv(var_name, None) or os.getenv("CONAN_LOGIN_USERNAME", None)
             if not user:
                 return
-        app.remote_manager.check_credentials(remote)
+        app.remote_manager.check_credentials(remote, force)
         user, token, _ = app.localdb.get_login(remote.url)
         return user
 

conan-2.10.1/conan/api/subapi/workspace.py

@@ -0,0 +1,82 @@
+import os
+import shutil
+
+from conan.cli import make_abs_path
+from conan.internal.conan_app import ConanApp
+from conan.internal.workspace import Workspace
+from conan.tools.scm import Git
+from conan.errors import ConanException
+from conans.client.graph.graph import RECIPE_EDITABLE
+from conans.client.source import retrieve_exports_sources
+from conans.model.recipe_ref import RecipeReference
+from conans.util.files import merge_directories
+
+
+class WorkspaceAPI:
+
+    def __init__(self, conan_api):
+        self._conan_api = conan_api
+        self._workspace = Workspace()
+
+    def home_folder(self):
+        return self._workspace.home_folder()
+
+    def folder(self):
+        return self._workspace.folder
+
+    def config_folder(self):
+        return self._workspace.config_folder()
+
+    def editables(self):
+        return self._workspace.editables()
+
+    def open(self, require, remotes, cwd=None):
+        app = ConanApp(self._conan_api)
+        ref = RecipeReference.loads(require)
+        recipe = app.proxy.get_recipe(ref, remotes, update=False, check_update=False)
+
+        layout, recipe_status, remote = recipe
+        if recipe_status == RECIPE_EDITABLE:
+            raise ConanException(f"Can't open a dependency that is already an editable: {ref}")
+        ref = layout.reference
+        conanfile_path = layout.conanfile()
+        conanfile, module = app.loader.load_basic_module(conanfile_path, remotes=remotes)
+
+        scm = conanfile.conan_data.get("scm") if conanfile.conan_data else None
+        dst_path = os.path.join(cwd or os.getcwd(), ref.name)
+        if scm is None:
+            conanfile.output.warning("conandata doesn't contain 'scm' information\n"
+                                     "doing a local copy!!!")
+            shutil.copytree(layout.export(), dst_path)
+            retrieve_exports_sources(app.remote_manager, layout, conanfile, ref, remotes)
+            export_sources = layout.export_sources()
+            if os.path.exists(export_sources):
+                conanfile.output.warning("There are export-sources, copying them, but the location"
+                                         " might be incorrect, use 'scm' approach")
+                merge_directories(export_sources, dst_path)
+        else:
+            git = Git(conanfile, folder=cwd)
+            git.clone(url=scm["url"], target=ref.name)
+            git.folder = ref.name  # change to the cloned folder
+            git.checkout(commit=scm["commit"])
+        return dst_path
+
+    def add(self, path, name=None, version=None, user=None, channel=None, cwd=None,
+            output_folder=None, remotes=None):
+        path = self._conan_api.local.get_conanfile_path(path, cwd, py=True)
+        app = ConanApp(self._conan_api)
+        conanfile = app.loader.load_named(path, name, version, user, channel, remotes=remotes)
+        if conanfile.name is None or conanfile.version is None:
+            raise ConanException("Editable package recipe should declare its name and version")
+        ref = RecipeReference(conanfile.name, conanfile.version, conanfile.user, conanfile.channel)
+        ref.validate_ref()
+        output_folder = make_abs_path(output_folder) if output_folder else None
+        # Check the conanfile is there, and name/version matches
+        self._workspace.add(ref, path, output_folder=output_folder)
+        return ref
+
+    def remove(self, path):
+        return self._workspace.remove(path)
+
+    def info(self):
+        return self._workspace.serialize()

{conan-2.9.3 → conan-2.10.1}/conan/cli/cli.py

@@ -16,7 +16,7 @@ from conan.cli.command import ConanSubCommand
 from conan.cli.exit_codes import SUCCESS, ERROR_MIGRATION, ERROR_GENERAL, USER_CTRL_C, \
     ERROR_SIGTERM, USER_CTRL_BREAK, ERROR_INVALID_CONFIGURATION, ERROR_UNEXPECTED
 from conan.internal.cache.home_paths import HomePaths
-from conans import __version__ as client_version
+from conan import __version__
 from conan.errors import ConanException, ConanInvalidConfiguration, ConanMigrationError
 
 _CONAN_INTERNAL_CUSTOM_COMMANDS_PATH = "_CONAN_INTERNAL_CUSTOM_COMMANDS_PATH"
@@ -176,7 +176,7 @@ class Cli:
             command = self._commands[command_argument]
         except KeyError as exc:
             if command_argument in ["-v", "--version"]:
-                cli_out_write("Conan version %s" % client_version)
+                cli_out_write("Conan version %s" % __version__)
                 return
 
             if command_argument in ["-h", "--help"]:

{conan-2.9.3 → conan-2.10.1}/conan/cli/command.py

@@ -1,5 +1,4 @@
 import argparse
-import os
 import textwrap
 
 from conan.api.output import ConanOutput
@@ -98,13 +97,15 @@ class BaseConanCommand:
 
         formatter(info)
 
-    def _dispatch_errors(self, info):
+    @staticmethod
+    def _dispatch_errors(info):
         if info and isinstance(info, dict):
             if info.get("conan_error"):
                 raise ConanException(info["conan_error"])
             if info.get("conan_warning"):
                 ConanOutput().warning(info["conan_warning"])
 
+
 class ConanArgumentParser(argparse.ArgumentParser):
 
     def __init__(self, conan_api, *args, **kwargs):
@@ -113,9 +114,10 @@ class ConanArgumentParser(argparse.ArgumentParser):
 
     def parse_args(self, args=None, namespace=None):
         args = super().parse_args(args)
-        ConanOutput.define_log_level(os.getenv("CONAN_LOG_LEVEL", args.v))
+        ConanOutput.define_log_level(args.v)
         if getattr(args, "lockfile_packages", None):
             ConanOutput().error("The --lockfile-packages arg is private and shouldn't be used")
+        global_conf = self._conan_api.config.global_conf
         if args.core_conf:
             from conans.model.conf import ConfDefinition
             confs = ConfDefinition()
@@ -124,7 +126,14 @@ class ConanArgumentParser(argparse.ArgumentParser):
                     raise ConanException(f"Only core. values are allowed in --core-conf. Got {c}")
             confs.loads("\n".join(args.core_conf))
             confs.validate()
-            self._conan_api.config.global_conf.update_conf_definition(confs)
+            global_conf.update_conf_definition(confs)
+
+        # TODO: This might be even better moved to the ConanAPI so users without doing custom
+        #  commands can benefit from it
+        ConanOutput.set_warnings_as_errors(global_conf.get("core:warnings_as_errors",
+                                                           default=[], check_type=list))
+        ConanOutput.define_silence_warnings(global_conf.get("core:skip_warnings",
+                                                            default=[], check_type=list))
         return args
 
 

{conan-2.9.3 → conan-2.10.1}/conan/cli/commands/build.py

@@ -61,7 +61,6 @@ def build(conan_api, parser, *args):
     print_graph_packages(deps_graph)
 
     out = ConanOutput()
-    out.title("Installing packages")
     conan_api.install.install_binaries(deps_graph=deps_graph, remotes=remotes)
 
     out.title("Finalizing install (deploy, generators)")

{conan-2.9.3 → conan-2.10.1}/conan/cli/commands/config.py

@@ -73,14 +73,23 @@ def config_install_pkg(conan_api, parser, subparser, *args):
     subparser.add_argument("--url", action=OnceArgument,
                            help="(Experimental) Provide Conan repository URL "
                                 "(for first install without remotes)")
+    subparser.add_argument("-pr", "--profile", help="Profile to install config")
+    subparser.add_argument("-s", "--settings", action="append", help="Settings to install config")
+    subparser.add_argument("-o", "--options", action="append", help="Options to install config")
     args = parser.parse_args(*args)
 
     lockfile = conan_api.lockfile.get_lockfile(lockfile=args.lockfile,
                                                partial=args.lockfile_partial)
 
+    try:
+        default_profile = args.profile or conan_api.profiles.get_default_build()
+    except ConanException:  # it can fail if the default profile doesn't exist yet
+        default_profile = None
+    profiles = [default_profile] if default_profile else []
+    profile = conan_api.profiles.get_profile(profiles, args.settings, args.options)
     remotes = [Remote("_tmp_conan_config", url=args.url)] if args.url else None
     config_pref = conan_api.config.install_pkg(args.item, lockfile=lockfile, force=args.force,
-                                               remotes=remotes)
+                                               remotes=remotes, profile=profile)
     lockfile = conan_api.lockfile.add_lockfile(lockfile, config_requires=[config_pref.ref])
     conan_api.lockfile.save_lockfile(lockfile, args.lockfile_out)