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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conan-server
-Version: 2.0.10
+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.10 → conan-server-2.0.12}/conan/api/output.py

@@ -227,7 +227,7 @@ def cli_out_write(data, fg=None, bg=None, endline="\n", indentation=0):
 
     fg_ = fg or ''
     bg_ = bg or ''
-    if color_enabled(sys.stdout):
+    if (fg or bg) and color_enabled(sys.stdout):
         data = f"{' ' * indentation}{fg_}{bg_}{data}{Style.RESET_ALL}{endline}"
     else:
         data = f"{' ' * indentation}{data}{endline}"

{conan-server-2.0.10 → conan-server-2.0.12}/conan/cli/args.py

@@ -133,3 +133,5 @@ def validate_common_graph_args(args):
     if args.path and (args.requires or args.tool_requires):
         raise ConanException("--requires and --tool-requires arguments are incompatible with "
                              f"[path] '{args.path}' argument")
+    if not args.path and args.build_require:
+        raise ConanException("--build-require should only be used with <path> argument")

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

@@ -13,35 +13,43 @@ 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.')
     add_reference_args(parser)
-    # TODO: Missing --build-require argument and management
+    parser.add_argument("-g", "--generator", action="append", help='Generators to use')
     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')
+    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,
+                        help='Whether the provided path is a build-require')
     add_common_install_arguments(parser)
     add_lockfile_args(parser)
     args = parser.parse_args(*args)
 
     cwd = os.getcwd()
     path = conan_api.local.get_conanfile_path(args.path, cwd, py=True)
-    folder = os.path.dirname(path)
+    source_folder = os.path.dirname(path)
+    output_folder = make_abs_path(args.output_folder, cwd) if args.output_folder else None
+    deployer_folder = make_abs_path(args.deployer_folder, cwd) if args.deployer_folder else None
+
+    # Basic collaborators: remotes, lockfile, profiles
     remotes = conan_api.remotes.list(args.remote) if not args.no_remote else []
     overrides = eval(args.lockfile_overrides) if args.lockfile_overrides else None
-    lockfile = conan_api.lockfile.get_lockfile(lockfile=args.lockfile,
-                                               conanfile_path=path,
-                                               cwd=cwd,
-                                               partial=args.lockfile_partial,
-                                               overrides=overrides)
+    lockfile = conan_api.lockfile.get_lockfile(lockfile=args.lockfile, conanfile_path=path, cwd=cwd,
+                                               partial=args.lockfile_partial, overrides=overrides)
     profile_host, profile_build = conan_api.profiles.get_profiles_from_args(args)
     print_profiles(profile_host, profile_build)
 
     deps_graph = conan_api.graph.load_graph_consumer(path, args.name, args.version,
                                                      args.user, args.channel,
                                                      profile_host, profile_build, lockfile, remotes,
-                                                     args.update)
+                                                     args.update,
+                                                     is_build_require=args.build_require)
     print_graph_basic(deps_graph)
     deps_graph.report_graph_error()
     conan_api.graph.analyze_binaries(deps_graph, args.build, remotes=remotes, update=args.update,
@@ -52,11 +60,9 @@ def build(conan_api, parser, *args):
     out.title("Installing packages")
     conan_api.install.install_binaries(deps_graph=deps_graph, remotes=remotes)
 
-    source_folder = folder
-    output_folder = make_abs_path(args.output_folder, cwd) if args.output_folder else None
     out.title("Finalizing install (deploy, generators)")
-    conan_api.install.install_consumer(deps_graph=deps_graph, source_folder=source_folder,
-                                       output_folder=output_folder)
+    conan_api.install.install_consumer(deps_graph, args.generator, source_folder, output_folder,
+                                       deploy=args.deployer, deploy_folder=deployer_folder)
 
     out.title("Calling build()")
     conanfile = deps_graph.root.conanfile

{conan-server-2.0.10 → 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)
 
@@ -91,7 +94,7 @@ def export_pkg(conan_api, parser, *args):
     if test_conanfile_path:
         from conan.cli.commands.test import run_test
         deps_graph = run_test(conan_api, test_conanfile_path, ref, profile_host, profile_build,
-                              remotes=None, lockfile=lockfile, update=False, build_modes=None)
+                              remotes=remotes, lockfile=lockfile, update=False, build_modes=None)
         # TODO: Do something with lockfile, same as create()
 
     conan_api.lockfile.save_lockfile(lockfile, args.lockfile_out, cwd)

conan-server-2.0.12/conan/cli/commands/install.py

@@ -0,0 +1,81 @@
+import os
+
+from conan.api.output import ConanOutput
+from conan.cli import make_abs_path
+from conan.cli.args import common_graph_args, validate_common_graph_args
+from conan.cli.command import conan_command
+from conan.cli.formatters.graph import format_graph_json
+from conan.cli.printers import print_profiles
+from conan.cli.printers.graph import print_graph_packages, print_graph_basic
+
+
+@conan_command(group="Consumer", formatters={"json": format_graph_json})
+def install(conan_api, parser, *args):
+    """
+    Install the requirements specified in a recipe (conanfile.py or conanfile.txt).
+
+    It can also be used to install packages without a conanfile, using the
+    --requires and --tool-requires arguments.
+
+    If any requirement is not found in the local cache, it will iterate the remotes
+    looking for it. When the full dependency graph is computed, and all dependencies
+    recipes have been found, it will look for binary packages matching the current settings.
+    If no binary package is found for some or several dependencies, it will error,
+    unless the '--build' argument is used to build it from source.
+
+    After installation of packages, the generators and deployers will be called.
+    """
+    common_graph_args(parser)
+    parser.add_argument("-g", "--generator", action="append", help='Generators to use')
+    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')
+    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,
+                        help='Whether the provided path is a build-require')
+    args = parser.parse_args(*args)
+    validate_common_graph_args(args)
+
+    # basic paths
+    cwd = os.getcwd()
+    path = conan_api.local.get_conanfile_path(args.path, cwd, py=None) if args.path else None
+    source_folder = os.path.dirname(path) if args.path else cwd
+    output_folder = make_abs_path(args.output_folder, cwd) if args.output_folder else None
+
+    # Basic collaborators: remotes, lockfile, profiles
+    remotes = conan_api.remotes.list(args.remote) if not args.no_remote else []
+    overrides = eval(args.lockfile_overrides) if args.lockfile_overrides else None
+    lockfile = conan_api.lockfile.get_lockfile(lockfile=args.lockfile, conanfile_path=path, cwd=cwd,
+                                               partial=args.lockfile_partial, overrides=overrides)
+    profile_host, profile_build = conan_api.profiles.get_profiles_from_args(args)
+    print_profiles(profile_host, profile_build)
+
+    # Graph computation (without installation of binaries)
+    gapi = conan_api.graph
+    if path:
+        deps_graph = gapi.load_graph_consumer(path, args.name, args.version, args.user, args.channel,
+                                              profile_host, profile_build, lockfile, remotes,
+                                              args.update, is_build_require=args.build_require)
+    else:
+        deps_graph = gapi.load_graph_requires(args.requires, args.tool_requires, profile_host,
+                                              profile_build, lockfile, remotes, args.update)
+    print_graph_basic(deps_graph)
+    deps_graph.report_graph_error()
+    gapi.analyze_binaries(deps_graph, args.build, remotes, update=args.update, lockfile=lockfile)
+    print_graph_packages(deps_graph)
+
+    # Installation of binaries and consumer generators
+    conan_api.install.install_binaries(deps_graph=deps_graph, remotes=remotes)
+    ConanOutput().title("Finalizing install (deploy, generators)")
+    conan_api.install.install_consumer(deps_graph, args.generator, source_folder, output_folder,
+                                       deploy=args.deployer, deploy_folder=args.deployer_folder)
+    ConanOutput().success("Install finished successfully")
+
+    # Update lockfile if necessary
+    lockfile = conan_api.lockfile.update_lockfile(lockfile, deps_graph, args.lockfile_packages,
+                                                  clean=args.lockfile_clean)
+    conan_api.lockfile.save_lockfile(lockfile, args.lockfile_out, cwd)
+    return {"graph": deps_graph,
+            "conan_api": conan_api}

{conan-server-2.0.10 → conan-server-2.0.12}/conan/cli/commands/lock.py

@@ -43,12 +43,12 @@ def lock_create(conan_api, parser, subparser, *args):
         graph = conan_api.graph.load_graph_consumer(path, args.name, args.version,
                                                     args.user, args.channel,
                                                     profile_host, profile_build, lockfile,
-                                                    remotes, args.build, args.update,
+                                                    remotes, args.update,
                                                     is_build_require=args.build_require)
     else:
         graph = conan_api.graph.load_graph_requires(args.requires, args.tool_requires,
                                                     profile_host, profile_build, lockfile,
-                                                    remotes, args.build, args.update)
+                                                    remotes, args.update)
 
     print_graph_basic(graph)
     graph.report_graph_error()

{conan-server-2.0.10 → conan-server-2.0.12}/conan/cli/commands/profile.py

@@ -1,3 +1,4 @@
+import json
 import os
 
 from conan.api.output import ConanOutput, cli_out_write
@@ -22,12 +23,14 @@ def profiles_list_cli_output(profiles):
         cli_out_write(p)
 
 
-def detected_profile_cli_output(detect_profile):
-    cli_out_write("Detected profile:")
-    cli_out_write(detect_profile.dumps())
+def json_profiles(profiles):
+    host, build = profiles
+    result = {"host": host.serialize(),
+              "build": build.serialize()}
+    cli_out_write(json.dumps(result))
 
 
-@conan_subcommand(formatters={"text": print_profiles})
+@conan_subcommand(formatters={"text": print_profiles, "json": json_profiles})
 def profile_show(conan_api, parser, subparser, *args):
     """
     Show aggregated profiles from the passed arguments.
@@ -63,7 +66,9 @@ def profile_detect(conan_api, parser, subparser, *args):
         raise ConanException(f"Profile '{profile_pathname}' already exists")
 
     detected_profile = conan_api.profiles.detect()
-    detected_profile_cli_output(detected_profile)
+    ConanOutput().success("\nDetected profile:")
+    cli_out_write(detected_profile.dumps())
+
     contents = detected_profile.dumps()
     ConanOutput().warning("This profile is a guess of your environment, please check it.")
     if detected_profile.settings.get("os") == "Macos":

{conan-server-2.0.10 → 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)