conan-server 2.10.3__tar.gz → 2.11.0__tar.gz

{conan_server-2.10.3 → conan_server-2.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conan_server
-Version: 2.10.3
+Version: 2.11.0
 Summary: Conan Server of Conan C/C++ package manager
 Home-page: https://conan.io
 Author: JFrog LTD

{conan_server-2.10.3 → conan_server-2.11.0}/conan/__init__.py

@@ -1,5 +1,5 @@
 from conans.model.conan_file import ConanFile
 from conan.tools.scm import Version as _Version
 
-__version__ = '2.10.3'
+__version__ = '2.11.0'
 conan_version = _Version(__version__)

{conan_server-2.10.3 → conan_server-2.11.0}/conan/api/subapi/download.py

@@ -4,7 +4,7 @@ from typing import Optional, List
 
 from conan.api.model import Remote, PackagesList
 from conan.api.output import ConanOutput
-from conan.internal.conan_app import ConanApp
+from conan.internal.conan_app import ConanBasicApp
 from conan.errors import ConanException
 from conans.model.package_ref import PkgReference
 from conans.model.recipe_ref import RecipeReference
@@ -20,7 +20,7 @@ class DownloadAPI:
         If the recipe is already in the cache it will be skipped,
         but the specified metadata will be downloaded."""
         output = ConanOutput()
-        app = ConanApp(self.conan_api)
+        app = ConanBasicApp(self.conan_api)
         assert ref.revision, f"Reference '{ref}' must have revision"
         try:
             app.cache.recipe_layout(ref)  # raises if not found
@@ -53,7 +53,7 @@ class DownloadAPI:
         If the package is already in the cache it will be skipped,
         but the specified metadata will be downloaded."""
         output = ConanOutput()
-        app = ConanApp(self.conan_api)
+        app = ConanBasicApp(self.conan_api)
         try:
             app.cache.recipe_layout(pref.ref)  # raises if not found
         except ConanException:

{conan_server-2.10.3 → conan_server-2.11.0}/conan/api/subapi/install.py

@@ -2,7 +2,7 @@ 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 ConanApp
+from conan.internal.conan_app import ConanBasicApp
 from conan.internal.deploy import do_deploys
 
 from conans.client.graph.install_graph import InstallGraph
@@ -21,9 +21,8 @@ class InstallAPI:
         :param deps_graph: Dependency graph to intall packages for
         :param remotes:
         """
-        app = ConanApp(self.conan_api)
-        installer = BinaryInstaller(app, self.conan_api.config.global_conf,
-                                    self.conan_api.local.editable_packages)
+        app = ConanBasicApp(self.conan_api)
+        installer = BinaryInstaller(app, self.conan_api.config.global_conf, app.editable_packages)
         install_graph = InstallGraph(deps_graph)
         install_graph.raise_errors()
         install_order = install_graph.install_order()
@@ -35,9 +34,8 @@ class InstallAPI:
         :param only_info: Only allow reporting and checking, but never install
         :param graph: Dependency graph to intall packages for
         """
-        app = ConanApp(self.conan_api)
-        installer = BinaryInstaller(app, self.conan_api.config.global_conf,
-                                    self.conan_api.local.editable_packages)
+        app = ConanBasicApp(self.conan_api)
+        installer = BinaryInstaller(app, self.conan_api.config.global_conf, app.editable_packages)
         installer.install_system_requires(graph, only_info)
 
     def install_sources(self, graph, remotes):
@@ -46,9 +44,8 @@ class InstallAPI:
         :param remotes:
         :param graph: Dependency graph to install packages for
         """
-        app = ConanApp(self.conan_api)
-        installer = BinaryInstaller(app, self.conan_api.config.global_conf,
-                                    self.conan_api.local.editable_packages)
+        app = ConanBasicApp(self.conan_api)
+        installer = BinaryInstaller(app, self.conan_api.config.global_conf, app.editable_packages)
         installer.install_sources(graph, remotes)
 
     # TODO: Look for a better name

{conan_server-2.10.3 → conan_server-2.11.0}/conan/api/subapi/list.py

@@ -5,7 +5,7 @@ from typing import Dict
 from conan.api.model import PackagesList
 from conan.api.output import ConanOutput, TimedOutput
 from conan.internal.api.list.query_parse import filter_package_configs
-from conan.internal.conan_app import ConanApp
+from conan.internal.conan_app import ConanBasicApp
 from conan.internal.paths import CONANINFO
 from conan.internal.errors import NotFoundException
 from conan.errors import ConanException
@@ -26,7 +26,7 @@ class ListAPI:
 
     def latest_recipe_revision(self, ref: RecipeReference, remote=None):
         assert ref.revision is None, "latest_recipe_revision: ref already have a revision"
-        app = ConanApp(self.conan_api)
+        app = ConanBasicApp(self.conan_api)
         if remote:
             ret = app.remote_manager.get_latest_recipe_reference(ref, remote=remote)
         else:
@@ -36,7 +36,7 @@ class ListAPI:
 
     def recipe_revisions(self, ref: RecipeReference, remote=None):
         assert ref.revision is None, "recipe_revisions: ref already have a revision"
-        app = ConanApp(self.conan_api)
+        app = ConanBasicApp(self.conan_api)
         if remote:
             results = app.remote_manager.get_recipe_revisions_references(ref, remote=remote)
         else:
@@ -50,7 +50,7 @@ class ListAPI:
         #  is used as an "exists" check too in other places, lets respect the None return
         assert pref.revision is None, "latest_package_revision: ref already have a revision"
         assert pref.package_id is not None, "package_id must be defined"
-        app = ConanApp(self.conan_api)
+        app = ConanBasicApp(self.conan_api)
         if remote:
             ret = app.remote_manager.get_latest_package_reference(pref, remote=remote)
         else:
@@ -60,7 +60,7 @@ class ListAPI:
     def package_revisions(self, pref: PkgReference, remote=None):
         assert pref.ref.revision is not None, "package_revisions requires a recipe revision, " \
                                               "check latest first if needed"
-        app = ConanApp(self.conan_api)
+        app = ConanBasicApp(self.conan_api)
         if remote:
             results = app.remote_manager.get_package_revisions_references(pref, remote=remote)
         else:
@@ -71,12 +71,11 @@ class ListAPI:
                                 remote=None) -> Dict[PkgReference, dict]:
         assert ref.revision is not None, "packages: ref should have a revision. " \
                                          "Check latest if needed."
+        app = ConanBasicApp(self.conan_api)
         if not remote:
-            app = ConanApp(self.conan_api)
             prefs = app.cache.get_package_references(ref)
             packages = _get_cache_packages_binary_info(app.cache, prefs)
         else:
-            app = ConanApp(self.conan_api)
             if ref.revision == "latest":
                 ref.revision = None
                 ref = app.remote_manager.get_latest_recipe_reference(ref, remote=remote)
@@ -143,7 +142,7 @@ class ListAPI:
         select_bundle = PackagesList()
         # Avoid doing a ``search`` of recipes if it is an exact ref and it will be used later
         search_ref = pattern.search_ref
-        app = ConanApp(self.conan_api)
+        app = ConanBasicApp(self.conan_api)
         limit_time = timelimit(lru) if lru else None
         out = ConanOutput()
         remote_name = "local cache" if not remote else remote.name

{conan_server-2.10.3 → conan_server-2.11.0}/conan/api/subapi/local.py

@@ -19,9 +19,6 @@ class LocalAPI:
     def __init__(self, conan_api):
         self._conan_api = conan_api
         self.editable_packages = EditablePackages(conan_api.home_folder)
-        editables = conan_api.workspace.editables()
-        if editables:
-            self.editable_packages.edited_refs.update(editables)
 
     @staticmethod
     def get_conanfile_path(path, cwd, py):
@@ -50,30 +47,27 @@ class LocalAPI:
 
     def editable_add(self, path, name=None, version=None, user=None, channel=None, cwd=None,
                      output_folder=None, remotes=None):
-        path = self._conan_api.local.get_conanfile_path(path, cwd, py=True)
+        path = self.get_conanfile_path(path, cwd, py=True)
         app = ConanApp(self._conan_api)
         conanfile = app.loader.load_named(path, name, version, user, channel, remotes=remotes)
         if conanfile.name is None or conanfile.version is None:
             raise ConanException("Editable package recipe should declare its name and version")
         ref = RecipeReference(conanfile.name, conanfile.version, conanfile.user, conanfile.channel)
         # Retrieve conanfile.py from target_path
-        target_path = self._conan_api.local.get_conanfile_path(path=path, cwd=cwd, py=True)
+        target_path = self.get_conanfile_path(path=path, cwd=cwd, py=True)
         output_folder = make_abs_path(output_folder) if output_folder else None
         # Check the conanfile is there, and name/version matches
-        editable_packages = EditablePackages(self._conan_api.home_folder)
-        editable_packages.add(ref, target_path, output_folder=output_folder)
+        self.editable_packages.add(ref, target_path, output_folder=output_folder)
         return ref
 
     def editable_remove(self, path=None, requires=None, cwd=None):
         if path:
             path = make_abs_path(path, cwd)
             path = os.path.join(path, "conanfile.py")
-        editable_packages = EditablePackages(self._conan_api.home_folder)
-        return editable_packages.remove(path, requires)
+        return self.editable_packages.remove(path, requires)
 
     def editable_list(self):
-        editable_packages = EditablePackages(self._conan_api.home_folder)
-        return editable_packages.edited_refs
+        return self.editable_packages.edited_refs
 
     def source(self, path, name=None, version=None, user=None, channel=None, remotes=None):
         """ calls the 'source()' method of the current (user folder) conanfile.py

{conan_server-2.10.3 → conan_server-2.11.0}/conan/api/subapi/remotes.py

@@ -29,7 +29,8 @@ class RemotesAPI:
     def __init__(self, conan_api):
         # This method is private, the subapi is not instantiated by users
         self.conan_api = conan_api
-        self._remotes_file = HomePaths(self.conan_api.cache_folder).remotes_path
+        self._home_folder = conan_api.home_folder
+        self._remotes_file = HomePaths(self._home_folder).remotes_path
 
     def list(self, pattern=None, only_enabled=True):
         """
@@ -107,7 +108,7 @@ class RemotesAPI:
         :param index: if not defined, the new remote will be last one. Pass an integer to insert
           the remote in that position instead of the last one
         """
-        add_local_recipes_index_remote(self.conan_api, remote)
+        add_local_recipes_index_remote(self._home_folder, remote)
         remotes = _load(self._remotes_file)
         if remote.remote_type != LOCAL_RECIPES_INDEX:
             _validate_url(remote.url)
@@ -142,9 +143,9 @@ class RemotesAPI:
         removed = _filter(remotes, pattern, only_enabled=False)
         remotes = [r for r in remotes if r not in removed]
         _save(self._remotes_file, remotes)
-        localdb = LocalDB(self.conan_api.cache_folder)
+        localdb = LocalDB(self._home_folder)
         for remote in removed:
-            remove_local_recipes_index_remote(self.conan_api, remote)
+            remove_local_recipes_index_remote(self._home_folder, remote)
             localdb.clean(remote_url=remote.url)
         return removed
 
@@ -201,7 +202,7 @@ class RemotesAPI:
 
     def user_info(self, remote: Remote):
         # TODO: Review
-        localdb = LocalDB(self.conan_api.cache_folder)
+        localdb = LocalDB(self._home_folder)
         user_info = {}
         user, token, _ = localdb.get_login(remote.url)
         user_info["name"] = remote.name
@@ -226,29 +227,30 @@ class RemotesAPI:
 
         :param remote: The ``Remote`` object to logout
         """
-        localdb = LocalDB(self.conan_api.cache_folder)
+        localdb = LocalDB(self._home_folder)
         # The localdb only stores url + username + token, not remote name, so use URL as key
         localdb.clean(remote_url=remote.url)
 
     def user_set(self, remote: Remote, username):
         # TODO: Review
-        localdb = LocalDB(self.conan_api.cache_folder)
+        localdb = LocalDB(self._home_folder)
         if username == "":
             username = None
         localdb.store(username, token=None, refresh_token=None, remote_url=remote.url)
 
     def user_auth(self, remote: Remote, with_user=False, force=False):
         # TODO: Review
+        localdb = LocalDB(self._home_folder)
         app = ConanApp(self.conan_api)
         if with_user:
-            user, token, _ = app.localdb.get_login(remote.url)
+            user, token, _ = localdb.get_login(remote.url)
             if not user:
                 var_name = f"CONAN_LOGIN_USERNAME_{remote.name.replace('-', '_').upper()}"
                 user = os.getenv(var_name, None) or os.getenv("CONAN_LOGIN_USERNAME", None)
             if not user:
                 return
         app.remote_manager.check_credentials(remote, force)
-        user, token, _ = app.localdb.get_login(remote.url)
+        user, token, _ = localdb.get_login(remote.url)
         return user
 
 

{conan_server-2.10.3 → conan_server-2.11.0}/conan/api/subapi/workspace.py

@@ -27,7 +27,8 @@ class WorkspaceAPI:
     def config_folder(self):
         return self._workspace.config_folder()
 
-    def editables(self):
+    @property
+    def editable_packages(self):
         return self._workspace.editables()
 
     def open(self, require, remotes, cwd=None):

{conan_server-2.10.3 → conan_server-2.11.0}/conan/cli/cli.py

@@ -249,7 +249,7 @@ def _warn_python_version():
 def _warn_frozen_center(conan_api):
     remotes = conan_api.remotes.list()
     for r in remotes:
-        if r.url == "https://center.conan.io":
+        if r.url == "https://center.conan.io" and not r.disabled:
             ConanOutput().warning(
                 "The remote 'https://center.conan.io' is now frozen and has been replaced by 'https://center2.conan.io'. \n"
                 "Starting from Conan 2.9.2, the default remote is 'center2.conan.io'. \n"

{conan_server-2.10.3 → conan_server-2.11.0}/conan/cli/printers/graph.py

@@ -68,6 +68,10 @@ def print_graph_basic(graph):
                        "it might be removed in 3.0.")
         output.warning("Consider using version-ranges instead.")
     _format_resolved("Resolved version ranges", graph.resolved_ranges)
+    for req in graph.resolved_ranges:
+        if str(req.version) == "[]":
+            output.warning("Empty version range usage is discouraged. Use [*] instead", warn_tag="deprecated")
+            break
 
     overrides = graph.overrides()
     if overrides:

{conan_server-2.10.3 → conan_server-2.11.0}/conan/internal/api/local/editable.py

@@ -12,7 +12,10 @@ EDITABLE_PACKAGES_FILE = 'editable_packages.json'
 
 
 class EditablePackages:
-    def __init__(self, cache_folder):
+    def __init__(self, cache_folder=None):
+        if cache_folder is None:
+            self._edited_refs = {}
+            return
         self._edited_file = normpath(join(cache_folder, EDITABLE_PACKAGES_FILE))
         if os.path.exists(self._edited_file):
             edited = load(self._edited_file)
@@ -22,6 +25,17 @@ class EditablePackages:
         else:
             self._edited_refs = {}  # {ref: {"path": path, "layout": layout}}
 
+    def update_copy(self, ws_editables):
+        """
+        Create a new instance with the union of the editable packages of self and other
+        """
+        if ws_editables is None:
+            return self
+        result = EditablePackages()
+        result._edited_refs = self._edited_refs.copy()
+        result._edited_refs.update(ws_editables)
+        return result
+
     @property
     def edited_refs(self):
         return self._edited_refs

{conan_server-2.10.3 → conan_server-2.11.0}/conan/internal/api/profile/profile_loader.py

@@ -123,7 +123,10 @@ class ProfileLoader:
                    "conan_version": conan_version,
                    "detect_api": detect_api}
 
-        rtemplate = Environment(loader=FileSystemLoader(base_path)).from_string(text)
+        # Always include the root Conan home "profiles" folder as secondary route for loading
+        # imports and includes from jinja2 templates.
+        loader_paths = [base_path, profiles_folder]
+        rtemplate = Environment(loader=FileSystemLoader(loader_paths)).from_string(text)
 
         try:
             text = rtemplate.render(context)

{conan_server-2.10.3 → conan_server-2.11.0}/conan/internal/conan_app.py

@@ -5,7 +5,6 @@ from conan.internal.cache.home_paths import HomePaths
 from conans.client.graph.proxy import ConanProxy
 from conans.client.graph.python_requires import PyRequireLoader
 from conans.client.graph.range_resolver import RangeResolver
-from conans.client.hook_manager import HookManager
 from conans.client.loader import ConanFileLoader, load_python_file
 from conans.client.remote_manager import RemoteManager
 from conans.client.rest.auth_manager import ConanApiAuthManager
@@ -36,29 +35,42 @@ class ConanFileHelpers:
         self.home_folder = home_folder
 
 
-class ConanApp:
+class ConanBasicApp:
     def __init__(self, conan_api):
+        """ Needs:
+        - Global configuration
+        - Cache home folder
+        """
         global_conf = conan_api.config.global_conf
+        self.global_conf = global_conf
         cache_folder = conan_api.home_folder
         self.cache_folder = cache_folder
         self.cache = PkgCache(self.cache_folder, global_conf)
 
-        home_paths = HomePaths(self.cache_folder)
-
         # Wraps an http_requester to inject proxies, certs, etc
         self.requester = ConanRequester(global_conf, cache_folder)
         # To handle remote connections
         # Wraps RestApiClient to add authentication support (same interface)
-        self.localdb = LocalDB(cache_folder)
-        auth_manager = ConanApiAuthManager(self.requester, cache_folder, self.localdb, global_conf)
+        localdb = LocalDB(cache_folder)
+        auth_manager = ConanApiAuthManager(self.requester, cache_folder, localdb, global_conf)
         # Handle remote connections
         self.remote_manager = RemoteManager(self.cache, auth_manager, cache_folder)
+        global_editables = conan_api.local.editable_packages
+        ws_editables = conan_api.workspace.editable_packages
+        self.editable_packages = global_editables.update_copy(ws_editables)
 
-        self.proxy = ConanProxy(self, conan_api.local.editable_packages)
-        self.range_resolver = RangeResolver(self, global_conf, conan_api.local.editable_packages)
 
-        self.pyreq_loader = PyRequireLoader(self, global_conf)
-        cmd_wrap = CmdWrapper(home_paths.wrapper_path)
-        conanfile_helpers = ConanFileHelpers(self.requester, cmd_wrap, global_conf, self.cache,
+class ConanApp(ConanBasicApp):
+    def __init__(self, conan_api):
+        """ Needs:
+        - LocalAPI to read editable packages
+        """
+        super().__init__(conan_api)
+        self.proxy = ConanProxy(self, self.editable_packages)
+        self.range_resolver = RangeResolver(self, self.global_conf, self.editable_packages)
+
+        self.pyreq_loader = PyRequireLoader(self, self.global_conf)
+        cmd_wrap = CmdWrapper(HomePaths(self.cache_folder).wrapper_path)
+        conanfile_helpers = ConanFileHelpers(self.requester, cmd_wrap, self.global_conf, self.cache,
                                              self.cache_folder)
         self.loader = ConanFileLoader(self.pyreq_loader, conanfile_helpers)

{conan_server-2.10.3 → conan_server-2.11.0}/conan/test/utils/tools.py

@@ -24,6 +24,8 @@ from mock import Mock
 from requests.exceptions import HTTPError
 from webtest.app import TestApp
 
+from conan.api.subapi.config import ConfigAPI
+from conan.api.subapi.remotes import _save
 from conan.cli.exit_codes import SUCCESS, ERROR_GENERAL
 from conan.internal.cache.cache import PackageLayout, RecipeLayout, PkgCache
 from conan.internal.cache.home_paths import HomePaths
@@ -456,10 +458,10 @@ class TestClient:
         # create default profile
         if light:
             text = "[settings]\nos=Linux"  # Needed at least build-os
-            save(self.cache.settings_path, "os: [Linux, Windows]")
+            save(self.paths.settings_path, "os: [Linux, Windows]")
         else:
             text = default_profiles[platform.system()]
-        save(self.cache.default_profile_path, text)
+        save(os.path.join(self.cache_folder, "profiles", "default"), text)
         # Using internal env variable to add another custom commands folder
         self._custom_commands_folder = custom_commands_folder
 
@@ -475,23 +477,11 @@ class TestClient:
     @property
     def cache(self):
         # Returns a temporary cache object intended for inspecting it
-        api = ConanAPI(cache_folder=self.cache_folder)
-        global_conf = api.config.global_conf
-
-        class MyCache(PkgCache, HomePaths):  # Temporary class to avoid breaking all tests
-            def __init__(self, cache_folder):
-                PkgCache.__init__(self, cache_folder, global_conf)
-                HomePaths.__init__(self, cache_folder)
-
-            @property
-            def plugins_path(self):  # Temporary to not break tests
-                return os.path.join(self._home, "extensions", "plugins")
-
-            @property
-            def default_profile_path(self):
-                return os.path.join(self._home, "profiles", "default")
+        return PkgCache(self.cache_folder, ConfigAPI.load_config(self.cache_folder))
 
-        return MyCache(self.cache_folder)
+    @property
+    def paths(self):
+        return HomePaths(self.cache_folder)
 
     @property
     def base_folder(self):
@@ -503,17 +493,15 @@ class TestClient:
         return self.cache.store
 
     def update_servers(self):
-        api = ConanAPI(cache_folder=self.cache_folder)
-        for r in api.remotes.list():
-            api.remotes.remove(r.name)
-
+        remotes = []
         for name, server in self.servers.items():
             if isinstance(server, ArtifactoryServer):
-                api.remotes.add(Remote(name, server.repo_api_url))
+                remotes.append(Remote(name, server.repo_api_url))
             elif isinstance(server, TestServer):
-                api.remotes.add(Remote(name, server.fake_url))
+                remotes.append(Remote(name, server.fake_url))
             else:
-                api.remotes.add(Remote(name, server))
+                remotes.append(Remote(name, server))
+        _save(HomePaths(self.cache_folder).remotes_path, remotes)
 
     @contextmanager
     def chdir(self, newdir):
@@ -563,7 +551,7 @@ class TestClient:
         try:
             if self._custom_commands_folder:
                 with environment_update({_CONAN_INTERNAL_CUSTOM_COMMANDS_PATH:
-                                             self._custom_commands_folder}):
+                                         self._custom_commands_folder}):
                     command.run(args)
             else:
                 command.run(args)

{conan_server-2.10.3 → conan_server-2.11.0}/conan/tools/cmake/cmakedeps/templates/macros.py

@@ -65,8 +65,7 @@ class MacrosTemplate(CMakeDepsFileTemplate):
                                   NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
                      set(CMAKE_FIND_LIBRARY_SUFFIXES ${_OLD_CMAKE_FIND_LIBRARY_SUFFIXES})
                      if(NOT CONAN_SHARED_FOUND_LIBRARY)
-                       message(STATUS "Cannot locate shared library: ${_LIBRARY_NAME}")
-                       message(DEBUG "DLL library not found, creating UNKNOWN IMPORTED target")
+                       message(DEBUG "DLL library not found, creating UNKNOWN IMPORTED target, searched for: ${_LIBRARY_NAME}")
                        if(NOT TARGET ${_LIB_NAME})
                           add_library(${_LIB_NAME} UNKNOWN IMPORTED)
                        endif()

{conan_server-2.10.3 → conan_server-2.11.0}/conan/tools/cmake/cmakedeps2/target_configuration.py

@@ -4,6 +4,7 @@ import textwrap
 import jinja2
 from jinja2 import Template
 
+from conan.api.output import ConanOutput
 from conan.errors import ConanException
 from conans.client.graph.graph import CONTEXT_BUILD, CONTEXT_HOST
 from conans.model.pkg_type import PackageType
@@ -166,7 +167,7 @@ class TargetConfigurationTemplate2:
                   "system_libs": system_libs}
 
         if info.frameworks:
-            self._conanfile.output.warning("frameworks not supported yet in new CMakeDeps generator")
+            ConanOutput(scope=str(self._conanfile)).warning("frameworks not supported yet in new CMakeDeps generator")
 
         if info.libs:
             if len(info.libs) != 1:

{conan_server-2.10.3 → conan_server-2.11.0}/conan/tools/env/environment.py

@@ -3,6 +3,7 @@ import textwrap
 from collections import OrderedDict
 from contextlib import contextmanager
 
+from conan.api.output import ConanOutput
 from conan.internal.api.install.generators import relativize_paths
 from conans.client.subsystems import deduce_subsystem, WINDOWS, subsystem_path
 from conan.errors import ConanException
@@ -14,7 +15,7 @@ class _EnvVarPlaceHolder:
     pass
 
 
-def environment_wrap_command(env_filenames, env_folder, cmd, subsystem=None,
+def environment_wrap_command(conanfile, env_filenames, env_folder, cmd, subsystem=None,
                              accepted_extensions=None):
     if not env_filenames:
         return cmd
@@ -51,22 +52,24 @@ def environment_wrap_command(env_filenames, env_folder, cmd, subsystem=None,
         raise ConanException("Cannot wrap command with different envs,"
                              "{} - {}".format(bats+ps1s, shs))
 
+    powershell = conanfile.conf.get("tools.env.virtualenv:powershell") or "powershell.exe"
+    powershell = "powershell.exe" if powershell is True else powershell
+
     if bats:
         launchers = " && ".join('"{}"'.format(b) for b in bats)
         if ps1s:
-            ps1_launchers = " ; ".join('"&\'{}\'"'.format(f) for f in ps1s)
-            cmd = cmd.replace('"', "'")
-            return '{} && powershell.exe {} ; cmd /c {}'.format(launchers, ps1_launchers, cmd)
+            ps1_launchers = f'{powershell} -Command "' + " ; ".join('&\'{}\''.format(f) for f in ps1s) + '"'
+            cmd = cmd.replace('"', r'\"')
+            return '{} && {} ; cmd /c "{}"'.format(launchers, ps1_launchers, cmd)
         else:
             return '{} && {}'.format(launchers, cmd)
     elif shs:
         launchers = " && ".join('. "{}"'.format(f) for f in shs)
         return '{} && {}'.format(launchers, cmd)
     elif ps1s:
-        # TODO: at the moment it only works with path without spaces
-        launchers = " ; ".join('"&\'{}\'"'.format(f) for f in ps1s)
-        cmd = cmd.replace('"', "'")
-        return 'powershell.exe {} ; cmd /c {}'.format(launchers, cmd)
+        ps1_launchers = f'{powershell} -Command "' + " ; ".join('&\'{}\''.format(f) for f in ps1s) + '"'
+        cmd = cmd.replace('"', r'\"')
+        return '{} ; cmd /c "{}"'.format(ps1_launchers, cmd)
     else:
         return cmd
 
@@ -523,7 +526,8 @@ class EnvVars:
     def save_script(self, filename):
         """
         Saves a script file (bat, sh, ps1) with a launcher to set the environment.
-        If the conf "tools.env.virtualenv:powershell" is set to True it will generate powershell
+        If the conf "tools.env.virtualenv:powershell" is not an empty string
+        it will generate powershell
         launchers if Windows.
 
         :param filename: Name of the file to generate. If the extension is provided, it will generate
@@ -536,7 +540,19 @@ class EnvVars:
             is_ps1 = ext == ".ps1"
         else:  # Need to deduce it automatically
             is_bat = self._subsystem == WINDOWS
-            is_ps1 = self._conanfile.conf.get("tools.env.virtualenv:powershell", check_type=bool)
+            try:
+                is_ps1 = self._conanfile.conf.get("tools.env.virtualenv:powershell", check_type=bool)
+                if is_ps1 is not None:
+                    ConanOutput().warning(
+                        "Boolean values for 'tools.env.virtualenv:powershell' are deprecated. "
+                        "Please specify 'powershell.exe' or 'pwsh' instead, appending arguments if needed "
+                        "(for example: 'powershell.exe -argument'). "
+                        "To unset this configuration, use `tools.env.virtualenv:powershell=!`, which matches "
+                        "the previous 'False' behavior.",
+                        warn_tag="deprecated"
+                    )
+            except ConanException:
+                is_ps1 = self._conanfile.conf.get("tools.env.virtualenv:powershell", check_type=str)
             if is_ps1:
                 filename = filename + ".ps1"
                 is_bat = False