conan 2.13.0__tar.gz → 2.15.0__tar.gz

{conan-2.13.0/conan.egg-info → conan-2.15.0}/PKG-INFO

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

{conan-2.13.0 → conan-2.15.0}/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.13.0'
+__version__ = '2.15.0'
 conan_version = Version(__version__)

{conan-2.13.0 → conan-2.15.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.13.0 → conan-2.15.0}/conan/api/model/list.py

@@ -3,9 +3,10 @@ import json
 import os
 from json import JSONDecodeError
 
+from conan.api.model import RecipeReference, PkgReference
+from conan.cli import make_abs_path
 from conan.errors import ConanException
 from conan.internal.errors import NotFoundException
-from conan.api.model import RecipeReference, PkgReference
 from conan.internal.model.version_range import VersionRange
 from conans.client.graph.graph import RECIPE_EDITABLE, RECIPE_CONSUMER, RECIPE_PLATFORM, \
     RECIPE_VIRTUAL, BINARY_SKIP, BINARY_MISSING, BINARY_INVALID
@@ -36,6 +37,10 @@ class MultiPackagesList:
         for k, v in other.lists.items():
             self.lists.setdefault(k, PackagesList()).merge(v)
 
+    def keep_outer(self, other):
+        for namespace, other_pkg_list in other.lists.items():
+            self.lists.get(namespace, PackagesList()).keep_outer(other_pkg_list)
+
     @staticmethod
     def load(file):
         try:
@@ -44,6 +49,14 @@ class MultiPackagesList:
             raise ConanException(f"Package list file invalid JSON: {file}\n{e}")
         except Exception as e:
             raise ConanException(f"Package list file missing or broken: {file}\n{e}")
+        # Check if input json is not a graph file
+        if "graph" in content:
+            base_path = os.path.basename(file)
+            raise ConanException(
+                'Expected a package list file but found a graph file. You can create a "package list" JSON file by running:\n\n'
+                f"\tconan list --graph {base_path} --format=json > pkglist.json\n\n"
+                "More Info at 'https://docs.conan.io/2/examples/commands/pkglists.html"
+            )
         result = {}
         for remote, pkglist in content.items():
             if "error" in pkglist:
@@ -55,19 +68,40 @@ class MultiPackagesList:
         return pkglist
 
     @staticmethod
-    def load_graph(graphfile, graph_recipes=None, graph_binaries=None):
+    def load_graph(graphfile, graph_recipes=None, graph_binaries=None, context=None):
         if not os.path.isfile(graphfile):
             raise ConanException(f"Graph file not found: {graphfile}")
         try:
+            base_context = context.split("-")[0] if context else None
             graph = json.loads(load(graphfile))
-            return MultiPackagesList._define_graph(graph, graph_recipes, graph_binaries)
+            # Check if input json is a graph file
+            if "graph" not in graph:
+                raise ConanException(
+                    'Expected a graph file but found an unexpected JSON file format. You can create a "graph" JSON file by running:\n\n'
+                    f"\tconan [ graph-info | create | export-pkg | install | test ] --format=json > graph.json\n\n"
+                    "More Info at 'https://docs.conan.io/2/reference/commands/formatters/graph_info_json_formatter.html"
+                )
+
+            mpkglist =  MultiPackagesList._define_graph(graph, graph_recipes, graph_binaries,
+                                                        context=base_context)
+            if context == "build-only":
+                host = MultiPackagesList._define_graph(graph, graph_recipes, graph_binaries,
+                                                       context="host")
+                mpkglist.keep_outer(host)
+            elif context == "host-only":
+                build = MultiPackagesList._define_graph(graph, graph_recipes, graph_binaries,
+                                                        context="build")
+                mpkglist.keep_outer(build)
+            return mpkglist
         except JSONDecodeError as e:
             raise ConanException(f"Graph file invalid JSON: {graphfile}\n{e}")
+        except ConanException as e:
+            raise e
         except Exception as e:
             raise ConanException(f"Graph file broken: {graphfile}\n{e}")
 
     @staticmethod
-    def _define_graph(graph, graph_recipes=None, graph_binaries=None):
+    def _define_graph(graph, graph_recipes=None, graph_binaries=None, context=None):
         pkglist = MultiPackagesList()
         cache_list = PackagesList()
         if graph_recipes is None and graph_binaries is None:
@@ -79,6 +113,9 @@ class MultiPackagesList:
 
         pkglist.lists["Local Cache"] = cache_list
         for node in graph["graph"]["nodes"].values():
+            if context and node['context'] != context:
+                continue
+
             # We need to add the python_requires too
             python_requires = node.get("python_requires")
             if python_requires is not None:
@@ -142,6 +179,14 @@ class PackagesList:
             return d
         recursive_dict_update(self.recipes, other.recipes)
 
+    def keep_outer(self, other):
+        if not self.recipes:
+            return
+
+        for ref, info in other.recipes.items():
+            if self.recipes.get(ref, {}) == info:
+                self.recipes.pop(ref)
+
     def split(self):
         """
         Returns a list of PackageList, splitted one per reference.

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

@@ -0,0 +1,162 @@
+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,
+        }
+
+    @staticmethod
+    def scan(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)
+
+    @staticmethod
+    def list(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.13.0 → conan-2.15.0}/conan/api/subapi/command.py

@@ -1,3 +1,5 @@
+import os
+
 from conan.api.output import ConanOutput
 from conan.errors import ConanException
 
@@ -25,9 +27,9 @@ class CommandAPI:
         # get redefined when running a command and leak to the calling scope
         # if running from a custom command.
         # Store the old one and restore it after the command execution as a workaround.
-        _conan_output_level = ConanOutput._conan_output_level
-        _silent_warn_tags = ConanOutput._silent_warn_tags
-        _warnings_as_errors = ConanOutput._warnings_as_errors
+        _conan_output_level = ConanOutput._conan_output_level  # noqa
+        _silent_warn_tags = ConanOutput._silent_warn_tags  # noqa
+        _warnings_as_errors = ConanOutput._warnings_as_errors  # noqa
 
         try:
             result = command.run_cli(self.conan_api, args)
@@ -36,3 +38,25 @@ class CommandAPI:
             ConanOutput._silent_warn_tags = _silent_warn_tags
             ConanOutput._warnings_as_errors = _warnings_as_errors
         return result
+
+    @staticmethod
+    def get_runner(profile_host):
+        if profile_host.runner and not os.environ.get("CONAN_RUNNER_ENVIRONMENT"):
+            from conan.internal.runner.docker import DockerRunner
+            from conan.internal.runner.ssh import SSHRunner
+            from conan.internal.runner.wsl import WSLRunner
+            try:
+                runner_type = profile_host.runner['type'].lower()
+            except KeyError:
+                raise ConanException(f"Invalid runner configuration. 'type' must be defined")
+            runner_instances_map = {
+                'docker': DockerRunner,
+                # 'ssh': SSHRunner,
+                # 'wsl': WSLRunner,
+            }
+            try:
+                runner_instance = runner_instances_map[runner_type]
+            except KeyError:
+                raise ConanException(f"Invalid runner type '{runner_type}'. "
+                                     f"Allowed values: {', '.join(runner_instances_map.keys())}")
+            return runner_instance

{conan-2.13.0 → conan-2.15.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.13.0 → conan-2.15.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.13.0 → conan-2.15.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.13.0 → conan-2.15.0}/conan/api/subapi/list.py

@@ -1,8 +1,9 @@
+import copy
 import os
 from collections import OrderedDict
 from typing import Dict
 
-from conan.api.model import PackagesList
+from conan.api.model import PackagesList, MultiPackagesList, ListPattern
 from conan.api.output import ConanOutput, TimedOutput
 from conan.internal.api.list.query_parse import filter_package_configs
 from conan.internal.conan_app import ConanBasicApp
@@ -242,7 +243,7 @@ class ListAPI:
                 ConanOutput().info(f"Finding binaries in remote {remote.name}")
                 pkg_configurations = self.packages_configurations(ref, remote=remote)
             except Exception as e:
-                ConanOutput(f"ERROR IN REMOTE {remote.name}: {e}")
+                ConanOutput().error(f"Error in remote '{remote.name}': {e}")
             else:
                 candidates.extend(_BinaryDistance(pref, data, conaninfo, remote)
                                   for pref, data in pkg_configurations.items())
@@ -266,6 +267,82 @@ class ListAPI:
             rev_dict["packages"][pref.package_id]["remote"] = remote
         return pkglist
 
+    def find_remotes(self, package_list, remotes):
+        """
+        (Experimental) Find the remotes where the current package lists can be found
+        """
+        result = MultiPackagesList()
+        for r in remotes:
+            result_pkg_list = PackagesList()
+            for ref, recipe_bundle in package_list.refs().items():
+                ref_no_rev = copy.copy(ref)  # TODO: Improve ugly API
+                ref_no_rev.revision = None
+                try:
+                    revs = self.recipe_revisions(ref_no_rev, remote=r)
+                except NotFoundException:
+                    continue
+                if ref not in revs:  # not found
+                    continue
+                result_pkg_list.add_refs([ref])
+                for pref, pref_bundle in package_list.prefs(ref, recipe_bundle).items():
+                    pref_no_rev = copy.copy(pref)  # TODO: Improve ugly API
+                    pref_no_rev.revision = None
+                    try:
+                        prevs = self.package_revisions(pref_no_rev, remote=r)
+                    except NotFoundException:
+                        continue
+                    if pref in prevs:
+                        result_pkg_list.add_prefs(ref, [pref])
+                        info = recipe_bundle["packages"][pref.package_id]["info"]
+                        result_pkg_list.add_configurations({pref: info})
+            if result_pkg_list.recipes:
+                result.add(r.name, result_pkg_list)
+        return result
+
+    def outdated(self, deps_graph, remotes):
+        # DO NOT USE YET
+        # Data structure to store info per library
+        dependencies = deps_graph.nodes[1:]
+        dict_nodes = {}
+
+        # When there are no dependencies command should stop
+        if len(dependencies) == 0:
+            return dict_nodes
+
+        ConanOutput().title("Checking remotes")
+
+        for node in dependencies:
+            dict_nodes.setdefault(node.name, {"cache_refs": set(), "version_ranges": [],
+                                              "latest_remote": None})["cache_refs"].add(node.ref)
+
+        for version_range in deps_graph.resolved_ranges.keys():
+            dict_nodes[version_range.name]["version_ranges"].append(version_range)
+
+        # find in remotes
+        for node_name, node_info in dict_nodes.items():
+            ref_pattern = ListPattern(node_name, rrev=None, prev=None)
+            for remote in remotes:
+                try:
+                    remote_ref_list = self.select(ref_pattern, package_query=None, remote=remote)
+                except NotFoundException:
+                    continue
+                if not remote_ref_list.recipes:
+                    continue
+                str_latest_ref = list(remote_ref_list.recipes.keys())[-1]
+                recipe_ref = RecipeReference.loads(str_latest_ref)
+                if (node_info["latest_remote"] is None
+                        or node_info["latest_remote"]["ref"] < recipe_ref):
+                    node_info["latest_remote"] = {"ref": recipe_ref, "remote": remote.name}
+
+        # Filter nodes with no outdated versions
+        filtered_nodes = {}
+        for node_name, node in dict_nodes.items():
+            if node['latest_remote'] is not None and sorted(list(node['cache_refs']))[0] < \
+                    node['latest_remote']['ref']:
+                filtered_nodes[node_name] = node
+
+        return filtered_nodes
+
 
 class _BinaryDistance:
     def __init__(self, pref, binary, expected, remote=None):

{conan-2.13.0 → conan-2.15.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.13.0 → conan-2.15.0}/conan/api/subapi/workspace.py

@@ -122,6 +122,16 @@ class WorkspaceAPI:
                                                                    v["output_folder"]))
         return editables
 
+    def select_editables(self, paths):
+        filtered_refs = [self.editable_from_path(p) for p in paths or []]
+        editables = self.editable_packages
+        requires = [ref for ref in editables]
+        if filtered_refs:
+            ConanOutput().info(f"Filtering and installing only selected editable packages")
+            requires = [ref for ref in requires if ref in filtered_refs]
+            ConanOutput().info(f"Filtered references: {requires}")
+        return requires
+
     @property
     def products(self):
         self._check_ws()

{conan-2.13.0 → conan-2.15.0}/conan/cli/cli.py

@@ -15,7 +15,6 @@ from conan.api.output import ConanOutput, Color, cli_out_write, LEVEL_TRACE
 from conan.cli.command import ConanSubCommand
 from conan.cli.exit_codes import SUCCESS, ERROR_MIGRATION, ERROR_GENERAL, USER_CTRL_C, \
     ERROR_SIGTERM, USER_CTRL_BREAK, ERROR_INVALID_CONFIGURATION, ERROR_UNEXPECTED
-from conan.internal.cache.home_paths import HomePaths
 from conan import __version__
 from conan.errors import ConanException, ConanInvalidConfiguration, ConanMigrationError
 
@@ -49,7 +48,8 @@ class Cli:
             for k, v in self._commands.items():  # Fill groups data too
                 self._groups[v.group].append(k)
 
-        conan_custom_commands_path = HomePaths(self._conan_api.cache_folder).custom_commands_path
+        conan_custom_commands_path = os.path.join(self._conan_api.cache_folder, "extensions",
+                                                  "commands")
         # Important! This variable should be only used for testing/debugging purpose
         developer_custom_commands_path = os.getenv(_CONAN_INTERNAL_CUSTOM_COMMANDS_PATH)
         # Notice that in case of having same custom commands file names, the developer one has