def test_load_plugins_with_plugins_disabled(
no_plugin_manager: PluginManager,
poetry: Poetry,
io: BufferedIO,
with_my_plugin: None,
):
no_plugin_manager.load_plugins()
assert poetry.package.version.text == "1.2.3"
assert io.fetch_output() == ""
def test_load_plugins_with_plugins_disabled(
no_plugin_manager: PluginManager,
poetry: Poetry,
io: BufferedIO,
mocker: MockerFixture,
):
mocker.patch(
"entrypoints.get_group_all",
return_value=[
EntryPoint("my-plugin", "tests.plugins.test_plugin_manager", "MyPlugin")
],
)
no_plugin_manager.load_plugins()
assert poetry.package.version.text == "1.2.3"
assert io.fetch_output() == ""
def create_poetry(
self,
cwd: Optional[Path] = None,
io: Optional[IO] = None,
disable_plugins: bool = False,
) -> Poetry:
if io is None:
io = NullIO()
base_poetry = super(Factory, self).create_poetry(cwd)
locker = Locker(
base_poetry.file.parent / "poetry.lock", base_poetry.local_config
)
# Loading global configuration
config = self.create_config(io)
# Loading local configuration
local_config_file = TOMLFile(base_poetry.file.parent / "poetry.toml")
if local_config_file.exists():
if io.is_debug():
io.write_line(
"Loading configuration file {}".format(local_config_file.path)
)
config.merge(local_config_file.read())
# Load local sources
repositories = {}
existing_repositories = config.get("repositories", {})
for source in base_poetry.pyproject.poetry_config.get("source", []):
name = source.get("name")
url = source.get("url")
if name and url:
if name not in existing_repositories:
repositories[name] = {"url": url}
config.merge({"repositories": repositories})
poetry = Poetry(
base_poetry.file.path,
base_poetry.local_config,
base_poetry.package,
locker,
config,
)
# Configuring sources
self.configure_sources(
poetry, poetry.local_config.get("source", []), config, io
)
plugin_manager = PluginManager("plugin", disable_plugins=disable_plugins)
plugin_manager.load_plugins()
poetry.set_plugin_manager(plugin_manager)
plugin_manager.activate(poetry, io)
return poetry
def _load_plugins(self, io: "IO") -> None:
if self._plugins_loaded:
return
self._disable_plugins = io.input.has_parameter_option("--no-plugins")
if not self._disable_plugins:
from poetry.plugins.plugin_manager import PluginManager
manager = PluginManager("application.plugin")
manager.load_plugins()
manager.activate(self)
self._plugins_loaded = True
def _load_plugins(self, io: IO = None) -> None:
if self._plugins_loaded:
return
if io is None:
io = NullIO()
self._disable_plugins = io.input.has_parameter_option("--no-plugins")
if not self._disable_plugins:
from poetry.plugins.application_plugin import ApplicationPlugin
from poetry.plugins.plugin_manager import PluginManager
manager = PluginManager(ApplicationPlugin.group)
manager.load_plugins()
manager.activate(self)
self._plugins_loaded = True
def handle(self) -> int:
from poetry.plugins.application_plugin import ApplicationPlugin
from poetry.plugins.plugin import Plugin
from poetry.plugins.plugin_manager import PluginManager
from poetry.repositories.installed_repository import InstalledRepository
from poetry.utils.env import EnvManager
from poetry.utils.helpers import canonicalize_name
from poetry.utils.helpers import pluralize
plugins: dict[str, dict[str,
Any]] = defaultdict(lambda: {
"package": None,
"plugins": [],
"application_plugins": [],
})
entry_points = (
PluginManager(ApplicationPlugin.group).get_plugin_entry_points() +
PluginManager(Plugin.group).get_plugin_entry_points())
system_env = EnvManager.get_system_env(naive=True)
installed_repository = InstalledRepository.load(system_env,
with_dependencies=True)
packages_by_name = {
pkg.name: pkg
for pkg in installed_repository.packages
}
for entry_point in entry_points:
plugin = entry_point.load()
category = "plugins"
if issubclass(plugin, ApplicationPlugin):
category = "application_plugins"
package = packages_by_name[canonicalize_name(
entry_point.distro.name)]
plugins[package.pretty_name]["package"] = package
plugins[package.pretty_name][category].append(entry_point)
for name, info in plugins.items():
package = info["package"]
description = " " + package.description if package.description else ""
self.line("")
self.line(
f" • <c1>{name}</c1> (<c2>{package.version}</c2>){description}"
)
provide_line = " "
if info["plugins"]:
count = len(info["plugins"])
provide_line += f" <info>{count}</info> plugin{pluralize(count)}"
if info["application_plugins"]:
if info["plugins"]:
provide_line += " and"
count = len(info["application_plugins"])
provide_line += (
f" <info>{count}</info> application plugin{pluralize(count)}"
)
self.line(provide_line)
if package.requires:
self.line("")
self.line(" <info>Dependencies</info>")
for dependency in package.requires:
self.line(f" - {dependency.pretty_name}"
f" (<c2>{dependency.pretty_constraint}</c2>)")
return 0
def no_plugin_manager(poetry: Poetry, io: BufferedIO) -> PluginManager:
return PluginManager(Plugin.group, disable_plugins=True)
def _manager(group: str = Plugin.group) -> PluginManager:
return PluginManager(group)
def handle(self) -> int:
from poetry.plugins.application_plugin import ApplicationPlugin
from poetry.plugins.plugin_manager import PluginManager
from poetry.repositories.installed_repository import InstalledRepository
from poetry.utils.env import EnvManager
from poetry.utils.helpers import canonicalize_name
plugins: DefaultDict[str, Dict[str, Union[
"Package", List[str]]]] = defaultdict(lambda: {
"package": None,
"plugins": [],
"application_plugins": [],
})
entry_points = (
PluginManager("application.plugin").get_plugin_entry_points() +
PluginManager("plugin").get_plugin_entry_points())
system_env = EnvManager.get_system_env(naive=True)
installed_repository = InstalledRepository.load(system_env,
with_dependencies=True)
packages_by_name = {
pkg.name: pkg
for pkg in installed_repository.packages
}
for entry_point in entry_points:
plugin = entry_point.load()
category = "plugins"
if issubclass(plugin, ApplicationPlugin):
category = "application_plugins"
package = packages_by_name[canonicalize_name(entry_point.name)]
plugins[package.pretty_name]["package"] = package
plugins[package.pretty_name][category].append(entry_point)
for name, info in plugins.items():
package = info["package"]
self.line("")
self.line(" • <c1>{}</c1> (<c2>{}</c2>){}".format(
name,
package.version,
" " + package.description if package.description else "",
))
provide_line = " "
if info["plugins"]:
provide_line += " <info>{}</info> plugin{}".format(
len(info["plugins"]),
"s" if len(info["plugins"]) > 1 else "")
if info["application_plugins"]:
if info["plugins"]:
provide_line += " and"
provide_line += " <info>{}</info> application plugin{}".format(
len(info["application_plugins"]),
"s" if len(info["application_plugins"]) > 1 else "",
)
self.line(provide_line)
if package.requires:
self.line("")
self.line(" <info>Dependencies</info>")
for dependency in package.requires:
self.line(" - {} (<c2>{}</c2>)".format(
dependency.pretty_name, dependency.pretty_constraint))
return 0
def _system_project_handle(self) -> int:
from poetry.plugins.application_plugin import ApplicationPlugin
from poetry.plugins.plugin import Plugin
from poetry.plugins.plugin_manager import PluginManager
from poetry.repositories.installed_repository import InstalledRepository
from poetry.utils.env import EnvManager
from poetry.utils.helpers import canonicalize_name
from poetry.utils.helpers import pluralize
plugins: dict[str, PluginPackage] = {}
system_env = EnvManager.get_system_env(naive=True)
entry_points = PluginManager(
ApplicationPlugin.group).get_plugin_entry_points(
env=system_env) + PluginManager(
Plugin.group).get_plugin_entry_points(env=system_env)
installed_repository = InstalledRepository.load(system_env,
with_dependencies=True)
packages_by_name: dict[str, Package] = {
pkg.name: pkg
for pkg in installed_repository.packages
}
for entry_point in entry_points:
plugin = entry_point.load()
assert entry_point.distro is not None
package = packages_by_name[canonicalize_name(
entry_point.distro.name)]
name = package.pretty_name
info = plugins.get(name) or PluginPackage(package=package)
if issubclass(plugin, ApplicationPlugin):
info.application_plugins.append(entry_point)
else:
info.plugins.append(entry_point)
plugins[name] = info
for name, info in plugins.items():
package = info.package
description = " " + package.description if package.description else ""
self.line("")
self.line(
f" • <c1>{name}</c1> (<c2>{package.version}</c2>){description}"
)
provide_line = " "
if info.plugins:
count = len(info.plugins)
provide_line += f" <info>{count}</info> plugin{pluralize(count)}"
if info.application_plugins:
if info.plugins:
provide_line += " and"
count = len(info.application_plugins)
provide_line += (
f" <info>{count}</info> application plugin{pluralize(count)}"
)
self.line(provide_line)
if package.requires:
self.line("")
self.line(" <info>Dependencies</info>")
for dependency in package.requires:
self.line(f" - {dependency.pretty_name}"
f" (<c2>{dependency.pretty_constraint}</c2>)")
return 0
def create_poetry(
self,
cwd: Path | None = None,
io: IO | None = None,
disable_plugins: bool = False,
disable_cache: bool = False,
) -> Poetry:
if io is None:
io = NullIO()
base_poetry = super().create_poetry(cwd)
locker = Locker(base_poetry.file.parent / "poetry.lock",
base_poetry.local_config)
# Loading global configuration
with warnings.catch_warnings():
# this is preserved to ensure export plugin tests pass in ci,
# once poetry-plugin-export version is updated to use one that do not
# use Factory.create_config(), this can be safely removed.
warnings.filterwarnings("ignore", category=DeprecationWarning)
config = self.create_config()
# Loading local configuration
local_config_file = TOMLFile(base_poetry.file.parent / "poetry.toml")
if local_config_file.exists():
if io.is_debug():
io.write_line(
f"Loading configuration file {local_config_file.path}")
config.merge(local_config_file.read())
# Load local sources
repositories = {}
existing_repositories = config.get("repositories", {})
for source in base_poetry.pyproject.poetry_config.get("source", []):
name = source.get("name")
url = source.get("url")
if name and url and name not in existing_repositories:
repositories[name] = {"url": url}
config.merge({"repositories": repositories})
poetry = Poetry(
base_poetry.file.path,
base_poetry.local_config,
base_poetry.package,
locker,
config,
)
# Configuring sources
self.configure_sources(
poetry,
poetry.local_config.get("source", []),
config,
io,
disable_cache=disable_cache,
)
plugin_manager = PluginManager(Plugin.group,
disable_plugins=disable_plugins)
plugin_manager.load_plugins()
poetry.set_plugin_manager(plugin_manager)
plugin_manager.activate(poetry, io)
return poetry
def _manager(type: str = "plugin") -> PluginManager:
return PluginManager(type)
def no_plugin_manager(poetry, io):
return PluginManager("plugin", disable_plugins=True)
def _manager(type="plugin"):
return PluginManager(type)