conan 2.20.1__tar.gz → 2.22.0__tar.gz

{conan-2.20.1/conan.egg-info → conan-2.22.0}/PKG-INFO

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

{conan-2.20.1 → conan-2.22.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.20.1'
+__version__ = '2.22.0'
 conan_version = Version(__version__)

{conan-2.20.1 → conan-2.22.0}/conan/api/conan_api.py

@@ -28,6 +28,7 @@ from conan.internal.model.settings import load_settings_yml
 from conan.internal.paths import get_conan_user_home
 from conan.internal.api.migrations import ClientMigrator
 from conan.internal.model.version_range import validate_conan_version
+from conan.internal.rest.conan_requester import ConanRequester
 
 
 class ConanAPI:
@@ -65,7 +66,8 @@ class ConanAPI:
         self.profiles = ProfilesAPI(self, self._api_helpers)
         self.install = InstallAPI(self, self._api_helpers)
         self.graph = GraphAPI(self, self._api_helpers)
-        self.export = ExportAPI(self, self._api_helpers)
+        #: Used to export recipes and pre-compiled package binaries to the Conan cache
+        self.export: ExportAPI = ExportAPI(self, self._api_helpers)
         self.remove = RemoveAPI(self)
         self.new = NewAPI(self)
         #: Used to upload recipes and packages to remotes
@@ -81,7 +83,7 @@ class ConanAPI:
         self.report = ReportAPI(self, self._api_helpers)
 
     @property
-    def home_folder(self):
+    def home_folder(self) -> str:
         """ Where the Conan user home is located. Read only.
         Can be modified by the ``CONAN_HOME`` environment variable or by the
         ``.conanrc`` file in the current directory or any parent directory
@@ -94,7 +96,6 @@ class ConanAPI:
         Reinitialize the Conan API. This is useful when the configuration changes.
         """
         self._api_helpers.reinit()
-        self.remotes.reinit()
         self.local.reinit()
 
     def migrate(self):
@@ -110,6 +111,9 @@ class ConanAPI:
             self._cli_core_confs = None
             self._init_global_conf()
             self.hook_manager = HookManager(HomePaths(self._conan_api.home_folder).hooks_path)
+            # Wraps an http_requester to inject proxies, certs, etc
+            self._requester = ConanRequester(self.global_conf, self._conan_api.home_folder)
+            self._settings_yml = None
 
         def set_core_confs(self, core_confs):
             confs = ConfDefinition()
@@ -134,7 +138,16 @@ class ConanAPI:
         def reinit(self):
             self._init_global_conf()
             self.hook_manager.reinit()
+            self._requester = ConanRequester(self.global_conf, self._conan_api.home_folder)
+            self._settings_yml = None
 
         @property
         def settings_yml(self):
-            return load_settings_yml(self._conan_api.home_folder)
+            if self._settings_yml is None:
+                self._settings_yml = load_settings_yml(self._conan_api.home_folder)
+            return self._settings_yml
+
+        @property
+        def requester(self):
+            return self._requester
+

{conan-2.20.1 → conan-2.22.0}/conan/api/model/list.py

@@ -1,9 +1,12 @@
+import copy
 import fnmatch
 import json
 import os
 from json import JSONDecodeError
+from typing import Iterable, Tuple, Dict
 
 from conan.api.model import RecipeReference, PkgReference
+from conan.api.output import ConanOutput
 from conan.errors import ConanException
 from conan.internal.errors import NotFoundException
 from conan.internal.model.version_range import VersionRange
@@ -104,7 +107,7 @@ class MultiPackagesList:
                 )
 
             mpkglist = MultiPackagesList._define_graph(graph, graph_recipes, graph_binaries,
-                                                        context=base_context)
+                                                       context=base_context)
             if context == "build-only":
                 host = MultiPackagesList._define_graph(graph, graph_recipes, graph_binaries,
                                                        context="host")
@@ -150,11 +153,11 @@ class MultiPackagesList:
                         continue
                     pyref = RecipeReference.loads(pyref)
                     if any(r == "*" or r == pyrecipe for r in recipes):
-                        cache_list.add_refs([pyref])
+                        cache_list.add_ref(pyref)
                     pyremote = pyreq["remote"]
                     if pyremote:
                         remote_list = pkglist.lists.setdefault(pyremote, PackagesList())
-                        remote_list.add_refs([pyref])
+                        remote_list.add_ref(pyref)
 
             recipe = node["recipe"]
             if recipe in (RECIPE_EDITABLE, RECIPE_CONSUMER, RECIPE_VIRTUAL, RECIPE_PLATFORM):
@@ -165,18 +168,18 @@ class MultiPackagesList:
             ref.timestamp = node["rrev_timestamp"]
             recipe = recipe.lower()
             if any(r == "*" or r == recipe for r in recipes):
-                cache_list.add_refs([ref])
+                cache_list.add_ref(ref)
 
             remote = node["remote"]
             if remote:
                 remote_list = pkglist.lists.setdefault(remote, PackagesList())
-                remote_list.add_refs([ref])
+                remote_list.add_ref(ref)
             pref = PkgReference(ref, node["package_id"], node["prev"], node["prev_timestamp"])
             binary_remote = node["binary_remote"]
             if binary_remote:
                 remote_list = pkglist.lists.setdefault(binary_remote, PackagesList())
-                remote_list.add_refs([ref])  # Binary listed forces recipe listed
-                remote_list.add_prefs(ref, [pref])
+                remote_list.add_ref(ref)  # Binary listed forces recipe listed
+                remote_list.add_pref(pref)
 
             binary = node["binary"]
             if binary in (BINARY_SKIP, BINARY_INVALID, BINARY_MISSING):
@@ -184,18 +187,22 @@ class MultiPackagesList:
 
             binary = binary.lower()
             if any(b == "*" or b == binary for b in binaries):
-                cache_list.add_refs([ref])  # Binary listed forces recipe listed
-                cache_list.add_prefs(ref, [pref])
-                cache_list.add_configurations({pref: node["info"]})
+                cache_list.add_ref(ref)  # Binary listed forces recipe listed
+                cache_list.add_pref(pref, node["info"])
         return pkglist
 
 
 class PackagesList:
     """ A collection of recipes, revisions and packages."""
     def __init__(self):
-        self.recipes = {}
+        self._data = {}
+
+    def __bool__(self):
+        """ Whether the package list contains any recipe"""
+        return bool(self._data)
 
     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):
@@ -203,71 +210,94 @@ class PackagesList:
                 else:
                     d[k] = v
             return d
-        recursive_dict_update(self.recipes, other.recipes)
+        recursive_dict_update(self._data, other._data)
 
     def keep_outer(self, other):
-        if not self.recipes:
+        assert isinstance(other, PackagesList)
+        if not self._data:
             return
 
-        for ref, info in other.recipes.items():
-            if self.recipes.get(ref, {}) == info:
-                self.recipes.pop(ref)
+        for ref, info in other._data.items():
+            if self._data.get(ref, {}) == info:
+                self._data.pop(ref)
 
     def split(self):
         """
-        Returns a list of PackageList, splitted one per reference.
+        Returns a list of PackageList, split one per reference.
         This can be useful to parallelize things like upload, parallelizing per-reference
         """
         result = []
-        for r, content in self.recipes.items():
+        for r, content in self._data.items():
             subpkglist = PackagesList()
-            subpkglist.recipes[r] = content
+            subpkglist._data[r] = content
             result.append(subpkglist)
         return result
 
     def only_recipes(self) -> None:
         """ Filter out all the packages and package revisions, keep only the recipes and
-            recipe revisions in self.recipes.
+            recipe revisions in self._data.
         """
-        for ref, ref_dict in self.recipes.items():
+        for ref, ref_dict in self._data.items():
             for rrev_dict in ref_dict.get("revisions", {}).values():
                 rrev_dict.pop("packages", None)
 
     def add_refs(self, refs):
+        ConanOutput().warning("PackagesLists.add_refs() non-public, non-documented method will be "
+                              "removed, use .add_ref() instead", warn_tag="deprecated")
         # RREVS alreday come in ASCENDING order, so upload does older revisions first
         for ref in refs:
-            ref_dict = self.recipes.setdefault(str(ref), {})
-            if ref.revision:
-                revs_dict = ref_dict.setdefault("revisions", {})
-                rev_dict = revs_dict.setdefault(ref.revision, {})
-                if ref.timestamp:
-                    rev_dict["timestamp"] = ref.timestamp
+            self.add_ref(ref)
+
+    def add_ref(self, ref: RecipeReference) -> None:
+        """
+        Adds a new RecipeReference to a package list
+        """
+        ref_dict = self._data.setdefault(str(ref), {})
+        if ref.revision:
+            revs_dict = ref_dict.setdefault("revisions", {})
+            rev_dict = revs_dict.setdefault(ref.revision, {})
+            if ref.timestamp:
+                rev_dict["timestamp"] = ref.timestamp
 
     def add_prefs(self, rrev, prefs):
+        ConanOutput().warning("PackageLists.add_prefs() non-public, non-documented method will be "
+                              "removed, use .add_pref() instead", warn_tag="deprecated")
         # Prevs already come in ASCENDING order, so upload does older revisions first
-        revs_dict = self.recipes[str(rrev)]["revisions"]
-        rev_dict = revs_dict[rrev.revision]
-        packages_dict = rev_dict.setdefault("packages", {})
+        for p in prefs:
+            self.add_pref(p)
 
-        for pref in prefs:
-            package_dict = packages_dict.setdefault(pref.package_id, {})
-            if pref.revision:
-                prevs_dict = package_dict.setdefault("revisions", {})
-                prev_dict = prevs_dict.setdefault(pref.revision, {})
-                if pref.timestamp:
-                    prev_dict["timestamp"] = pref.timestamp
+    def add_pref(self, pref: PkgReference, pkg_info: dict = None) -> None:
+        """
+        Add a PkgReference to an already existing RecipeReference inside a package list
+        """
+        # Prevs already come in ASCENDING order, so upload does older revisions first
+        rev_dict = self.recipe_dict(pref.ref)
+        packages_dict = rev_dict.setdefault("packages", {})
+        package_dict = packages_dict.setdefault(pref.package_id, {})
+        if pref.revision:
+            prevs_dict = package_dict.setdefault("revisions", {})
+            prev_dict = prevs_dict.setdefault(pref.revision, {})
+            if pref.timestamp:
+                prev_dict["timestamp"] = pref.timestamp
+        if pkg_info is not None:
+            package_dict["info"] = pkg_info
 
     def add_configurations(self, confs):
+        ConanOutput().warning("PackageLists.add_configurations() non-public, non-documented method "
+                              "will be removed, use .add_pref() instead",
+                              warn_tag="deprecated")
         for pref, conf in confs.items():
-            rev_dict = self.recipes[str(pref.ref)]["revisions"][pref.ref.revision]
+            rev_dict = self.recipe_dict(pref.ref)
             try:
                 rev_dict["packages"][pref.package_id]["info"] = conf
             except KeyError:  # If package_id does not exist, do nothing, only add to existing prefs
                 pass
 
     def refs(self):
+        ConanOutput().warning("PackageLists.refs() non-public, non-documented method will be "
+                              "removed, use .items() instead", warn_tag="deprecated")
         result = {}
-        for ref, ref_dict in self.recipes.items():
+        for ref, ref_dict in self._data.items():
             for rrev, rrev_dict in ref_dict.get("revisions", {}).items():
                 t = rrev_dict.get("timestamp")
                 recipe = RecipeReference.loads(f"{ref}#{rrev}")  # TODO: optimize this
@@ -276,8 +306,45 @@ class PackagesList:
                 result[recipe] = rrev_dict
         return result
 
+    def items(self) -> Iterable[Tuple[RecipeReference, Dict[PkgReference, Dict]]]:
+        """ Iterate the contents of the package list.
+
+        The first dictionary is the information directly belonging to the recipe-revision.
+        The second dictionary contains PkgReference as keys, and a dictionary with the values
+        belonging to that specific package reference (settings, options, etc.).
+        """
+        for ref, ref_dict in self._data.items():
+            for rrev, rrev_dict in ref_dict.get("revisions", {}).items():
+                recipe = RecipeReference.loads(f"{ref}#{rrev}")  # TODO: optimize this
+                t = rrev_dict.get("timestamp")
+                if t is not None:
+                    recipe.timestamp = t
+                packages = {}
+                for package_id, pkg_info in rrev_dict.get("packages", {}).items():
+                    prevs = pkg_info.get("revisions", {})
+                    for prev, prev_info in prevs.items():
+                        t = prev_info.get("timestamp")
+                        pref = PkgReference(recipe, package_id, prev, t)
+                        packages[pref] = prev_info
+                yield recipe, packages
+
+    def recipe_dict(self, ref: RecipeReference):
+        """ Gives read/write access to the dictionary containing a specific RecipeReference
+        information.
+        """
+        return self._data[str(ref)]["revisions"][ref.revision]
+
+    def package_dict(self, pref: PkgReference):
+        """ Gives read/write access to the dictionary containing a specific PkgReference
+        information
+        """
+        ref_dict = self.recipe_dict(pref.ref)
+        return ref_dict["packages"][pref.package_id]["revisions"][pref.revision]
+
     @staticmethod
     def prefs(ref, recipe_bundle):
+        ConanOutput().warning("PackageLists.prefs() non-public, non-documented method will be "
+                              "removed, use .items() instead", warn_tag="deprecated")
         result = {}
         for package_id, pkg_bundle in recipe_bundle.get("packages", {}).items():
             prevs = pkg_bundle.get("revisions", {})
@@ -289,13 +356,13 @@ class PackagesList:
 
     def serialize(self):
         """ Serialize the instance to a dictionary."""
-        return self.recipes.copy()
+        return copy.deepcopy(self._data)
 
     @staticmethod
     def deserialize(data):
         """ Loads the data from a serialized dictionary."""
         result = PackagesList()
-        result.recipes = data
+        result._data = copy.deepcopy(data)
         return result
 
 
@@ -358,10 +425,10 @@ class ListPattern:
         if self.version and self.version.startswith("[") and self.version.endswith("]"):
             return VersionRange(self.version[1:-1])
 
-    def filter_versions(self, refs):
+    def filter_versions(self, refs, resolve_prereleases=None):
         vrange = self._version_range
         if vrange:
-            refs = [r for r in refs if vrange.contains(r.version, None)]
+            refs = [r for r in refs if vrange.contains(r.version, resolve_prereleases)]
         return refs
 
     @property

{conan-2.20.1 → conan-2.22.0}/conan/api/model/remote.py

@@ -7,12 +7,13 @@ class Remote:
     should not be created directly, but obtained from the relevant ``RemotesAPI`` subapi methods.
     """
     def __init__(self, name, url, verify_ssl=True, disabled=False, allowed_packages=None,
-                 remote_type=None):
+                 remote_type=None, recipes_only=False):
         self.name = name  # Read only, is the key
         self.url = url
         self.verify_ssl = verify_ssl
         self.disabled = disabled
         self.allowed_packages = allowed_packages
+        self.recipes_only = recipes_only
         self.remote_type = remote_type
         self._caching = {}
 
@@ -26,6 +27,8 @@ class Remote:
         allowed_msg = ""
         if self.allowed_packages:
             allowed_msg = ", Allowed packages: {}".format(", ".join(self.allowed_packages))
+        if self.recipes_only:
+            allowed_msg += ", Recipes only"
         if self.remote_type == LOCAL_RECIPES_INDEX:
             return "{}: {} [{}, Enabled: {}{}]".format(self.name, self.url, LOCAL_RECIPES_INDEX,
                                                        not self.disabled, allowed_msg)

{conan-2.20.1 → conan-2.22.0}/conan/api/output.py

@@ -124,22 +124,26 @@ class ConanOutput:
     def set_warnings_as_errors(cls, value):
         cls._warnings_as_errors = value
 
+    @classmethod
+    def valid_log_levels(cls):
+        return {"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
+        }
+
     @classmethod
     def define_log_level(cls, v):
         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
-                  }
+        levels = cls.valid_log_levels()
         try:
             level = levels[v]
         except KeyError:

{conan-2.20.1 → conan-2.22.0}/conan/api/subapi/audit.py

@@ -3,6 +3,7 @@ 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
@@ -28,12 +29,14 @@ class AuditAPI:
         }
 
     @staticmethod
-    def scan(deps_graph, provider):
+    def scan(deps_graph, provider, context=None):
         """
         Scan a given recipe for vulnerabilities in its dependencies.
         """
         refs = sorted(set(RecipeReference.loads(f"{node.ref.name}/{node.ref.version}")
-                          for node in deps_graph.nodes[1:]), key=lambda ref: ref.name)
+                          for node in deps_graph.nodes[1:]
+                          if context is None or node.context == context),
+                      key=lambda ref: ref.name)
         return provider.get_cves(refs)
 
     @staticmethod

{conan-2.20.1 → conan-2.22.0}/conan/api/subapi/cache.py

@@ -109,14 +109,14 @@ class CacheAPI:
             for f in backup_files:
                 remove(f)
 
-        for ref, ref_bundle in package_list.refs().items():
+        for ref, packages in package_list.items():
             ConanOutput(ref.repr_notime()).verbose("Cleaning recipe cache contents")
             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():
+            for pref in packages:
                 ConanOutput(pref).verbose("Cleaning package cache contents")
                 pref_layout = cache.pkg_layout(pref)
                 if build:
@@ -135,10 +135,11 @@ class CacheAPI:
         compresslevel = global_conf.get("core.gzip:compresslevel", check_type=int)
         tar_files: dict[str, str] = {}  # {path_in_tar: abs_path}
 
-        for ref, ref_bundle in package_list.refs().items():
+        for ref, packages in package_list.items():
             ref_layout = cache.recipe_layout(ref)
             recipe_folder = os.path.relpath(ref_layout.base_folder, cache_folder)
             recipe_folder = recipe_folder.replace("\\", "/")  # make win paths portable
+            ref_bundle = package_list.recipe_dict(ref)
             ref_bundle["recipe_folder"] = recipe_folder
             out.info(f"Saving {ref}: {recipe_folder}")
             # Package only selected folders, not DOWNLOAD one
@@ -152,19 +153,20 @@ class CacheAPI:
             if os.path.exists(path):
                 tar_files[f"{recipe_folder}/{DOWNLOAD_EXPORT_FOLDER}/{METADATA}"] = path
 
-            for pref, pref_bundle in package_list.prefs(ref, ref_bundle).items():
+            for pref in packages:
                 pref_layout = cache.pkg_layout(pref)
                 pkg_folder = pref_layout.package()
                 folder = os.path.relpath(pkg_folder, cache_folder)
                 folder = folder.replace("\\", "/")  # make win paths portable
-                pref_bundle["package_folder"] = folder
+                pkg_dict = package_list.package_dict(pref)
+                pkg_dict["package_folder"] = folder
                 out.info(f"Saving {pref}: {folder}")
                 tar_files[folder] = os.path.join(cache_folder, folder)
 
                 if os.path.exists(pref_layout.metadata()):
                     metadata_folder = os.path.relpath(pref_layout.metadata(), cache_folder)
                     metadata_folder = metadata_folder.replace("\\", "/")  # make paths portable
-                    pref_bundle["metadata_folder"] = metadata_folder
+                    pkg_dict["metadata_folder"] = metadata_folder
                     out.info(f"Saving {pref} metadata: {metadata_folder}")
                     tar_files[metadata_folder] = os.path.join(cache_folder, metadata_folder)
 
@@ -194,7 +196,8 @@ class CacheAPI:
         # After unzipping the files, we need to update the DB that references these files
         out = ConanOutput()
         package_list = PackagesList.deserialize(json.loads(pkglist))
-        for ref, ref_bundle in package_list.refs().items():
+        for ref, packages in package_list.items():
+            ref_bundle = package_list.recipe_dict(ref)
             ref.timestamp = revision_timestamp_now()
             ref_bundle["timestamp"] = ref.timestamp
             try:
@@ -207,8 +210,9 @@ class CacheAPI:
             # In the case of recipes, they are always "in place", so just checking it
             assert rel_path == recipe_folder, f"{rel_path}!={recipe_folder}"
             out.info(f"Restore: {ref} in {recipe_folder}")
-            for pref, pref_bundle in package_list.prefs(ref, ref_bundle).items():
+            for pref in packages:
                 pref.timestamp = revision_timestamp_now()
+                pref_bundle = package_list.package_dict(pref)
                 pref_bundle["timestamp"] = pref.timestamp
                 try:
                     pkg_layout = cache.pkg_layout(pref)
@@ -272,7 +276,7 @@ class CacheAPI:
 def _resolve_latest_ref(cache, ref):
     if ref.revision is None or ref.revision == "latest":
         ref.revision = None
-        result = cache.get_latest_recipe_reference(ref)
+        result = cache.get_latest_recipe_revision(ref)
         if result is None:
             raise ConanException(f"'{ref}' not found in cache")
         ref = result
@@ -283,7 +287,7 @@ 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 = cache.get_latest_package_reference(pref)
+        result = cache.get_latest_package_revision(pref)
         if result is None:
             raise ConanException(f"'{pref.repr_notime()}' not found in cache")
         pref = result

{conan-2.20.1 → conan-2.22.0}/conan/api/subapi/config.py

@@ -42,7 +42,7 @@ class ConfigAPI:
         """
         from conan.internal.api.config.config_installer import configuration_install
         cache_folder = self._conan_api.cache_folder
-        requester = self._conan_api.remotes.requester
+        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)
@@ -103,7 +103,7 @@ class ConfigAPI:
 
         from conan.internal.api.config.config_installer import configuration_install
         cache_folder = self._conan_api.cache_folder
-        requester = self._conan_api.remotes.requester
+        requester = self._helpers.requester
         configuration_install(cache_folder, requester, uri=pkg.conanfile.package_folder,
                               verify_ssl=False, config_type="dir",
                               ignore=["conaninfo.txt", "conanmanifest.txt"])
@@ -150,3 +150,40 @@ class ConfigAPI:
         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.20.1 → conan-2.22.0}/conan/api/subapi/download.py

@@ -37,7 +37,7 @@ class DownloadAPI:
         if ref.timestamp is None:  # we didnt obtain the timestamp before (in general it should be)
             # Respect the timestamp of the server, the ``get_recipe()`` doesn't do it internally
             # Best would be that ``get_recipe()`` returns the timestamp in the same call
-            server_ref = app.remote_manager.get_recipe_revision_reference(ref, remote)
+            server_ref = app.remote_manager.get_recipe_revision(ref, remote)
             assert server_ref == ref
             ref.timestamp = server_ref.timestamp
         app.remote_manager.get_recipe(ref, remote, metadata)
@@ -70,7 +70,7 @@ class DownloadAPI:
 
         if pref.timestamp is None:  # we didn't obtain the timestamp before (in general it should be)
             # Respect the timestamp of the server
-            server_pref = app.remote_manager.get_package_revision_reference(pref, remote)
+            server_pref = app.remote_manager.get_package_revision(pref, remote)
             assert server_pref == pref
             pref.timestamp = server_pref.timestamp
 
@@ -83,15 +83,21 @@ class DownloadAPI:
         """Download the recipes and packages specified in the ``package_list`` from the remote,
         parallelized based on ``core.download:parallel``"""
         def _download_pkglist(pkglist):
-            for ref, recipe_bundle in pkglist.refs().items():
+            for ref, packages in pkglist.items():
                 self.recipe(ref, remote, metadata)
-                for pref, _ in pkglist.prefs(ref, recipe_bundle).items():
+                ref_dict = pkglist.recipe_dict(ref)
+                ref_dict.pop("files", None)
+                ref_dict.pop("upload-urls", None)
+                for pref in packages:
                     self.package(pref, remote, metadata)
+                    pkg_dict = pkglist.package_dict(pref)
+                    pkg_dict.pop("files", None)
+                    pkg_dict.pop("upload-urls", None)
 
         t = time.time()
         parallel = self._conan_api.config.get("core.download:parallel", default=1, check_type=int)
         thread_pool = ThreadPool(parallel) if parallel > 1 else None
-        if not thread_pool or len(package_list.refs()) <= 1:
+        if not thread_pool or len(package_list._data) <= 1:  # FIXME: Iteration when multiple rrevs
             _download_pkglist(package_list)
         else:
             ConanOutput().subtitle(f"Downloading with {parallel} parallel threads")