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 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_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_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_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)