def handle(self):
from poetry.packages import Dependency
from poetry.packages import ProjectPackage
from poetry.puzzle import Solver
from poetry.repositories.repository import Repository
from poetry.semver import parse_constraint
packages = self.argument("package")
if not packages:
package = self.poetry.package
else:
requirements = self._determine_requirements(packages)
requirements = self._format_requirements(requirements)
# validate requirements format
for constraint in requirements.values():
parse_constraint(constraint)
dependencies = []
for name, constraint in requirements.items():
dep = Dependency(name, constraint)
extras = []
for extra in self.option("extras"):
if " " in extra:
extras += [e.strip() for e in extra.split(" ")]
else:
extras.append(extra)
for ex in extras:
dep.extras.append(ex)
dependencies.append(dep)
package = ProjectPackage(self.poetry.package.name,
self.poetry.package.version)
package.python_versions = (self.option("python")
or self.poetry.package.python_versions)
for dep in dependencies:
package.requires.append(dep)
solver = Solver(package, self.poetry.pool, Repository(), Repository(),
self.output)
ops = solver.solve()
self.line("")
self.line("Resolution results:")
self.line("")
for op in ops:
package = op.package
self.line(" - <info>{}</info> (<comment>{}</comment>)".format(
package.name, package.version))
if package.requirements:
for req_name, req_value in package.requirements.items():
self.line(" - {}: {}".format(req_name, req_value))
def handle(self):
from poetry.packages import ProjectPackage
from poetry.puzzle import Solver
from poetry.repositories.repository import Repository
from poetry.semver import parse_constraint
from poetry.utils.env import Env
packages = self.argument("package")
if not packages:
package = self.poetry.package
else:
package = ProjectPackage(self.poetry.package.name,
self.poetry.package.version)
requirements = self._format_requirements(packages)
for name, constraint in requirements.items():
dep = package.add_dependency(name, constraint)
extras = []
for extra in self.option("extras"):
if " " in extra:
extras += [e.strip() for e in extra.split(" ")]
else:
extras.append(extra)
for ex in extras:
dep.extras.append(ex)
package.python_versions = self.option("python") or (
self.poetry.package.python_versions)
pool = self.poetry.pool
solver = Solver(package, pool, Repository(), Repository(), self.output)
ops = solver.solve()
self.line("")
self.line("Resolution results:")
self.line("")
if self.option("tree"):
show_command = self.get_application().find("show")
show_command.output = self.output
show_command.init_styles()
packages = [op.package for op in ops]
repo = Repository(packages)
requires = package.requires + package.dev_requires
for pkg in repo.packages:
for require in requires:
if pkg.name == require.name:
show_command.display_package_tree(pkg, repo)
break
return 0
env = Env.get()
current_python_version = parse_constraint(".".join(
str(v) for v in env.version_info))
for op in ops:
pkg = op.package
if self.option("install"):
if not pkg.python_constraint.allows(
current_python_version) or not env.is_valid_for_marker(
pkg.marker):
continue
self.line(" - <info>{}</info> (<comment>{}</comment>)".format(
pkg.name, pkg.version))
if not pkg.python_constraint.is_any():
self.line(" - python: {}".format(pkg.python_versions))
if not pkg.marker.is_any():
self.line(" - marker: {}".format(pkg.marker))
def handle(self):
from poetry.packages import ProjectPackage
from poetry.puzzle import Solver
from poetry.repositories.repository import Repository
from poetry.semver import parse_constraint
from poetry.utils.env import EnvManager
packages = self.argument("package")
if not packages:
package = self.poetry.package
else:
# Using current pool for determine_requirements()
self._pool = self.poetry.pool
package = ProjectPackage(self.poetry.package.name,
self.poetry.package.version)
# Silencing output
is_quiet = self.io.output.is_quiet()
if not is_quiet:
self.io.output.set_quiet(True)
requirements = self._determine_requirements(packages)
if not is_quiet:
self.io.output.set_quiet(False)
for constraint in requirements:
name = constraint.pop("name")
dep = package.add_dependency(name, constraint)
extras = []
for extra in self.option("extras"):
if " " in extra:
extras += [e.strip() for e in extra.split(" ")]
else:
extras.append(extra)
for ex in extras:
dep.extras.append(ex)
package.python_versions = self.option("python") or (
self.poetry.package.python_versions)
pool = self.poetry.pool
solver = Solver(package, pool, Repository(), Repository(), self._io)
ops = solver.solve()
self.line("")
self.line("Resolution results:")
self.line("")
if self.option("tree"):
show_command = self.application.find("show")
show_command.init_styles(self.io)
packages = [op.package for op in ops]
repo = Repository(packages)
requires = package.requires + package.dev_requires
for pkg in repo.packages:
for require in requires:
if pkg.name == require.name:
show_command.display_package_tree(self.io, pkg, repo)
break
return 0
env = EnvManager(self.poetry.config).get(self.poetry.file.parent)
current_python_version = parse_constraint(".".join(
str(v) for v in env.version_info))
table = self.table([], style="borderless")
rows = []
for op in ops:
pkg = op.package
if self.option("install"):
if not pkg.python_constraint.allows(
current_python_version) or not env.is_valid_for_marker(
pkg.marker):
continue
row = [
"<info>{}</info>".format(pkg.name),
"<b>{}</b>".format(pkg.version),
"",
]
if not pkg.marker.is_any():
row[2] = str(pkg.marker)
rows.append(row)
table.set_rows(rows)
table.render(self.io)
def handle(self):
from poetry.packages import Dependency
from poetry.packages import ProjectPackage
from poetry.puzzle import Solver
from poetry.repositories.repository import Repository
from poetry.semver import parse_constraint
packages = self.argument("package")
if not packages:
package = self.poetry.package
else:
requirements = self._determine_requirements(packages)
requirements = self._format_requirements(requirements)
# validate requirements format
for constraint in requirements.values():
parse_constraint(constraint)
dependencies = []
for name, constraint in requirements.items():
dep = Dependency(name, constraint)
extras = []
for extra in self.option("extras"):
if " " in extra:
extras += [e.strip() for e in extra.split(" ")]
else:
extras.append(extra)
for ex in extras:
dep.extras.append(ex)
dependencies.append(dep)
package = ProjectPackage(
self.poetry.package.name, self.poetry.package.version
)
package.python_versions = (
self.option("python") or self.poetry.package.python_versions
)
for dep in dependencies:
package.requires.append(dep)
solver = Solver(
package, self.poetry.pool, Repository(), Repository(), self.output
)
ops = solver.solve()
self.line("")
self.line("Resolution results:")
self.line("")
for op in ops:
package = op.package
self.line(
" - <info>{}</info> (<comment>{}</comment>)".format(
package.name, package.version
)
)
if package.requirements:
for req_name, req_value in package.requirements.items():
self.line(" - {}: {}".format(req_name, req_value))
def create(cls, path=None):
path = path or os.getcwd()
pyproject_file = Path(path)
if pyproject_file.name != "pyproject.toml":
pyproject_file = pyproject_file / "pyproject.toml"
if not pyproject_file.exists():
raise RuntimeError(
"Jetty could not find a pyproject.toml file in {}".format(
path))
local_config = TomlFile(pyproject_file.as_posix()).read()
tool = local_config.setdefault('tool', {})
if 'jetty' not in tool and 'poetry' not in tool:
raise RuntimeError("[tool.jetty] section not found in {}".format(
pyproject_file.name))
local_config = merge(tool.get('jetty', {}), tool.get('poetry', {}))
# Checking validity
cls.check(local_config)
# Load package
name = local_config.get('name', pyproject_file.parent.name)
version = local_config.get('version', '0')
package = ProjectPackage(name, version, version)
if 'dependencies' in local_config:
for name, constraint in local_config['dependencies'].items():
if name.lower() == 'python':
package.python_versions = constraint
continue
if isinstance(constraint, list):
for _constraint in constraint:
package.add_dependency(name, _constraint)
continue
package.add_dependency(name, constraint)
if 'dev-dependencies' in local_config:
for name, constraint in local_config['dev-dependencies'].items():
if isinstance(constraint, list):
for _constraint in constraint:
package.add_dependency(name,
_constraint,
category='dev')
continue
package.add_dependency(name, constraint, category='dev')
extras = local_config.get("extras", {})
for extra_name, requirements in extras.items():
package.extras[extra_name] = []
# Checking for dependency
for req in requirements:
req = Dependency(req, "*")
for dep in package.requires:
if dep.name == req.name:
dep.in_extras.append(extra_name)
package.extras[extra_name].append(dep)
break
lock = pyproject_file.parent / "poetry.lock"
locker = Locker(lock, local_config)
return cls(pyproject_file, local_config, package, locker)