def handle(self):
from poetry.installation import Installer
installer = Installer(
self.output,
self.venv,
self.poetry.package,
self.poetry.locker,
self.poetry.pool,
)
extras = []
for extra in self.option("extras"):
if " " in extra:
extras += [e.strip() for e in extra.split(" ")]
else:
extras.append(extra)
installer.extras(extras)
installer.dev_mode(not self.option("no-dev"))
installer.develop(self.option("develop"))
installer.dry_run(self.option("dry-run"))
installer.verbose(self.option("verbose"))
return installer.run()
def handle(self):
from poetry.installation import Installer
packages = self.argument("packages")
is_dev = self.option("dev")
original_content = self.poetry.file.read()
content = self.poetry.file.read()
poetry_content = content["tool"]["poetry"]
section = "dependencies"
if is_dev:
section = "dev-dependencies"
# Deleting entries
requirements = {}
for name in packages:
found = False
for key in poetry_content[section]:
if key.lower() == name.lower():
found = True
requirements[key] = poetry_content[section][key]
break
if not found:
raise ValueError("Package {} not found".format(name))
for key in requirements:
del poetry_content[section][key]
# Write the new content back
self.poetry.file.write(content)
# Update packages
self.reset_poetry()
installer = Installer(self.io, self.env, self.poetry.package,
self.poetry.locker, self.poetry.pool)
installer.dry_run(self.option("dry-run"))
installer.update(True)
installer.whitelist(requirements)
try:
status = installer.run()
except Exception:
self.poetry.file.write(original_content)
raise
if status != 0 or self.option("dry-run"):
# Revert changes
if not self.option("dry-run"):
self.error("\n"
"Removal failed, reverting pyproject.toml "
"to its original content.")
self.poetry.file.write(original_content)
return status
def handle(self):
from poetry.installation import Installer
packages = self.argument('packages')
is_dev = self.option('dev')
original_content = self.poetry.file.read()
content = self.poetry.file.read()
poetry_content = content['tool']['poetry']
section = 'dependencies'
if is_dev:
section = 'dev-dependencies'
# Deleting entries
requirements = {}
for name in packages:
found = False
for key in poetry_content[section]:
if key.lower() == name.lower():
found = True
requirements[name] = poetry_content[section][name]
break
if not found:
raise ValueError('Package {} not found'.format(name))
for key in requirements:
del poetry_content[section][key]
# Write the new content back
self.poetry.file.write(content)
# Update packages
self.reset_poetry()
installer = Installer(self.output, self.venv, self.poetry.package,
self.poetry.locker, self.poetry.pool)
installer.dry_run(self.option('dry-run'))
installer.update(True)
installer.whitelist(requirements)
try:
status = installer.run()
except Exception:
self.poetry.file.write(original_content)
raise
if status != 0 or self.option('dry-run'):
# Revert changes
if not self.option('dry-run'):
self.error('\n'
'Removal failed, reverting pyproject.toml '
'to its original content.')
self.poetry.file.write(original_content)
return status
def handle(self):
installer = Installer(self.output, self.poetry.package,
self.poetry.locker, self.poetry.pool)
installer.update(True)
installer.execute_operations(False)
return installer.run()
def handle(self):
installer = Installer(self.output, self.poetry.package,
self.poetry.locker, self.poetry.pool)
installer.extras(self.option('extras'))
installer.dev_mode(not self.option('no-dev'))
installer.dry_run(self.option('dry-run'))
return installer.run()
def handle(self):
from poetry.installation import Installer
installer = Installer(
self.io, self.env, self.poetry.package, self.poetry.locker, self.poetry.pool
)
installer.lock()
return installer.run()
def handle(self):
from poetry.installation import Installer
from poetry.io import NullIO
from poetry.masonry.builders import SdistBuilder
from poetry.utils._compat import decode
from poetry.utils.env import NullEnv
installer = Installer(
self.output,
self.env,
self.poetry.package,
self.poetry.locker,
self.poetry.pool,
)
extras = []
for extra in self.option("extras"):
if " " in extra:
extras += [e.strip() for e in extra.split(" ")]
else:
extras.append(extra)
installer.extras(extras)
installer.dev_mode(not self.option("no-dev"))
installer.develop(self.option("develop"))
installer.dry_run(self.option("dry-run"))
installer.verbose(self.option("verbose"))
return_code = installer.run()
if return_code != 0:
return return_code
setup = self.poetry.file.parent / "setup.py"
has_setup = setup.exists()
if has_setup:
self.line(
"<warning>A setup.py file already exists. Using it.</warning>")
else:
builder = SdistBuilder(self.poetry, NullEnv(), NullIO())
with setup.open("w") as f:
f.write(decode(builder.build_setup()))
self.line("Installing <info>{}</info> (<comment>{}</comment>)".format(
self.poetry.package.pretty_name,
self.poetry.package.pretty_version))
try:
self.env.run("pip", "install", "-e", str(setup.parent),
"--no-deps")
finally:
if not has_setup:
os.remove(str(setup))
def handle(self):
from poetry.installation import Installer
from poetry.io import NullIO
from poetry.masonry.builders import EditableBuilder
from poetry.masonry.utils.module import ModuleOrPackageNotFound
installer = Installer(
self.output,
self.env,
self.poetry.package,
self.poetry.locker,
self.poetry.pool,
)
extras = []
for extra in self.option("extras"):
if " " in extra:
extras += [e.strip() for e in extra.split(" ")]
else:
extras.append(extra)
installer.extras(extras)
installer.dev_mode(not self.option("no-dev"))
installer.develop(self.option("develop"))
installer.dry_run(self.option("dry-run"))
installer.verbose(self.option("verbose"))
return_code = installer.run()
if return_code != 0:
return return_code
if self.option("no-root"):
return 0
try:
builder = EditableBuilder(self.poetry, self._env, NullIO())
except ModuleOrPackageNotFound:
# This is likely due to the fact that the project is an application
# not following the structure expected by Poetry
# If this is a true error it will be picked up later by build anyway.
return 0
self.line(
" - Installing <info>{}</info> (<comment>{}</comment>)".format(
self.poetry.package.pretty_name,
self.poetry.package.pretty_version))
if self.option("dry-run"):
return 0
builder.build()
return 0
def handle(self):
from poetry.installation import Installer
installer = Installer(self.output, self.venv, self.poetry.package,
self.poetry.locker, self.poetry.pool)
installer.extras(self.option('extras'))
installer.dev_mode(not self.option('no-dev'))
installer.dry_run(self.option('dry-run'))
installer.verbose(self.option('verbose'))
return installer.run()
def handle(self):
from poetry.installation import Installer
installer = Installer(
self.output,
self.env,
self.poetry.package,
self.poetry.locker,
self.poetry.pool,
)
installer.update(True)
installer.execute_operations(False)
return installer.run()
def handle(self):
packages = self.argument('packages')
installer = Installer(self.output, self.venv, self.poetry.package,
self.poetry.locker, self.poetry.pool)
if packages:
installer.whitelist({name: '*' for name in packages})
installer.dev_mode(not self.option('no-dev'))
installer.dry_run(self.option('dry-run'))
# Force update
installer.update(True)
return installer.run()
def handle(self):
from poetry.installation import Installer
packages = self.argument("packages")
installer = Installer(self.io, self.env, self.poetry.package,
self.poetry.locker, self.poetry.pool)
if packages:
installer.whitelist({name: "*" for name in packages})
installer.dev_mode(not self.option("no-dev"))
installer.dry_run(self.option("dry-run"))
installer.execute_operations(not self.option("lock"))
# Force update
installer.update(True)
return installer.run()
def handle(self):
from poetry.installation import Installer
installer = Installer(self.output, self.venv, self.poetry.package,
self.poetry.locker, self.poetry.pool)
extras = []
for extra in self.option('extras'):
if ' ' in extra:
extras += [e.strip() for e in extra.split(' ')]
else:
extras.append(extra)
installer.extras(extras)
installer.dev_mode(not self.option('no-dev'))
installer.develop(self.option('develop'))
installer.dry_run(self.option('dry-run'))
installer.verbose(self.option('verbose'))
return installer.run()
def handle(self):
from poetry.installation import Installer
packages = self.argument("packages")
installer = Installer(
self.output,
self.venv,
self.poetry.package,
self.poetry.locker,
self.poetry.pool,
)
if packages:
installer.whitelist({name: "*" for name in packages})
installer.dev_mode(not self.option("no-dev"))
installer.dry_run(self.option("dry-run"))
# Force update
installer.update(True)
return installer.run()
def handle(self):
from poetry.installation import Installer
from poetry.semver import parse_constraint
from tomlkit import inline_table
packages = self.argument("name")
is_dev = self.option("dev")
if (self.option("git") or self.option("path") or self.option("extras")) and len(
packages
) > 1:
raise ValueError(
"You can only specify one package "
"when using the --git or --path options"
)
if self.option("git") and self.option("path"):
raise RuntimeError("--git and --path cannot be used at the same time")
section = "dependencies"
if is_dev:
section = "dev-dependencies"
original_content = self.poetry.file.read()
content = self.poetry.file.read()
poetry_content = content["tool"]["poetry"]
if section not in poetry_content:
poetry_content[section] = {}
for name in packages:
for key in poetry_content[section]:
if key.lower() == name.lower():
raise ValueError("Package {} is already present".format(name))
if self.option("git") or self.option("path"):
requirements = {packages[0]: ""}
else:
requirements = self._determine_requirements(
packages, allow_prereleases=self.option("allow-prereleases")
)
requirements = self._format_requirements(requirements)
# validate requirements format
for constraint in requirements.values():
parse_constraint(constraint)
for name, _constraint in requirements.items():
constraint = inline_table()
constraint["version"] = _constraint
if self.option("git"):
del constraint["version"]
constraint["git"] = self.option("git")
elif self.option("path"):
del constraint["version"]
constraint["path"] = self.option("path")
if self.option("optional"):
constraint["optional"] = True
if self.option("allow-prereleases"):
constraint["allows-prereleases"] = True
if self.option("extras"):
extras = []
for extra in self.option("extras"):
if " " in extra:
extras += [e.strip() for e in extra.split(" ")]
else:
extras.append(extra)
constraint["extras"] = self.option("extras")
if self.option("python"):
constraint["python"] = self.option("python")
if self.option("platform"):
constraint["platform"] = self.option("platform")
if len(constraint) == 1 and "version" in constraint:
constraint = constraint["version"]
poetry_content[section][name] = constraint
# Write new content
self.poetry.file.write(content)
# Cosmetic new line
self.line("")
# Update packages
self.reset_poetry()
installer = Installer(
self.output,
self.venv,
self.poetry.package,
self.poetry.locker,
self.poetry.pool,
)
installer.dry_run(self.option("dry-run"))
installer.update(True)
installer.whitelist(requirements)
try:
status = installer.run()
except Exception:
self.poetry.file.write(original_content)
raise
if status != 0 or self.option("dry-run"):
# Revert changes
if not self.option("dry-run"):
self.error(
"\n"
"Addition failed, reverting pyproject.toml "
"to its original content."
)
self.poetry.file.write(original_content)
return status
def handle(self):
from poetry.installation import Installer
from poetry.io import NullIO
from poetry.masonry.builders import SdistBuilder
from poetry.masonry.utils.module import ModuleOrPackageNotFound
from poetry.utils._compat import decode
from poetry.utils.env import NullEnv
installer = Installer(
self.output,
self.env,
self.poetry.package,
self.poetry.locker,
self.poetry.pool,
)
extras = []
for extra in self.option("extras"):
if " " in extra:
extras += [e.strip() for e in extra.split(" ")]
else:
extras.append(extra)
installer.extras(extras)
installer.dev_mode(not self.option("no-dev"))
installer.develop(self.option("develop"))
installer.dry_run(self.option("dry-run"))
installer.verbose(self.option("verbose"))
return_code = installer.run()
if return_code != 0:
return return_code
try:
builder = SdistBuilder(self.poetry, NullEnv(), NullIO())
except ModuleOrPackageNotFound:
# This is likely due to the fact that the project is an application
# not following the structure expected by Poetry
# If this is a true error it will be picked up later by build anyway.
return 0
self.line(
" - Installing <info>{}</info> (<comment>{}</comment>)".format(
self.poetry.package.pretty_name, self.poetry.package.pretty_version
)
)
if self.option("dry-run"):
return 0
setup = self.poetry.file.parent / "setup.py"
has_setup = setup.exists()
if has_setup:
self.line("<warning>A setup.py file already exists. Using it.</warning>")
else:
with setup.open("w", encoding="utf-8") as f:
f.write(decode(builder.build_setup()))
try:
self.env.run("pip", "install", "-e", str(setup.parent), "--no-deps")
finally:
if not has_setup:
os.remove(str(setup))
def handle(self):
from poetry.installation import Installer
packages = self.argument("packages")
is_dev = self.option("dev")
original_content = self.poetry.file.read()
content = self.poetry.file.read()
poetry_content = content["tool"]["poetry"]
section = "dependencies"
if is_dev:
section = "dev-dependencies"
# Deleting entries
requirements = {}
for name in packages:
found = False
for key in poetry_content[section]:
if key.lower() == name.lower():
found = True
requirements[key] = poetry_content[section][key]
break
if not found:
raise ValueError("Package {} not found".format(name))
for key in requirements:
del poetry_content[section][key]
# Write the new content back
self.poetry.file.write(content)
# Update packages
self.reset_poetry()
installer = Installer(
self.output,
self.venv,
self.poetry.package,
self.poetry.locker,
self.poetry.pool,
)
installer.dry_run(self.option("dry-run"))
installer.update(True)
installer.whitelist(requirements)
try:
status = installer.run()
except Exception:
self.poetry.file.write(original_content)
raise
if status != 0 or self.option("dry-run"):
# Revert changes
if not self.option("dry-run"):
self.error(
"\n"
"Removal failed, reverting pyproject.toml "
"to its original content."
)
self.poetry.file.write(original_content)
return status
def handle(self):
from poetry.installation import Installer
from poetry.semver import parse_constraint
packages = self.argument('name')
is_dev = self.option('dev')
if (self.option('git') or self.option('path')
or self.option('extras')) and len(packages) > 1:
raise ValueError('You can only specify one package '
'when using the --git or --path options')
if self.option('git') and self.option('path'):
raise RuntimeError(
'--git and --path cannot be used at the same time')
section = 'dependencies'
if is_dev:
section = 'dev-dependencies'
original_content = self.poetry.file.read()
content = self.poetry.file.read()
poetry_content = content['tool']['poetry']
for name in packages:
for key in poetry_content[section]:
if key.lower() == name.lower():
raise ValueError(
'Package {} is already present'.format(name))
if self.option('git') or self.option('path'):
requirements = {packages[0]: ''}
else:
requirements = self._determine_requirements(
packages, allow_prereleases=self.option('allow-prereleases'))
requirements = self._format_requirements(requirements)
# validate requirements format
for constraint in requirements.values():
parse_constraint(constraint)
for name, constraint in requirements.items():
constraint = {'version': constraint}
if self.option('git'):
del constraint['version']
constraint['git'] = self.option('git')
elif self.option('path'):
del constraint['version']
constraint['path'] = self.option('path')
if self.option('optional'):
constraint['optional'] = True
if self.option('allow-prereleases'):
constraint['allows-prereleases'] = True
if self.option('extras'):
extras = []
for extra in self.option('extras'):
if ' ' in extra:
extras += [e.strip() for e in extra.split(' ')]
else:
extras.append(extra)
constraint['extras'] = self.option('extras')
if self.option('python'):
constraint['python'] = self.option('python')
if self.option('platform'):
constraint['platform'] = self.option('platform')
if len(constraint) == 1 and 'version' in constraint:
constraint = constraint['version']
poetry_content[section][name] = constraint
# Write new content
self.poetry.file.write(content)
# Cosmetic new line
self.line('')
# Update packages
self.reset_poetry()
installer = Installer(self.output, self.venv, self.poetry.package,
self.poetry.locker, self.poetry.pool)
installer.dry_run(self.option('dry-run'))
installer.update(True)
installer.whitelist(requirements)
try:
status = installer.run()
except Exception:
self.poetry.file.write(original_content)
raise
if status != 0 or self.option('dry-run'):
# Revert changes
if not self.option('dry-run'):
self.error('\n'
'Addition failed, reverting pyproject.toml '
'to its original content.')
self.poetry.file.write(original_content)
return status
def handle(self):
packages = self.argument('name')
is_dev = self.option('dev')
section = 'dependencies'
if is_dev:
section = 'dev-dependencies'
original_content = self.poetry.file.read()
content = self.poetry.file.read()
poetry_content = content['tool']['poetry']
for name in packages:
for key in poetry_content[section]:
if key.lower() == name.lower():
raise ValueError(f'Package {name} is already present')
requirements = self._determine_requirements(packages)
requirements = self._format_requirements(requirements)
# validate requirements format
parser = VersionParser()
for constraint in requirements.values():
parser.parse_constraints(constraint)
for name, constraint in requirements.items():
if self.option('optional'):
constraint = {'version': constraint, 'optional': True}
poetry_content[section][name] = constraint
# Write new content
self.poetry.file.write(content)
# Cosmetic new line
self.line('')
# Update packages
self.reset_poetry()
installer = Installer(self.output, self.venv, self.poetry.package,
self.poetry.locker, self.poetry.pool)
installer.dry_run(self.option('dry-run'))
installer.update(True)
installer.whitelist(requirements)
try:
status = installer.run()
except Exception:
self.poetry.file.write(original_content)
raise
if status != 0 or self.option('dry-run'):
# Revert changes
if not self.option('dry-run'):
self.error('\n'
'Addition failed, reverting pyproject.toml '
'to its original content.')
self.poetry.file.write(original_content)
return status
def handle(self):
from poetry.installation import Installer
from poetry.semver import parse_constraint
from tomlkit import inline_table
packages = self.argument("name")
is_dev = self.option("dev")
if (self.option("git") or self.option("path") or self.option("extras")) and len(
packages
) > 1:
raise ValueError(
"You can only specify one package "
"when using the --git or --path options"
)
if self.option("git") and self.option("path"):
raise RuntimeError("--git and --path cannot be used at the same time")
section = "dependencies"
if is_dev:
section = "dev-dependencies"
original_content = self.poetry.file.read()
content = self.poetry.file.read()
poetry_content = content["tool"]["poetry"]
if section not in poetry_content:
poetry_content[section] = {}
for name in packages:
for key in poetry_content[section]:
if key.lower() == name.lower():
raise ValueError("Package {} is already present".format(name))
if self.option("git") or self.option("path"):
requirements = {packages[0]: ""}
else:
requirements = self._determine_requirements(
packages, allow_prereleases=self.option("allow-prereleases")
)
requirements = self._format_requirements(requirements)
# validate requirements format
for constraint in requirements.values():
parse_constraint(constraint)
for name, _constraint in requirements.items():
constraint = inline_table()
constraint["version"] = _constraint
if self.option("git"):
del constraint["version"]
constraint["git"] = self.option("git")
elif self.option("path"):
del constraint["version"]
constraint["path"] = self.option("path")
if self.option("optional"):
constraint["optional"] = True
if self.option("allow-prereleases"):
constraint["allows-prereleases"] = True
if self.option("extras"):
extras = []
for extra in self.option("extras"):
if " " in extra:
extras += [e.strip() for e in extra.split(" ")]
else:
extras.append(extra)
constraint["extras"] = self.option("extras")
if self.option("python"):
constraint["python"] = self.option("python")
if self.option("platform"):
constraint["platform"] = self.option("platform")
if len(constraint) == 1 and "version" in constraint:
constraint = constraint["version"]
poetry_content[section][name] = constraint
# Write new content
self.poetry.file.write(content)
# Cosmetic new line
self.line("")
# Update packages
self.reset_poetry()
installer = Installer(
self.output,
self.env,
self.poetry.package,
self.poetry.locker,
self.poetry.pool,
)
installer.dry_run(self.option("dry-run"))
installer.update(True)
installer.whitelist(requirements)
try:
status = installer.run()
except Exception:
self.poetry.file.write(original_content)
raise
if status != 0 or self.option("dry-run"):
# Revert changes
if not self.option("dry-run"):
self.error(
"\n"
"Addition failed, reverting pyproject.toml "
"to its original content."
)
self.poetry.file.write(original_content)
return status
def handle(self):
from poetry.installation import Installer
from poetry.semver import parse_constraint
from tomlkit import inline_table
packages = self.argument("name")
is_dev = self.option("dev")
if self.option("extras") and len(packages) > 1:
raise ValueError("You can only specify one package "
"when using the --extras option")
section = "dependencies"
if is_dev:
section = "dev-dependencies"
original_content = self.poetry.file.read()
content = self.poetry.file.read()
poetry_content = content["tool"]["poetry"]
if section not in poetry_content:
poetry_content[section] = {}
for name in packages:
for key in poetry_content[section]:
if key.lower() == name.lower():
pair = self._parse_requirements([name])[0]
if ("git" in pair or "url" in pair
or pair.get("version") == "latest"):
continue
raise ValueError(
"Package {} is already present".format(name))
requirements = self._determine_requirements(
packages, allow_prereleases=self.option("allow-prereleases"))
for _constraint in requirements:
if "version" in _constraint:
# Validate version constraint
parse_constraint(_constraint["version"])
constraint = inline_table()
for name, value in _constraint.items():
if name == "name":
continue
constraint[name] = value
if self.option("optional"):
constraint["optional"] = True
if self.option("allow-prereleases"):
constraint["allows-prereleases"] = True
if self.option("extras"):
extras = []
for extra in self.option("extras"):
if " " in extra:
extras += [e.strip() for e in extra.split(" ")]
else:
extras.append(extra)
constraint["extras"] = self.option("extras")
if self.option("python"):
constraint["python"] = self.option("python")
if self.option("platform"):
constraint["platform"] = self.option("platform")
if len(constraint) == 1 and "version" in constraint:
constraint = constraint["version"]
poetry_content[section][_constraint["name"]] = constraint
# Write new content
self.poetry.file.write(content)
# Cosmetic new line
self.line("")
# Update packages
self.reset_poetry()
installer = Installer(self.io, self.env, self.poetry.package,
self.poetry.locker, self.poetry.pool)
installer.dry_run(self.option("dry-run"))
installer.update(True)
installer.whitelist([r["name"] for r in requirements])
try:
status = installer.run()
except Exception:
self.poetry.file.write(original_content)
raise
if status != 0 or self.option("dry-run"):
# Revert changes
if not self.option("dry-run"):
self.error("\n"
"Addition failed, reverting pyproject.toml "
"to its original content.")
self.poetry.file.write(original_content)
return status