def handle(self) -> int:
from pathlib import Path
from cleo.io.inputs.string_input import StringInput
from cleo.io.io import IO
from poetry.factory import Factory
from poetry.utils.env import EnvManager
plugins = self.argument("plugins")
system_env = EnvManager.get_system_env(naive=True)
env_dir = Path(os.getenv("POETRY_HOME") or system_env.path)
# From this point forward, all the logic will be deferred to
# the remove command, by using the global `pyproject.toml` file.
application = cast(Application, self.application)
remove_command: RemoveCommand = cast(RemoveCommand,
application.find("remove"))
# We won't go through the event dispatching done by the application
# so we need to configure the command manually
remove_command.set_poetry(Factory().create_poetry(env_dir))
remove_command.set_env(system_env)
application._configure_installer(remove_command, self._io)
argv = ["remove"] + plugins
if self.option("dry-run"):
argv.append("--dry-run")
return remove_command.run(
IO(
StringInput(" ".join(argv)),
self._io.output,
self._io.error_output,
))
def execute(
self,
args: Optional[str] = "",
inputs: Optional[str] = None,
interactive: Optional[bool] = None,
verbosity: Optional[Verbosity] = None,
decorated: Optional[bool] = None,
supports_utf8: bool = True,
) -> int:
"""
Executes the command
"""
application = self._command.application
input = StringInput(args)
if application is not None and application.definition.has_argument("command"):
name = self._command.name
if " " in name:
# If the command is namespaced we rearrange
# the input to parse it as a single argument
argv = [application.name, self._command.name] + input._tokens
input = ArgvInput(argv)
else:
input = StringInput(name + " " + args)
self._io.set_input(input)
self._io.output.set_supports_utf8(supports_utf8)
self._io.error_output.set_supports_utf8(supports_utf8)
if inputs is not None:
self._io.input.set_stream(StringIO(inputs))
if interactive is not None:
self._io.interactive(interactive)
if verbosity is not None:
self._io.set_verbosity(verbosity)
if decorated is not None:
self._io.decorated(decorated)
self._status_code = self._command.run(self._io)
return self._status_code
def call(self, name: str, args: Optional[str] = None) -> int:
"""
Call another command.
"""
if args is None:
args = ""
input = StringInput(args)
command = self.application.get(name)
return self.application._run_command(command, self._io.with_input(input))
def call_silent(self, name, args=None): # type: (str, Optional[str]) -> int
"""
Call another command silently.
"""
if args is None:
args = ""
args = StringInput(args)
command = self.application.get(name)
return self.application._run_command(command, NullIO(input))
def handle(self) -> int:
self.line_error(self.help)
application = cast(Application, self.application)
command: SelfShowPluginsCommand = cast(
SelfShowPluginsCommand, application.find("self show plugins"))
exit_code: int = command.run(
IO(
StringInput(""),
self.io.output,
self.io.error_output,
))
return exit_code
def handle(self) -> int:
self.line_error(self.deprecation)
application = self.get_application()
command: SelfAddCommand = application.find("self add")
application.configure_installer_for_command(command, self.io)
argv: list[str] = ["add", *self.argument("plugins")]
if self.option("--dry-run"):
argv.append("--dry-run")
exit_code: int = command.run(
IO(
StringInput(" ".join(argv)),
self.io.output,
self.io.error_output,
))
return exit_code
def handle(self) -> int:
self.line_error(self.help)
application = cast(Application, self.application)
command: SelfRemoveCommand = cast(SelfRemoveCommand,
application.find("self remove"))
application.configure_installer_for_command(command, self.io)
argv: list[str] = ["remove", *self.argument("plugins")]
if self.option("--dry-run"):
argv.append("--dry-run")
exit_code: int = command.run(
IO(
StringInput(" ".join(argv)),
self.io.output,
self.io.error_output,
))
return exit_code
def _system_project_handle(self) -> int:
self.write("<info>Updating Poetry version ...</info>\n\n")
application = self.get_application()
add_command: AddCommand = application.find("add")
add_command.set_env(self.env)
application.configure_installer_for_command(add_command, self.io)
argv = ["add", f"poetry@{self.argument('version')}"]
if self.option("dry-run"):
argv.append("--dry-run")
if self.option("preview"):
argv.append("--allow-prereleases")
exit_code: int = add_command.run(
IO(
StringInput(" ".join(argv)),
self.io.output,
self.io.error_output,
))
return exit_code
def execute(
self,
args: Optional[str] = "",
inputs: Optional[str] = None,
interactive: Optional[bool] = None,
verbosity: Optional[Verbosity] = None,
decorated: bool = False,
supports_utf8: bool = True,
) -> int:
"""
Executes the command
"""
self._io.clear()
input = StringInput(args)
self._io.set_input(input)
self._io.decorated(decorated)
self._io.output.set_supports_utf8(supports_utf8)
self._io.error_output.set_supports_utf8(supports_utf8)
if inputs is not None:
self._io.input.set_stream(StringIO(inputs))
if interactive is not None:
self._io.interactive(interactive)
if verbosity is not None:
self._io.set_verbosity(verbosity)
self._status_code = self._application.run(
self._io.input,
self._io.output,
self._io.error_output,
)
return self._status_code
def handle(self) -> int:
from pathlib import Path
import tomlkit
from cleo.io.inputs.string_input import StringInput
from cleo.io.io import IO
from poetry.core.pyproject.toml import PyProjectTOML
from poetry.core.semver.helpers import parse_constraint
from poetry.factory import Factory
from poetry.packages.project_package import ProjectPackage
from poetry.repositories.installed_repository import InstalledRepository
from poetry.utils.env import EnvManager
plugins = self.argument("plugins")
# Plugins should be installed in the system env to be globally available
system_env = EnvManager.get_system_env(naive=True)
env_dir = Path(os.getenv("POETRY_HOME") or system_env.path)
# We check for the plugins existence first.
if env_dir.joinpath("pyproject.toml").exists():
pyproject = tomlkit.loads(
env_dir.joinpath("pyproject.toml").read_text(encoding="utf-8"))
poetry_content = pyproject["tool"]["poetry"]
existing_packages = self.get_existing_packages_from_input(
plugins, poetry_content, "dependencies")
if existing_packages:
self.notify_about_existing_packages(existing_packages)
plugins = [
plugin for plugin in plugins if plugin not in existing_packages
]
if not plugins:
return 0
plugins = self._determine_requirements(plugins)
# We retrieve the packages installed in the system environment.
# We assume that this environment will be a self contained virtual environment
# built by the official installer or by pipx.
# If not, it might lead to side effects since other installed packages
# might not be required by Poetry but still taken into account when resolving dependencies.
installed_repository = InstalledRepository.load(system_env,
with_dependencies=True)
root_package = None
for package in installed_repository.packages:
if package.name == "poetry":
root_package = ProjectPackage(package.name, package.version)
for dependency in package.requires:
root_package.add_dependency(dependency)
break
root_package.python_versions = ".".join(
str(v) for v in system_env.version_info[:3])
# We create a `pyproject.toml` file based on all the information
# we have about the current environment.
if not env_dir.joinpath("pyproject.toml").exists():
Factory.create_pyproject_from_package(root_package, env_dir)
# We add the plugins to the dependencies section of the previously
# created `pyproject.toml` file
pyproject = PyProjectTOML(env_dir.joinpath("pyproject.toml"))
poetry_content = pyproject.poetry_config
poetry_dependency_section = poetry_content["dependencies"]
plugin_names = []
for plugin in plugins:
if "version" in plugin:
# Validate version constraint
parse_constraint(plugin["version"])
constraint = tomlkit.inline_table()
for name, value in plugin.items():
if name == "name":
continue
constraint[name] = value
if len(constraint) == 1 and "version" in constraint:
constraint = constraint["version"]
poetry_dependency_section[plugin["name"]] = constraint
plugin_names.append(plugin["name"])
pyproject.save()
# From this point forward, all the logic will be deferred to
# the update command, by using the previously created `pyproject.toml`
# file.
application = cast(Application, self.application)
update_command: UpdateCommand = cast(UpdateCommand,
application.find("update"))
# We won't go through the event dispatching done by the application
# so we need to configure the command manually
update_command.set_poetry(Factory().create_poetry(env_dir))
update_command.set_env(system_env)
application._configure_installer(update_command, self._io)
argv = ["update"] + plugin_names
if self.option("dry-run"):
argv.append("--dry-run")
return update_command.run(
IO(
StringInput(" ".join(argv)),
self._io.output,
self._io.error_output,
))
def ansi_io():
input_ = StringInput("")
input_.set_stream(StringIO())
return BufferedIO(input_, decorated=True)
def io():
input_ = StringInput("")
input_.set_stream(StringIO())
return BufferedIO(input_)