def test_search_for_directory_setup_with_base(provider: Provider, directory: str): dependency = DirectoryDependency( "demo", Path(__file__).parent.parent / "fixtures" / "git" / "github.com" / "demo" / directory, base=Path(__file__).parent.parent / "fixtures" / "git" / "github.com" / "demo" / directory, ) package = provider.search_for_directory(dependency)[0] assert package.name == "demo" assert package.version.text == "0.1.2" required = [r for r in package.requires if not r.is_optional()] optional = [r for r in package.requires if r.is_optional()] assert required == [get_dependency("pendulum", ">=1.4.4")] assert optional == [get_dependency("tomlkit"), get_dependency("cleo")] assert package.extras == { "foo": [get_dependency("cleo")], "bar": [get_dependency("tomlkit")], } assert package.root_dir == (Path(__file__).parent.parent / "fixtures" / "git" / "github.com" / "demo" / directory)
def test_search_for_directory_poetry_with_extras(provider: Provider): dependency = DirectoryDependency( "project-with-extras", Path(__file__).parent.parent / "fixtures" / "project_with_extras", extras=["extras_a"], ) package = provider.search_for_directory(dependency)[0] assert package.name == "project-with-extras" assert package.version.text == "1.2.3" required = [ r for r in sorted(package.requires, key=lambda r: r.name) if not r.is_optional() ] optional = [ r for r in sorted(package.requires, key=lambda r: r.name) if r.is_optional() ] assert required == [] assert optional == [ get_dependency("cachy", ">=0.2.0"), get_dependency("pendulum", ">=1.4.4"), ] assert package.extras == { "extras_a": [get_dependency("pendulum", ">=1.4.4")], "extras_b": [get_dependency("cachy", ">=0.2.0")], }
def test_search_for_directory_setup_read_setup_with_extras(provider, mocker): mocker.patch("poetry.utils.env.EnvManager.get", return_value=MockEnv()) dependency = DirectoryDependency( "demo", Path(__file__).parent.parent / "fixtures" / "git" / "github.com" / "demo" / "demo", extras=["foo"], ) package = provider.search_for_directory(dependency)[0] assert package.name == "demo" assert package.version.text == "0.1.2" required = [r for r in package.requires if not r.is_optional()] optional = [r for r in package.requires if r.is_optional()] assert required == [get_dependency("pendulum", ">=1.4.4")] assert optional == [get_dependency("tomlkit"), get_dependency("cleo")] assert package.extras == { "foo": [get_dependency("cleo")], "bar": [get_dependency("tomlkit")], }
def dependencies(self) -> list[Dependency]: if self._dependencies is None: # avoid circular dependency when loading DirectoryDependency from poetry.core.packages.dependency import Dependency from poetry.core.packages.directory_dependency import DirectoryDependency from poetry.core.packages.file_dependency import FileDependency self._dependencies = [] for requirement in self.requires: dependency = None try: dependency = Dependency.create_from_pep_508(requirement) except ValueError: # PEP 517 requires can be path if not PEP 508 path = Path(requirement) # compatibility Python < 3.8 # https://docs.python.org/3/library/pathlib.html#methods with suppress(OSError): if path.is_file(): dependency = FileDependency(name=canonicalize_name( path.name), path=path) elif path.is_dir(): dependency = DirectoryDependency( name=canonicalize_name(path.name), path=path) if dependency is None: # skip since we could not determine requirement continue self._dependencies.append(dependency) return self._dependencies
def search_for_directory(self, dependency: DirectoryDependency) -> List[Package]: if dependency in self._deferred_cache: dependency, _package = self._deferred_cache[dependency] package = _package.clone() else: package = self.get_package_from_directory(dependency.full_path, name=dependency.name) dependency._constraint = package.version dependency._pretty_constraint = package.version.text self._deferred_cache[dependency] = (dependency, package) package.develop = dependency.develop if dependency.base is not None: package.root_dir = dependency.base return [package]
def test_search_for_directory_setup_read_setup_with_no_dependencies(provider): dependency = DirectoryDependency( "demo", Path(__file__).parent.parent / "fixtures" / "git" / "github.com" / "demo" / "no-dependencies", ) package = provider.search_for_directory(dependency)[0] assert package.name == "demo" assert package.version.text == "0.1.2" assert package.requires == [] assert package.extras == {}
def test_search_for_directory_poetry(provider): dependency = DirectoryDependency( "project-with-extras", Path(__file__).parent.parent / "fixtures" / "project_with_extras", ) package = provider.search_for_directory(dependency)[0] assert package.name == "project-with-extras" assert package.version.text == "1.2.3" assert package.requires == [] assert package.extras == { "extras_a": [get_dependency("pendulum", ">=1.4.4")], "extras_b": [get_dependency("cachy", ">=0.2.0")], }
def test_search_for_directory_setup_egg_info(provider, directory): dependency = DirectoryDependency( "demo", Path(__file__).parent.parent / "fixtures" / "git" / "github.com" / "demo" / directory, ) package = provider.search_for_directory(dependency)[0] assert package.name == "demo" assert package.version.text == "0.1.2" assert package.requires == [get_dependency("pendulum", ">=1.4.4")] assert package.extras == { "foo": [get_dependency("cleo")], "bar": [get_dependency("tomlkit")], }
def test_search_for_directory_setup_egg_info_with_extras(provider: Provider): dependency = DirectoryDependency( "demo", Path(__file__).parent.parent / "fixtures" / "git" / "github.com" / "demo" / "demo", extras=["foo"], ) package = provider.search_for_direct_origin_dependency(dependency) assert package.name == "demo" assert package.version.text == "0.1.2" required = [r for r in package.requires if not r.is_optional()] optional = [r for r in package.requires if r.is_optional()] assert required == [get_dependency("pendulum", ">=1.4.4")] assert optional == [get_dependency("tomlkit"), get_dependency("cleo")] assert package.extras == { "foo": [get_dependency("cleo")], "bar": [get_dependency("tomlkit")], }
def _make_file_or_dir_dep( name: str, path: Path, base: Optional[Path] = None, extras: Optional[List[str]] = None, ) -> Optional[Union["FileDependency", "DirectoryDependency"]]: """ Helper function to create a file or directoru dependency with the given arguments. If path is not a file or directory that exists, `None` is returned. """ from .directory_dependency import DirectoryDependency from .file_dependency import FileDependency _path = path if not path.is_absolute() and base: # a base path was specified, so we should respect that _path = Path(base) / path if _path.is_file(): return FileDependency(name, path, base=base, extras=extras) elif _path.is_dir(): return DirectoryDependency(name, path, base=base, extras=extras) return None
def _make_file_or_dir_dep( name: str, path: Path, base: Path | None = None, extras: list[str] | None = None, ) -> FileDependency | DirectoryDependency | None: """ Helper function to create a file or directoru dependency with the given arguments. If path is not a file or directory that exists, `None` is returned. """ from poetry.core.packages.directory_dependency import DirectoryDependency from poetry.core.packages.file_dependency import FileDependency _path = path if not path.is_absolute() and base: # a base path was specified, so we should respect that _path = Path(base) / path if _path.is_file(): return FileDependency(name, path, base=base, extras=extras) elif _path.is_dir(): return DirectoryDependency(name, path, base=base, extras=extras) return None
def _export_requirements_txt( self, cwd, output, with_hashes=True, dev=False, extras=None, with_credentials=False, ): # type: (Path, Union[IO, str], bool, bool, bool) -> None indexes = set() content = "" packages = self._poetry.locker.locked_repository(dev).packages # Build a set of all packages required by our selected extras extra_package_names = set( get_extra_package_names( packages, self._poetry.locker.lock_data.get("extras", {}), extras or ())) for package in sorted(packages, key=lambda p: p.name): # If a package is optional and we haven't opted in to it, continue if package.optional and package.name not in extra_package_names: continue if package.source_type == "git": dependency = VCSDependency( package.name, package.source_type, package.source_url, package.source_reference, ) dependency.marker = package.marker line = "-e git+{}@{}#egg={}".format(package.source_url, package.source_reference, package.name) elif package.source_type in ["directory", "file", "url"]: url = package.source_url if package.source_type == "file": dependency = FileDependency( package.name, Path(package.source_url), base=self._poetry.locker.lock.path.parent, ) url = Path( os.path.relpath( url, self._poetry.locker.lock.path.parent.as_posix( ))).as_posix() elif package.source_type == "directory": dependency = DirectoryDependency( package.name, Path(package.source_url), base=self._poetry.locker.lock.path.parent, ) url = Path( os.path.relpath( url, self._poetry.locker.lock.path.parent.as_posix( ))).as_posix() else: dependency = URLDependency(package.name, package.source_url) dependency.marker = package.marker line = "{}".format(url) if package.develop and package.source_type == "directory": line = "-e " + line else: dependency = package.to_dependency() line = "{}=={}".format(package.name, package.version) requirement = dependency.to_pep_508() if ";" in requirement: line += "; {}".format(requirement.split(";")[1].strip()) if (package.source_type not in {"git", "directory", "file", "url"} and package.source_url): indexes.add(package.source_url) if package.files and with_hashes: hashes = [] for f in package.files: h = f["hash"] algorithm = "sha256" if ":" in h: algorithm, h = h.split(":") if algorithm not in self.ALLOWED_HASH_ALGORITHMS: continue hashes.append("{}:{}".format(algorithm, h)) if hashes: line += " \\\n" for i, h in enumerate(hashes): line += " --hash={}{}".format( h, " \\\n" if i < len(hashes) - 1 else "") line += "\n" content += line if indexes: # If we have extra indexes, we add them to the beginning of the output indexes_header = "" for index in sorted(indexes): repository = [ r for r in self._poetry.pool.repositories if r.url == index.rstrip("/") ][0] if (self._poetry.pool.has_default() and repository is self._poetry.pool.repositories[0]): url = (repository.authenticated_url if with_credentials else repository.url) indexes_header = "--index-url {}\n".format(url) continue url = (repository.authenticated_url if with_credentials else repository.url) indexes_header += "--extra-index-url {}\n".format(url) content = indexes_header + "\n" + content self._output(content, cwd, output)
def to_dependency(self) -> Dependency: from pathlib import Path from poetry.core.packages.dependency import Dependency from poetry.core.packages.directory_dependency import DirectoryDependency from poetry.core.packages.file_dependency import FileDependency from poetry.core.packages.url_dependency import URLDependency from poetry.core.packages.vcs_dependency import VCSDependency dep: Dependency if self.source_type == "directory": dep = DirectoryDependency( self._name, Path(cast(str, self._source_url)), groups=list(self._dependency_groups.keys()), optional=self.optional, base=self.root_dir, develop=self.develop, extras=self.features, ) elif self.source_type == "file": dep = FileDependency( self._name, Path(cast(str, self._source_url)), groups=list(self._dependency_groups.keys()), optional=self.optional, base=self.root_dir, extras=self.features, ) elif self.source_type == "url": dep = URLDependency( self._name, cast(str, self._source_url), groups=list(self._dependency_groups.keys()), optional=self.optional, extras=self.features, ) elif self.source_type == "git": dep = VCSDependency( self._name, self.source_type, cast(str, self.source_url), rev=self.source_reference, resolved_rev=self.source_resolved_reference, directory=self.source_subdirectory, groups=list(self._dependency_groups.keys()), optional=self.optional, develop=self.develop, extras=self.features, ) else: dep = Dependency(self._name, self._version, extras=self.features) if not self.marker.is_any(): dep.marker = self.marker if not self.python_constraint.is_any(): dep.python_versions = self.python_versions if not self.is_direct_origin(): return dep return dep.with_constraint(self._version)
def test_directory_dependency_must_exist() -> None: with pytest.raises(ValueError): DirectoryDependency("demo", DIST_PATH / "invalid")
def create_dependency( cls, name: str, constraint: DependencyConstraint, groups: list[str] | None = None, root_dir: Path | None = None, ) -> Dependency: from poetry.core.packages.constraints import ( parse_constraint as parse_generic_constraint, ) from poetry.core.packages.dependency import Dependency from poetry.core.packages.dependency_group import MAIN_GROUP from poetry.core.packages.directory_dependency import DirectoryDependency from poetry.core.packages.file_dependency import FileDependency from poetry.core.packages.url_dependency import URLDependency from poetry.core.packages.utils.utils import create_nested_marker from poetry.core.packages.vcs_dependency import VCSDependency from poetry.core.semver.helpers import parse_constraint from poetry.core.version.markers import AnyMarker from poetry.core.version.markers import parse_marker if groups is None: groups = [MAIN_GROUP] if constraint is None: constraint = "*" if isinstance(constraint, dict): optional = constraint.get("optional", False) python_versions = constraint.get("python") platform = constraint.get("platform") markers = constraint.get("markers") if "allows-prereleases" in constraint: message = ( f'The "{name}" dependency specifies ' 'the "allows-prereleases" property, which is deprecated. ' 'Use "allow-prereleases" instead.') warn(message, DeprecationWarning) logger.warning(message) allows_prereleases = constraint.get( "allow-prereleases", constraint.get("allows-prereleases", False)) dependency: Dependency if "git" in constraint: # VCS dependency dependency = VCSDependency( name, "git", constraint["git"], branch=constraint.get("branch", None), tag=constraint.get("tag", None), rev=constraint.get("rev", None), directory=constraint.get("subdirectory", None), groups=groups, optional=optional, develop=constraint.get("develop", False), extras=constraint.get("extras", []), ) elif "file" in constraint: file_path = Path(constraint["file"]) dependency = FileDependency( name, file_path, groups=groups, base=root_dir, extras=constraint.get("extras", []), ) elif "path" in constraint: path = Path(constraint["path"]) if root_dir: is_file = root_dir.joinpath(path).is_file() else: is_file = path.is_file() if is_file: dependency = FileDependency( name, path, groups=groups, optional=optional, base=root_dir, extras=constraint.get("extras", []), ) else: dependency = DirectoryDependency( name, path, groups=groups, optional=optional, base=root_dir, develop=constraint.get("develop", False), extras=constraint.get("extras", []), ) elif "url" in constraint: dependency = URLDependency( name, constraint["url"], groups=groups, optional=optional, extras=constraint.get("extras", []), ) else: version = constraint["version"] dependency = Dependency( name, version, optional=optional, groups=groups, allows_prereleases=allows_prereleases, extras=constraint.get("extras", []), ) marker = parse_marker(markers) if markers else AnyMarker() if python_versions: marker = marker.intersect( parse_marker( create_nested_marker( "python_version", parse_constraint(python_versions)))) if platform: marker = marker.intersect( parse_marker( create_nested_marker( "sys_platform", parse_generic_constraint(platform)))) if not marker.is_any(): dependency.marker = marker dependency.source_name = constraint.get("source") else: dependency = Dependency(name, constraint, groups=groups) return dependency