def test_accepts_python_versions():
dependency = Dependency("A", "^1.0")
dependency.python_versions = "^3.6"
package = Package("A", "1.4")
package.python_versions = "~3.6"
assert dependency.accepts(package)
def solve(self): # type: () -> SolverResult
"""
Finds a set of dependencies that match the root package's constraints,
or raises an error if no such set is available.
"""
start = time.time()
root_dependency = Dependency(self._root.name, self._root.version)
root_dependency.is_root = True
self._add_incompatibility(
Incompatibility([Term(root_dependency, False)], RootCause()))
try:
next = self._root.name
while next is not None:
self._propagate(next)
next = self._choose_package_version()
return self._result()
except Exception:
raise
finally:
self._log("Version solving took {:.3f} seconds.\n"
"Tried {} solutions.".format(
time.time() - start,
self._solution.attempted_solutions))
def test_accepts_fails_with_python_versions_mismatch():
dependency = Dependency('A', '^1.0')
dependency.python_versions = '^3.6'
package = Package('B', '1.4')
package.python_versions = '~3.5'
assert not dependency.accepts(package)
def test_accepts_fails_with_python_versions_mismatch():
dependency = Dependency("A", "^1.0")
dependency.python_versions = "^3.6"
package = Package("B", "1.4")
package.python_versions = "~3.5"
assert not dependency.accepts(package)
def test_accepts_fails_with_python_versions_mismatch():
dependency = Dependency("A", "^1.0")
dependency.python_versions = "^3.6"
package = Package("B", "1.4")
package.python_versions = "~3.5"
assert not dependency.accepts(package)
def solve(self): # type: () -> SolverResult
"""
Finds a set of dependencies that match the root package's constraints,
or raises an error if no such set is available.
"""
start = time.time()
root_dependency = Dependency(self._root.name, self._root.version)
root_dependency.is_root = True
self._add_incompatibility(
Incompatibility([Term(root_dependency, False)], RootCause())
)
try:
next = self._root.name
while next is not None:
self._propagate(next)
next = self._choose_package_version()
return self._result()
except Exception:
raise
finally:
self._log(
"Version solving took {:.3f} seconds.\n"
"Tried {} solutions.".format(
time.time() - start, self._solution.attempted_solutions
)
)
def find_best_candidate(
self,
package_name, # type: str
target_package_version=None, # type: Union[str, None]
allow_prereleases=False, # type: bool
): # type: (...) -> Union[Package, bool]
"""
Given a package name and optional version,
returns the latest Package that matches
"""
if target_package_version:
constraint = parse_constraint(target_package_version)
else:
constraint = parse_constraint("*")
candidates = self._pool.find_packages(
package_name, constraint, allow_prereleases=allow_prereleases)
if not candidates:
return False
dependency = Dependency(package_name, constraint)
# Select highest version if we have many
package = candidates[0]
for candidate in candidates:
if candidate.is_prerelease(
) and not dependency.allows_prereleases():
continue
# Select highest version of the two
if package.version < candidate.version:
package = candidate
return package
def find_best_candidate(
self,
package_name, # type: str
target_package_version=None, # type: Union[str, None]
allow_prereleases=False, # type: bool
): # type: (...) -> Union[Package, bool]
"""
Given a package name and optional version,
returns the latest Package that matches
"""
if target_package_version:
constraint = parse_constraint(target_package_version)
else:
constraint = parse_constraint("*")
candidates = self._pool.find_packages(
package_name, constraint, allow_prereleases=allow_prereleases
)
if not candidates:
return False
dependency = Dependency(package_name, constraint)
# Select highest version if we have many
package = candidates[0]
for candidate in candidates:
if candidate.is_prerelease() and not dependency.allows_prereleases():
continue
# Select highest version of the two
if package.version < candidate.version:
package = candidate
return package
def test_accepts_python_versions():
dependency = Dependency('A', '^1.0')
dependency.python_versions = '^3.6'
package = Package('A', '1.4')
package.python_versions = '~3.6'
assert dependency.accepts(package)
def test_accepts_python_versions():
dependency = Dependency("A", "^1.0")
dependency.python_versions = "^3.6"
package = Package("A", "1.4")
package.python_versions = "~3.6"
assert dependency.accepts(package)
def test_to_pep_508_with_patch_python_version(python_versions, marker):
dependency = Dependency("Django", "^1.23")
dependency.python_versions = python_versions
expected = "Django (>=1.23,<2.0); {}".format(marker)
assert expected == dependency.to_pep_508()
assert marker == str(dependency.marker)
def _non_empty_term(self, constraint, is_positive):
if constraint.is_empty():
return
dep = Dependency(self.dependency.name, constraint)
dep.python_versions = str(self.dependency.python_versions)
return Term(dep, is_positive)
def test_to_pep_508_with_platform():
dependency = Dependency("Django", "^1.23")
dependency.python_versions = "~2.7 || ^3.6"
dependency.platform = "linux || linux2"
result = dependency.to_pep_508()
assert result == (
"Django (>=1.23,<2.0); "
'((python_version >= "2.7" and python_version < "2.8") '
'or (python_version >= "3.6" and python_version < "4.0"))'
' and (sys_platform == "linux" or sys_platform == "linux2")')
def test_to_pep_508_with_platform():
dependency = Dependency("Django", "^1.23")
dependency.python_versions = "~2.7 || ^3.6"
dependency.platform = "linux || linux2"
result = dependency.to_pep_508()
assert result == (
"Django (>=1.23,<2.0); "
'((python_version >= "2.7" and python_version < "2.8") '
'or (python_version >= "3.6" and python_version < "4.0"))'
' and (sys_platform == "linux" or sys_platform == "linux2")'
)
def test_to_pep_508_with_platform():
dependency = Dependency('Django', '^1.23')
dependency.python_versions = '~2.7 || ^3.6'
dependency.platform = 'linux || linux2'
result = dependency.to_pep_508()
assert result == (
'Django (>=1.23,<2.0); '
'((python_version >= "2.7" and python_version < "2.8") '
'or (python_version >= "3.6" and python_version < "4.0"))'
' and (sys_platform == "linux" or sys_platform == "linux2")'
)
def test_to_pep_508():
dependency = Dependency("Django", "^1.23")
result = dependency.to_pep_508()
assert result == "Django (>=1.23,<2.0)"
dependency = Dependency("Django", "^1.23")
dependency.python_versions = "~2.7 || ^3.6"
result = dependency.to_pep_508()
assert (
result == "Django (>=1.23,<2.0); "
'(python_version >= "2.7" and python_version < "2.8") '
'or (python_version >= "3.6" and python_version < "4.0")'
)
def search_for(self, dependency: Dependency) -> List[Package]:
"""
Search for the specifications that match the given dependency.
The specifications in the returned list will be considered in reverse
order, so the latest version ought to be last.
"""
if dependency in self._search_for:
return self._search_for[dependency]
if dependency.is_vcs():
packages = self.search_for_vcs(dependency)
else:
packages = self._pool.find_packages(
dependency.name,
dependency.constraint,
extras=dependency.extras,
)
packages.sort(
key=cmp_to_key(lambda x, y: 0 if x.version == y.version else -1
* int(less_than(x.version, y.version) or -1)))
self._search_for[dependency] = packages
return self._search_for[dependency]
def _get_extra_packages(self, repo):
"""
Returns all packages required by extras.
Maybe we just let the solver handle it?
"""
if self._update:
extras = {
k: [d.name for d in v]
for k, v in self._package.extras.items()
}
else:
extras = self._locker.lock_data.get("extras", {})
extra_packages = []
for extra_name, packages in extras.items():
if extra_name not in self._extras:
continue
extra_packages += [Dependency(p, "*") for p in packages]
def _extra_packages(packages):
pkgs = []
for package in packages:
for pkg in repo.packages:
if pkg.name == package.name:
pkgs.append(package)
pkgs += _extra_packages(pkg.requires)
break
return pkgs
return _extra_packages(extra_packages)
def specs_from_fixtures(cls, fixture_name):
if fixture_name in cls._specs_from_fixtures:
return cls._specs_from_fixtures[fixture_name]
packages_by_name = {}
with open(os.path.join(FIXTURE_INDEX_DIR,
fixture_name + '.json')) as fd:
content = json.load(fd)
for name, releases in content.items():
packages_by_name[name] = []
for release in releases:
package = Package(name, release['version'],
release['version'])
for dependency_name, requirements in release[
'dependencies'].items():
package.requires.append(
Dependency(dependency_name, requirements))
packages_by_name[name].append(package)
packages_by_name[name].sort(
key=cmp_to_key(lambda x, y: 0 if x.version[1] == y.version[
1] else -1 * int(less_than(x[1], y[1]) or -1)))
return packages_by_name
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 get_dependency(name,
constraint=None,
category='main',
optional=False,
allows_prereleases=False):
return Dependency(name,
constraint or '*',
category=category,
optional=optional,
allows_prereleases=allows_prereleases)
def requested(self):
if self._requested is not None:
return self._requested
requested = []
for name, requirement in self._fixture['requested'].items():
requested.append(Dependency(name, requirement))
self._requested = requested
return self._requested
def test_get_package_information_chooses_correct_distribution():
repo = MockRepository()
package = repo.package("isort", "4.3.4")
assert package.name == "isort"
assert package.version.text == "4.3.4"
assert package.requires == [Dependency("futures", "*")]
futures_dep = package.requires[0]
assert futures_dep.python_versions == "~2.7"
def is_requirement_satisfied_by(self, requirement: Dependency,
activated: DependencyGraph,
package: Package) -> bool:
"""
Determines whether the given requirement is satisfied by the given
spec, in the context of the current activated dependency graph.
"""
if isinstance(requirement, Package):
return requirement == package
if not requirement.accepts(package):
return False
if package.is_prerelease() and not requirement.allows_prereleases():
vertex = activated.vertex_named(package.name)
if not any([r.allows_prereleases() for r in vertex.requirements]):
return False
return self._package.python_constraint.matches(
package.python_constraint)
def test_fallback_can_read_setup_to_get_dependencies():
repo = MockRepository(fallback=True)
package = repo.package("sqlalchemy", "1.2.12")
assert package.name == "sqlalchemy"
assert len(package.requires) == 0
assert package.extras == {
"mssql_pymssql": [Dependency("pymssql", "*")],
"mssql_pyodbc": [Dependency("pyodbc", "*")],
"mysql": [Dependency("mysqlclient", "*")],
"oracle": [Dependency("cx_oracle", "*")],
"postgresql": [Dependency("psycopg2", "*")],
"postgresql_pg8000": [Dependency("pg8000", "*")],
"postgresql_psycopg2binary": [Dependency("psycopg2-binary", "*")],
"postgresql_psycopg2cffi": [Dependency("psycopg2cffi", "*")],
"pymysql": [Dependency("pymysql", "*")],
}
def test_to_pep_508_in_extras():
dependency = Dependency("Django", "^1.23")
dependency.in_extras.append("foo")
result = dependency.to_pep_508()
assert result == 'Django (>=1.23,<2.0); extra == "foo"'
dependency.in_extras.append("bar")
result = dependency.to_pep_508()
assert result == 'Django (>=1.23,<2.0); extra == "foo" or extra == "bar"'
dependency.python_versions = "~2.7 || ^3.6"
result = dependency.to_pep_508()
assert result == (
"Django (>=1.23,<2.0); "
"("
'(python_version >= "2.7" and python_version < "2.8") '
'or (python_version >= "3.6" and python_version < "4.0")'
") "
'and (extra == "foo" or extra == "bar")'
)
def test_to_pep_508():
dependency = Dependency("Django", "^1.23")
result = dependency.to_pep_508()
assert result == "Django (>=1.23,<2.0)"
dependency = Dependency("Django", "^1.23")
dependency.python_versions = "~2.7 || ^3.6"
result = dependency.to_pep_508()
assert (result == "Django (>=1.23,<2.0); "
'python_version >= "2.7" and python_version < "2.8" '
'or python_version >= "3.6" and python_version < "4.0"')
def test_to_pep_508():
dependency = Dependency('Django', '^1.23')
result = dependency.to_pep_508()
assert result == 'Django (>=1.23,<2.0)'
dependency = Dependency('Django', '^1.23')
dependency.python_versions = '~2.7 || ^3.6'
result = dependency.to_pep_508()
assert result == 'Django (>=1.23,<2.0); ' \
'(python_version >= "2.7" and python_version < "2.8") ' \
'or (python_version >= "3.6" and python_version < "4.0")'
def get_dependency(
name,
constraint=None,
category="main",
optional=False,
allows_prereleases=False,
global_options=[],
):
return Dependency(
name,
constraint or "*",
category=category,
optional=optional,
allows_prereleases=allows_prereleases,
global_options=global_options,
)
def handle(self):
packages = self.argument('package')
if not packages:
package = self.poetry.package
dependencies = package.requires + package.dev_requires
else:
requirements = self._determine_requirements(packages)
requirements = self._format_requirements(requirements)
# validate requirements format
parser = VersionParser()
for constraint in requirements.values():
parser.parse_constraints(constraint)
dependencies = []
for name, constraint in requirements.items():
dependencies.append(
Dependency(name, constraint)
)
solver = Solver(
self.poetry.package,
self.poetry.pool,
Repository(),
self.output
)
ops = solver.solve(dependencies)
self.line('')
self.line('Resolution results:')
self.line('')
for op in ops:
package = op.package
self.line(f' - <info>{package.name}</info> '
f'(<comment>{package.version}</comment>)')
def test_get_package_information_fallback_read_setup():
repo = MockRepository()
package = repo.package("jupyter", "1.0.0")
assert package.name == "jupyter"
assert package.version.text == "1.0.0"
assert (
package.description ==
"Jupyter metapackage. Install all the Jupyter components in one go.")
if PY35:
assert package.requires == [
Dependency("notebook", "*"),
Dependency("qtconsole", "*"),
Dependency("jupyter-console", "*"),
Dependency("nbconvert", "*"),
Dependency("ipykernel", "*"),
Dependency("ipywidgets", "*"),
]
def test_to_pep_508_in_extras():
dependency = Dependency("Django", "^1.23")
dependency.in_extras.append("foo")
result = dependency.to_pep_508()
assert result == 'Django (>=1.23,<2.0); extra == "foo"'
dependency.in_extras.append("bar")
result = dependency.to_pep_508()
assert result == 'Django (>=1.23,<2.0); extra == "foo" or extra == "bar"'
dependency.python_versions = "~2.7 || ^3.6"
result = dependency.to_pep_508()
assert result == ("Django (>=1.23,<2.0); "
"("
'python_version >= "2.7" and python_version < "2.8" '
'or python_version >= "3.6" and python_version < "4.0"'
") "
'and (extra == "foo" or extra == "bar")')
def test_to_pep_508_in_extras():
dependency = Dependency('Django', '^1.23')
dependency.in_extras.append('foo')
result = dependency.to_pep_508()
assert result == 'Django (>=1.23.0.0,<2.0.0.0); extra == "foo"'
dependency.in_extras.append('bar')
result = dependency.to_pep_508()
assert result == 'Django (>=1.23.0.0,<2.0.0.0); extra == "foo" or extra == "bar"'
dependency.python_versions = '~2.7 || ^3.6'
result = dependency.to_pep_508()
assert result == (
'Django (>=1.23.0.0,<2.0.0.0); '
'('
'(python_version >= "2.7.0.0" and python_version < "2.8.0.0") '
'or (python_version >= "3.6.0.0" and python_version < "4.0.0.0")'
') '
'and (extra == "foo" or extra == "bar")')
def test_accepts_prerelease():
dependency = Dependency("A", "^1.0", allows_prereleases=True)
package = Package("A", "1.4-beta.1")
assert dependency.accepts(package)
def test_to_pep_508_wilcard():
dependency = Dependency("Django", "*")
result = dependency.to_pep_508()
assert result == "Django"
def test_to_pep_508_wilcard():
dependency = Dependency("Django", "*")
result = dependency.to_pep_508()
assert result == "Django"
def test_accepts_fails_with_prerelease_mismatch():
dependency = Dependency("A", "^1.0")
package = Package("B", "1.4-beta.1")
assert not dependency.accepts(package)
def test_accepts():
dependency = Dependency("A", "^1.0")
package = Package("A", "1.4")
assert dependency.accepts(package)
def test_accepts():
dependency = Dependency("A", "^1.0")
package = Package("A", "1.4")
assert dependency.accepts(package)
def test_accepts_fails_with_prerelease_mismatch():
dependency = Dependency("A", "^1.0")
package = Package("B", "1.4-beta.1")
assert not dependency.accepts(package)
def test_accepts_fails_with_version_mismatch():
dependency = Dependency("A", "~1.0")
package = Package("B", "1.4")
assert not dependency.accepts(package)
def test_accepts_fails_with_version_mismatch():
dependency = Dependency("A", "~1.0")
package = Package("B", "1.4")
assert not dependency.accepts(package)
def test_accepts_fails_with_different_names():
dependency = Dependency("A", "^1.0")
package = Package("B", "1.4")
assert not dependency.accepts(package)
