conan-server 2.0.11__tar.gz → 2.0.12__tar.gz

{conan-server-2.0.11 → conan-server-2.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conan-server
-Version: 2.0.11
+Version: 2.0.12
 Summary: Conan Server of Conan C/C++ package manager
 Home-page: https://conan.io
 Author: JFrog LTD

{conan-server-2.0.11 → conan-server-2.0.12}/conan/cli/commands/build.py

@@ -13,7 +13,7 @@ def build(conan_api, parser, *args):
     """
     Install dependencies and call the build() method.
     """
-    parser.add_argument("path", nargs="?",
+    parser.add_argument("path",
                         help='Path to a python-based recipe file or a folder '
                              'containing a conanfile.py recipe. conanfile.txt '
                              'cannot be used with conan build.')

{conan-server-2.0.11 → conan-server-2.0.12}/conan/cli/commands/export_pkg.py

@@ -7,6 +7,7 @@ from conan.cli.command import conan_command, OnceArgument
 from conan.cli.commands.create import _get_test_conanfile_path
 from conan.cli.formatters.graph import format_graph_json
 from conan.cli.printers.graph import print_graph_basic
+from conans.errors import ConanException
 
 
 @conan_command(group="Creator", formatters={"json": format_graph_json})
@@ -45,11 +46,13 @@ def export_pkg(conan_api, parser, *args):
     profile_host, profile_build = conan_api.profiles.get_profiles_from_args(args)
     remotes = conan_api.remotes.list(args.remote) if not args.no_remote else []
 
+    conanfile = conan_api.local.inspect(path, remotes, lockfile)
+    # The package_type is not fully processed at export
+    if conanfile.package_type == "python-require":
+        raise ConanException("export-pkg can only be used for binaries, not for 'python-require'")
     ref, conanfile = conan_api.export.export(path=path, name=args.name, version=args.version,
                                              user=args.user, channel=args.channel, lockfile=lockfile,
                                              remotes=remotes)
-    # The package_type is not fully processed at export
-    assert conanfile.package_type != "python-require", "A python-require cannot be export-pkg"
     lockfile = conan_api.lockfile.update_lockfile_export(lockfile, conanfile, ref,
                                                          args.build_require)
 

{conan-server-2.0.11 → conan-server-2.0.12}/conan/cli/commands/remove.py

@@ -9,8 +9,8 @@ from conans.errors import ConanException
 
 
 def summary_remove_list(results):
-    """ Do litte format modification to serialized
-    list bundle so it looks prettier on text output
+    """ Do a little format modification to serialized
+    list bundle, so it looks prettier on text output
     """
     cli_out_write("Remove summary:")
     info = results["results"]
@@ -51,6 +51,8 @@ def remove(conan_api: ConanAPI, parser, *args):
     parser.add_argument('-r', '--remote', action=OnceArgument,
                         help='Will remove from the specified remote')
     parser.add_argument("-l", "--list", help="Package list file")
+    parser.add_argument("--dry-run", default=False, action="store_true",
+                        help="Do not remove any items, only print those which would be removed")
     args = parser.parse_args(*args)
 
     if args.pattern is None and args.list is None:
@@ -88,7 +90,8 @@ def remove(conan_api: ConanAPI, parser, *args):
         packages = ref_bundle.get("packages")
         if packages is None:
             if confirmation(f"Remove the recipe and all the packages of '{ref.repr_notime()}'?"):
-                conan_api.remove.recipe(ref, remote=remote)
+                if not args.dry_run:
+                    conan_api.remove.recipe(ref, remote=remote)
             else:
                 ref_dict.pop(ref.revision)
                 if not ref_dict:
@@ -104,7 +107,8 @@ def remove(conan_api: ConanAPI, parser, *args):
 
         for pref, _ in prefs.items():
             if confirmation(f"Remove the package '{pref.repr_notime()}'?"):
-                conan_api.remove.package(pref, remote=remote)
+                if not args.dry_run:
+                    conan_api.remove.package(pref, remote=remote)
             else:
                 pref_dict = packages[pref.package_id]["revisions"]
                 pref_dict.pop(pref.revision)

{conan-server-2.0.11 → conan-server-2.0.12}/conan/tools/build/flags.py

@@ -309,6 +309,10 @@ def _cppstd_clang(clang_version, cppstd):
         v23 = "c++2b"
         vgnu23 = "gnu++2b"
 
+    if clang_version >= "17":
+        v23 = "c++23"
+        vgnu23 = "gnu++23"
+
     flag = {"98": v98, "gnu98": vgnu98,
             "11": v11, "gnu11": vgnu11,
             "14": v14, "gnu14": vgnu14,

{conan-server-2.0.11 → conan-server-2.0.12}/conan/tools/cmake/cmakedeps/templates/config_version.py

@@ -20,7 +20,7 @@ class ConfigVersionTemplate(CMakeDepsFileTemplate):
 
     @property
     def context(self):
-        policy = self.conanfile.cpp_info.get_property("cmake_config_version_compat")
+        policy = self.cmakedeps.get_property("cmake_config_version_compat", self.conanfile)
         if policy is None:
             policy = "SameMajorVersion"
         if policy not in ("AnyNewerVersion", "SameMajorVersion", "SameMinorVersion", "ExactVersion"):

{conan-server-2.0.11 → conan-server-2.0.12}/conan/tools/cmake/cmakedeps/templates/target_configuration.py

@@ -28,7 +28,8 @@ class TargetConfigurationTemplate(CMakeDepsFileTemplate):
                             for components_target_name in components_targets_names]
 
         is_win = self.conanfile.settings.get_safe("os") == "Windows"
-        auto_link = self.conanfile.cpp_info.get_property("cmake_set_interface_link_directories")
+        auto_link = self.cmakedeps.get_property("cmake_set_interface_link_directories",
+                                                self.conanfile)
         return {"pkg_name": self.pkg_name,
                 "root_target_name": self.root_target_name,
                 "config_suffix": self.config_suffix,

{conan-server-2.0.11 → conan-server-2.0.12}/conan/tools/cmake/cmakedeps/templates/target_data.py

@@ -183,7 +183,8 @@ class ConfigDataTemplate(CMakeDepsFileTemplate):
         global_cppinfo = self.conanfile.cpp_info.aggregated_components()
         pfolder_var_name = "{}_PACKAGE_FOLDER{}".format(self.pkg_name, self.config_suffix)
         return _TargetDataContext(global_cppinfo, pfolder_var_name, self._root_folder,
-                                  self.require, self.cmake_package_type, self.is_host_windows)
+                                  self.require, self.cmake_package_type, self.is_host_windows,
+                                  self.conanfile, self.cmakedeps)
 
     @property
     def _root_folder(self):
@@ -199,7 +200,8 @@ class ConfigDataTemplate(CMakeDepsFileTemplate):
         for comp_name, comp in sorted_comps.items():
             deps_cpp_cmake = _TargetDataContext(comp, pfolder_var_name, self._root_folder,
                                                 self.require, self.cmake_package_type,
-                                                self.is_host_windows)
+                                                self.is_host_windows, self.conanfile, self.cmakedeps,
+                                                comp_name)
 
             public_comp_deps = []
             for required_pkg, required_comp in comp.parsed_requires():
@@ -260,7 +262,7 @@ class ConfigDataTemplate(CMakeDepsFileTemplate):
 class _TargetDataContext(object):
 
     def __init__(self, cpp_info, pfolder_var_name, package_folder, require, library_type,
-                 is_host_windows):
+                 is_host_windows, conanfile, cmakedeps, comp_name=None):
 
         def join_paths(paths):
             """
@@ -346,7 +348,8 @@ class _TargetDataContext(object):
         if require and not require.run:
             self.bin_paths = ""
 
-        build_modules = cpp_info.get_property("cmake_build_modules") or []
+        build_modules = cmakedeps.get_property("cmake_build_modules", conanfile) or []
         self.build_modules_paths = join_paths(build_modules)
         # SONAME flag only makes sense for SHARED libraries
-        self.no_soname = str((cpp_info.get_property("nosoname") if self.library_type == "SHARED" else False) or False).upper()
+        nosoname = cmakedeps.get_property("nosoname", conanfile, comp_name)
+        self.no_soname = str((nosoname if self.library_type == "SHARED" else False) or False).upper()

{conan-server-2.0.11 → conan-server-2.0.12}/conan/tools/system/package_manager.py

@@ -62,9 +62,12 @@ class _SystemPackageManagerTool(object):
                 if d in os_name:
                     return tool
 
-    def get_package_name(self, package):
-        # TODO: should we only add the arch if cross-building?
-        if self._arch in self._arch_names and cross_building(self._conanfile):
+    def get_package_name(self, package, host_package=True):        
+        # Only if the package is for building, for example a library,
+        # we should add the host arch when cross building.
+        # If the package is a tool that should be installed on the current build 
+        # machine we should not add the arch.
+        if self._arch in self._arch_names and cross_building(self._conanfile) and host_package:
             return "{}{}{}".format(package, self._arch_separator,
                                    self._arch_names.get(self._arch))
         return package
@@ -149,7 +152,7 @@ class _SystemPackageManagerTool(object):
             self._conanfile.output.warning(str(error))
         raise ConanException("None of the installs for the package substitutes succeeded.")
 
-    def _install(self, packages, update=False, check=True, **kwargs):
+    def _install(self, packages, update=False, check=True, host_package=True, **kwargs):
         pkgs = self._conanfile.system_requires.setdefault(self._active_tool, {})
         install_pkgs = pkgs.setdefault("install", [])
         install_pkgs.extend(p for p in packages if p not in install_pkgs)
@@ -157,7 +160,7 @@ class _SystemPackageManagerTool(object):
             return
 
         if check or self._mode in (self.mode_check, self.mode_report_installed):
-            packages = self.check(packages)
+            packages = self.check(packages, host_package=host_package)
             missing_pkgs = pkgs.setdefault("missing", [])
             missing_pkgs.extend(p for p in packages if p not in missing_pkgs)
 
@@ -178,7 +181,7 @@ class _SystemPackageManagerTool(object):
             if update:
                 self.update()
 
-            packages_arch = [self.get_package_name(package) for package in packages]
+            packages_arch = [self.get_package_name(package, host_package=host_package) for package in packages]
             if packages_arch:
                 command = self.install_command.format(sudo=self.sudo_str,
                                                       tool=self.tool_name,
@@ -196,8 +199,8 @@ class _SystemPackageManagerTool(object):
             command = self.update_command.format(sudo=self.sudo_str, tool=self.tool_name)
             return self._conanfile_run(command, self.accepted_update_codes)
 
-    def _check(self, packages):
-        missing = [pkg for pkg in packages if self.check_package(self.get_package_name(pkg)) != 0]
+    def _check(self, packages, host_package=True):
+        missing = [pkg for pkg in packages if self.check_package(self.get_package_name(pkg, host_package=host_package)) != 0]
         return missing
 
     def check_package(self, package):
@@ -234,7 +237,7 @@ class Apt(_SystemPackageManagerTool):
 
         self._arch_separator = ":"
 
-    def install(self, packages, update=False, check=True, recommends=False):
+    def install(self, packages, update=False, check=True, recommends=False, host_package=True):
         """
         Will try to install the list of packages passed as a parameter. Its
         behaviour is affected by the value of ``tools.system.package_manager:mode``
@@ -243,13 +246,15 @@ class Apt(_SystemPackageManagerTool):
         :param packages: try to install the list of packages passed as a parameter.
         :param update: try to update the package manager database before checking and installing.
         :param check: check if the packages are already installed before installing them.
+        :param host_package: install the packages for the host machine architecture (the machine
+               that will run the software), it has an effect when cross building.
         :param recommends: if the parameter ``recommends`` is ``False`` it will add the
                ``'--no-install-recommends'`` argument to the *apt-get* command call.
         :return: the return code of the executed apt command.
         """
         recommends_str = '' if recommends else '--no-install-recommends '
         return super(Apt, self).install(packages, update=update, check=check,
-                                        recommends=recommends_str)
+                                        host_package=host_package, recommends=recommends_str)
 
 
 class Yum(_SystemPackageManagerTool):

{conan-server-2.0.11 → conan-server-2.0.12}/conan_server.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conan-server
-Version: 2.0.11
+Version: 2.0.12
 Summary: Conan Server of Conan C/C++ package manager
 Home-page: https://conan.io
 Author: JFrog LTD

{conan-server-2.0.11 → conan-server-2.0.12}/conans/__init__.py

@@ -2,4 +2,4 @@ CHECKSUM_DEPLOY = "checksum_deploy"  # Only when v2
 REVISIONS = "revisions"  # Only when enabled in config, not by default look at server_launcher.py
 OAUTH_TOKEN = "oauth_token"
 
-__version__ = '2.0.11'
+__version__ = '2.0.12'

{conan-server-2.0.11 → conan-server-2.0.12}/conans/client/conf/__init__.py

@@ -105,14 +105,14 @@ compiler:
     clang:
         version: ["3.3", "3.4", "3.5", "3.6", "3.7", "3.8", "3.9", "4.0",
                   "5.0", "6.0", "7.0", "7.1",
-                  "8", "9", "10", "11", "12", "13", "14", "15", "16"]
+                  "8", "9", "10", "11", "12", "13", "14", "15", "16", "17"]
         libcxx: [null, libstdc++, libstdc++11, libc++, c++_shared, c++_static]
         cppstd: [null, 98, gnu98, 11, gnu11, 14, gnu14, 17, gnu17, 20, gnu20, 23, gnu23]
         runtime: [null, static, dynamic]
         runtime_type: [null, Debug, Release]
         runtime_version: [null, v140, v141, v142, v143]
     apple-clang:
-        version: ["5.0", "5.1", "6.0", "6.1", "7.0", "7.3", "8.0", "8.1", "9.0", "9.1", "10.0", "11.0", "12.0", "13", "13.0", "13.1", "14", "14.0", "15"]
+        version: ["5.0", "5.1", "6.0", "6.1", "7.0", "7.3", "8.0", "8.1", "9.0", "9.1", "10.0", "11.0", "12.0", "13", "13.0", "13.1", "14", "14.0", "15", "15.0"]
         libcxx: [libstdc++, libc++]
         cppstd: [null, 98, gnu98, 11, gnu11, 14, gnu14, 17, gnu17, 20, gnu20, 23, gnu23]
     intel-cc:

{conan-server-2.0.11 → conan-server-2.0.12}/conans/client/graph/compatibility.py

@@ -90,6 +90,7 @@ class BinaryCompatibility:
         result = OrderedDict()
         original_info = conanfile.info
         original_settings = conanfile.settings
+        original_settings_target = conanfile.settings_target
         original_options = conanfile.options
         for c in compat_infos:
             # we replace the conanfile, so ``validate()`` and ``package_id()`` can
@@ -105,6 +106,7 @@ class BinaryCompatibility:
         # Restore the original state
         conanfile.info = original_info
         conanfile.settings = original_settings
+        conanfile.settings_target = original_settings_target
         conanfile.options = original_options
         return result
 

{conan-server-2.0.11 → conan-server-2.0.12}/conans/client/graph/graph_binaries.py

@@ -104,30 +104,48 @@ class GraphBinariesAnalyzer(object):
         existing = compatibles.pop(original_package_id, None)   # Skip main package_id
         if existing:  # Skip the check if same package_id
             conanfile.output.info(f"Compatible package ID {original_package_id} equal to "
-                                  "the default package ID")
+                                  "the default package ID: Skipping it.")
 
-        if compatibles:
-            conanfile.output.info(f"Checking {len(compatibles)} compatible configurations:")
+        if not compatibles:
+            return
+
+        def _compatible_found(pkg_id, compatible_pkg):
+            diff = conanfile.info.dump_diff(compatible_pkg)
+            conanfile.output.info(f"Main binary package '{original_package_id}' missing. Using "
+                                  f"compatible package '{pkg_id}': {diff}")
+            # So they are available in package_info() method
+            conanfile.info = compatible_pkg  # Redefine current
+            conanfile.settings.update_values(compatible_pkg.settings.values_list)
+            # Trick to allow mutating the options (they were freeze=True)
+            # TODO: Improve this interface
+            conanfile.options = conanfile.options.copy_conaninfo_options()
+            conanfile.options.update_options(compatible_pkg.options)
+
+        conanfile.output.info(f"Checking {len(compatibles)} compatible configurations")
         for package_id, compatible_package in compatibles.items():
-            conanfile.output.info(f"'{package_id}': "
-                                  f"{conanfile.info.dump_diff(compatible_package)}")
+            if update:
+                conanfile.output.info(f"'{package_id}': "
+                                      f"{conanfile.info.dump_diff(compatible_package)}")
             node._package_id = package_id  # Modifying package id under the hood, FIXME
             node.binary = None  # Invalidate it
-            self._process_compatible_node(node, remotes, update)
-            if node.binary in (BINARY_CACHE, BINARY_DOWNLOAD, BINARY_UPDATE):
-                conanfile.output.info("Main binary package '%s' missing. Using "
-                                      "compatible package '%s'" % (original_package_id, package_id))
-                # So they are available in package_info() method
-                conanfile.info = compatible_package  # Redefine current
-                conanfile.settings.update_values(compatible_package.settings.values_list)
-                # Trick to allow mutating the options (they were freeze=True)
-                # TODO: Improve this interface
-                conanfile.options = conanfile.options.copy_conaninfo_options()
-                conanfile.options.update_options(compatible_package.options)
-                break
-        else:  # If no compatible is found, restore original state
-            node.binary = original_binary
-            node._package_id = original_package_id
+            self._process_compatible_node(node, remotes, update)  # TODO: what if BINARY_BUILD
+            if node.binary in (BINARY_CACHE, BINARY_UPDATE, BINARY_DOWNLOAD):
+                _compatible_found(package_id, compatible_package)
+                return
+        if not update:
+            conanfile.output.info(f"Compatible configurations not found in cache, checking servers")
+            for package_id, compatible_package in compatibles.items():
+                conanfile.output.info(f"'{package_id}': "
+                                      f"{conanfile.info.dump_diff(compatible_package)}")
+                node._package_id = package_id  # Modifying package id under the hood, FIXME
+                node.binary = None  # Invalidate it
+                self._evaluate_download(node, remotes, update)
+                if node.binary == BINARY_DOWNLOAD:
+                    _compatible_found(package_id, compatible_package)
+                    return
+        # If no compatible is found, restore original state
+        node.binary = original_binary
+        node._package_id = original_package_id
 
     def _evaluate_node(self, node, build_mode, remotes, update):
         assert node.binary is None, "Node.binary should be None"
@@ -225,10 +243,11 @@ class GraphBinariesAnalyzer(object):
             if not self._evaluate_clean_pkg_folder_dirty(node, package_layout):
                 break
 
-        if cache_latest_prev is None:  # This binary does NOT exist in the cache
-            self._evaluate_download(node, remotes, update)
-        else:  # This binary already exists in the cache, maybe can be updated
+        if cache_latest_prev is not None:
+            # This binary already exists in the cache, maybe can be updated
             self._evaluate_in_cache(cache_latest_prev, node, remotes, update)
+        elif update:
+            self._evaluate_download(node, remotes, update)
 
     def _process_locked_node(self, node, build_mode, locked_prev):
         # Check that this same reference hasn't already been checked

{conan-server-2.0.11 → conan-server-2.0.12}/conans/client/rest/conan_requester.py

@@ -81,6 +81,8 @@ class ConanRequester(object):
             adapter = HTTPAdapter(max_retries=self._get_retries(config))
             self._http_requester.mount("http://", adapter)
             self._http_requester.mount("https://", adapter)
+        else:
+            self._http_requester = requests
 
         self._url_creds = URLCredentials(cache_folder)
         self._timeout = config.get("core.net.http:timeout", default=DEFAULT_TIMEOUT)
@@ -171,7 +173,7 @@ class ConanRequester(object):
                 popped = True if os.environ.pop(var_name.upper(), None) else popped
         try:
             all_kwargs = self._add_kwargs(url, kwargs)
-            tmp = getattr(requests, method)(url, **all_kwargs)
+            tmp = getattr(self._http_requester, method)(url, **all_kwargs)
             return tmp
         finally:
             if popped:

{conan-server-2.0.11 → conan-server-2.0.12}/conans/model/build_info.py

@@ -459,7 +459,8 @@ class CppInfo:
         self._package.sysroot = self._package.sysroot or other._package.sysroot
         # COMPONENTS
         for cname, c in other.components.items():
-            self.components[cname].merge(c, overwrite)
+            # Make sure each component created on the fly does not bring new defaults
+            self.components.setdefault(cname, _Component(set_defaults=False)).merge(c, overwrite)
 
     def set_relative_base_folder(self, folder):
         """Prepend the folder to all the directories definitions, that are relative"""

{conan-server-2.0.11 → conan-server-2.0.12}/conans/test/utils/tools.py

@@ -417,7 +417,8 @@ class TestClient(object):
         self.out = ""
         self.stdout = RedirectedTestOutput()
         self.stderr = RedirectedTestOutput()
-        self.user_inputs = RedirectedInputStream(inputs)
+        self.user_inputs = RedirectedInputStream([])
+        self.inputs = inputs or []
 
         # create default profile
         text = default_profiles[platform.system()]
@@ -513,13 +514,14 @@ class TestClient(object):
         self._handle_cli_result(command_line, assert_error=assert_error, error=error, trace=trace)
         return error
 
-    def run(self, command_line, assert_error=False, redirect_stdout=None, redirect_stderr=None):
+    def run(self, command_line, assert_error=False, redirect_stdout=None, redirect_stderr=None, inputs=None):
         """ run a single command as in the command line.
             If user or password is filled, user_io will be mocked to return this
             tuple if required
         """
         from conans.test.utils.mocks import RedirectedTestOutput
         with environment_update({"NO_COLOR": "1"}):  # Not initialize colorama in testing
+            self.user_inputs = RedirectedInputStream(inputs or self.inputs)
             self.stdout = RedirectedTestOutput()  # Initialize each command
             self.stderr = RedirectedTestOutput()
             self.out = ""