conan 2.12.2__tar.gz → 2.14.0__tar.gz

{conan-2.12.2/conan.egg-info → conan-2.14.0}/PKG-INFO

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

{conan-2.12.2 → conan-2.14.0}/conan/__init__.py

@@ -1,5 +1,6 @@
 from conan.internal.model.conan_file import ConanFile
+from conan.internal.model.workspace import Workspace
 from conan.internal.model.version import Version
 
-__version__ = '2.12.2'
+__version__ = '2.14.0'
 conan_version = Version(__version__)

{conan-2.12.2 → conan-2.14.0}/conan/api/conan_api.py

@@ -1,6 +1,8 @@
+import os
 import sys
 
 from conan.api.output import init_colorama
+from conan.api.subapi.audit import AuditAPI
 from conan.api.subapi.cache import CacheAPI
 from conan.api.subapi.command import CommandAPI
 from conan.api.subapi.local import LocalAPI
@@ -31,10 +33,16 @@ class ConanAPI:
     not be created directly.
     """
     def __init__(self, cache_folder=None):
+        """
+        :param cache_folder: Conan cache/home folder. It will have less priority than the
+                             "home_folder" defined in a Workspace.
+        """
 
         version = sys.version_info
         if version.major == 2 or version.minor < 6:
             raise ConanException("Conan needs Python >= 3.6")
+        if cache_folder is not None and not os.path.isabs(cache_folder):
+            raise ConanException("cache_folder has to be an absolute path")
 
         init_colorama(sys.stderr)
         self.workspace = WorkspaceAPI(self)
@@ -62,6 +70,7 @@ class ConanAPI:
         self.cache = CacheAPI(self)
         self.lockfile = LockfileAPI(self)
         self.local = LocalAPI(self)
+        self.audit = AuditAPI(self)
 
         _check_conan_version(self)
 

{conan-2.12.2 → conan-2.14.0}/conan/api/model/list.py

@@ -16,9 +16,6 @@ class MultiPackagesList:
     def __init__(self):
         self.lists = {}
 
-    def setdefault(self, key, default):
-        return self.lists.setdefault(key, default)
-
     def __getitem__(self, name):
         try:
             return self.lists[name]
@@ -57,11 +54,6 @@ class MultiPackagesList:
         pkglist.lists = result
         return pkglist
 
-    @staticmethod
-    def from_graph(graph, graph_recipes=None, graph_binaries=None):
-        graph = {"graph": graph.serialize()}
-        return MultiPackagesList._define_graph(graph, graph_recipes, graph_binaries)
-
     @staticmethod
     def load_graph(graphfile, graph_recipes=None, graph_binaries=None):
         if not os.path.isfile(graphfile):

{conan-2.12.2 → conan-2.14.0}/conan/api/model/refs.py

@@ -44,12 +44,6 @@ class RecipeReference:
             result += "#{}".format(self.revision)
         return result
 
-    def repr_reduced(self):
-        result = self.__str__()
-        if self.revision is not None:
-            result += "#{}".format(self.revision[0:4])
-        return result
-
     def repr_humantime(self):
         result = self.repr_notime()
         assert self.timestamp
@@ -236,16 +230,6 @@ class PkgReference:
             result += "#{}".format(self.revision)
         return result
 
-    def repr_reduced(self):
-        if self.ref is None:
-            return ""
-        result = self.ref.repr_reduced()
-        if self.package_id:
-            result += ":{}".format(self.package_id[0:4])
-        if self.revision is not None:
-            result += "#{}".format(self.revision[0:4])
-        return result
-
     def repr_humantime(self):
         result = self.repr_notime()
         assert self.timestamp

{conan-2.12.2 → conan-2.14.0}/conan/api/output.py

@@ -175,18 +175,7 @@ class ConanOutput:
 
         return self
 
-    def rewrite_line(self, line):
-        tmp_color = self._color
-        self._color = False
-        total_size = 70
-        limit_size = total_size // 2 - 3
-        if len(line) > total_size:
-            line = line[0:limit_size] + " ... " + line[-limit_size:]
-        self.write("\r%s%s" % (line, " " * (total_size - len(line))))
-        self.stream.flush()
-        self._color = tmp_color
-
-    def _write_message(self, msg, fg=None, bg=None):
+    def _write_message(self, msg, fg=None, bg=None, newline=True):
         if isinstance(msg, dict):
             # For traces we can receive a dict already, we try to transform then into more natural
             # text
@@ -206,8 +195,11 @@ class ConanOutput:
         else:
             ret += "{}".format(msg)
 
+        if newline:
+            ret = "%s\n" % ret
+
         with self.lock:
-            self.stream.write("{}\n".format(ret))
+            self.stream.write(ret)
             self.stream.flush()
 
     def trace(self, msg):

conan-2.14.0/conan/api/subapi/audit.py

@@ -0,0 +1,159 @@
+import binascii
+import json
+import os
+import base64
+
+from conan.internal.api.audit.providers import ConanCenterProvider, PrivateProvider
+from conan.errors import ConanException
+from conan.internal.api.remotes.encrypt import encode, decode
+from conan.internal.model.recipe_ref import RecipeReference
+from conans.util.files import save, load
+
+CONAN_CENTER_AUDIT_PROVIDER_NAME = "conancenter"
+CYPHER_KEY = "private"
+
+class AuditAPI:
+    """
+    This class provides the functionality to scan references for vulnerabilities.
+    """
+
+    def __init__(self, conan_api):
+        self.conan_api = conan_api
+        self._home_folder = conan_api.home_folder
+        self._providers_path = os.path.join(self._home_folder, "audit_providers.json")
+        self._provider_cls = {
+            "conan-center-proxy": ConanCenterProvider,
+            "private": PrivateProvider,
+        }
+
+    def scan(self, deps_graph, provider):
+        """
+        Scan a given recipe for vulnerabilities in its dependencies.
+        """
+        refs = sorted(set(RecipeReference.loads(f"{node.ref.name}/{node.ref.version}")
+                        for node in deps_graph.nodes[1:]), key= lambda ref: ref.name)
+        return provider.get_cves(refs)
+
+    def list(self, references, provider):
+        """
+        List the vulnerabilities of the given reference.
+        """
+        refs = [RecipeReference.loads(ref) for ref in references]
+        for ref in refs:
+            ref.validate_ref()
+        return provider.get_cves(refs)
+
+    def get_provider(self, provider_name):
+        """
+        Get the provider by name.
+        """
+        # TODO: More work remains to be done here, hardcoded for now for testing
+        providers = _load_providers(self._providers_path)
+        if provider_name not in providers:
+            add_arguments = (
+                "--url=https://audit.conan.io/ --type=conan-center-proxy"
+                if provider_name == CONAN_CENTER_AUDIT_PROVIDER_NAME
+                else "--url=<url> --type=<type>"
+            )
+
+            register_message = (
+                f"If you don't have a valid token, register at: https://audit.conan.io/register."
+                if provider_name == CONAN_CENTER_AUDIT_PROVIDER_NAME
+                else ""
+            )
+
+            raise ConanException(
+                f"Provider '{provider_name}' not found. Please specify a valid provider name or add it using: "
+                f"'conan audit provider add {provider_name} {add_arguments} --token=<token>'\n"
+                f"{register_message}"
+            )
+
+        provider_data = providers[provider_name]
+        safe_provider_name = provider_name.replace("-", "_")
+        env_token = os.getenv(f"CONAN_AUDIT_PROVIDER_TOKEN_{safe_provider_name.upper()}")
+
+        if env_token:
+            # Always override the token with the environment variable
+            provider_data["token"] = env_token
+        elif "token" in provider_data:
+            try:
+                provider_data["token"] = decode(base64.standard_b64decode(provider_data["token"]).decode(), CYPHER_KEY)
+            except binascii.Error as e:
+                raise ConanException(f"Invalid token format for provider '{provider_name}'. The token might be corrupt.")
+
+        provider_cls = self._provider_cls.get(provider_data["type"])
+
+        return provider_cls(self.conan_api, provider_name, provider_data)
+
+    def list_providers(self):
+        """
+        Get all available providers.
+        """
+        providers = _load_providers(self._providers_path)
+        result = []
+        for name, provider_data in providers.items():
+            provider_cls = self._provider_cls.get(provider_data["type"])
+            result.append(provider_cls(self.conan_api, name, provider_data))
+        return result
+
+    def add_provider(self, name, url, provider_type):
+        """
+        Add a provider.
+        """
+        providers = _load_providers(self._providers_path)
+        if name in providers:
+            raise ConanException(f"Provider '{name}' already exists")
+
+        if provider_type not in self._provider_cls:
+            raise ConanException(f"Provider type '{provider_type}' not found")
+
+        providers[name] = {
+            "name": name,
+            "url": url,
+            "type": provider_type
+        }
+
+        _save_providers(self._providers_path, providers)
+
+    def remove_provider(self, provider_name):
+        """
+        Remove a provider.
+        """
+        providers = _load_providers(self._providers_path)
+        if provider_name not in providers:
+            raise ConanException(f"Provider '{provider_name}' not found")
+
+        del providers[provider_name]
+
+        _save_providers(self._providers_path, providers)
+
+    def auth_provider(self, provider, token):
+        """
+        Authenticate a provider.
+        """
+        if not provider:
+            raise ConanException("Provider not found")
+
+        providers = _load_providers(self._providers_path)
+
+        assert provider.name in providers
+        providers[provider.name]["token"] = base64.standard_b64encode(encode(token, CYPHER_KEY).encode()).decode()
+        setattr(provider, "token", token)
+        _save_providers(self._providers_path, providers)
+
+
+def _load_providers(providers_path):
+    if not os.path.exists(providers_path):
+        default_providers = {
+            CONAN_CENTER_AUDIT_PROVIDER_NAME: {
+                "url": "https://audit.conan.io/",
+                "type": "conan-center-proxy"
+            }
+        }
+        save(providers_path, json.dumps(default_providers, indent=4))
+
+    return json.loads(load(providers_path))
+
+
+def _save_providers(providers_path, providers):
+    save(providers_path, json.dumps(providers, indent=4))

{conan-2.12.2 → conan-2.14.0}/conan/api/subapi/config.py

@@ -20,6 +20,7 @@ from conan.internal.model.conf import ConfDefinition, BUILT_IN_CONFS, CORE_CONF_
 from conan.internal.model.pkg_type import PackageType
 from conan.api.model import RecipeReference
 from conan.internal.model.settings import Settings
+from conans.client.hook_manager import HookManager
 from conans.util.files import load, save, rmdir, remove
 
 
@@ -29,6 +30,7 @@ class ConfigAPI:
         self.conan_api = conan_api
         self._new_config = None
         self._cli_core_confs = None
+        self.hook_manager = HookManager(HomePaths(conan_api.home_folder).hooks_path)
 
     def home(self):
         return self.conan_api.cache_folder
@@ -234,3 +236,4 @@ class ConfigAPI:
         if self._new_config is not None:
             self._new_config.clear()
             self._populate_global_conf()
+        self.hook_manager = HookManager(HomePaths(self.conan_api.home_folder).hooks_path)

{conan-2.12.2 → conan-2.14.0}/conan/api/subapi/export.py

@@ -1,11 +1,9 @@
 from conan.api.output import ConanOutput
 from conan.internal.cache.cache import PkgCache
-from conan.internal.cache.home_paths import HomePaths
 from conan.internal.conan_app import ConanApp
 from conan.internal.api.export import cmd_export
 from conan.internal.methods import run_package_method
 from conans.client.graph.graph import BINARY_BUILD, RECIPE_INCACHE
-from conans.client.hook_manager import HookManager
 from conan.api.model import PkgReference
 from conans.util.files import mkdir
 
@@ -18,13 +16,13 @@ class ExportAPI:
     def export(self, path, name, version, user, channel, lockfile=None, remotes=None):
         ConanOutput().title("Exporting recipe to the cache")
         app = ConanApp(self.conan_api)
-        hook_manager = HookManager(HomePaths(self.conan_api.home_folder).hooks_path)
+        hook_manager = self.conan_api.config.hook_manager
         return cmd_export(app, hook_manager, self.conan_api.config.global_conf, path, name, version,
                           user, channel, graph_lock=lockfile, remotes=remotes)
 
     def export_pkg(self, deps_graph, source_folder, output_folder):
         cache = PkgCache(self.conan_api.cache_folder, self.conan_api.config.global_conf)
-        hook_manager = HookManager(HomePaths(self.conan_api.home_folder).hooks_path)
+        hook_manager = self.conan_api.config.hook_manager
 
         # The graph has to be loaded with build_mode=[ref.name], so that node is not tried
         # to be downloaded from remotes

{conan-2.12.2 → conan-2.14.0}/conan/api/subapi/install.py

@@ -1,12 +1,10 @@
 import os
 
 from conan.internal.api.install.generators import write_generators
-from conan.internal.cache.home_paths import HomePaths
 from conan.internal.conan_app import ConanBasicApp
 from conan.internal.deploy import do_deploys
 
 from conans.client.graph.install_graph import InstallGraph
-from conans.client.hook_manager import HookManager
 from conans.client.installer import BinaryInstaller
 from conan.errors import ConanInvalidConfiguration
 
@@ -22,7 +20,8 @@ class InstallAPI:
         :param remotes:
         """
         app = ConanBasicApp(self.conan_api)
-        installer = BinaryInstaller(app, self.conan_api.config.global_conf, app.editable_packages)
+        installer = BinaryInstaller(app, self.conan_api.config.global_conf, app.editable_packages,
+                                    self.conan_api.config.hook_manager)
         install_graph = InstallGraph(deps_graph)
         install_graph.raise_errors()
         install_order = install_graph.install_order()
@@ -35,7 +34,8 @@ class InstallAPI:
         :param graph: Dependency graph to intall packages for
         """
         app = ConanBasicApp(self.conan_api)
-        installer = BinaryInstaller(app, self.conan_api.config.global_conf, app.editable_packages)
+        installer = BinaryInstaller(app, self.conan_api.config.global_conf, app.editable_packages,
+                                    self.conan_api.config.hook_manager)
         installer.install_system_requires(graph, only_info)
 
     def install_sources(self, graph, remotes):
@@ -45,7 +45,8 @@ class InstallAPI:
         :param graph: Dependency graph to install packages for
         """
         app = ConanBasicApp(self.conan_api)
-        installer = BinaryInstaller(app, self.conan_api.config.global_conf, app.editable_packages)
+        installer = BinaryInstaller(app, self.conan_api.config.global_conf, app.editable_packages,
+                                    self.conan_api.config.hook_manager)
         installer.install_sources(graph, remotes)
 
     # TODO: Look for a better name
@@ -86,7 +87,7 @@ class InstallAPI:
             if gen not in final_generators:
                 final_generators.append(gen)
         conanfile.generators = final_generators
-        hook_manager = HookManager(HomePaths(self.conan_api.home_folder).hooks_path)
+        hook_manager = self.conan_api.config.hook_manager
         write_generators(conanfile, hook_manager, self.conan_api.home_folder,
                          envs_generation=envs_generation)
 

{conan-2.12.2 → conan-2.14.0}/conan/api/subapi/local.py

@@ -1,7 +1,6 @@
 import os
 
 from conan.cli import make_abs_path
-from conan.internal.cache.home_paths import HomePaths
 from conan.internal.conan_app import ConanApp
 from conan.internal.api.local.editable import EditablePackages
 from conan.internal.methods import run_build_method, run_source_method
@@ -9,7 +8,6 @@ from conans.client.graph.graph import CONTEXT_HOST
 from conans.client.graph.profile_node_definer import initialize_conanfile_profile
 from conan.internal.errors import conanfile_exception_formatter
 from conan.errors import ConanException
-from conans.client.hook_manager import HookManager
 from conan.api.model import RecipeReference
 from conans.util.files import chdir
 
@@ -93,13 +91,13 @@ class LocalAPI:
         conanfile.folders.set_base_build(None)
         conanfile.folders.set_base_package(None)
 
-        hook_manager = HookManager(HomePaths(self._conan_api.home_folder).hooks_path)
+        hook_manager = self._conan_api.config.hook_manager
         run_source_method(conanfile, hook_manager)
 
     def build(self, conanfile):
         """ calls the 'build()' method of the current (user folder) conanfile.py
         """
-        hook_manager = HookManager(HomePaths(self._conan_api.home_folder).hooks_path)
+        hook_manager = self._conan_api.config.hook_manager
         conanfile.folders.set_base_package(conanfile.folders.base_build)
         conanfile.folders.set_base_pkg_metadata(os.path.join(conanfile.build_folder, "metadata"))
         run_build_method(conanfile, hook_manager)

{conan-2.12.2 → conan-2.14.0}/conan/api/subapi/new.py

@@ -111,7 +111,7 @@ class NewAPI:
         ensure_list("tool_requires")
 
         def as_package_name(n):
-            return n.replace("-", "_").replace("+", "_").replace(".", "_")
+            return n.replace("-", "_").replace("+", "_")
 
         def as_name(ref):
             ref = as_package_name(ref)
@@ -119,7 +119,7 @@ class NewAPI:
                 ref = ref[0:ref.index('/')]
             return ref
 
-        definitions["package_name"] = as_package_name(name)
+        definitions["package_name"] = as_package_name(name).replace(".", "_")
         definitions["as_name"] = as_name
         definitions["names"] = lambda x: ", ".join(r.split("/", 1)[0] for r in x)
         if "name" not in definitions: