conan-server 2.4.1__tar.gz → 2.5.0__tar.gz

{conan-server-2.4.1/conan_server.egg-info → conan-server-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conan-server
-Version: 2.4.1
+Version: 2.5.0
 Summary: Conan Server of Conan C/C++ package manager
 Home-page: https://conan.io
 Author: JFrog LTD
@@ -136,7 +136,7 @@ Description: <picture>
         To run specific tests, you can specify the test name too, something like:
         
         ```bash
-        $ python -m pytest conans/test/functional/command/export_test.py::TestRevisionModeSCM::test_revision_mode_scm -s
+        $ python -m pytest test/functional/command/export_test.py::TestRevisionModeSCM::test_revision_mode_scm -s
         ```
         
         The `-s` argument can be useful to see some output that otherwise is captured by *pytest*.

{conan-server-2.4.1 → conan-server-2.5.0}/README.md

@@ -128,7 +128,7 @@ OK
 To run specific tests, you can specify the test name too, something like:
 
 ```bash
-$ python -m pytest conans/test/functional/command/export_test.py::TestRevisionModeSCM::test_revision_mode_scm -s
+$ python -m pytest test/functional/command/export_test.py::TestRevisionModeSCM::test_revision_mode_scm -s
 ```
 
 The `-s` argument can be useful to see some output that otherwise is captured by *pytest*.

{conan-server-2.4.1 → conan-server-2.5.0}/conan/api/conan_api.py

@@ -22,7 +22,7 @@ from conans.client.migrations import ClientMigrator
 from conans.client.userio import init_colorama
 from conans.errors import ConanException
 from conans.model.version import Version
-from conans.paths import get_conan_user_home
+from conan.internal.paths import get_conan_user_home
 
 
 class ConanAPI(object):

{conan-server-2.4.1 → conan-server-2.5.0}/conan/api/subapi/install.py

@@ -1,3 +1,5 @@
+import os
+
 from conan.internal.conan_app import ConanApp
 from conan.internal.deploy import do_deploys
 from conans.client.generators import write_generators
@@ -70,7 +72,9 @@ class InstallAPI:
 
         # The previous .set_base_folders has already decided between the source_folder and output
         if deploy or deploy_package:
-            base_folder = deploy_folder or conanfile.folders.base_build
+            # Issue related: https://github.com/conan-io/conan/issues/16543
+            base_folder = os.path.abspath(deploy_folder) if deploy_folder \
+                else conanfile.folders.base_build
             do_deploys(self.conan_api, deps_graph, deploy, deploy_package, base_folder)
 
         final_generators = []

{conan-server-2.4.1 → conan-server-2.5.0}/conan/api/subapi/list.py

@@ -104,7 +104,9 @@ class ListAPI:
             options = data.get("options", {})
             for k, v in options.items():
                 for pattern, pattern_options in profile_options.items():
-                    if ref_matches(ref, pattern, None):
+                    # Accept &: as referring to the current package being listed,
+                    # even if it's not technically a "consumer"
+                    if ref_matches(ref, pattern, True):
                         value = pattern_options.get_safe(k)
                         if value is not None and value != v:
                             options_match = False

{conan-server-2.4.1 → conan-server-2.5.0}/conan/api/subapi/lockfile.py

@@ -64,11 +64,13 @@ class LockfileAPI:
         else:
             python_requires = []
         python_requires = python_requires + ([ref] if is_python_require else [])
-        lockfile = self.add_lockfile(lockfile,
+        new_lock = self.add_lockfile(lockfile,
                                      requires=[ref] if is_require else None,
                                      python_requires=python_requires,
                                      build_requires=[ref] if is_build_require else None)
-        return lockfile
+        if lockfile is None:  # If there was no lockfile, it is a partial one to lock export
+            new_lock.partial = True
+        return new_lock
 
     @staticmethod
     def update_lockfile(lockfile, graph, lock_packages=False, clean=False):
@@ -83,7 +85,6 @@ class LockfileAPI:
                      config_requires=None):
         if lockfile is None:
             lockfile = Lockfile()  # create a new lockfile
-            lockfile.partial = True
 
         lockfile.add(requires=requires, build_requires=build_requires,
                      python_requires=python_requires, config_requires=config_requires)

{conan-server-2.4.1 → conan-server-2.5.0}/conan/api/subapi/upload.py

@@ -114,23 +114,29 @@ class UploadAPI:
 
         app = ConanApp(self.conan_api)
         # TODO: verify might need a config to force it to False
-        uploader = FileUploader(app.requester, verify=True, config=config)
+        uploader = FileUploader(app.requester, verify=True, config=config, source_credentials=True)
         # TODO: For Artifactory, we can list all files once and check from there instead
         #  of 1 request per file, but this is more general
         for file in files:
             basename = os.path.basename(file)
             full_url = url + basename
+            is_summary = file.endswith(".json")
+            file_kind = "summary" if is_summary else "file"
             try:
-                # Always upload summary .json but only upload blob if it does not already exist
-                if file.endswith(".json") or not uploader.exists(full_url, auth=None):
-                    output.info(f"Uploading file '{basename}' to backup sources server")
+                if is_summary or not uploader.exists(full_url, auth=None):
+                    output.info(f"Uploading {file_kind} '{basename}' to backup sources server")
                     uploader.upload(full_url, file, dedup=False, auth=None)
                 else:
                     output.info(f"File '{basename}' already in backup sources server, "
                                 "skipping upload")
             except (AuthenticationException, ForbiddenException) as e:
-                raise ConanException(f"The source backup server '{url}' needs authentication"
-                                     f"/permissions, please provide 'source_credentials.json': {e}")
+                if is_summary:
+                    output.warning(f"Could not update summary '{basename}' in backup sources server. "
+                                   "Skipping updating file but continuing with upload. "
+                                   f"Missing permissions?: {e}")
+                else:
+                    raise ConanException(f"The source backup server '{url}' needs authentication"
+                                         f"/permissions, please provide 'source_credentials.json': {e}")
 
         output.success("Upload backup sources complete\n")
         return files

{conan-server-2.4.1 → conan-server-2.5.0}/conan/cli/commands/build.py

@@ -23,7 +23,8 @@ def build(conan_api, parser, *args):
     parser.add_argument("-of", "--output-folder",
                         help='The root output folder for generated and build files')
     parser.add_argument("-d", "--deployer", action="append",
-                        help='Deploy using the provided deployer to the output folder')
+                        help="Deploy using the provided deployer to the output folder. "
+                             "Built-in deployers: 'full_deploy', 'direct_deploy', 'runtime_deploy'")
     parser.add_argument("--deployer-folder",
                         help="Deployer output folder, base build folder by default if not set")
     parser.add_argument("--build-require", action='store_true', default=False,

{conan-server-2.4.1 → conan-server-2.5.0}/conan/cli/commands/graph.py

@@ -175,7 +175,10 @@ def graph_info(conan_api, parser, subparser, *args):
     subparser.add_argument("--package-filter", action="append",
                            help='Print information only for packages that match the patterns')
     subparser.add_argument("-d", "--deployer", action="append",
-                           help='Deploy using the provided deployer to the output folder')
+                           help="Deploy using the provided deployer to the output folder. "
+                                "Built-in deployers: 'full_deploy', 'direct_deploy'. Deployers "
+                                "will only deploy recipes, as 'conan graph info' do not retrieve "
+                                "binaries")
     subparser.add_argument("-df", "--deployer-folder",
                            help="Deployer output folder, base build folder by default if not set")
     subparser.add_argument("--build-require", action='store_true', default=False,

{conan-server-2.4.1 → conan-server-2.5.0}/conan/cli/commands/install.py

@@ -30,7 +30,8 @@ def install(conan_api, parser, *args):
     parser.add_argument("-of", "--output-folder",
                         help='The root output folder for generated and build files')
     parser.add_argument("-d", "--deployer", action="append",
-                        help='Deploy using the provided deployer to the output folder')
+                        help="Deploy using the provided deployer to the output folder. "
+                             "Built-in deployers: 'full_deploy', 'direct_deploy', 'runtime_deploy'")
     parser.add_argument("--deployer-folder",
                         help="Deployer output folder, base build folder by default if not set")
     parser.add_argument("--deployer-package", action="append",

{conan-server-2.4.1 → conan-server-2.5.0}/conan/cli/commands/list.py

@@ -184,8 +184,9 @@ def prepare_pkglist_compact(pkglist):
             pkg_common_options = compute_common_options(prefs)
             pkg_common_options = pkg_common_options if len(pkg_common_options) > 4 else None
             for pref, pref_contents in prefs.items():
-                pref_info = pref_contents.pop("info")
-                pref_contents.update(compact_format_info(pref_info, pkg_common_options))
+                pref_info = pref_contents.pop("info", None)
+                if pref_info is not None:
+                    pref_contents.update(compact_format_info(pref_info, pkg_common_options))
                 diff_info = pref_contents.pop("diff", None)
                 if diff_info is not None:
                     pref_contents["diff"] = compact_diff(diff_info)

{conan-server-2.4.1 → conan-server-2.5.0}/conan/cli/commands/lock.py

@@ -11,7 +11,7 @@ from conans.model.recipe_ref import RecipeReference
 
 
 @conan_command(group="Consumer")
-def lock(conan_api, parser, *args):
+def lock(conan_api, parser, *args):  # noqa
     """
     Create or manage lockfiles.
     """
@@ -63,7 +63,7 @@ def lock_create(conan_api, parser, subparser, *args):
 
 
 @conan_subcommand()
-def lock_merge(conan_api, parser, subparser, *args):
+def lock_merge(conan_api, parser, subparser, *args): # noqa
     """
     Merge 2 or more lockfiles.
     """
@@ -132,7 +132,7 @@ def lock_add(conan_api, parser, subparser, *args):
 @conan_subcommand()
 def lock_remove(conan_api, parser, subparser, *args):
     """
-    Remove requires, build-requires or python-requires from an existing or new lockfile.
+    Remove requires, build-requires or python-requires from an existing lockfile.
     References can be supplied with and without revisions like "--requires=pkg/version",
     """
     subparser.add_argument('--requires', action="append", help='Remove references to lockfile.')
@@ -154,3 +154,28 @@ def lock_remove(conan_api, parser, subparser, *args):
                                                   build_requires=args.build_requires,
                                                   config_requires=args.config_requires)
     conan_api.lockfile.save_lockfile(lockfile, args.lockfile_out)
+
+
+@conan_subcommand()
+def lock_update(conan_api, parser, subparser, *args):
+    """
+    Update requires, build-requires or python-requires from an existing lockfile.
+    References that matches the arguments package names will be replaced by the arguments.
+    References can be supplied with and without revisions like "--requires=pkg/version",
+    """
+    subparser.add_argument('--requires', action="append", help='Update references to lockfile.')
+    subparser.add_argument('--build-requires', action="append",
+                           help='Update build-requires from lockfile')
+    subparser.add_argument('--python-requires', action="append",
+                           help='Update python-requires from lockfile')
+    subparser.add_argument('--config-requires', action="append",
+                           help='Update config-requires from lockfile')
+    subparser.add_argument("--lockfile-out", action=OnceArgument, default=LOCKFILE,
+                           help="Filename of the created lockfile")
+    subparser.add_argument("--lockfile", action=OnceArgument, help="Filename of the input lockfile")
+    args = parser.parse_args(*args)
+
+    lockfile = conan_api.lockfile.get_lockfile(lockfile=args.lockfile, partial=True)
+    lockfile.update(requires=args.requires, build_requires=args.build_requires,
+                    python_requires=args.python_requires, config_requires=args.config_requires)
+    conan_api.lockfile.save_lockfile(lockfile, args.lockfile_out)

{conan-server-2.4.1 → conan-server-2.5.0}/conan/cli/printers/graph.py

@@ -1,5 +1,5 @@
 from conan.api.output import ConanOutput, Color, LEVEL_VERBOSE
-from conans.client.graph.graph import RECIPE_CONSUMER, RECIPE_VIRTUAL, CONTEXT_BUILD, BINARY_SKIP,\
+from conans.client.graph.graph import BINARY_INVALID, BINARY_MISSING, RECIPE_CONSUMER, RECIPE_VIRTUAL, CONTEXT_BUILD, BINARY_SKIP,\
     BINARY_PLATFORM
 
 
@@ -122,13 +122,18 @@ def print_graph_packages(graph):
         output.info(title, Color.BRIGHT_YELLOW)
         for pref, (status, remote) in sorted(reqs_to_print.items(), key=repr):
             name = pref.repr_notime() if status != BINARY_PLATFORM else str(pref.ref)
-            msg = f"{tab}{name} - {status}"
-            if remote is not None and status != BINARY_SKIP:
-                msg += f" ({remote.name})"
+            msg = f"{tab}{name} - "
             if status == BINARY_SKIP:
                 skipped_requires.append(str(pref.ref))
-                output.verbose(msg, Color.BRIGHT_CYAN)
+                output.verbose(f"{msg}{status}", Color.BRIGHT_CYAN)
+            elif status == BINARY_MISSING or status == BINARY_INVALID:
+                output.write(msg, Color.BRIGHT_CYAN)
+                output.writeln(status, Color.BRIGHT_RED)
             else:
+                # Support python36
+                msg += status
+                if remote:
+                    msg += f" ({remote.name})"
                 output.info(msg, Color.BRIGHT_CYAN)
 
     _format_requires("Requirements", requires)

{conan-server-2.4.1 → conan-server-2.5.0}/conan/internal/api/detect_api.py

@@ -384,14 +384,9 @@ def detect_default_compiler():
         return None, None, None
 
     if platform.system() == "Windows":
-        ide_version = _detect_vs_ide_version()
-        version = {"17": "193", "16": "192", "15": "191"}.get(str(ide_version))  # Map to compiler
-        if ide_version == "17":
-            update = detect_msvc_update(version)  # FIXME weird passing here the 193 compiler version
-            if update and int(update) >= 10:
-                version = "194"
-        if version:
-            return 'msvc', Version(version), None
+        compiler, version, compiler_exe = detect_msvc_compiler()
+        if compiler:
+            return compiler, version, compiler_exe
 
     if platform.system() == "SunOS":
         sun_cc, sun_cc_version, compiler_exe = detect_suncc_compiler()
@@ -533,8 +528,12 @@ def detect_clang_compiler(compiler_exe="clang"):
 
 
 def detect_msvc_compiler():
-    version = _detect_vs_ide_version()
-    version = {"17": "193", "16": "192", "15": "191"}.get(str(version))  # Map to compiler
+    ide_version = _detect_vs_ide_version()
+    version = {"17": "193", "16": "192", "15": "191"}.get(str(ide_version))  # Map to compiler
+    if ide_version == "17":
+        update = detect_msvc_update(version)  # FIXME weird passing here the 193 compiler version
+        if update and int(update) >= 10:
+            version = "194"
     if version:
         return 'msvc', Version(version), None
     return None, None, None

{conan-server-2.4.1 → conan-server-2.5.0}/conan/internal/api/new/qbs_lib.py

@@ -19,14 +19,13 @@ class {{package_name}}Recipe(ConanFile):
 
     def build(self):
         qbs = Qbs(self)
-        qbs.profile = ""
         qbs_config = {"products.{{name}}.isShared": "true" if self.options.shared else "false"}
         qbs.add_configuration("default", qbs_config)
+        qbs.resolve()
         qbs.build()
 
     def package(self):
         qbs = Qbs(self)
-        qbs.profile = ""
         qbs.install()
 
     def package_info(self):
@@ -69,7 +68,7 @@ class {{package_name}}TestConan(ConanFile):
 
     def build(self):
         qbs = Qbs(self)
-        qbs.profile = ""
+        qbs.resolve()
         qbs.build()
         qbs.install()
 

{conan-server-2.4.1 → conan-server-2.5.0}/conan/internal/cache/conan_reference_layout.py

@@ -2,7 +2,7 @@ import os
 from contextlib import contextmanager
 
 from conans.model.manifest import FileTreeManifest
-from conans.paths import CONANFILE, DATA_YML
+from conan.internal.paths import CONANFILE, DATA_YML
 from conans.util.files import set_dirty, clean_dirty, is_dirty, rmdir
 
 

{conan-server-2.4.1 → conan-server-2.5.0}/conan/internal/deploy.py

@@ -1,3 +1,4 @@
+import filecmp
 import os
 import shutil
 
@@ -31,7 +32,8 @@ def _find_deployer(d, cache_deploy_folder):
     if os.path.isfile(cache_path):
         return _load(cache_path)
     builtin_deploy = {"full_deploy.py": full_deploy,
-                      "direct_deploy.py": direct_deploy}.get(d)
+                      "direct_deploy.py": direct_deploy,
+                      "runtime_deploy.py": runtime_deploy}.get(d)
     if builtin_deploy is not None:
         return builtin_deploy
     raise ConanException(f"Cannot find deployer '{d}'")
@@ -87,6 +89,75 @@ def full_deploy(graph, output_folder):
         _deploy_single(dep, conanfile, output_folder, folder_name)
 
 
+def runtime_deploy(graph, output_folder):
+    """
+    Deploy all the shared libraries and the executables of the dependencies in a flat directory.
+    """
+    conanfile = graph.root.conanfile
+    output = ConanOutput(scope="runtime_deploy")
+    output.info(f"Deploying dependencies runtime to folder: {output_folder}")
+    output.warning("This deployer is experimental and subject to change. "
+                   "Please give feedback at https://github.com/conan-io/conan/issues")
+    mkdir(output_folder)
+    symlinks = conanfile.conf.get("tools.deployer:symlinks", check_type=bool, default=True)
+    for _, dep in conanfile.dependencies.host.items():
+        if dep.package_folder is None:
+            output.warning(f"{dep.ref} does not have any package folder, skipping binary")
+            continue
+        count = 0
+        cpp_info = dep.cpp_info.aggregated_components()
+        for bindir in cpp_info.bindirs:
+            if not os.path.isdir(bindir):
+                output.warning(f"{dep.ref} {bindir} does not exist")
+                continue
+            count += _flatten_directory(dep, bindir, output_folder, symlinks)
+
+        for libdir in cpp_info.libdirs:
+            if not os.path.isdir(libdir):
+                output.warning(f"{dep.ref} {libdir} does not exist")
+                continue
+            count += _flatten_directory(dep, libdir, output_folder, symlinks, [".dylib", ".so"])
+
+        output.info(f"Copied {count} files from {dep.ref}")
+    conanfile.output.success(f"Runtime deployed to folder: {output_folder}")
+
+
+def _flatten_directory(dep, src_dir, output_dir, symlinks, extension_filter=None):
+    """
+    Copy all the files from the source directory in a flat output directory.
+    An optional string, named extension_filter, can be set to copy only the files with
+    the listed extensions.
+    """
+    file_count = 0
+
+    output = ConanOutput(scope="runtime_deploy")
+    for src_dirpath, _, src_filenames in os.walk(src_dir, followlinks=symlinks):
+        for src_filename in src_filenames:
+            if extension_filter and not any(src_filename.endswith(ext) for ext in extension_filter):
+                continue
+
+            src_filepath = os.path.join(src_dirpath, src_filename)
+            dest_filepath = os.path.join(output_dir, src_filename)
+            if os.path.exists(dest_filepath):
+                if filecmp.cmp(src_filepath, dest_filepath):  # Be efficient, do not copy
+                    output.verbose(f"{dest_filepath} exists with same contents, skipping copy")
+                    continue
+                else:
+                    output.warning(f"{dest_filepath} exists and will be overwritten")
+
+            try:
+                file_count += 1
+                shutil.copy2(src_filepath, dest_filepath, follow_symlinks=symlinks)
+                output.verbose(f"Copied {src_filepath} into {output_dir}")
+            except Exception as e:
+                if "WinError 1314" in str(e):
+                    ConanOutput().error("runtime_deploy: Windows symlinks require admin privileges "
+                                        "or 'Developer mode = ON'", error_type="exception")
+                raise ConanException(f"runtime_deploy: Copy of '{dep}' files failed: {e}.\nYou can "
+                                     f"use 'tools.deployer:symlinks' conf to disable symlinks")
+    return file_count
+
+
 def _deploy_single(dep, conanfile, output_folder, folder_name):
     new_folder = os.path.join(output_folder, folder_name)
     rmdir(new_folder)

conan-server-2.4.1/conans/paths/__init__.py → conan-server-2.5.0/conan/internal/paths.py

@@ -17,12 +17,13 @@ def get_conan_user_home():
 
     def _find_conanrc_file():
         path = Path(os.getcwd())
-        while path.is_dir() and len(path.parts) > 1:  # finish at '/'
+        while True:
             conanrc_file = path / ".conanrc"
             if conanrc_file.is_file():
                 return conanrc_file
-            else:
-                path = path.parent
+            if len(path.parts) == 1:  # finish at '/'
+                break
+            path = path.parent
 
     def _user_home_from_conanrc_file():
         try:
@@ -49,8 +50,8 @@ def get_conan_user_home():
         user_home = conan_expand_user(user_home)
     if not os.path.isabs(user_home):
         raise ConanException("Invalid CONAN_HOME value '%s', "
-                        "please specify an absolute or path starting with ~/ "
-                        "(relative to user home)" % user_home)
+                             "please specify an absolute or path starting with ~/ "
+                             "(relative to user home)" % user_home)
     return user_home
 
 

{conan-server-2.4.1 → conan-server-2.5.0}/conan/internal/runner/docker.py

@@ -64,13 +64,26 @@ class DockerRunner:
         import docker
         import docker.api.build
         try:
-            self.docker_client = docker.from_env()
-            self.docker_api = docker.APIClient()
+            docker_base_urls = [
+                None, # Default docker configuration, let the python library detect the socket
+                os.environ.get('DOCKER_HOST'), # Connect to socket defined in DOCKER_HOST
+                'unix:///var/run/docker.sock', # Default linux socket
+                f'unix://{os.path.expanduser("~")}/.rd/docker.sock' # Rancher linux socket
+            ]
+            for base_url in docker_base_urls:
+                try:
+                    ConanOutput().verbose(f'Trying to connect to docker "{base_url or "default"}" socket')
+                    self.docker_client = docker.DockerClient(base_url=base_url, version='auto')
+                    ConanOutput().verbose(f'Connected to docker "{base_url or "default"}" socket')
+                    break
+                except:
+                    continue
+            self.docker_api = self.docker_client.api
             docker.api.build.process_dockerfile = lambda dockerfile, path: ('Dockerfile', dockerfile)
         except:
             raise ConanException("Docker Client failed to initialize."
                                  "\n - Check if docker is installed and running"
-                                 "\n - Run 'pip install pip install conan[runners]'")
+                                 "\n - Run 'pip install conan[runners]'")
         self.conan_api = conan_api
         self.build_profile = build_profile
         self.args = args
@@ -243,6 +256,7 @@ class DockerRunner:
             raise ConanException( f'conan version inside the container must be greater than {min_conan_version}')
         if self.cache != 'shared':
             self.run_command('mkdir -p ${HOME}/.conan2/profiles', log=False)
+            self.run_command('cp -r "'+self.abs_docker_path+'/.conanrunner/profiles/." ${HOME}/.conan2/profiles/.', log=False)
             for file_name in ['global.conf', 'settings.yml', 'remotes.json']:
                 if os.path.exists( os.path.join(self.abs_runner_home_path, file_name)):
                     self.run_command('cp "'+self.abs_docker_path+'/.conanrunner/'+file_name+'" ${HOME}/.conan2/'+file_name, log=False)

{conan-server-2.4.1 → conan-server-2.5.0}/conan/test/utils/test_files.py

@@ -11,7 +11,7 @@ from io import BytesIO
 from conan.tools.files.files import untargz
 from conans.client.subsystems import get_cased_path
 from conans.errors import ConanException
-from conans.paths import PACKAGE_TGZ_NAME
+from conan.internal.paths import PACKAGE_TGZ_NAME
 from conans.util.files import gzopen_without_timestamps
 
 

{conan-server-2.4.1 → conan-server-2.5.0}/conan/test/utils/tools.py

@@ -244,6 +244,7 @@ class TestRequester:
             kwargs["expect_errors"] = True
             kwargs.pop("stream", None)
             kwargs.pop("verify", None)
+            kwargs.pop("source_credentials", None)
             auth = kwargs.pop("auth", None)
             if auth and isinstance(auth, tuple):
                 app.set_authorization(("Basic", auth))

{conan-server-2.4.1 → conan-server-2.5.0}/conan/tools/apple/xcodetoolchain.py

@@ -109,7 +109,7 @@ class XcodeToolchain(object):
 
     @property
     def _check_if_extra_flags(self):
-        return self._global_cflags or self._global_cxxflags or self._global_ldflags
+        return self._global_cflags or self._global_cxxflags or self._global_ldflags or self._global_defines
 
     @property
     def _flags_xcconfig_content(self):

{conan-server-2.4.1 → conan-server-2.5.0}/conan/tools/cmake/cmake.py

@@ -31,7 +31,7 @@ def _cmake_cmd_line_args(conanfile, generator):
     return args
 
 
-class CMake(object):
+class CMake:
     """ CMake helper to use together with the CMakeToolchain feature """
 
     def __init__(self, conanfile):
@@ -60,7 +60,6 @@ class CMake(object):
         """
 
         Reads the ``CMakePresets.json`` file generated by the
-        :param cli_args: Extra CLI arguments to pass to cmake invocation
         :ref:`CMakeToolchain<conan-cmake-toolchain>` to get:
 
            - The generator, to append ``-G="xxx"``.
@@ -77,7 +76,8 @@ class CMake(object):
                           work in the toolchain approach.
         :param build_script_folder: Path to the CMakeLists.txt in case it is not in the declared
                                     ``self.folders.source`` at the ``layout()`` method.
-        :param cli_args: List of extra arguments provided when calling to CMake.
+        :param cli_args: List of arguments ``[arg1, arg2, ...]`` that will be passed
+                         as extra CLI arguments to pass to cmake invocation
         :param stdout: Use it to redirect stdout to this stream
         :param stderr: Use it to redirect stderr to this stream
         """
@@ -173,7 +173,7 @@ class CMake(object):
         :param target: The name of a single build target as a string, or names of multiple build targets in a
                        list of strings to be passed to the ``--target`` argument.
         :param cli_args: A list of arguments ``[arg1, arg2, ...]`` that will be passed to the
-                        ``cmake --build ... arg1 arg2`` command directly.
+                         ``cmake --build ... arg1 arg2`` command directly.
         :param build_tool_args: A list of arguments ``[barg1, barg2, ...]`` for the underlying
                                 build system that will be passed to the command
                                 line after the ``--`` indicator: ``cmake --build ... -- barg1 barg2``
@@ -192,9 +192,8 @@ class CMake(object):
                            It can fail if the build is single configuration (e.g. Unix Makefiles),
                            as in that case the build type must be specified at configure time,
                            not build type.
-        :param cli_args: A list of arguments ``[arg1, arg2, ...]`` for the underlying
-                         build system that will be passed to the command line:
-                         ``cmake --install ... arg1 arg2``
+        :param cli_args: A list of arguments ``[arg1, arg2, ...]`` for the underlying build system
+                         that will be passed to the command line: ``cmake --install ... arg1 arg2``
         :param stdout: Use it to redirect stdout to this stream
         :param stderr: Use it to redirect stderr to this stream
         """
@@ -233,7 +232,8 @@ class CMake(object):
                            in that case the build type must be specified at configure time, not build
                            time.
         :param target: Name of the build target to run, by default ``RUN_TESTS`` or ``test``
-        :param cli_args: Same as above ``build()``
+        :param cli_args: Same as above ``build()``, a list of arguments ``[arg1, arg2, ...]``
+                         to be passed as extra arguments for the underlying build system
         :param build_tool_args: Same as above ``build()``
         :param stdout: Use it to redirect stdout to this stream
         :param stderr: Use it to redirect stderr to this stream
@@ -255,7 +255,7 @@ class CMake(object):
         """
         Equivalent to running ctest ...
 
-        :param cli_args: Extra ctest command line arguments
+        :param cli_args: List of arguments ``[arg1, arg2, ...]`` to be passed as extra ctest command line arguments
         :param env: the environment files to activate, by default conanbuild + conanrun
         :param stdout: Use it to redirect stdout to this stream
         :param stderr: Use it to redirect stderr to this stream