def test_from_link_archive() -> None: direct_url = direct_url_from_link(Link("https://g.c/archive.tgz")) assert direct_url.url == "https://g.c/archive.tgz" assert isinstance(direct_url.info, ArchiveInfo) direct_url = direct_url_from_link( Link("https://g.c/archive.tgz#sha1=1b8c5bc61a86f377fea47b4276c8c8a5842d2220") ) assert isinstance(direct_url.info, ArchiveInfo) assert direct_url.info.hash == "sha1=1b8c5bc61a86f377fea47b4276c8c8a5842d2220"
def test_from_link_hide_user_password() -> None: # Basic test only here, other variants are covered by # direct_url.redact_url tests. direct_url = direct_url_from_link( Link("git+https://user:[email protected]/u/p.git@branch#egg=pkg"), link_is_in_wheel_cache=True, ) assert direct_url.to_dict()["url"] == "https://g.c/u/p.git" direct_url = direct_url_from_link( Link("git+ssh://[email protected]/u/p.git@branch#egg=pkg"), link_is_in_wheel_cache=True, ) assert direct_url.to_dict()["url"] == "ssh://[email protected]/u/p.git"
def _populate_link(self, req: InstallRequirement) -> None: """Ensure that if a link can be found for this, that it is found. Note that req.link may still be None - if the requirement is already installed and not needed to be upgraded based on the return value of _is_upgrade_allowed(). If preparer.require_hashes is True, don't use the wheel cache, because cached wheels, always built locally, have different hashes than the files downloaded from the index server and thus throw false hash mismatches. Furthermore, cached wheels at present have undeterministic contents due to file modification times. """ if req.link is None: req.link = self._find_requirement_link(req) if self.wheel_cache is None or self.preparer.require_hashes: return cache_entry = self.wheel_cache.get_cache_entry( link=req.link, package_name=req.name, supported_tags=get_supported(), ) if cache_entry is not None: logger.debug("Using cached wheel link: %s", cache_entry.link) if req.link is req.original_link and cache_entry.persistent: req.original_link_is_in_wheel_cache = True if cache_entry.origin is not None: req.download_info = cache_entry.origin else: # Legacy cache entry that does not have origin.json. # download_info may miss the archive_info.hash field. req.download_info = direct_url_from_link( req.link, link_is_in_wheel_cache=cache_entry.persistent) req.link = cache_entry.link
def test_from_link_vcs_without_source_dir(script: PipTestEnvironment) -> None: direct_url = direct_url_from_link( Link("git+https://g.c/u/p.git@1"), link_is_in_wheel_cache=True ) assert direct_url.url == "https://g.c/u/p.git" assert isinstance(direct_url.info, VcsInfo) assert direct_url.info.commit_id == "1"
def _prepare_linked_requirement(self, req: InstallRequirement, parallel_builds: bool) -> BaseDistribution: assert req.link link = req.link self._ensure_link_req_src_dir(req, parallel_builds) hashes = self._get_linked_req_hashes(req) if link.is_existing_dir(): local_file = None elif link.url not in self._downloaded: try: local_file = unpack_url( link, req.source_dir, self._download, self.verbosity, self.download_dir, hashes, ) except NetworkConnectionError as exc: raise InstallationError( "Could not install requirement {} because of HTTP " "error {} for URL {}".format(req, exc, link)) else: file_path = self._downloaded[link.url] if hashes: hashes.check_against_path(file_path) local_file = File(file_path, content_type=None) # If download_info is set, we got it from the wheel cache. if req.download_info is None: # Editables don't go through this function (see # prepare_editable_requirement). assert not req.editable req.download_info = direct_url_from_link(link, req.source_dir) # Make sure we have a hash in download_info. If we got it as part of the # URL, it will have been verified and we can rely on it. Otherwise we # compute it from the downloaded file. if (isinstance(req.download_info.info, ArchiveInfo) and not req.download_info.info.hash and local_file): hash = hash_file(local_file.path)[0].hexdigest() req.download_info.info.hash = f"sha256={hash}" # For use in later processing, # preserve the file path on the requirement. if local_file: req.local_file_path = local_file.path dist = _get_prepared_distribution( req, self.build_tracker, self.finder, self.build_isolation, self.check_build_deps, ) return dist
def test_from_link_vcs_with_source_dir_obtains_commit_id(tmpdir: Path) -> None: repo_path = tmpdir / "test-repo" repo_path.mkdir() repo_dir = os.fspath(repo_path) Git.run_command(["init"], cwd=repo_dir) (repo_path / "somefile").touch() Git.run_command(["add", "."], cwd=repo_dir) Git.run_command(["commit", "-m", "commit msg"], cwd=repo_dir) commit_id = Git.get_revision(repo_dir) direct_url = direct_url_from_link(Link("git+https://g.c/u/p.git"), source_dir=repo_dir) assert direct_url.url == "https://g.c/u/p.git" assert isinstance(direct_url.info, VcsInfo) assert direct_url.info.commit_id == commit_id
def test_from_link_vcs_with_source_dir_obtains_commit_id(script, tmpdir): repo_path = tmpdir / 'test-repo' repo_path.mkdir() repo_dir = str(repo_path) script.run('git', 'init', cwd=repo_dir) (repo_path / "somefile").touch() script.run('git', 'add', '.', cwd=repo_dir) script.run('git', 'commit', '-m', 'commit msg', cwd=repo_dir) commit_id = script.run('git', 'rev-parse', 'HEAD', cwd=repo_dir).stdout.strip() direct_url = direct_url_from_link(Link("git+https://g.c/u/p.git"), source_dir=repo_dir) assert direct_url.url == "https://g.c/u/p.git" assert direct_url.info.commit_id == commit_id
def __init__( self, link: Link, template: InstallRequirement, factory: "Factory", name: Optional[NormalizedName] = None, version: Optional[CandidateVersion] = None, ) -> None: source_link = link cache_entry = factory.get_wheel_cache_entry(link, name) if cache_entry is not None: logger.debug("Using cached wheel link: %s", cache_entry.link) link = cache_entry.link ireq = make_install_req_from_link(link, template) assert ireq.link == link if ireq.link.is_wheel and not ireq.link.is_file: wheel = Wheel(ireq.link.filename) wheel_name = canonicalize_name(wheel.name) assert name == wheel_name, f"{name!r} != {wheel_name!r} for wheel" # Version may not be present for PEP 508 direct URLs if version is not None: wheel_version = Version(wheel.version) assert version == wheel_version, "{!r} != {!r} for wheel {}".format( version, wheel_version, name ) if cache_entry is not None: if cache_entry.persistent and template.link is template.original_link: ireq.original_link_is_in_wheel_cache = True if cache_entry.origin is not None: ireq.download_info = cache_entry.origin else: # Legacy cache entry that does not have origin.json. # download_info may miss the archive_info.hash field. ireq.download_info = direct_url_from_link( source_link, link_is_in_wheel_cache=cache_entry.persistent ) super().__init__( link=link, source_link=source_link, ireq=ireq, factory=factory, name=name, version=version, )
def test_from_link_vcs_with_source_dir_obtains_commit_id( script: PipTestEnvironment, tmpdir: Path ) -> None: repo_path = tmpdir / "test-repo" repo_path.mkdir() repo_dir = str(repo_path) script.run("git", "init", cwd=repo_dir) (repo_path / "somefile").touch() script.run("git", "add", ".", cwd=repo_dir) script.run("git", "commit", "-m", "commit msg", cwd=repo_dir) commit_id = script.run("git", "rev-parse", "HEAD", cwd=repo_dir).stdout.strip() direct_url = direct_url_from_link( Link("git+https://g.c/u/p.git"), source_dir=repo_dir ) assert direct_url.url == "https://g.c/u/p.git" assert isinstance(direct_url.info, VcsInfo) assert direct_url.info.commit_id == commit_id
def test_from_link_dir(tmpdir: Path) -> None: dir_url = tmpdir.as_uri() direct_url = direct_url_from_link(Link(dir_url)) assert direct_url.url == dir_url assert isinstance(direct_url.info, DirInfo)
def test_from_link_dir(tmpdir): dir_url = path_to_url(tmpdir) direct_url = direct_url_from_link(Link(dir_url)) assert direct_url.url == dir_url assert isinstance(direct_url.info, DirInfo)
def test_from_link_vcs_without_source_dir(script, tmpdir): direct_url = direct_url_from_link(Link("git+https://g.c/u/p.git@1"), link_is_in_wheel_cache=True) assert direct_url.url == "https://g.c/u/p.git" assert direct_url.info.commit_id == "1"
def install( self, install_options, # type: List[str] global_options=None, # type: Optional[Sequence[str]] root=None, # type: Optional[str] home=None, # type: Optional[str] prefix=None, # type: Optional[str] warn_script_location=True, # type: bool use_user_site=False, # type: bool pycompile=True # type: bool ): # type: (...) -> None scheme = get_scheme( self.name, user=use_user_site, home=home, root=root, isolated=self.isolated, prefix=prefix, ) global_options = global_options if global_options is not None else [] if self.editable: install_editable_legacy( install_options, global_options, prefix=prefix, home=home, use_user_site=use_user_site, name=self.name, setup_py_path=self.setup_py_path, isolated=self.isolated, build_env=self.build_env, unpacked_source_directory=self.unpacked_source_directory, ) self.install_succeeded = True return if self.is_wheel: assert self.local_file_path direct_url = None if self.original_link: direct_url = direct_url_from_link( self.original_link, self.source_dir, self.original_link_is_in_wheel_cache, ) install_wheel( self.name, self.local_file_path, scheme=scheme, req_description=str(self.req), pycompile=pycompile, warn_script_location=warn_script_location, direct_url=direct_url, ) self.install_succeeded = True return # TODO: Why don't we do this for editable installs? # Extend the list of global and install options passed on to # the setup.py call with the ones from the requirements file. # Options specified in requirements file override those # specified on the command line, since the last option given # to setup.py is the one that is used. global_options = list(global_options) + self.global_options install_options = list(install_options) + self.install_options try: success = install_legacy( install_options=install_options, global_options=global_options, root=root, home=home, prefix=prefix, use_user_site=use_user_site, pycompile=pycompile, scheme=scheme, setup_py_path=self.setup_py_path, isolated=self.isolated, req_name=self.name, build_env=self.build_env, unpacked_source_directory=self.unpacked_source_directory, req_description=str(self.req), ) except LegacyInstallFailure as exc: self.install_succeeded = False six.reraise(*exc.parent) except Exception: self.install_succeeded = True raise self.install_succeeded = success
def install( self, install_options, # type: List[str] global_options=None, # type: Optional[Sequence[str]] root=None, # type: Optional[str] home=None, # type: Optional[str] prefix=None, # type: Optional[str] warn_script_location=True, # type: bool use_user_site=False, # type: bool pycompile=True # type: bool ): # type: (...) -> None scheme = get_scheme( name, user=use_user_site, home=home, root=root, isolated=isolated, prefix=prefix, ) global_options = global_options if global_options is not None else [] if editable: install_editable_legacy( install_options, global_options, prefix=prefix, home=home, use_user_site=use_user_site, name=name, setup_py_path=setup_py_path, isolated=isolated, build_env=build_env, unpacked_source_directory=unpacked_source_directory, ) install_succeeded = True return if is_wheel: assert local_file_path direct_url = None if original_link: direct_url = direct_url_from_link( original_link, source_dir, original_link_is_in_wheel_cache, ) install_wheel( name, local_file_path, scheme=scheme, req_description=str(req), pycompile=pycompile, warn_script_location=warn_script_location, direct_url=direct_url, requested=user_supplied, ) install_succeeded = True return # TODO: Why don't we do this for editable installs? # Extend the list of global and install options passed on to # the setup.py call with the ones from the requirements file. # Options specified in requirements file override those # specified on the command line, since the last option given # to setup.py is the one that is used. global_options = list(global_options) + global_options install_options = list(install_options) + install_options try: success = install_legacy( install_options=install_options, global_options=global_options, root=root, home=home, prefix=prefix, use_user_site=use_user_site, pycompile=pycompile, scheme=scheme, setup_py_path=setup_py_path, isolated=isolated, req_name=name, build_env=build_env, unpacked_source_directory=unpacked_source_directory, req_description=str(req), ) except LegacyInstallFailure as exc: install_succeeded = False six.reraise(*exc.parent) except Exception: install_succeeded = True raise install_succeeded = success if success and legacy_install_reason == 8368: deprecated( reason=( "{} was installed using the legacy 'setup.py install' " "method, because a wheel could not be built for it.". format(name) ), replacement="to fix the wheel build issue reported above", gone_in="21.0", issue=8368, )
def install( self, install_options: List[str], global_options: Optional[Sequence[str]] = None, root: Optional[str] = None, home: Optional[str] = None, prefix: Optional[str] = None, warn_script_location: bool = True, use_user_site: bool = False, pycompile: bool = True, ) -> None: scheme = get_scheme( self.name, user=use_user_site, home=home, root=root, isolated=self.isolated, prefix=prefix, ) global_options = global_options if global_options is not None else [] if self.editable and not self.is_wheel: install_editable_legacy( install_options, global_options, prefix=prefix, home=home, use_user_site=use_user_site, name=self.name, setup_py_path=self.setup_py_path, isolated=self.isolated, build_env=self.build_env, unpacked_source_directory=self.unpacked_source_directory, ) self.install_succeeded = True return if self.is_wheel: assert self.local_file_path direct_url = None # TODO this can be refactored to direct_url = self.download_info if self.editable: direct_url = direct_url_for_editable( self.unpacked_source_directory) elif self.original_link: direct_url = direct_url_from_link( self.original_link, self.source_dir, self.original_link_is_in_wheel_cache, ) install_wheel( self.name, self.local_file_path, scheme=scheme, req_description=str(self.req), pycompile=pycompile, warn_script_location=warn_script_location, direct_url=direct_url, requested=self.user_supplied, ) self.install_succeeded = True return # TODO: Why don't we do this for editable installs? # Extend the list of global and install options passed on to # the setup.py call with the ones from the requirements file. # Options specified in requirements file override those # specified on the command line, since the last option given # to setup.py is the one that is used. global_options = list(global_options) + self.global_options install_options = list(install_options) + self.install_options try: success = install_legacy( install_options=install_options, global_options=global_options, root=root, home=home, prefix=prefix, use_user_site=use_user_site, pycompile=pycompile, scheme=scheme, setup_py_path=self.setup_py_path, isolated=self.isolated, req_name=self.name, build_env=self.build_env, unpacked_source_directory=self.unpacked_source_directory, req_description=str(self.req), ) except LegacyInstallFailure as exc: self.install_succeeded = False raise exc except Exception: self.install_succeeded = True raise self.install_succeeded = success if success and self.legacy_install_reason == 8368: deprecated( reason=("{} was installed using the legacy 'setup.py install' " "method, because a wheel could not be built for it.". format(self.name)), replacement="to fix the wheel build issue reported above", gone_in=None, issue=8368, )