conan 2.15.1__tar.gz → 2.16.1__tar.gz

{conan-2.15.1/conan.egg-info → conan-2.16.1}/PKG-INFO

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

{conan-2.15.1 → conan-2.16.1}/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.15.1'
+__version__ = '2.16.1'
 conan_version = Version(__version__)

{conan-2.15.1 → conan-2.16.1}/conan/api/output.py

@@ -207,9 +207,9 @@ class ConanOutput:
             self._write_message(msg, fg=Color.BLUE)
         return self
 
-    def debug(self, msg):
+    def debug(self, msg, fg=Color.MAGENTA, bg=None):
         if self._conan_output_level <= LEVEL_DEBUG:
-            self._write_message(msg, fg=Color.MAGENTA)
+            self._write_message(msg, fg=fg, bg=bg)
         return self
 
     def verbose(self, msg, fg=None, bg=None):

{conan-2.15.1 → conan-2.16.1}/conan/api/subapi/audit.py

@@ -160,3 +160,5 @@ def _load_providers(providers_path):
 
 def _save_providers(providers_path, providers):
     save(providers_path, json.dumps(providers, indent=4))
+    # Make readable & writeable only by current user
+    os.chmod(providers_path, 0o600)

{conan-2.15.1 → conan-2.16.1}/conan/api/subapi/cache.py

@@ -24,7 +24,7 @@ class CacheAPI:
 
     def export_path(self, ref: RecipeReference):
         cache = PkgCache(self.conan_api.cache_folder, self.conan_api.config.global_conf)
-        ref.revision = None if ref.revision == "latest" else ref.revision
+        ref = _resolve_latest_ref(cache, ref)
         ref_layout = cache.recipe_layout(ref)
         return _check_folder_existence(ref, "export", ref_layout.export())
 
@@ -36,13 +36,13 @@ class CacheAPI:
 
     def export_source_path(self, ref: RecipeReference):
         cache = PkgCache(self.conan_api.cache_folder, self.conan_api.config.global_conf)
-        ref.revision = None if ref.revision == "latest" else ref.revision
+        ref = _resolve_latest_ref(cache, ref)
         ref_layout = cache.recipe_layout(ref)
         return _check_folder_existence(ref, "export_sources", ref_layout.export_sources())
 
     def source_path(self, ref: RecipeReference):
         cache = PkgCache(self.conan_api.cache_folder, self.conan_api.config.global_conf)
-        ref.revision = None if ref.revision == "latest" else ref.revision
+        ref = _resolve_latest_ref(cache, ref)
         ref_layout = cache.recipe_layout(ref)
         return _check_folder_existence(ref, "source", ref_layout.source())
 

{conan-2.15.1 → conan-2.16.1}/conan/api/subapi/graph.py

@@ -5,6 +5,7 @@ from conans.client.graph.graph import Node, RECIPE_CONSUMER, CONTEXT_HOST, RECIP
     CONTEXT_BUILD, BINARY_MISSING
 from conans.client.graph.graph_binaries import GraphBinariesAnalyzer
 from conans.client.graph.graph_builder import DepsGraphBuilder
+from conans.client.graph.install_graph import InstallGraph, ProfileArgs
 from conans.client.graph.profile_node_definer import initialize_conanfile_profile, consumer_definer
 from conan.errors import ConanException
 from conan.api.model import RecipeReference
@@ -212,3 +213,27 @@ class GraphAPI:
                     or (missing and ref_matches(node.ref, missing, is_consumer=None))):
                 return node.ref, node.conanfile.info
         raise ConanException("There is no missing binary")
+
+    @staticmethod
+    def build_order(deps_graph, order_by="recipe", reduce=False, profile_args=None):
+        install_graph = InstallGraph(deps_graph, order_by=order_by,
+                                     profile_args=ProfileArgs.from_args(profile_args))
+        if reduce:
+            if order_by is None:
+                raise ConanException("--reduce needs --order-by argument defined")
+            install_graph.reduce()
+        return install_graph
+
+    @staticmethod
+    def build_order_merge(files, reduce=False):
+        result = InstallGraph.load(files[0])
+        if result.reduced:
+            raise ConanException(f"Reduced build-order file cannot be merged: {files[0]}")
+        for f in files[1:]:
+            install_graph = InstallGraph.load(f)
+            if install_graph.reduced:
+                raise ConanException(f"Reduced build-order file cannot be merged: {f}")
+            result.merge(install_graph)
+        if reduce:
+            result.reduce()
+        return result

{conan-2.15.1 → conan-2.16.1}/conan/api/subapi/new.py

@@ -1,10 +1,12 @@
 import fnmatch
 import os
+import shutil
 
 from jinja2 import Template, StrictUndefined, UndefinedError, Environment, meta
 
+from conan.api.output import ConanOutput
 from conan.errors import ConanException
-from conans.util.files import load
+from conans.util.files import load, save
 from conan import __version__
 
 
@@ -14,6 +16,69 @@ class NewAPI:
     def __init__(self, conan_api):
         self.conan_api = conan_api
 
+    def save_template(self, template, defines=None, output_folder=None, force=False):
+        """
+        Save the 'template' files in the output_folder, replacing the template variables
+        with the 'defines'
+        :param template: The name of the template to use
+        :param defines: A list with the 'k=v' variables to replace in the template
+        :param output_folder: The folder where the template files will be saved, cwd if None
+        :param force: If True, overwrite the files if they already exist, otherwise raise an error
+        """
+        # Manually parsing the remainder
+        definitions = {}
+        for u in defines or []:
+            try:
+                k, v = u.split("=", 1)
+            except ValueError:
+                raise ConanException(f"Template definitions must be 'key=value', received {u}")
+            k = k.replace("-", "")  # Remove possible "--name=value"
+            # For variables that only show up once, no need for list to keep compatible behaviour
+            if k in definitions:
+                if isinstance(definitions[k], list):
+                    definitions[k].append(v)
+                else:
+                    definitions[k] = [definitions[k], v]
+            else:
+                definitions[k] = v
+
+        files = self.get_template(template)  # First priority: user folder
+        is_builtin = False
+        if not files:  # then, try the templates in the Conan home
+            files = self.get_home_template(template)
+        if files:
+            template_files, non_template_files = files
+        else:
+            template_files = self.get_builtin_template(template)
+            non_template_files = {}
+            is_builtin = True
+
+        if not template_files and not non_template_files:
+            raise ConanException(f"Template doesn't exist or not a folder: {template}")
+
+        if is_builtin and template == "workspace":  # hardcoded for the workspace special case
+            definitions["name"] = "liba"
+        template_files = self.render(template_files, definitions)
+
+        # Saving the resulting files
+        output = ConanOutput()
+        output_folder = output_folder or os.getcwd()
+        # Making sure they don't overwrite existing files
+        for f, v in sorted(template_files.items()):
+            path = os.path.join(output_folder, f)
+            if os.path.exists(path) and not force:
+                raise ConanException(f"File '{f}' already exists, and --force not defined, aborting")
+            save(path, v)
+            output.success("File saved: %s" % f)
+
+        # copy non-templates
+        for f, v in sorted(non_template_files.items()):
+            path = os.path.join(output_folder, f)
+            if os.path.exists(path) and not force:
+                raise ConanException(f"File '{f}' already exists, and --force not defined, aborting")
+            shutil.copy2(v, path)
+            output.success("File saved: %s" % f)
+
     @staticmethod
     def get_builtin_template(template_name):
         from conan.internal.api.new.basic import basic_file

{conan-2.15.1 → conan-2.16.1}/conan/api/subapi/remotes.py

@@ -1,6 +1,7 @@
 import fnmatch
 import json
 import os
+from collections import OrderedDict
 from urllib.parse import urlparse
 
 from conan.api.model import Remote, LOCAL_RECIPES_INDEX
@@ -8,6 +9,7 @@ from conan.api.output import ConanOutput
 from conan.internal.cache.home_paths import HomePaths
 from conan.internal.conan_app import ConanBasicApp
 from conans.client.rest.conan_requester import ConanRequester
+from conans.client.rest.remote_credentials import RemoteCredentials
 from conans.client.rest_client_local_recipe_index import add_local_recipes_index_remote, \
     remove_local_recipes_index_remote
 from conan.internal.api.remotes.localdb import LocalDB
@@ -29,14 +31,14 @@ class RemotesAPI:
 
     def __init__(self, conan_api):
         # This method is private, the subapi is not instantiated by users
-        self.conan_api = conan_api
+        self._conan_api = conan_api
         self._home_folder = conan_api.home_folder
         self._remotes_file = HomePaths(self._home_folder).remotes_path
         # Wraps an http_requester to inject proxies, certs, etc
-        self._requester = ConanRequester(self.conan_api.config.global_conf, self.conan_api.cache_folder)
+        self._requester = ConanRequester(self._conan_api.config.global_conf, self._conan_api.cache_folder)
 
     def reinit(self):
-        self._requester = ConanRequester(self.conan_api.config.global_conf, self.conan_api.cache_folder)
+        self._requester = ConanRequester(self._conan_api.config.global_conf, self._conan_api.cache_folder)
 
     def list(self, pattern=None, only_enabled=True):
         """
@@ -224,9 +226,29 @@ class RemotesAPI:
         :param username: the user login as ``str``
         :param password: password ``str``
         """
-        app = ConanBasicApp(self.conan_api)
+        app = ConanBasicApp(self._conan_api)
         app.remote_manager.authenticate(remote, username, password)
 
+    def login(self, remotes, username=None, password=None):
+        creds = RemoteCredentials(self._conan_api.cache_folder, self._conan_api.config.global_conf)
+
+        ret = OrderedDict()
+        for r in remotes:
+            previous_info = self.user_info(r)
+
+            if username is not None and password is not None:
+                user, password = username, password
+            else:
+                user, password, _ = creds.auth(r, username)
+                if username is not None and username != user:
+                    raise ConanException(f"User '{username}' doesn't match user '{user}' in "
+                                         f"credentials.json or environment variables")
+
+            self.user_login(r, user, password)
+            info = self.user_info(r)
+            ret[r.name] = {"previous_info": previous_info, "info": info}
+        return ret
+
     def user_logout(self, remote: Remote):
         """
         Logout from the given :ref:`Remote <conan.api.model.Remote>`
@@ -247,7 +269,7 @@ class RemotesAPI:
     def user_auth(self, remote: Remote, with_user=False, force=False):
         # TODO: Review
         localdb = LocalDB(self._home_folder)
-        app = ConanBasicApp(self.conan_api)
+        app = ConanBasicApp(self._conan_api)
         if with_user:
             user, token, _ = localdb.get_login(remote.url)
             if not user:

{conan-2.15.1 → conan-2.16.1}/conan/cli/cli.py

@@ -45,6 +45,7 @@ class Cli:
             Cli._builtin_commands = self._commands.copy()
         else:
             self._commands = Cli._builtin_commands.copy()
+            self._groups = defaultdict(list)
             for k, v in self._commands.items():  # Fill groups data too
                 self._groups[v.group].append(k)
 

{conan-2.15.1 → conan-2.16.1}/conan/cli/commands/audit.py

@@ -20,10 +20,31 @@ def _add_provider_arg(subparser):
     subparser.add_argument("-p", "--provider", help="Provider to use for scanning")
 
 
+def _parse_error_threshold(result: dict, error_level: float) -> None:
+    """Mark the result as error if any of the vulnerabilities has a severity greater than or equal to
+       The error_level reflects the severity level configured by the user. As it uses float and CVSS
+       score is limited to 10.0, users can use any higher number to skip it.
+
+       :param result: Conan audit scan result. It's expected to find cvss there
+       :param error_level: Threshold to raise an error in case of matching the severity level
+       :return: None
+    """
+    if "conan_error" not in result:
+        for ref in result["data"]:
+            for edge in result["data"][ref]["vulnerabilities"]["edges"]:
+                preferred_base_score = float(edge["node"]["cvss"].get("preferredBaseScore", 0.0))
+                if preferred_base_score >= error_level:
+                    result.update(
+                        {"conan_error":
+                             f"The package {ref} has a CVSS score {preferred_base_score} and "
+                             f"exceeded the threshold severity level {error_level}."})
+                    break
+
+
 @conan_subcommand(formatters={"text": text_vuln_formatter,
                               "json": json_vuln_formatter,
                               "html": html_vuln_formatter})
-def audit_scan(conan_api: ConanAPI, parser, subparser, *args):
+def audit_scan(conan_api: ConanAPI, parser, subparser, *args) -> dict:
     """
     Scan a given recipe for vulnerabilities in its dependencies.
     """
@@ -32,6 +53,10 @@ def audit_scan(conan_api: ConanAPI, parser, subparser, *args):
     # TODO: Do we then want to hide it in the --help?
     subparser.add_argument("--build-require", action='store_true', default=False,
                            help='Whether the provided reference is a build-require')
+    subparser.add_argument("-sl", "--severity-level", action="store", default=9.0, type=float,
+                           help="Set threshold for severity level to raise an error. "
+                                "By default raises an error for any critical CVSS (9.0 or higher). "
+                                " Use 100.0 to disable it.")
 
     _add_provider_arg(subparser)
     args = parser.parse_args(*args)
@@ -65,11 +90,13 @@ def audit_scan(conan_api: ConanAPI, parser, subparser, *args):
     deps_graph.report_graph_error()
 
     if deps_graph.error:
-        return {"error": deps_graph.error}
+        return {"conan_error": deps_graph.error}
 
     provider = conan_api.audit.get_provider(args.provider or CONAN_CENTER_AUDIT_PROVIDER_NAME)
 
-    return conan_api.audit.scan(deps_graph, provider)
+    scan_result = conan_api.audit.scan(deps_graph, provider)
+    _parse_error_threshold(scan_result, args.severity_level)
+    return scan_result
 
 
 @conan_subcommand(formatters={"text": text_vuln_formatter,

{conan-2.15.1 → conan-2.16.1}/conan/cli/commands/graph.py

@@ -12,7 +12,6 @@ from conan.cli.formatters.graph.graph_info_text import format_graph_info
 from conan.cli.printers import print_profiles
 from conan.cli.printers.graph import print_graph_packages, print_graph_basic
 from conan.errors import ConanException
-from conans.client.graph.install_graph import InstallGraph, ProfileArgs
 
 
 def explain_formatter_text(data):
@@ -111,13 +110,8 @@ def graph_build_order(conan_api, parser, subparser, *args):
 
     out = ConanOutput()
     out.title("Computing the build order")
-
-    install_graph = InstallGraph(deps_graph, order_by=args.order_by,
-                                 profile_args=ProfileArgs.from_args(args))
-    if args.reduce:
-        if args.order_by is None:
-            raise ConanException("--reduce needs --order-by argument defined")
-        install_graph.reduce()
+    install_graph = conan_api.graph.build_order(deps_graph, args.order_by, args.reduce,
+                                                profile_args=args)
     install_order_serialized = install_graph.install_build_order()
     if args.order_by is None:  # legacy
         install_order_serialized = install_order_serialized["order"]
@@ -144,21 +138,12 @@ def graph_build_order_merge(conan_api, parser, subparser, *args):  # noqa
     if not args.file or len(args.file) < 2:
         raise ConanException("At least 2 files are needed to be merged")
 
-    result = InstallGraph.load(make_abs_path(args.file[0]))
-    if result.reduced:
-        raise ConanException(f"Reduced build-order file cannot be merged: {args.file[0]}")
-    for f in args.file[1:]:
-        install_graph = InstallGraph.load(make_abs_path(f))
-        if install_graph.reduced:
-            raise ConanException(f"Reduced build-order file cannot be merged: {f}")
-        result.merge(install_graph)
-
-    if args.reduce:
-        result.reduce()
+    files = [make_abs_path(f) for f in args.file]
+    result = conan_api.graph.build_order_merge(files, args.reduce)
+
     install_order_serialized = result.install_build_order()
     if getattr(result, "legacy"):
         install_order_serialized = install_order_serialized["order"]
-
     return {"build_order": install_order_serialized,
             "conan_error": result.get_errors()}
 
@@ -236,13 +221,22 @@ def graph_info(conan_api, parser, subparser, *args):
             base_folder = args.deployer_folder or os.getcwd()
             conan_api.install.deploy(deps_graph, args.deployer, None, base_folder)
 
+    warn_msg = None
+    missing = set(str(n.ref.name) for n in deps_graph.nodes if n.binary == "Missing")
+    invalid = set(str(n.ref.name) for n in deps_graph.nodes if n.binary == "Invalid")
+    if missing or invalid:
+        warn_msg = "There are some error(s) in the graph:"
+        if missing:
+            warn_msg += f"\n    - Missing packages: {', '.join(missing)}"
+        if invalid:
+            warn_msg += f"\n    - Invalid packages: {', '.join(invalid)}"
+
     return {"graph": deps_graph,
             "field_filter": args.filter,
             "package_filter": args.package_filter,
             "conan_api": conan_api,
             "conan_error": str(deps_graph.error) if deps_graph.error else None,
-            # Do not compute graph errors if there are dependency errors
-            "conan_warning": InstallGraph(deps_graph).get_errors() if not deps_graph.error else None}
+            "conan_warning": warn_msg}
 
 
 @conan_subcommand(formatters={"text": explain_formatter_text,

{conan-2.15.1 → conan-2.16.1}/conan/cli/commands/list.py

@@ -1,4 +1,5 @@
 import json
+import datetime
 
 from conan.api.conan_api import ConanAPI
 from conan.api.model import ListPattern, MultiPackagesList
@@ -7,7 +8,6 @@ from conan.cli import make_abs_path
 from conan.cli.command import conan_command, OnceArgument
 from conan.cli.formatters.list import list_packages_html
 from conan.errors import ConanException
-from conans.util.dates import timestamp_to_str
 
 # Keep them so we don't break other commands that import them, but TODO: Remove later
 remote_color = Color.BRIGHT_BLUE
@@ -19,6 +19,12 @@ field_color = Color.BRIGHT_YELLOW
 value_color = Color.CYAN
 
 
+def _format_timestamp_human(timestamp):
+    # used by ref.repr_humantime() to print human readable time
+    return datetime.datetime.fromtimestamp(int(timestamp),
+                                           datetime.timezone.utc).strftime('%Y-%m-%d %H:%M:%S UTC')
+
+
 def print_serial(item, indent=None, color_index=None):
     indent = "" if indent is None else (indent + "  ")
     color_index = 0 if color_index is None else (color_index + 1)
@@ -78,7 +84,7 @@ def print_list_text(results):
             for k, v in item.items():
                 if isinstance(v, dict) and v.get("timestamp"):
                     timestamp = v.pop("timestamp")
-                    k = f"{k} ({timestamp_to_str(timestamp)})"
+                    k = f"{k} ({_format_timestamp_human(timestamp)})"
                 result[k] = format_timestamps(v)
             return result
         return item
@@ -108,7 +114,7 @@ def prepare_pkglist_compact(pkglist):
             new_rrev = f"{ref}#{rrev}"
             timestamp = rrev_info.pop("timestamp", None)
             if timestamp:
-                new_rrev += f"%{timestamp} ({timestamp_to_str(timestamp)})"
+                new_rrev += f"%{timestamp} ({_format_timestamp_human(timestamp)})"
 
             packages = rrev_info.pop("packages", None)
             if packages:

conan-2.16.1/conan/cli/commands/new.py

@@ -0,0 +1,28 @@
+import os
+
+from conan.cli.command import conan_command
+
+
+@conan_command(group="Creator")
+def new(conan_api, parser, *args):
+    """
+    Create a new example recipe and source files from a template.
+    """
+    parser.add_argument("template", help="Template name, "
+                        "either a predefined built-in or a user-provided one. "
+                        "Available built-in templates: basic, cmake_lib, cmake_exe, "
+                        "meson_lib, meson_exe, msbuild_lib, msbuild_exe, bazel_lib, bazel_exe, "
+                        "autotools_lib, autotools_exe, local_recipes_index, workspace. "
+                        "E.g. 'conan new cmake_lib -d name=hello -d version=0.1'. "
+                        "You can define your own templates too by inputting an absolute path "
+                        "as your template, or a path relative to your conan home folder."
+                        )
+    parser.add_argument("-d", "--define", action="append",
+                        help="Define a template argument as key=value, e.g., -d name=mypkg")
+    parser.add_argument("-f", "--force", action='store_true',
+                        help="Overwrite file if it already exists")
+    parser.add_argument("-o", "--output", help="Output folder for the generated files",
+                        default=os.getcwd())
+
+    args = parser.parse_args(*args)
+    conan_api.new.save_template(args.template, args.define, args.output, args.force)

{conan-2.15.1 → conan-2.16.1}/conan/cli/commands/profile.py

@@ -6,7 +6,6 @@ from conan.cli.command import conan_command, conan_subcommand
 from conan.cli.formatters import default_json_formatter
 from conan.cli.args import add_profiles_args
 from conan.errors import ConanException
-from conans.util.files import save
 
 
 def _print_profiles(profiles):
@@ -92,11 +91,15 @@ def profile_detect(conan_api, parser, subparser, *args):
                           "change in future Conan versions.")
     ConanOutput().warning("Use your own profile files for stability.")
     ConanOutput().success(f"Saving detected profile to {profile_pathname}")
-    save(profile_pathname, contents)
+    dir_path = os.path.dirname(profile_pathname)
+    if dir_path:
+        os.makedirs(dir_path, exist_ok=True)
+    with open(profile_pathname, "w", encoding="utf-8", newline="") as f:
+        f.write(contents)
 
 
 @conan_subcommand(formatters={"text": profiles_list_cli_output, "json": default_json_formatter})
-def profile_list(conan_api, parser, subparser, *args):
+def profile_list(conan_api, parser, subparser, *args):  # noqa
     """
     List all profiles in the cache.
     """
@@ -105,7 +108,7 @@ def profile_list(conan_api, parser, subparser, *args):
 
 
 @conan_command(group="Consumer")
-def profile(conan_api, parser, *args):
+def profile(conan_api, parser, *args):  # noqa
     """
     Manage profiles.
     """