merged develop2

Author: memsharded

.github/workflows/osx-tests.yml

@@ -20,13 +20,6 @@ jobs:
         with:
           python-version: '3.10'
 
-      - name: Cache pip packages
-        id: cache-pip
-        uses: actions/cache@v4
-        with:
-          path: ~/.cache/pip
-          key: ${{ runner.os }}-pip-${{ hashFiles('conans/requirements*.txt') }}
-
       - name: Install Python requirements
         run: |
           pip install --upgrade pip
@@ -133,12 +126,6 @@ jobs:
       - name: Checkout code
         uses: actions/checkout@v4
 
-      - name: Restore pip cache
-        uses: actions/cache@v4
-        with:
-          path: ~/.cache/pip
-          key: ${{ runner.os }}-pip-${{ hashFiles('conans/requirements*.txt') }}
-
       - name: Restore tools cache
         uses: actions/cache@v4
         with:

conan/api/conan_api.py

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

conan/api/input.py

@@ -78,7 +78,7 @@ def request_boolean(self, msg, default_option=None):
         """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/api/output.py

@@ -124,6 +124,14 @@ def define_silence_warnings(cls, warnings):
     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 @@ def define_log_level(cls, v):
             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 @@ def verbose(self, msg: str, fg: str = None, bg: str = None):
             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/api/subapi/audit.py

@@ -68,9 +68,9 @@ def get_provider(self, provider_name):
             )
 
             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]
@@ -82,9 +82,11 @@ def get_provider(self, provider_name):
             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"])
 
@@ -142,7 +144,8 @@ def auth_provider(self, provider, token):
         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/api/subapi/cache.py

@@ -8,8 +8,9 @@
 from conan.api.output import ConanOutput
 from conan.internal.api.uploader import compress_files
 from conan.internal.cache.cache import PkgCache
-from conan.internal.cache.conan_reference_layout import EXPORT_SRC_FOLDER, EXPORT_FOLDER, SRC_FOLDER, \
-    METADATA, DOWNLOAD_EXPORT_FOLDER
+from conan.internal.cache.conan_reference_layout import (EXPORT_SRC_FOLDER, EXPORT_FOLDER,
+                                                         SRC_FOLDER, METADATA,
+                                                         DOWNLOAD_EXPORT_FOLDER)
 from conan.internal.cache.home_paths import HomePaths
 from conan.internal.cache.integrity_check import IntegrityChecker
 from conan.internal.rest.download_cache import DownloadCache
@@ -104,7 +105,8 @@ def clean(self, package_list, source=True, build=True, download=True, temp=True,
                     if not os.path.exists(manifest) or not os.path.exists(info):
                         rmdir(folder)
         if backup_sources:
-            backup_files = self._conan_api.cache.get_backup_sources(package_list, exclude=False, only_upload=False)
+            backup_files = self._conan_api.cache.get_backup_sources(package_list, exclude=False,
+                                                                    only_upload=False)
             ConanOutput().verbose(f"Cleaning {len(backup_files)} backup sources")
             for f in backup_files:
                 remove(f)
@@ -175,7 +177,8 @@ def save(self, package_list, tgz_path, no_source=False):
         pkglist_path = os.path.join(tempfile.gettempdir(), "pkglist.json")
         save(pkglist_path, serialized)
         tar_files["pkglist.json"] = pkglist_path
-        compress_files(tar_files, os.path.basename(tgz_path), os.path.dirname(tgz_path), compresslevel, recursive=True)
+        compress_files(tar_files, os.path.basename(tgz_path), os.path.dirname(tgz_path),
+                       compresslevel, recursive=True)
         remove(pkglist_path)
 
     def restore(self, path):
@@ -260,7 +263,8 @@ def get_backup_sources(self, package_list=None, exclude=True, only_upload=True):
         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/api/subapi/graph.py

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

conan/api/subapi/install.py

@@ -60,7 +60,8 @@ def install_sources(self, graph, remotes):
 
     # TODO: Look for a better name
     def install_consumer(self, deps_graph, generators=None, source_folder=None, output_folder=None,
-                         deploy=False, deploy_package=None, deploy_folder=None, envs_generation=None):
+                         deploy=False, deploy_package=None, deploy_folder=None,
+                         envs_generation=None):
         """ Once a dependency graph has been installed, there are things to be done, like invoking
         generators for the root consumer.
         This is necessary for example for conanfile.txt/py, or for "conan install <ref> -g
@@ -101,5 +102,5 @@ def install_consumer(self, deps_graph, generators=None, source_folder=None, outp
                          envs_generation=envs_generation)
 
     def deploy(self, graph, deployer, deploy_package=None, deploy_folder=None):
-        return do_deploys(self._conan_api.home_folder, graph, deployer, deploy_package=deploy_package,
-                          deploy_folder=deploy_folder)
+        return do_deploys(self._conan_api.home_folder, graph, deployer,
+                          deploy_package=deploy_package, deploy_folder=deploy_folder)

conan/api/subapi/remotes.py

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

conan/api/subapi/report.py

@@ -78,6 +78,7 @@ def _source(path_to_conanfile, reference):
             "dst_prefix": dst_prefix,
         }
 
+
 def _configure_source(conan_api, hook_manager, conanfile_path, ref, remotes):
     app = ConanApp(conan_api)
     conanfile = app.loader.load_consumer(conanfile_path, name=ref.name, version=str(ref.version),
@@ -100,6 +101,7 @@ def _configure_source(conan_api, hook_manager, conanfile_path, ref, remotes):
     conanfile.folders.set_base_recipe_metadata(recipe_layout.metadata())
     config_source(export_source_folder, conanfile, hook_manager)
 
+
 def _get_ref_from_cache_or_remote(conan_api, reference, enabled_remotes):
     ref = RecipeReference.loads(reference)
     full_ref, matching_remote = None, False