conan 2.23.0__tar.gz → 2.24.0__tar.gz

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

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

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

{conan-2.23.0 → 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:

{conan-2.23.0 → 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.23.0 → conan-2.24.0}/conan/api/subapi/cache.py

@@ -22,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
@@ -71,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
@@ -128,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
@@ -181,7 +195,7 @@ class CacheAPI:
                        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}")
 
@@ -253,11 +267,14 @@ 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")

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.23.0 → conan-2.24.0}/conan/api/subapi/graph.py

@@ -109,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):

{conan-2.23.0 → conan-2.24.0}/conan/api/subapi/lockfile.py

@@ -13,15 +13,20 @@ class LockfileAPI:
         self._conan_api = conan_api
 
     @staticmethod
-    def get_lockfile(lockfile=None, conanfile_path=None, cwd=None, partial=False, overrides=None):
+    def get_lockfile(lockfile=None, conanfile_path=None, cwd=None, partial=False,
+                     overrides=None) -> Lockfile:
         """ obtain a lockfile, following this logic:
-        - If lockfile is explicitly defined, it would be either absolute or relative to cwd and
-          the lockfile file must exist. If lockfile="" (empty string) the default "conan.lock"
-          lockfile will not be automatically used even if it is present.
-        - If lockfile is not defined, it will still look for a default conan.lock:
-           - if conanfile_path is defined, it will be besides it
-           - if conanfile_path is not defined, the default conan.lock should be in cwd
-           - if the default conan.lock cannot be found, it is not an error
+
+        If lockfile is explicitly defined, it would be either absolute or relative to cwd and
+        the lockfile file must exist. If lockfile="" (empty string) the default "conan.lock"
+        lockfile will not be automatically used even if it is present.
+
+        If lockfile is not defined, it will still look for a default conan.lock:
+
+         - if conanfile_path is defined, it will be besides it
+         - if conanfile_path is not defined, the default conan.lock should be in cwd
+         - if the default conan.lock cannot be found, it is not an error
+
 
         :param partial: If the obtained lockfile will allow partial resolving
         :param cwd: the current working dir, if None, os.getcwd() will be used

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

@@ -14,6 +14,9 @@ from conan.internal.util.runners import conan_run
 
 
 class ReportAPI:
+    """ Used to compute the differences (the "diff") between two versions or revisions, for
+    both the recipe and source code.
+    """
     def __init__(self, conan_api, helpers):
         self._conan_api = conan_api
         self._helpers = helpers
@@ -21,6 +24,7 @@ class ReportAPI:
     def diff(self, old_reference, new_reference, remotes, old_path=None, new_path=None, cwd=None):
         """
         Compare two recipes and return the differences.
+
         :param old_reference: The reference of the old recipe.
         :param new_reference: The reference of the new recipe.
         :param remotes: List of remotes to search for the recipes.
@@ -32,7 +36,8 @@ class ReportAPI:
 
         def _source(path_to_conanfile, reference):
             if path_to_conanfile is None:
-                export_ref, cache_path = _get_ref_from_cache_or_remote(self._conan_api, reference, remotes)
+                export_ref, cache_path = _get_ref_from_cache_or_remote(self._conan_api, reference,
+                                                                       remotes)
             else:
                 export_ref, cache_path = _export_recipe_from_path(self._conan_api, path_to_conanfile,
                                                                   reference, remotes, cwd)
@@ -56,7 +61,8 @@ class ReportAPI:
                    f'"{old_diff_path}" "{new_diff_path}"')
 
         ConanOutput().info(
-            f"Generating diff from {old_export_ref.repr_notime()} to {new_export_ref.repr_notime()} (this might take a while)")
+            f"Generating diff from {old_export_ref.repr_notime()} to {new_export_ref.repr_notime()} "
+            f"(this might take a while)")
         ConanOutput().info(command)
 
         stdout, stderr = StringIO(), StringIO()
@@ -116,19 +122,20 @@ def _get_ref_from_cache_or_remote(conan_api, reference, enabled_remotes):
                     full_ref = ref
                     matching_remote = remote
                     break
-            except:
+            except (Exception,):
                 continue
         else:
             try:
                 latest_recipe_revision = conan_api.list.latest_recipe_revision(ref, remote)
-            except:
+            except (Exception,):
                 continue
             if full_ref is None or (latest_recipe_revision.timestamp > full_ref.timestamp):
                 full_ref = latest_recipe_revision
                 matching_remote = remote
     if full_ref is None or matching_remote is False:
         raise ConanException(f"No matching reference for {reference} in remotes.\n"
-                             "If you want to check against a local recipe, add an additional --{old,new}-path arg.\n")
+                             "If you want to check against a local recipe, add an "
+                             "additional --{old,new}-path arg.\n")
     if matching_remote is not None:
         conan_api.download.recipe(full_ref, matching_remote)
     cache_path = conan_api.cache.export_path(full_ref)

{conan-2.23.0 → conan-2.24.0}/conan/api/subapi/upload.py

@@ -22,8 +22,8 @@ class UploadAPI:
         self._conan_api = conan_api
         self._api_helpers = api_helpers
 
-    def check_upstream(self, package_list: PackagesList, remote: Remote, enabled_remotes: List[Remote],
-                       force=False):
+    def check_upstream(self, package_list: PackagesList, remote: Remote,
+                       enabled_remotes: List[Remote], force=False):
         """ Checks ``remote`` for the existence of the recipes and packages in ``package_list``.
         Items that are not present in the remote will add an ``upload`` key to the entry
         with the value ``True``.
@@ -34,8 +34,8 @@ class UploadAPI:
         :parameter remote: Remote to check.
         :parameter enabled_remotes: List of enabled remotes. This is used to possibly load
             python_requires from the listed recipes if necessary.
-        :parameter force: If ``True``, it will skip the check and mark that all items need to be uploaded.
-            A ``force_upload`` key will be added to the entries that will be uploaded.
+        :parameter force: If ``True``, it will skip the check and mark that all items need to be
+            uploaded. A ``force_upload`` key will be added to the entries that will be uploaded.
         """
         app = ConanApp(self._conan_api)
         for ref, _ in package_list.items():
@@ -87,7 +87,8 @@ class UploadAPI:
         The steps that this method performs are:
             - calls ``conan_api.cache.check_integrity`` to ensure the packages are not corrupted
             - checks the upload policy of the recipes
-                - (if it is ``"skip"``, it will not upload the binaries, but will still upload the metadata)
+                - (if it is ``"skip"``, it will not upload the binaries, but will still upload
+                  the metadata)
             - checks which revisions already exist in the server so that it can skip the upload
             - prepares the artifacts to upload (compresses the conan_package.tgz)
             - executes the actual upload
@@ -142,7 +143,13 @@ class UploadAPI:
         ConanOutput().success(f"Upload completed in {int(elapsed)}s\n")
         add_urls(package_list, remote)
 
-    def upload_backup_sources(self, files):
+    def upload_backup_sources(self, files: List) -> None:
+        """
+        Upload to the server the backup sources files, that have been typically gathered by
+        CacheAPI.get_backup_sources()
+
+        :param files: The list of files that must be uploaded
+        """
         config = self._api_helpers.global_conf
         url = config.get("core.sources:upload_url", check_type=str)
         if url is None:
@@ -181,4 +188,3 @@ class UploadAPI:
                                          f"/permissions, please provide 'source_credentials.json': {e}")
 
         output.success("Upload backup sources complete\n")
-        return