pex 2.54.2__py2.py3-none-any.whl → 2.69.0__py2.py3-none-any.whl

pex/resolver.py

@@ -8,15 +8,14 @@ import functools
 import glob
 import hashlib
 import itertools
+import json
 import os
-import tarfile
 import zipfile
 from abc import abstractmethod
 from collections import OrderedDict, defaultdict
 
-from pex import targets
+from pex import sdist, targets
 from pex.atomic_directory import AtomicDirectory, atomic_directory
-from pex.auth import PasswordEntry
 from pex.cache.dirs import BuiltWheelDir, CacheDir
 from pex.common import (
     open_zip,
@@ -31,24 +30,29 @@ from pex.dependency_configuration import DependencyConfiguration
 from pex.dist_metadata import (
     DistMetadata,
     Distribution,
+    ProjectMetadata,
     Requirement,
     is_tar_sdist,
     is_wheel,
     is_zip_sdist,
 )
+from pex.exceptions import production_assert
 from pex.fingerprinted_distribution import FingerprintedDistribution
+from pex.installed_wheel import InstalledWheel
 from pex.jobs import Raise, SpawnedJob, execute_parallel, iter_map_parallel
 from pex.network_configuration import NetworkConfiguration
 from pex.orderedset import OrderedSet
-from pex.pep_376 import InstalledWheel
 from pex.pep_425 import CompatibilityTags
 from pex.pep_427 import InstallableType, WheelError, install_wheel_chroot
+from pex.pep_440 import Version
 from pex.pep_503 import ProjectName
 from pex.pip.download_observer import DownloadObserver
 from pex.pip.installation import get_pip
+from pex.pip.local_project import digest_local_project
 from pex.pip.tool import PackageIndexConfiguration
 from pex.pip.version import PipVersionValue
 from pex.requirements import LocalProjectRequirement, URLRequirement
+from pex.resolve.package_repository import ReposConfiguration
 from pex.resolve.requirement_configuration import RequirementConfiguration
 from pex.resolve.resolver_configuration import BuildConfiguration, PipLog, ResolverVersion
 from pex.resolve.resolvers import (
@@ -59,7 +63,10 @@ from pex.resolve.resolvers import (
     Untranslatable,
     check_resolve,
 )
+from pex.resolve.target_system import TargetSystem, UniversalTarget
+from pex.result import Error
 from pex.targets import AbbreviatedPlatform, CompletePlatform, LocalInterpreter, Target, Targets
+from pex.third_party.packaging.specifiers import SpecifierSet
 from pex.third_party.packaging.tags import Tag
 from pex.tracer import TRACER
 from pex.typing import TYPE_CHECKING
@@ -79,6 +86,7 @@ if TYPE_CHECKING:
         Sequence,
         Set,
         Tuple,
+        Union,
     )
 
     import attr  # vendor:skip
@@ -88,59 +96,135 @@ else:
     from pex.third_party import attr
 
 
-def _uniqued_targets(targets=None):
-    # type: (Optional[Iterable[Target]]) -> Tuple[Target, ...]
-    return tuple(OrderedSet(targets)) if targets is not None else ()
+@attr.s(frozen=True)
+class DownloadTarget(object):
+    @classmethod
+    def current(cls):
+        # type: () -> DownloadTarget
+        return cls(target=targets.current())
+
+    target = attr.ib()  # type: Target
+    universal_target = attr.ib(default=None)  # type: Optional[UniversalTarget]
+
+    def render_description(self):
+        # type: () -> str
+        target_description = self.target.render_description()
+        if self.universal_target:
+            description_components = ["universal resolve"]
+            if self.universal_target.systems and frozenset(
+                self.universal_target.systems
+            ) != frozenset(TargetSystem.values()):
+                description_components.append(
+                    "targeting {systems}".format(
+                        systems=" and ".join(map(str, self.universal_target.systems))
+                    )
+                )
+            if self.universal_target.implementation:
+                description_components.append(
+                    "for {impl}".format(impl=self.universal_target.implementation)
+                )
+            description_components.append("using {target}".format(target=target_description))
+            return " ".join(description_components)
+        return target_description
+
+    def id(self, complete=False):
+        # type: (bool) -> str
+
+        if self.universal_target:
+            id_components = ["universal"]
+            if self.universal_target.implementation:
+                id_components.append(str(self.universal_target.implementation))
+            id_components.append(
+                "-and-".join(map(str, self.universal_target.systems or TargetSystem.values()))
+            )
+            if complete:
+                id_components.append(
+                    hashlib.sha1(str(self.universal_target.marker()).encode("utf-8")).hexdigest()
+                )
+            return "-".join(id_components)
+
+        if isinstance(self.target, LocalInterpreter):
+            # e.g.: CPython 2.7.18
+            return self.target.interpreter.version_string
+        if isinstance(self.target, AbbreviatedPlatform):
+            return str(self.target.platform)
+        if isinstance(self.target, CompletePlatform):
+            return str(self.target.platform.tag)
+
+        return self.target.id
+
+
+def _uniqued_download_requests(requests=None):
+    # type: (Optional[Iterable[DownloadRequest]]) -> Tuple[DownloadRequest, ...]
+    return tuple(OrderedSet(requests)) if requests is not None else ()
 
 
 @attr.s(frozen=True)
 class PipLogManager(object):
+    @staticmethod
+    def _target_id(download_target):
+        # type: (DownloadTarget) -> str
+
+        universal_target = download_target.universal_target
+        if universal_target:
+            id_components = ["universal"]
+            if universal_target.implementation:
+                id_components.append(str(universal_target.implementation))
+            id_components.extend(map(str, universal_target.systems or TargetSystem.values()))
+            return "-and-".join(id_components)
+
+        target = download_target.target
+        if isinstance(target, LocalInterpreter):
+            # e.g.: CPython 2.7.18
+            return target.interpreter.version_string
+        if isinstance(target, AbbreviatedPlatform):
+            return str(target.platform)
+        if isinstance(target, CompletePlatform):
+            return str(target.platform.tag)
+        return target.id
+
     @classmethod
     def create(
         cls,
         log,  # type: Optional[PipLog]
-        targets,  # type: Sequence[Target]
+        download_targets,  # type: Sequence[DownloadTarget]
     ):
         # type: (...) -> PipLogManager
-        log_by_target = {}  # type: Dict[Target, str]
-        if log and len(targets) == 1:
-            log_by_target[targets[0]] = log.path
+        log_by_download_target = {}  # type: Dict[DownloadTarget, str]
+        if log and len(download_targets) == 1:
+            log_by_download_target[download_targets[0]] = log.path
         elif log:
             log_dir = safe_mkdtemp(prefix="pex-pip-log.")
-            log_by_target.update(
-                (target, os.path.join(log_dir, "pip.{target}.log".format(target=target.id)))
-                for target in targets
+            log_by_download_target.update(
+                (
+                    download_target,
+                    os.path.join(
+                        log_dir,
+                        "pip.{target}.log".format(target=download_target.id(complete=True)),
+                    ),
+                )
+                for download_target in download_targets
             )
-        return cls(log=log, log_by_target=log_by_target)
+        return cls(log=log, log_by_download_target=log_by_download_target)
 
     log = attr.ib()  # type: Optional[PipLog]
-    _log_by_target = attr.ib()  # type: Mapping[Target, str]
-
-    @staticmethod
-    def _target_id(target):
-        # type: (Target) -> str
-        if isinstance(target, LocalInterpreter):
-            # e.g.: CPython 2.7.18
-            return target.interpreter.version_string
-        if isinstance(target, AbbreviatedPlatform):
-            return str(target.platform)
-        if isinstance(target, CompletePlatform):
-            return str(target.platform.tag)
-        return target.id
+    _log_by_download_target = attr.ib()  # type: Mapping[DownloadTarget, str]
 
     def finalize_log(self):
         # type: () -> None
         if not self.log:
             return
 
-        target_count = len(self._log_by_target)
+        target_count = len(self._log_by_download_target)
         if target_count <= 1:
             return
 
         with safe_open(self.log.path, "a") as out_fp:
-            for index, (target, log) in enumerate(self._log_by_target.items(), start=1):
+            for index, (download_target, log) in enumerate(
+                self._log_by_download_target.items(), start=1
+            ):
                 prefix = "{index}/{count}]{target}".format(
-                    index=index, count=target_count, target=self._target_id(target)
+                    index=index, count=target_count, target=download_target.id()
                 )
                 if not os.path.exists(log):
                     print(
@@ -153,18 +237,60 @@ class PipLogManager(object):
                     for line in in_fp:
                         out_fp.write("{prefix}: {line}".format(prefix=prefix, line=line))
 
-    def get_log(self, target):
-        # type: (Target) -> Optional[str]
-        return self._log_by_target.get(target)
+    def get_log(self, download_target):
+        # type: (DownloadTarget) -> Optional[str]
+        return self._log_by_download_target.get(download_target)
 
 
 @attr.s(frozen=True)
-class DownloadRequest(object):
-    targets = attr.ib(converter=_uniqued_targets)  # type: Tuple[Target, ...]
+class Report(object):
+    @classmethod
+    def parse(
+        cls,
+        download_target,  # type: DownloadTarget
+        report,  # type: str
+    ):
+        # type: (...) -> Report
+
+        with open(report) as fp:
+            data = json.load(fp)
+
+        project_metadata = []  # type: List[ProjectMetadata]
+        for distribution in data["install"]:
+            metadata = distribution["metadata"]
+            project_metadata.append(
+                ProjectMetadata(
+                    project_name=ProjectName(metadata["name"]),
+                    version=Version(metadata["version"]),
+                    requires_python=SpecifierSet(metadata.get("requires_python", "")),
+                    requires_dists=tuple(
+                        Requirement.parse(requirement)
+                        for requirement in metadata.get("requires_dist", ())
+                    ),
+                )
+            )
+        return cls(
+            download_target=download_target,
+            metadata={metadata.project_name: metadata for metadata in project_metadata},
+        )
+
+    download_target = attr.ib()  # type: DownloadTarget
+    metadata = attr.ib()  # type: Mapping[ProjectName, ProjectMetadata]
+
+
+@attr.s(frozen=True)
+class Reports(object):
+    reports = attr.ib(default=())  # type: Tuple[Report, ...]
+
+    def __iter__(self):
+        # type: () -> Iterator[Report]
+        return iter(self.reports)
+
+
+@attr.s(frozen=True)
+class _PipSession(object):
+    requests = attr.ib(converter=_uniqued_download_requests)  # type: Tuple[DownloadRequest, ...]
     direct_requirements = attr.ib()  # type: Iterable[ParsedRequirement]
-    requirements = attr.ib(default=None)  # type: Optional[Iterable[str]]
-    requirement_files = attr.ib(default=None)  # type: Optional[Iterable[str]]
-    constraint_files = attr.ib(default=None)  # type: Optional[Iterable[str]]
     allow_prereleases = attr.ib(default=False)  # type: bool
     transitive = attr.ib(default=True)  # type: bool
     package_index_configuration = attr.ib(default=None)  # type: Optional[PackageIndexConfiguration]
@@ -181,12 +307,114 @@ class DownloadRequest(object):
         # type: () -> Iterator[BuildRequest]
         for requirement in self.direct_requirements:
             if isinstance(requirement, LocalProjectRequirement):
-                for target in self.targets:
-                    yield BuildRequest.create(target=target, source_path=requirement.path)
+                for request in self.requests:
+                    yield BuildRequest.for_directory(
+                        target=request.target, source_path=requirement.path
+                    )
+
+    def generate_reports(self, max_parallel_jobs=None):
+        # type: (Optional[int]) -> Reports
+
+        if not self.requests or not any(request.has_requirements for request in self.requests):
+            # Nothing to report.
+            return Reports()
+
+        dest = safe_mkdtemp(
+            prefix="resolver_report.", dir=safe_mkdir(CacheDir.DOWNLOADS.path(".tmp"))
+        )
+
+        log_manager = PipLogManager.create(
+            self.pip_log,
+            download_targets=tuple(request.download_target for request in self.requests),
+        )
+        if self.pip_log and not self.pip_log.user_specified:
+            TRACER.log(
+                "Preserving `pip install --dry-run` log at {log_path}".format(
+                    log_path=self.pip_log.path
+                ),
+                V=ENV.PEX_VERBOSE,
+            )
+
+        spawn_report = functools.partial(
+            self._spawn_report, resolved_target_dir=dest, log_manager=log_manager
+        )
+        with TRACER.timed(
+            "Resolving for:\n  {}".format(
+                "\n  ".join(request.render_description() for request in self.requests)
+            )
+        ):
+            try:
+                return Reports(
+                    reports=tuple(
+                        Report.parse(download_request.download_target, report)
+                        for download_request, report in zip(
+                            self.requests,
+                            execute_parallel(
+                                inputs=self.requests,
+                                spawn_func=spawn_report,
+                                error_handler=Raise[DownloadRequest, str](Unsatisfiable),
+                                max_jobs=max_parallel_jobs,
+                            ),
+                        )
+                    )
+                )
+            finally:
+                log_manager.finalize_log()
+
+    def _spawn_report(
+        self,
+        request,  # type: DownloadRequest
+        resolved_target_dir,  # type: str
+        log_manager,  # type: PipLogManager
+    ):
+        # type: (...) -> SpawnedJob[str]
+
+        report_dir = safe_mkdir(
+            os.path.join(resolved_target_dir, request.download_target.id(complete=True))
+        )
+        report = os.path.join(report_dir, "pip-report.json")
+        download_target = request.download_target
+        observer = (
+            self.observer.observe_download(
+                download_target=download_target, download_dir=resolved_target_dir
+            )
+            if self.observer
+            else None
+        )
+
+        target = download_target.target
+
+        download_job = get_pip(
+            interpreter=target.get_interpreter(),
+            version=self.pip_version,
+            resolver=self.resolver,
+            extra_requirements=(
+                self.package_index_configuration.extra_pip_requirements
+                if self.package_index_configuration
+                else ()
+            ),
+        ).spawn_report(
+            report_path=report,
+            requirements=request.requirements,
+            requirement_files=request.requirement_files,
+            constraint_files=request.constraint_files,
+            allow_prereleases=self.allow_prereleases,
+            transitive=self.transitive,
+            target=target,
+            package_index_configuration=self.package_index_configuration,
+            build_configuration=self.build_configuration,
+            observer=observer,
+            dependency_configuration=self.dependency_configuration,
+            universal_target=download_target.universal_target,
+            log=log_manager.get_log(download_target),
+        )
+
+        return SpawnedJob.wait(job=download_job, result=report)
 
     def download_distributions(self, dest=None, max_parallel_jobs=None):
         # type: (...) -> List[DownloadResult]
-        if not self.requirements and not self.requirement_files:
+
+        if not self.requests or not any(request.has_requirements for request in self.requests):
             # Nothing to resolve.
             return []
 
@@ -194,48 +422,32 @@ class DownloadRequest(object):
             prefix="resolver_download.", dir=safe_mkdir(CacheDir.DOWNLOADS.path(".tmp"))
         )
 
-        log_manager = PipLogManager.create(self.pip_log, self.targets)
+        log_manager = PipLogManager.create(
+            self.pip_log,
+            download_targets=tuple(request.download_target for request in self.requests),
+        )
         if self.pip_log and not self.pip_log.user_specified:
             TRACER.log(
                 "Preserving `pip download` log at {log_path}".format(log_path=self.pip_log.path),
                 V=ENV.PEX_VERBOSE,
             )
 
-        requirement_config = RequirementConfiguration(
-            requirements=self.requirements,
-            requirement_files=self.requirement_files,
-            constraint_files=self.constraint_files,
-        )
-        network_configuration = (
-            self.package_index_configuration.network_configuration
-            if self.package_index_configuration
-            else None
-        )
-        subdirectory_by_filename = {}  # type: Dict[str, str]
-        for parsed_requirement in requirement_config.parse_requirements(network_configuration):
-            if not isinstance(parsed_requirement, URLRequirement):
-                continue
-            subdirectory = parsed_requirement.subdirectory
-            if subdirectory:
-                subdirectory_by_filename[parsed_requirement.filename] = subdirectory
-
         spawn_download = functools.partial(
             self._spawn_download,
             resolved_dists_dir=dest,
             log_manager=log_manager,
-            subdirectory_by_filename=subdirectory_by_filename,
         )
         with TRACER.timed(
             "Resolving for:\n  {}".format(
-                "\n  ".join(target.render_description() for target in self.targets)
+                "\n  ".join(request.render_description() for request in self.requests)
             )
         ):
             try:
                 return list(
                     execute_parallel(
-                        inputs=self.targets,
+                        inputs=self.requests,
                         spawn_func=spawn_download,
-                        error_handler=Raise[Target, DownloadResult](Unsatisfiable),
+                        error_handler=Raise[DownloadRequest, DownloadResult](Unsatisfiable),
                         max_jobs=max_parallel_jobs,
                     )
                 )
@@ -244,20 +456,42 @@ class DownloadRequest(object):
 
     def _spawn_download(
         self,
-        target,  # type: Target
+        request,  # type: DownloadRequest
         resolved_dists_dir,  # type: str
         log_manager,  # type: PipLogManager
-        subdirectory_by_filename,  # type: Mapping[str, str]
     ):
         # type: (...) -> SpawnedJob[DownloadResult]
-        download_dir = os.path.join(resolved_dists_dir, target.id)
+
+        requirement_config = RequirementConfiguration(
+            requirements=request.requirements,
+            requirement_files=request.requirement_files,
+            constraint_files=request.constraint_files,
+        )
+        network_configuration = (
+            self.package_index_configuration.network_configuration
+            if self.package_index_configuration
+            else None
+        )
+        subdirectory_by_filename = {}  # type: Dict[str, str]
+        for parsed_requirement in requirement_config.parse_requirements(network_configuration):
+            if not isinstance(parsed_requirement, URLRequirement):
+                continue
+            subdirectory = parsed_requirement.subdirectory
+            if subdirectory:
+                subdirectory_by_filename[parsed_requirement.filename] = subdirectory
+
+        download_target = request.download_target
+        download_dir = os.path.join(resolved_dists_dir, download_target.id(complete=True))
         observer = (
-            self.observer.observe_download(target=target, download_dir=download_dir)
+            self.observer.observe_download(
+                download_target=download_target, download_dir=download_dir
+            )
             if self.observer
             else None
         )
 
-        download_result = DownloadResult(target, download_dir, subdirectory_by_filename)
+        download_result = DownloadResult(download_target, download_dir, subdirectory_by_filename)
+        target = download_target.target
         download_job = get_pip(
             interpreter=target.get_interpreter(),
             version=self.pip_version,
@@ -269,9 +503,9 @@ class DownloadRequest(object):
             ),
         ).spawn_download_distributions(
             download_dir=download_dir,
-            requirements=self.requirements,
-            requirement_files=self.requirement_files,
-            constraint_files=self.constraint_files,
+            requirements=request.requirements,
+            requirement_files=request.requirement_files,
+            constraint_files=request.constraint_files,
             allow_prereleases=self.allow_prereleases,
             transitive=self.transitive,
             target=target,
@@ -279,7 +513,8 @@ class DownloadRequest(object):
             build_configuration=self.build_configuration,
             observer=observer,
             dependency_configuration=self.dependency_configuration,
-            log=log_manager.get_log(target),
+            universal_target=download_target.universal_target,
+            log=log_manager.get_log(download_target),
         )
 
         return SpawnedJob.wait(job=download_job, result=download_result)
@@ -292,7 +527,7 @@ class DownloadResult(object):
         # type: (str) -> bool
         return is_wheel(path) and zipfile.is_zipfile(path)
 
-    target = attr.ib()  # type: Target
+    download_target = attr.ib()  # type: DownloadTarget
     download_dir = attr.ib()  # type: str
     subdirectory_by_filename = attr.ib()  # type: Mapping[str, str]
 
@@ -310,70 +545,135 @@ class DownloadResult(object):
                 subdirectory = self.subdirectory_by_filename.get(
                     os.path.basename(distribution_path)
                 )
-                yield BuildRequest.create(
-                    target=self.target, source_path=distribution_path, subdirectory=subdirectory
+                production_assert(
+                    os.path.isfile(distribution_path),
+                    (
+                        "Pip download results should always be files and never local project "
+                        "directories."
+                    ),
+                )
+                yield BuildRequest.for_file(
+                    target=self.download_target,
+                    source_path=distribution_path,
+                    subdirectory=subdirectory,
                 )
 
     def install_requests(self):
         # type: () -> Iterator[InstallRequest]
         for distribution_path in self._iter_distribution_paths():
             if self._is_wheel(distribution_path):
-                yield InstallRequest.create(target=self.target, wheel_path=distribution_path)
+                yield InstallRequest.create(
+                    target=self.download_target, wheel_path=distribution_path
+                )
 
 
 class IntegrityError(Exception):
     pass
 
 
-def fingerprint_path(path):
+if TYPE_CHECKING:
+    from pex.hashing import Hasher
+
+
+def _hasher():
+    # type: () -> Hasher
+
+    return hashlib.sha256()
+
+
+def _fingerprint_file(path):
     # type: (str) -> str
+    return CacheHelper.hash(path, digest=_hasher())
 
-    # We switched from sha1 to sha256 at the transition from using `pip install --target` to
-    # `pip install --prefix` to serve two purposes:
-    # 1. Insulate the new installation scheme from the old.
-    # 2. Move past sha1 which was shown to have practical collision attacks in 2019.
-    #
-    # The installation scheme switch was the primary purpose and switching hashes proved a pragmatic
-    # insulation. If the `pip install --prefix` re-arrangement scheme evolves, then some other
-    # option than switching hashing algorithms will be needed, like post-fixing a running version
-    # integer or just mixing one into the hashed content.
-    #
-    # See: https://github.com/pex-tool/pex/issues/1655 for a general overview of these cache
-    # structure concerns.
-    hasher = hashlib.sha256
 
-    if os.path.isdir(path):
-        return CacheHelper.dir_hash(path, hasher=hasher)
-    return CacheHelper.hash(path, hasher=hasher)
+def _fingerprint_directory(path):
+    # type: (str) -> str
+    return CacheHelper.dir_hash(path, digest=_hasher())
 
 
 class BuildError(Exception):
     pass
 
 
+def _fingerprint_local_project(
+    path,  # type: str
+    target,  # type: Target
+    resolver=None,  # type: Optional[Resolver]
+    pip_version=None,  # type: Optional[PipVersionValue]
+):
+    # type: (...) -> str
+    if resolver:
+        build_system_resolver = resolver
+    else:
+        from pex.resolve.configured_resolver import ConfiguredResolver
+
+        build_system_resolver = ConfiguredResolver.default()
+
+    hasher = _hasher()
+    result = digest_local_project(
+        directory=path,
+        digest=hasher,
+        target=target,
+        resolver=build_system_resolver,
+        pip_version=pip_version,
+    )
+    if isinstance(result, Error):
+        raise BuildError(
+            "Failed to create an sdist for hashing from the local project at {path}: "
+            "{err}".format(path=path, err=result)
+        )
+    return hasher.hexdigest()
+
+
+def _as_download_target(target):
+    # type: (Union[DownloadTarget, Target]) -> DownloadTarget
+    return target if isinstance(target, DownloadTarget) else DownloadTarget(target)
+
+
 @attr.s(frozen=True)
 class BuildRequest(object):
     @classmethod
-    def create(
+    def for_file(
         cls,
-        target,  # type: Target
+        target,  # type: Union[DownloadTarget, Target]
         source_path,  # type: str
         subdirectory=None,  # type: Optional[str]
     ):
         # type: (...) -> BuildRequest
-        fingerprint = fingerprint_path(source_path)
+        fingerprint = _fingerprint_file(source_path)
         return cls(
-            target=target,
+            download_target=_as_download_target(target),
             source_path=source_path,
             fingerprint=fingerprint,
             subdirectory=subdirectory,
         )
 
-    target = attr.ib()  # type: Target
+    @classmethod
+    def for_directory(
+        cls,
+        target,  # type: Union[DownloadTarget, Target]
+        source_path,  # type: str
+        subdirectory=None,  # type: Optional[str]
+    ):
+        # type: (...) -> BuildRequest
+        download_target = _as_download_target(target)
+        return cls(
+            download_target=download_target,
+            source_path=source_path,
+            fingerprint=None,
+            subdirectory=subdirectory,
+        )
+
+    download_target = attr.ib(converter=_as_download_target)  # type: DownloadTarget
     source_path = attr.ib()  # type: str
-    fingerprint = attr.ib()  # type: str
+    fingerprint = attr.ib()  # type: Optional[str]
     subdirectory = attr.ib()  # type: Optional[str]
 
+    @property
+    def target(self):
+        # type: () -> Target
+        return self.download_target.target
+
     def prepare(self):
         # type: () -> str
 
@@ -386,26 +686,26 @@ class BuildRequest(object):
         if is_zip_sdist(self.source_path):
             with open_zip(self.source_path) as zf:
                 zf.extractall(extract_dir)
-        elif is_tar_sdist(self.source_path):
-            with tarfile.open(self.source_path) as tf:
-                tf.extractall(extract_dir)
-        else:
-            raise BuildError(
-                "Unexpected archive type for sdist {project}".format(project=self.source_path)
-            )
 
-        listing = os.listdir(extract_dir)
-        if len(listing) != 1:
-            raise BuildError(
-                "Expected one top-level project directory to be extracted from {project}, "
-                "found {count}: {listing}".format(
-                    project=self.source_path, count=len(listing), listing=", ".join(listing)
+            listing = os.listdir(extract_dir)
+            if len(listing) != 1:
+                raise BuildError(
+                    "Expected one top-level project directory to be extracted from {project}, "
+                    "found {count}: {listing}".format(
+                        project=self.source_path, count=len(listing), listing=", ".join(listing)
+                    )
                 )
-            )
-        project_directory = os.path.join(extract_dir, listing[0])
-        if self.subdirectory:
-            project_directory = os.path.join(project_directory, self.subdirectory)
-        return project_directory
+            project_directory = os.path.join(extract_dir, listing[0])
+            if self.subdirectory:
+                project_directory = os.path.join(project_directory, self.subdirectory)
+            return project_directory
+
+        if is_tar_sdist(self.source_path):
+            return sdist.extract_tarball(self.source_path, dest_dir=extract_dir)
+
+        raise BuildError(
+            "Unexpected archive type for sdist {project}".format(project=self.source_path)
+        )
 
     def result(self, source_path=None):
         # type: (Optional[str]) -> BuildResult
@@ -421,12 +721,16 @@ class BuildResult(object):
         source_path=None,  # type: Optional[str]
     ):
         # type: (...) -> BuildResult
-        built_wheel = BuiltWheelDir.create(
-            sdist=source_path or build_request.source_path,
-            fingerprint=build_request.fingerprint,
-            target=build_request.target,
-        )
-        return cls(request=build_request, atomic_dir=AtomicDirectory(built_wheel.dist_dir))
+        if build_request.fingerprint:
+            built_wheel = BuiltWheelDir.create(
+                sdist=source_path or build_request.source_path,
+                fingerprint=build_request.fingerprint,
+                target=build_request.target,
+            )
+            target_dir = built_wheel.dist_dir
+        else:
+            target_dir = os.path.join(safe_mkdtemp(), "build")
+        return cls(request=build_request, atomic_dir=AtomicDirectory(target_dir))
 
     request = attr.ib()  # type: BuildRequest
     _atomic_dir = attr.ib()  # type: AtomicDirectory
@@ -483,7 +787,7 @@ class BuildResult(object):
                     return frozenset(platforms), is_linux
 
                 wheel_platform_tags, is_linux_wheel = collect_platforms(
-                    CompatibilityTags.from_wheel(wheel.location)
+                    CompatibilityTags.from_wheel(wheel)
                 )
                 abbreviated_target_platform_tags, is_linux_abbreviated_target = collect_platforms(
                     self.request.target.supported_tags
@@ -522,7 +826,7 @@ class BuildResult(object):
                         target=self.request.target.render_description(),
                     )
                 )
-        return InstallRequest.create(self.request.target, wheel_path)
+        return InstallRequest.create(self.request.target, wheel_path, was_built_locally=True)
 
 
 @attr.s(frozen=True)
@@ -530,16 +834,28 @@ class InstallRequest(object):
     @classmethod
     def create(
         cls,
-        target,  # type: Target
+        target,  # type: Union[DownloadTarget, Target]
         wheel_path,  # type: str
+        was_built_locally=False,  # type: bool
     ):
         # type: (...) -> InstallRequest
-        fingerprint = fingerprint_path(wheel_path)
-        return cls(target=target, wheel_path=wheel_path, fingerprint=fingerprint)
+        fingerprint = _fingerprint_file(wheel_path)
+        return cls(
+            download_target=_as_download_target(target),
+            wheel_path=wheel_path,
+            fingerprint=fingerprint,
+            was_built_locally=was_built_locally,
+        )
 
-    target = attr.ib()  # type: Target
+    download_target = attr.ib(converter=_as_download_target)  # type: DownloadTarget
     wheel_path = attr.ib()  # type: str
     fingerprint = attr.ib()  # type: str
+    was_built_locally = attr.ib(default=False)  # type: bool
+
+    @property
+    def target(self):
+        # type: () -> Target
+        return self.download_target.target
 
     @property
     def wheel_file(self):
@@ -656,7 +972,7 @@ class InstallResult(object):
         else:
             cached_fingerprint = installed_wheel.fingerprint
 
-        wheel_dir_hash = cached_fingerprint or fingerprint_path(self.install_chroot)
+        wheel_dir_hash = cached_fingerprint or _fingerprint_directory(self.install_chroot)
         runtime_key_dir = os.path.join(self._installation_root, wheel_dir_hash)
         with atomic_directory(runtime_key_dir) as atomic_dir:
             if not atomic_dir.is_finalized():
@@ -879,7 +1195,9 @@ def _perform_install(
     # type: (...) -> InstallResult
     install_result = install_request.result(installed_wheels_dir)
     install_wheel_chroot(
-        wheel_path=install_request.wheel_path, destination=install_result.build_chroot
+        wheel=install_request.wheel_path,
+        destination=install_result.build_chroot,
+        normalize_file_stat=install_request.was_built_locally,
     )
     return install_result
 
@@ -972,8 +1290,10 @@ class BuildAndInstallRequest(object):
                     )
                 if is_wheel(dist_path):
                     to_install.add(InstallRequest.create(install_request.target, dist_path))
+                elif os.path.isdir(dist_path):
+                    to_build.add(BuildRequest.for_directory(install_request.target, dist_path))
                 else:
-                    to_build.add(BuildRequest.create(install_request.target, dist_path))
+                    to_build.add(BuildRequest.for_file(install_request.target, dist_path))
             already_analyzed.add(metadata.project_name)
 
         all_install_requests = OrderedSet(install_requests)
@@ -1137,7 +1457,7 @@ def _parse_reqs(
     requirement_files=None,  # type: Optional[Iterable[str]]
     network_configuration=None,  # type: Optional[NetworkConfiguration]
 ):
-    # type: (...) -> Iterable[ParsedRequirement]
+    # type: (...) -> Tuple[ParsedRequirement, ...]
     requirement_configuration = RequirementConfiguration(
         requirements=requirements, requirement_files=requirement_files
     )
@@ -1151,11 +1471,9 @@ def resolve(
     constraint_files=None,  # type: Optional[Iterable[str]]
     allow_prereleases=False,  # type: bool
     transitive=True,  # type: bool
-    indexes=None,  # type: Optional[Sequence[str]]
-    find_links=None,  # type: Optional[Sequence[str]]
+    repos_configuration=ReposConfiguration(),  # type: ReposConfiguration
     resolver_version=None,  # type: Optional[ResolverVersion.Value]
     network_configuration=None,  # type: Optional[NetworkConfiguration]
-    password_entries=(),  # type: Iterable[PasswordEntry]
     build_configuration=BuildConfiguration(),  # type: BuildConfiguration
     compile=False,  # type: bool
     max_parallel_jobs=None,  # type: Optional[int]
@@ -1182,19 +1500,13 @@ def resolve(
     :keyword constraint_files: A sequence of constraint file paths.
     :keyword allow_prereleases: Whether to include pre-release and development versions when
       resolving requirements. Defaults to ``False``, but any requirements that explicitly request
-      prerelease or development versions will override this setting.
+      pre-release or development versions will override this setting.
     :keyword transitive: Whether to resolve transitive dependencies of requirements.
       Defaults to ``True``.
-    :keyword indexes: A list of urls or paths pointing to PEP 503 compliant repositories to search for
-      distributions. Defaults to ``None`` which indicates to use the default pypi index. To turn off
-      use of all indexes, pass an empty list.
-    :keyword find_links: A list or URLs, paths to local html files or directory paths. If URLs or
-      local html file paths, these are parsed for links to distributions. If a local directory path,
-      its listing is used to discover distributions.
+    :keyword repos_configuration: Configuration for package repositories to resolve packages from.
     :keyword resolver_version: The resolver version to use.
     :keyword network_configuration: Configuration for network requests made downloading and building
       distributions.
-    :keyword password_entries: Any known authentication information needed for resolving.
     :keyword build_configuration: The configuration for building resolved projects.
     :keyword compile: Whether to pre-compile resolved distribution python sources.
       Defaults to ``False``.
@@ -1212,6 +1524,23 @@ def resolve(
     :raises ValueError: If `build=False` and `use_wheel=False`.
     """
 
+    if not build_configuration.allow_wheels:
+        foreign_targets = [
+            target
+            for target in targets.unique_targets()
+            if not isinstance(target, LocalInterpreter)
+        ]
+        if foreign_targets:
+            raise ValueError(
+                "Cannot ignore wheels (use_wheel=False) when resolving for foreign {platforms}: "
+                "{foreign_platforms}".format(
+                    platforms=pluralize(foreign_targets, "platform"),
+                    foreign_platforms=", ".join(
+                        target.render_description() for target in foreign_targets
+                    ),
+                )
+            )
+
     # A resolve happens in four stages broken into two phases:
     # 1. Download phase: resolves sdists and wheels in a single operation per distribution target.
     # 2. Install phase:
@@ -1246,38 +1575,26 @@ def resolve(
     package_index_configuration = PackageIndexConfiguration.create(
         pip_version=pip_version,
         resolver_version=resolver_version,
-        indexes=indexes,
-        find_links=find_links,
+        repos_configuration=repos_configuration,
         network_configuration=network_configuration,
-        password_entries=password_entries,
         use_pip_config=use_pip_config,
         extra_pip_requirements=extra_pip_requirements,
         keyring_provider=keyring_provider,
     )
 
-    if not build_configuration.allow_wheels:
-        foreign_targets = [
-            target
-            for target in targets.unique_targets()
-            if not isinstance(target, LocalInterpreter)
-        ]
-        if foreign_targets:
-            raise ValueError(
-                "Cannot ignore wheels (use_wheel=False) when resolving for foreign {platforms}: "
-                "{foreign_platforms}".format(
-                    platforms=pluralize(foreign_targets, "platform"),
-                    foreign_platforms=", ".join(
-                        target.render_description() for target in foreign_targets
-                    ),
-                )
-            )
+    requests = tuple(
+        DownloadRequest(
+            download_target=DownloadTarget(target=target),
+            requirements=requirements,
+            requirement_files=requirement_files,
+            constraint_files=constraint_files,
+        )
+        for target in targets.unique_targets()
+    )
 
     build_requests, download_results = _download_internal(
-        targets=targets,
+        requests=requests,
         direct_requirements=direct_requirements,
-        requirements=requirements,
-        requirement_files=requirement_files,
-        constraint_files=constraint_files,
         allow_prereleases=allow_prereleases,
         transitive=transitive,
         package_index_configuration=package_index_configuration,
@@ -1325,11 +1642,8 @@ def resolve(
 
 
 def _download_internal(
-    targets,  # type: Targets
+    requests,  # type: Tuple[DownloadRequest, ...]
     direct_requirements,  # type: Iterable[ParsedRequirement]
-    requirements=None,  # type: Optional[Iterable[str]]
-    requirement_files=None,  # type: Optional[Iterable[str]]
-    constraint_files=None,  # type: Optional[Iterable[str]]
     allow_prereleases=False,  # type: bool
     transitive=True,  # type: bool
     package_index_configuration=None,  # type: Optional[PackageIndexConfiguration]
@@ -1344,13 +1658,9 @@ def _download_internal(
 ):
     # type: (...) -> Tuple[List[BuildRequest], List[DownloadResult]]
 
-    unique_targets = targets.unique_targets()
-    download_request = DownloadRequest(
-        targets=unique_targets,
+    pip_session = _PipSession(
+        requests=requests,
         direct_requirements=direct_requirements,
-        requirements=requirements,
-        requirement_files=requirement_files,
-        constraint_files=constraint_files,
         allow_prereleases=allow_prereleases,
         transitive=transitive,
         package_index_configuration=package_index_configuration,
@@ -1362,8 +1672,8 @@ def _download_internal(
         dependency_configuration=dependency_configuration,
     )
 
-    local_projects = list(download_request.iter_local_projects())
-    download_results = download_request.download_distributions(
+    local_projects = list(pip_session.iter_local_projects())
+    download_results = pip_session.download_distributions(
         dest=dest, max_parallel_jobs=max_parallel_jobs
     )
     return local_projects, download_results
@@ -1373,12 +1683,13 @@ def _download_internal(
 class LocalDistribution(object):
     path = attr.ib()  # type: str
     fingerprint = attr.ib()  # type: str
-    target = attr.ib(factory=targets.current)  # type: Target
+    download_target = attr.ib(factory=DownloadTarget.current)  # type: DownloadTarget
     subdirectory = attr.ib(default=None)  # type: Optional[str]
 
-    @fingerprint.default
-    def _calculate_fingerprint(self):
-        return fingerprint_path(self.path)
+    @property
+    def target(self):
+        # type: () -> Target
+        return self.download_target.target
 
     @property
     def is_wheel(self):
@@ -1394,8 +1705,8 @@ class ResolveObserver(object):
     @abstractmethod
     def observe_download(
         self,
-        target,
-        download_dir,
+        download_target,  # type: DownloadTarget
+        download_dir,  # type: str
     ):
         # type: (...) -> DownloadObserver
         raise NotImplementedError()
@@ -1408,11 +1719,9 @@ def download(
     constraint_files=None,  # type: Optional[Iterable[str]]
     allow_prereleases=False,  # type: bool
     transitive=True,  # type: bool
-    indexes=None,  # type: Optional[Sequence[str]]
-    find_links=None,  # type: Optional[Sequence[str]]
+    repos_configuration=ReposConfiguration(),  # type: ReposConfiguration
     resolver_version=None,  # type: Optional[ResolverVersion.Value]
     network_configuration=None,  # type: Optional[NetworkConfiguration]
-    password_entries=(),  # type: Iterable[PasswordEntry]
     build_configuration=BuildConfiguration(),  # type: BuildConfiguration
     dest=None,  # type: Optional[str]
     max_parallel_jobs=None,  # type: Optional[int]
@@ -1434,19 +1743,13 @@ def download(
     :keyword constraint_files: A sequence of constraint file paths.
     :keyword allow_prereleases: Whether to include pre-release and development versions when
       resolving requirements. Defaults to ``False``, but any requirements that explicitly request
-      prerelease or development versions will override this setting.
+      pre-release or development versions will override this setting.
     :keyword transitive: Whether to resolve transitive dependencies of requirements.
       Defaults to ``True``.
-    :keyword indexes: A list of urls or paths pointing to PEP 503 compliant repositories to search
-      for distributions. Defaults to ``None`` which indicates to use the default pypi index. To turn
-      off use of all indexes, pass an empty list.
-    :keyword find_links: A list of URLs, paths to local html files or directory paths. If URLs or
-      local html file paths, these are parsed for links to distributions. If a local directory path,
-      its listing is used to discover distributions.
+    :keyword repos_configuration: Configuration for package repositories to resolve packages from.
     :keyword resolver_version: The resolver version to use.
     :keyword network_configuration: Configuration for network requests made downloading and building
       distributions.
-    :keyword password_entries: Any known authentication information needed for downloading.
     :keyword build_configuration: The configuration for building resolved projects.
     :keyword dest: A directory path to download distributions to.
     :keyword max_parallel_jobs: The maximum number of parallel jobs to use when resolving,
@@ -1459,24 +1762,127 @@ def download(
     :raises ValueError: If a foreign platform was provided in `platforms`, and `use_wheel=False`.
     :raises ValueError: If `build=False` and `use_wheel=False`.
     """
-    direct_requirements = _parse_reqs(requirements, requirement_files, network_configuration)
+    return download_requests(
+        requests=tuple(
+            DownloadRequest(
+                download_target=DownloadTarget(target),
+                requirements=requirements,
+                requirement_files=requirement_files,
+                constraint_files=constraint_files,
+            )
+            for target in targets.unique_targets()
+        ),
+        direct_requirements=_parse_reqs(requirements, requirement_files, network_configuration),
+        allow_prereleases=allow_prereleases,
+        transitive=transitive,
+        repos_configuration=repos_configuration,
+        resolver_version=resolver_version,
+        network_configuration=network_configuration,
+        build_configuration=build_configuration,
+        dest=dest,
+        max_parallel_jobs=max_parallel_jobs,
+        observer=observer,
+        pip_log=pip_log,
+        pip_version=pip_version,
+        resolver=resolver,
+        use_pip_config=use_pip_config,
+        extra_pip_requirements=extra_pip_requirements,
+        keyring_provider=keyring_provider,
+        dependency_configuration=dependency_configuration,
+    )
+
+
+def _as_str_tuple(items):
+    # type: (Optional[Iterable[str]]) -> Tuple[str, ...]
+    if not items:
+        return ()
+    return items if isinstance(items, tuple) else tuple(items)
+
+
+@attr.s(frozen=True)
+class DownloadRequest(object):
+    @classmethod
+    def create(
+        cls,
+        target,  # type: Target
+        universal_target=None,  # type: Optional[UniversalTarget]
+        requirement_configuration=RequirementConfiguration(),  # type: RequirementConfiguration
+        provenance=None,  # type: Optional[str]
+    ):
+        # type: (...) -> DownloadRequest
+        return cls(
+            download_target=DownloadTarget(target=target, universal_target=universal_target),
+            requirements=requirement_configuration.requirements,
+            requirement_files=requirement_configuration.requirement_files,
+            constraint_files=requirement_configuration.constraint_files,
+            provenance=provenance,
+        )
+
+    download_target = attr.ib()  # type: DownloadTarget
+    requirements = attr.ib(default=(), converter=_as_str_tuple)  # type: Tuple[str, ...]
+    requirement_files = attr.ib(default=(), converter=_as_str_tuple)  # type: Tuple[str, ...]
+    constraint_files = attr.ib(default=(), converter=_as_str_tuple)  # type: Tuple[str, ...]
+    provenance = attr.ib(default=None)  # type: Optional[str]
+
+    def render_description(self):
+        # type: () -> str
+        description = self.download_target.render_description()
+        if not self.provenance:
+            return description
+        return "{description} from {provenance}".format(
+            description=description, provenance=self.provenance
+        )
+
+    @property
+    def target(self):
+        # type: () -> Target
+        return self.download_target.target
+
+    @property
+    def universal_target(self):
+        # type: () -> Optional[UniversalTarget]
+        return self.download_target.universal_target
+
+    @property
+    def has_requirements(self):
+        return bool(self.requirements) or bool(self.requirement_files)
+
+
+def download_requests(
+    requests,  # type: Tuple[DownloadRequest, ...]
+    direct_requirements,  # type: Tuple[ParsedRequirement, ...]
+    allow_prereleases=False,  # type: bool
+    transitive=True,  # type: bool
+    repos_configuration=ReposConfiguration(),  # type: ReposConfiguration
+    resolver_version=None,  # type: Optional[ResolverVersion.Value]
+    network_configuration=None,  # type: Optional[NetworkConfiguration]
+    build_configuration=BuildConfiguration(),  # type: BuildConfiguration
+    dest=None,  # type: Optional[str]
+    max_parallel_jobs=None,  # type: Optional[int]
+    observer=None,  # type: Optional[ResolveObserver]
+    pip_log=None,  # type: Optional[PipLog]
+    pip_version=None,  # type: Optional[PipVersionValue]
+    resolver=None,  # type: Optional[Resolver]
+    use_pip_config=False,  # type: bool
+    extra_pip_requirements=(),  # type: Tuple[Requirement, ...]
+    keyring_provider=None,  # type: Optional[str]
+    dependency_configuration=DependencyConfiguration(),  # type: DependencyConfiguration
+):
+    # type: (...) -> Downloaded
+
     package_index_configuration = PackageIndexConfiguration.create(
         pip_version=pip_version,
         resolver_version=resolver_version,
-        indexes=indexes,
-        find_links=find_links,
+        repos_configuration=repos_configuration,
         network_configuration=network_configuration,
-        password_entries=password_entries,
         use_pip_config=use_pip_config,
         extra_pip_requirements=extra_pip_requirements,
         keyring_provider=keyring_provider,
     )
+
     build_requests, download_results = _download_internal(
-        targets=targets,
+        requests=requests,
         direct_requirements=direct_requirements,
-        requirements=requirements,
-        requirement_files=requirement_files,
-        constraint_files=constraint_files,
         allow_prereleases=allow_prereleases,
         transitive=transitive,
         package_index_configuration=package_index_configuration,
@@ -1495,11 +1901,21 @@ def download(
     def add_build_requests(requests):
         # type: (Iterable[BuildRequest]) -> None
         for request in requests:
+            if request.fingerprint:
+                fingerprint = request.fingerprint
+            else:
+                production_assert(os.path.isdir(request.source_path))
+                fingerprint = _fingerprint_local_project(
+                    path=request.source_path,
+                    target=request.target,
+                    resolver=resolver,
+                    pip_version=pip_version,
+                )
             local_distributions.append(
                 LocalDistribution(
-                    target=request.target,
+                    download_target=request.download_target,
                     path=request.source_path,
-                    fingerprint=request.fingerprint,
+                    fingerprint=fingerprint,
                     subdirectory=request.subdirectory,
                 )
             )
@@ -1510,10 +1926,58 @@ def download(
         for install_request in download_result.install_requests():
             local_distributions.append(
                 LocalDistribution(
-                    target=install_request.target,
+                    download_target=install_request.download_target,
                     path=install_request.wheel_path,
                     fingerprint=install_request.fingerprint,
                 )
             )
 
     return Downloaded(local_distributions=tuple(local_distributions))
+
+
+def reports(
+    requests,  # type: Tuple[DownloadRequest, ...]
+    direct_requirements,  # type: Tuple[ParsedRequirement, ...]
+    allow_prereleases=False,  # type: bool
+    transitive=True,  # type: bool
+    repos_configuration=ReposConfiguration(),  # type: ReposConfiguration
+    resolver_version=None,  # type: Optional[ResolverVersion.Value]
+    network_configuration=None,  # type: Optional[NetworkConfiguration]
+    build_configuration=BuildConfiguration(),  # type: BuildConfiguration
+    max_parallel_jobs=None,  # type: Optional[int]
+    observer=None,  # type: Optional[ResolveObserver]
+    pip_log=None,  # type: Optional[PipLog]
+    pip_version=None,  # type: Optional[PipVersionValue]
+    resolver=None,  # type: Optional[Resolver]
+    use_pip_config=False,  # type: bool
+    extra_pip_requirements=(),  # type: Tuple[Requirement, ...]
+    keyring_provider=None,  # type: Optional[str]
+    dependency_configuration=DependencyConfiguration(),  # type: DependencyConfiguration
+):
+    # type: (...) -> Reports
+
+    package_index_configuration = PackageIndexConfiguration.create(
+        pip_version=pip_version,
+        resolver_version=resolver_version,
+        repos_configuration=repos_configuration,
+        network_configuration=network_configuration,
+        use_pip_config=use_pip_config,
+        extra_pip_requirements=extra_pip_requirements,
+        keyring_provider=keyring_provider,
+    )
+
+    pip_session = _PipSession(
+        requests=requests,
+        direct_requirements=direct_requirements,
+        allow_prereleases=allow_prereleases,
+        transitive=transitive,
+        package_index_configuration=package_index_configuration,
+        build_configuration=build_configuration,
+        observer=observer,
+        pip_log=pip_log,
+        pip_version=pip_version,
+        resolver=resolver,
+        dependency_configuration=dependency_configuration,
+    )
+
+    return pip_session.generate_reports(max_parallel_jobs=max_parallel_jobs)