conan 2.22.2__tar.gz → 2.24.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conan
-Version: 2.22.2
+Version: 2.24.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.24.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.24.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.24.0'
 conan_version = Version(__version__)

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

@@ -74,13 +74,16 @@ class ConanAPI:
         self.upload: UploadAPI = UploadAPI(self, self._api_helpers)
         #: Used to download recipes and packages from remotes
         self.download: DownloadAPI = DownloadAPI(self)
-        self.cache = CacheAPI(self, self._api_helpers)
-        self.lockfile = LockfileAPI(self)
+        #: Used to interact wit the packages storage cache
+        self.cache: CacheAPI = CacheAPI(self, self._api_helpers)
+        #: Used to read and manage lockfile files
+        self.lockfile: LockfileAPI = LockfileAPI(self)
         self.local = LocalAPI(self, self._api_helpers)
-        self.audit = AuditAPI(self)
+        #: Used to check vulnerabilities of dependencies
+        self.audit: AuditAPI = AuditAPI(self)
         # Now, lazy loading of editables
         self.workspace = WorkspaceAPI(self)
-        self.report = ReportAPI(self, self._api_helpers)
+        self.report: ReportAPI = ReportAPI(self, self._api_helpers)
 
     @property
     def home_folder(self) -> str:
@@ -150,4 +153,3 @@ class ConanAPI:
         @property
         def requester(self):
             return self._requester
-

{conan-2.22.2 → conan-2.24.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.24.0}/conan/api/model/list.py

@@ -203,6 +203,7 @@ class PackagesList:
 
     def merge(self, other):
         assert isinstance(other, PackagesList)
+
         def recursive_dict_update(d, u):  # TODO: repeated from conandata.py
             for k, v in u.items():
                 if isinstance(v, dict):

{conan-2.22.2 → conan-2.24.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.24.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.24.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.24.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
@@ -21,6 +22,8 @@ from conan.internal.util.files import rmdir, mkdir, remove, save
 
 
 class CacheAPI:
+    """ This CacheAPI is used to interact with the packages storage cache
+    """
 
     def __init__(self, conan_api, api_helpers):
         self._conan_api = conan_api
@@ -70,17 +73,29 @@ class CacheAPI:
             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)"""
+    def check_integrity(self, package_list, return_pkg_list=False):
+        """
+        Check if the recipes and packages are corrupted
+
+        :param package_list: PackagesList to check
+        :param return_pkg_list: If True, return a PackagesList with corrupted artifacts
+        :return: PackagesList with corrupted artifacts if return_pkg_list is True
+        :raises: ConanExcepcion if there are corrupted artifacts and return_pkg_list is False
+        """
         cache = PkgCache(self._conan_api.cache_folder, self._api_helpers.global_conf)
         checker = IntegrityChecker(cache)
-        checker.check(package_list)
+        corrupted_pkg_list = checker.check(package_list)
+        if return_pkg_list:
+            return corrupted_pkg_list
+        if corrupted_pkg_list:
+            raise ConanException("There are corrupted artifacts, check the error logs")
 
     def clean(self, package_list, source=True, build=True, download=True, temp=True,
               backup_sources=False):
         """
         Remove non critical folders from the cache, like source, build and download (.tgz store)
         folders.
+
         :param package_list: the package lists that should be cleaned
         :param source: boolean, remove the "source" folder if True
         :param build: boolean, remove the "build" folder if True
@@ -104,7 +119,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)
@@ -126,7 +142,7 @@ class CacheAPI:
                 if download:
                     rmdir(pref_layout.download_package())
 
-    def save(self, package_list, tgz_path, no_source=False):
+    def save(self, package_list: PackagesList, tgz_path, no_source=False) -> None:
         global_conf = self._api_helpers.global_conf
         cache = PkgCache(self._conan_api.cache_folder, global_conf)
         cache_folder = cache.store  # Note, this is not the home, but the actual package cache
@@ -175,10 +191,11 @@ 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):
+    def restore(self, path) -> PackagesList:
         if not os.path.isfile(path):
             raise ConanException(f"Restore archive doesn't exist in {path}")
 
@@ -250,17 +267,21 @@ class CacheAPI:
 
     def get_backup_sources(self, package_list=None, exclude=True, only_upload=True):
         """Get list of backup source files currently present in the cache,
-        either all of them if no argument, or filtered by those belonging to the references in the package_list
-
-        @param package_list: a PackagesList object to filter backup files from (The files should have been downloaded form any of the references in the package_list)
-        @param exclude: if True, exclude the sources that come from URLs present the core.sources:exclude_urls global conf
-        @param only_upload: if True, only return the files for packages that are set to be uploaded
+        either all of them if no argument, or filtered by those belonging to the references
+        in the package_list
+
+        :param package_list: a PackagesList object to filter backup files from (The files should
+          have been downloaded form any of the references in the package_list)
+        :param exclude: if True, exclude the sources that come from URLs present the
+          core.sources:exclude_urls global conf
+        :param only_upload: if True, only return the files for packages that are set to be uploaded
         """
         config = self._api_helpers.global_conf
         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.24.0/conan/api/subapi/config.py

@@ -0,0 +1,264 @@
+import os
+
+from conan.api.output import ConanOutput
+
+from conan.internal.cache.home_paths import HomePaths
+from conan.internal.conan_app import ConanApp
+from conan.internal.graph.graph import CONTEXT_HOST, RECIPE_VIRTUAL, Node
+from conan.internal.graph.graph_builder import DepsGraphBuilder
+from conan.internal.graph.profile_node_definer import consumer_definer
+from conan.errors import ConanException
+
+from conan.internal.model.conanconfig import loadconanconfig, saveconanconfig, loadconanconfig_yml
+from conan.internal.model.conf import BUILT_IN_CONFS
+from conan.internal.model.pkg_type import PackageType
+from conan.api.model import RecipeReference, Remote
+from conan.internal.util.files import rmdir, remove
+
+
+class ConfigAPI:
+    """ This API provides methods to manage the Conan configuration in the Conan home folder.
+    It allows installing configurations from various sources, retrieving global configuration
+    values, and listing available configurations. It also provides methods to clean the
+    Conan home folder, resetting it to a clean state.
+    """
+
+    def __init__(self, conan_api, helpers):
+        self._conan_api = conan_api
+        self._helpers = helpers
+
+    def home(self):
+        """ return the current Conan home folder containing the configuration files like
+        remotes, settings, profiles, and the packages cache. It is provided for debugging
+        purposes. Recall that it is not allowed to write, modify or remove packages in the
+        packages cache, and that to automate tasks that uses packages from the cache Conan
+        provides mechanisms like deployers or custom commands.
+        """
+        return self._conan_api.cache_folder
+
+    def install(self, path_or_url, verify_ssl, config_type=None, args=None,
+                source_folder=None, target_folder=None):
+        """ install Conan configuration from a git repo, from a zip file in an http server
+        or a local folder
+        """
+        from conan.internal.api.config.config_installer import configuration_install
+        cache_folder = self._conan_api.cache_folder
+        requester = self._helpers.requester
+        configuration_install(cache_folder, requester, path_or_url, verify_ssl,
+                              config_type=config_type, args=args,
+                              source_folder=source_folder, target_folder=target_folder)
+        self._conan_api.reinit()
+
+    def install_package(self, require, lockfile=None, force=False, remotes=None, profile=None):
+        ConanOutput().warning("The 'conan config install-pkg' is experimental",
+                              warn_tag="experimental")
+        require = RecipeReference.loads(require)
+        required_pkgs = self.fetch_packages([require], lockfile, remotes, profile)
+        installed_refs = self._install_pkgs(required_pkgs, force)
+        self._conan_api.reinit()
+        return installed_refs
+
+    @staticmethod
+    def load_conanconfig(path, remotes):
+        if os.path.isdir(path):
+            path = os.path.join(path, "conanconfig.yml")
+        requested_requires, urls = loadconanconfig_yml(path)
+        if urls:
+            new_remotes = [Remote(f"config_install_url{'_' + str(i)}", url=url)
+                           for i, url in enumerate(urls)]
+            remotes = remotes or []
+            remotes += new_remotes
+        return requested_requires, remotes
+
+    def install_conanconfig(self, path, lockfile=None, force=False, remotes=None, profile=None):
+        ConanOutput().warning("The 'conan config install-pkg' is experimental",
+                              warn_tag="experimental")
+        requested_requires, remotes = self.load_conanconfig(path, remotes)
+        required_pkgs = self.fetch_packages(requested_requires, lockfile, remotes, profile)
+        installed_refs = self._install_pkgs(required_pkgs, force)
+        self._conan_api.reinit()
+        return installed_refs
+
+    def _install_pkgs(self, required_pkgs, force):
+        out = ConanOutput()
+        out.title("Configuration packages to install")
+        config_version_file = HomePaths(self._conan_api.home_folder).config_version_path
+        if not os.path.exists(config_version_file):
+            config_versions = []
+        else:
+            ConanOutput().info(f"Reading existing config-versions file: {config_version_file}")
+            config_versions = loadconanconfig(config_version_file)
+        config_versions_dict = {r.name: r for r in config_versions}
+        if len(config_versions_dict) < len(config_versions):
+            raise ConanException("There are multiple requirements for the same package "
+                                 f"with different versions: {config_version_file}")
+
+        new_config = config_versions_dict.copy()
+        for required_pkg in required_pkgs:
+            new_config.pop(required_pkg.ref.name, None)  # To ensure new order
+            new_config[required_pkg.ref.name] = required_pkg.ref
+        final_config_refs = [r for r in new_config.values()]
+
+        prev_refs = "\n\t".join(repr(r) for r in config_versions)
+        out.info(f"Previously installed configuration packages:\n\t{prev_refs}")
+
+        new_refs = "\n\t".join(r.repr_notime() for r in final_config_refs)
+        out.info(f"New configuration packages to install:\n\t{new_refs}")
+
+        if list(config_versions_dict) == list(new_config)[:len(config_versions_dict)]:
+            # There is no conflict in order, can be done safely
+            if final_config_refs == config_versions:
+                if force:
+                    out.warning("The requested configurations are identical to the already "
+                                "installed ones, but forcing re-installation because --force")
+                    to_install = required_pkgs
+                else:
+                    out.info("The requested configurations are identical to the already "
+                             "installed ones, skipping re-installation")
+                    to_install = []
+            else:
+                out.info("Installing new or updating configuration packages")
+                to_install = required_pkgs
+        else:
+            # Change in order of existing configuration
+            if force:
+                out.warning("Installing these configuration packages will break the "
+                            "existing order, with possible side effects. "
+                            "Forcing the installation because --force was defined", warn_tag="risk")
+                to_install = required_pkgs
+            else:
+                msg = ("Installing these configuration packages will break the "
+                       "existing order, with possible side effects, like breaking 'package_ids'.\n"
+                       "If you still want to enforce this configuration you can:\n"
+                       "   Use 'conan config clean' first to fully reset your configuration.\n"
+                       "   Or use 'conan config install-pkg --force' to force installation.")
+                raise ConanException(msg)
+
+        out.title("Installing configuration from packages")
+        # install things and update the Conan cache "config_versions.json" file
+        from conan.internal.api.config.config_installer import configuration_install
+        cache_folder = self._conan_api.cache_folder
+        requester = self._helpers.requester
+        for pkg in to_install:
+            out.info(f"Installing configuration from {pkg.ref}")
+            configuration_install(cache_folder, requester, uri=pkg.conanfile.package_folder,
+                                  verify_ssl=False, config_type="dir",
+                                  ignore=["conaninfo.txt", "conanmanifest.txt"])
+
+        saveconanconfig(config_version_file, final_config_refs)
+        return final_config_refs
+
+    def fetch_packages(self, refs, lockfile=None, remotes=None, profile=None):
+        """ install configuration stored inside a Conan package
+        The installation of configuration will reinitialize the full ConanAPI
+        """
+        conan_api = self._conan_api
+        remotes = conan_api.remotes.list() if remotes is None else remotes
+        profile_host = profile_build = profile or conan_api.profiles.get_profile([])
+
+        app = ConanApp(self._conan_api)
+
+        ConanOutput().title("Fetching requested configuration packages")
+        result = []
+        for ref in refs:
+            # Computation of a very simple graph that requires "ref"
+            # Need to convert input requires to RecipeReference
+            conanfile = app.loader.load_virtual(requires=[ref])
+            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 = ["*"]
+            builder = DepsGraphBuilder(app.proxy, app.loader, app.range_resolver, app.cache, remotes,
+                                       update, update, self._helpers.global_conf)
+            deps_graph = builder.load_graph(root_node, profile_host, profile_build, lockfile)
+
+            # Basic checks of the package: correct package_type and no-dependencies
+            deps_graph.report_graph_error()
+            pkg = deps_graph.root.edges[0].dst
+            ConanOutput().info(f"Configuration from package: {pkg}")
+            if pkg.conanfile.package_type is not PackageType.CONF:
+                raise ConanException(f'{pkg.conanfile} is not of package_type="configuration"')
+            if pkg.edges:
+                raise ConanException(f"Configuration package {pkg.ref} cannot have dependencies")
+
+            # The computation of the "package_id" and the download of the package is done as usual
+            # By default we allow all remotes, and build_mode=None, always updating
+            conan_api.graph.analyze_binaries(deps_graph, None, remotes, update=update,
+                                             lockfile=lockfile)
+            conan_api.install.install_binaries(deps_graph=deps_graph, remotes=remotes)
+            result.append(pkg)
+        return result
+
+    def get(self, name, default=None, check_type=None):
+        """ get the value of a global.conf item
+        """
+        return self._helpers.global_conf.get(name, default=default, check_type=check_type)
+
+    def show(self, pattern) -> dict:
+        """ get the values of global.conf for those configurations that matches the pattern
+        """
+        return self._helpers.global_conf.show(pattern)
+
+    @staticmethod
+    def conf_list():
+        """ list all the available built-in configurations
+        """
+        return BUILT_IN_CONFS.copy()
+
+    def clean(self):
+        """ reset the Conan home folder to a clean state, removing all the user
+        custom configuration, custom files, and resetting modified files
+        """
+        contents = os.listdir(self.home())
+        packages_folder = (self._helpers.global_conf.get("core.cache:storage_path") or
+                           os.path.join(self.home(), "p"))
+        for content in contents:
+            content_path = os.path.join(self.home(), content)
+            if content_path == packages_folder:
+                continue
+            ConanOutput().debug(f"Removing {content_path}")
+            if os.path.isdir(content_path):
+                rmdir(content_path)
+            else:
+                remove(content_path)
+        self._conan_api.reinit()
+        # CHECK: This also generates a remotes.json that is not there after a conan profile show?
+        self._conan_api.migrate()
+
+    @property
+    def settings_yml(self):
+        """ Get the contents of the settings.yml and user_settings.yml files,
+            which define the possible values for settings.
+
+            Note that this is different from the settings present in a conanfile,
+            which represent the actual values for a specific package, while this
+            property represents the possible values for each setting.
+
+            :returns: A read-only object representing the settings scheme, with a
+                ``possible_values()`` method that returns a dictionary with the possible values for each setting,
+                and a ``fields`` property that returns an ordered list with the fields of each setting.
+                Note that it's possible to access nested settings using attribute access,
+                such as ``settings_yml.compiler.possible_values()``.
+        """
+
+        class SettingsYmlInterface:
+            def __init__(self, settings):
+                self._settings = settings
+
+            def possible_values(self):
+                """ returns a dict with the possible values for each setting """
+                return self._settings.possible_values()
+
+            @property
+            def fields(self):
+                """ returns a dict with the fields of each setting """
+                return self._settings.fields
+
+            def __getattr__(self, item):
+                return SettingsYmlInterface(getattr(self._settings, item))
+
+            def __str__(self):
+                return str(self._settings)
+
+        return SettingsYmlInterface(self._helpers.settings_yml)

{conan-2.22.2 → conan-2.24.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)
@@ -108,12 +109,15 @@ class GraphAPI:
         Command line helper to scope options when ``command -o myoption=myvalue`` is used,
         that needs to be converted to "-o pkg:myoption=myvalue". The "pkg" value will be
         computed from the given requires/tool_requires
+
+        This is legacy, as options should always be scoped now
         """
-        # FIXME: This helper function here is not great, find a better place
         if requires and len(requires) == 1 and not tool_requires:
-            profile.options.scope(requires[0])
-        if tool_requires and len(tool_requires) == 1 and not requires:
-            profile.options.scope(tool_requires[0])
+            ref = requires[0]
+            if str(ref.version).startswith("["):
+                ref = ref.copy()
+                ref.version = "*"
+            profile.options.scope(ref)
 
     def load_graph_requires(self, requires, tool_requires, profile_host, profile_build,
                             lockfile, remotes, update, check_updates=False, python_requires=None):
@@ -164,8 +168,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 +193,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 +203,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
         """