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

pex/resolve/lockfile/json_codec.py

@@ -7,8 +7,10 @@ import json
 
 from pex import compatibility
 from pex.artifact_url import Fingerprint
+from pex.dependency_configuration import Override
 from pex.dist_metadata import Requirement, RequirementParseError
 from pex.enum import Enum
+from pex.interpreter_constraints import InterpreterConstraint
 from pex.pep_440 import Version
 from pex.pep_503 import ProjectName
 from pex.pip.version import PipVersion
@@ -16,18 +18,20 @@ from pex.resolve.locked_resolve import (
     Artifact,
     FileArtifact,
     LocalProjectArtifact,
+    LockConfiguration,
     LockedRequirement,
     LockedResolve,
     LockStyle,
-    TargetSystem,
     VCSArtifact,
 )
 from pex.resolve.lockfile.model import Lockfile
 from pex.resolve.path_mappings import PathMappings
 from pex.resolve.resolved_requirement import Pin
 from pex.resolve.resolver_configuration import BuildConfiguration, PipConfiguration, ResolverVersion
+from pex.resolve.target_system import TargetSystem
 from pex.sorted_tuple import SortedTuple
 from pex.third_party.packaging import tags
+from pex.third_party.packaging.markers import InvalidMarker, Marker
 from pex.third_party.packaging.specifiers import InvalidSpecifier, SpecifierSet
 from pex.typing import TYPE_CHECKING, cast
 
@@ -184,6 +188,18 @@ def loads(
                 "The requirement string at '{path}' is invalid: {err}".format(path=path, err=e)
             )
 
+    def parse_override(
+        raw_override,  # type: str
+        path,  # type: str
+    ):
+        # type: (...) -> Override
+        try:
+            return Override.parse(raw_override)
+        except Override.InvalidError as e:
+            raise ParseError(
+                "The override string at '{path}' is invalid: {err}".format(path=path, err=e)
+            )
+
     def parse_version_specifier(
         raw_version_specifier,  # type: str
         path,  # type: str
@@ -196,6 +212,28 @@ def loads(
                 "The version specifier at '{path}' is invalid: {err}".format(path=path, err=e)
             )
 
+    def parse_interpreter_constraint(
+        value,  # type: str
+        path,  # type: str
+    ):
+        # type: (...) -> InterpreterConstraint
+        try:
+            return InterpreterConstraint.parse(value)
+        except ValueError as e:
+            raise ParseError(
+                "The interpreter constraint at '{path}' is invalid: {err}".format(path=path, err=e)
+            )
+
+    def parse_marker(
+        raw_marker,  # type: str
+        path,  # type: str
+    ):
+        # type: (...) -> Marker
+        try:
+            return Marker(raw_marker)
+        except InvalidMarker as e:
+            raise ParseError("The marker at '{path}' is invalid: {err}".format(path=path, err=e))
+
     required_path_mappings = get("path_mappings", dict, optional=True) or {}
     given_mappings = set(mapping.name for mapping in path_mappings.mappings)
     unspecified_paths = set(required_path_mappings) - given_mappings
@@ -204,16 +242,33 @@ def loads(
             required_path_mappings=required_path_mappings, unspecified_paths=unspecified_paths
         )
 
-    target_systems = [
-        parse_enum_value(
-            enum_type=TargetSystem,
-            value=target_system,
-            path=".target_systems[{index}]".format(index=index),
-        )
-        for index, target_system in enumerate(get("target_systems", list, optional=True) or ())
-    ]
-
+    style = get_enum_value(LockStyle, "style")
     elide_unused_requires_dist = get("elide_unused_requires_dist", bool, optional=True) or False
+    if style is LockStyle.UNIVERSAL:
+        lock_configuration = LockConfiguration.universal(
+            interpreter_constraints=[
+                parse_interpreter_constraint(
+                    value=interpreter_constraint,
+                    path=".requires_python[{index}]".format(index=index),
+                )
+                for index, interpreter_constraint in enumerate(get("requires_python", list))
+            ],
+            systems=[
+                parse_enum_value(
+                    enum_type=TargetSystem,
+                    value=target_system,
+                    path=".target_systems[{index}]".format(index=index),
+                )
+                for index, target_system in enumerate(
+                    get("target_systems", list, optional=True) or ()
+                )
+            ],
+            elide_unused_requires_dist=elide_unused_requires_dist,
+        )
+    else:
+        lock_configuration = LockConfiguration(
+            style=style, elide_unused_requires_dist=elide_unused_requires_dist
+        )
 
     only_wheels = [
         parse_project_name(project_name, path=".only_wheels[{index}]".format(index=index))
@@ -245,8 +300,8 @@ def loads(
     ]
 
     overridden = [
-        parse_requirement(req, path=".overridden[{index}]".format(index=index))
-        for index, req in enumerate(get("overridden", list, optional=True) or ())
+        parse_override(override, path=".overridden[{index}]".format(index=index))
+        for index, override in enumerate(get("overridden", list, optional=True) or ())
     ]
 
     def assemble_tag(
@@ -280,6 +335,12 @@ def loads(
             if platform_tag_components
             else None
         )
+        marker_str = get("marker", str, data=locked_resolve, path=lock_path, optional=True)
+        marker = (
+            parse_marker(marker_str, path='{lock_path}["marker"]'.format(lock_path=lock_path))
+            if marker_str
+            else None
+        )
         locked_reqs = []
         for req_index, req in enumerate(
             get("locked_requirements", list, data=locked_resolve, path=lock_path)
@@ -337,15 +398,16 @@ def loads(
             )
 
         locked_resolves.append(
-            LockedResolve(locked_requirements=SortedTuple(locked_reqs), platform_tag=platform_tag)
+            LockedResolve(
+                locked_requirements=SortedTuple(locked_reqs),
+                platform_tag=platform_tag,
+                marker=marker,
+            )
         )
 
     return Lockfile.create(
         pex_version=get("pex_version"),
-        style=get_enum_value(LockStyle, "style"),
-        requires_python=get("requires_python", list),
-        target_systems=target_systems,
-        elide_unused_requires_dist=elide_unused_requires_dist,
+        lock_configuration=lock_configuration,
         pip_version=get_enum_value(
             PipVersion,
             "pip_version",
@@ -406,12 +468,22 @@ def as_json_data(
             data["editable"] = artifact.editable
         return data
 
+    requires_python = []  # type: List[str]
+    target_systems = []  # type: List[str]
+    if lockfile.configuration.universal_target:
+        universal_target = lockfile.configuration.universal_target
+        requires_python.extend(
+            str(interpreter_constraint)
+            for interpreter_constraint in universal_target.iter_interpreter_constraints()
+        )
+        target_systems.extend(str(target_system) for target_system in universal_target.systems)
+
     return {
         "pex_version": lockfile.pex_version,
-        "style": str(lockfile.style),
-        "requires_python": list(lockfile.requires_python),
-        "target_systems": [str(target_system) for target_system in lockfile.target_systems],
-        "elide_unused_requires_dist": lockfile.elide_unused_requires_dist,
+        "style": str(lockfile.configuration.style),
+        "requires_python": requires_python,
+        "target_systems": target_systems,
+        "elide_unused_requires_dist": lockfile.configuration.elide_unused_requires_dist,
         "pip_version": str(lockfile.pip_version),
         "resolver_version": str(lockfile.resolver_version),
         "requirements": [
@@ -432,13 +504,16 @@ def as_json_data(
         "overridden": [str(override) for override in lockfile.overridden],
         "locked_resolves": [
             {
-                "platform_tag": [
-                    locked_resolve.platform_tag.interpreter,
-                    locked_resolve.platform_tag.abi,
-                    locked_resolve.platform_tag.platform,
-                ]
-                if locked_resolve.platform_tag
-                else None,
+                "platform_tag": (
+                    [
+                        locked_resolve.platform_tag.interpreter,
+                        locked_resolve.platform_tag.abi,
+                        locked_resolve.platform_tag.platform,
+                    ]
+                    if locked_resolve.platform_tag
+                    else None
+                ),
+                "marker": str(locked_resolve.marker) if locked_resolve.marker else None,
                 "locked_requirements": [
                     {
                         "project_name": str(req.pin.project_name),

pex/resolve/lockfile/model.py

@@ -5,19 +5,13 @@ from __future__ import absolute_import, print_function
 
 import os
 
-from pex.dependency_configuration import DependencyConfiguration
+from pex.dependency_configuration import DependencyConfiguration, Override
 from pex.dist_metadata import Constraint, Requirement
 from pex.orderedset import OrderedSet
 from pex.pep_503 import ProjectName
 from pex.pip.version import PipVersion, PipVersionValue
 from pex.requirements import LocalProjectRequirement
-from pex.resolve.locked_resolve import (
-    LocalProjectArtifact,
-    LockConfiguration,
-    LockedResolve,
-    LockStyle,
-    TargetSystem,
-)
+from pex.resolve.locked_resolve import LocalProjectArtifact, LockConfiguration, LockedResolve
 from pex.resolve.lockfile import requires_dist
 from pex.resolve.resolved_requirement import Pin
 from pex.resolve.resolver_configuration import BuildConfiguration, ResolverVersion
@@ -40,21 +34,18 @@ class Lockfile(object):
     def create(
         cls,
         pex_version,  # type: str
-        style,  # type: LockStyle.Value
-        requires_python,  # type: Iterable[str]
-        target_systems,  # type: Iterable[TargetSystem.Value]
+        lock_configuration,  # type: LockConfiguration
         requirements,  # type: Iterable[Union[Requirement, ParsedRequirement]]
         constraints,  # type: Iterable[Constraint]
         allow_prereleases,  # type: bool
         build_configuration,  # type: BuildConfiguration
         transitive,  # type: bool
         excluded,  # type: Iterable[Requirement]
-        overridden,  # type: Iterable[Requirement]
+        overridden,  # type: Iterable[Override]
         locked_resolves,  # type: Iterable[LockedResolve]
         source=None,  # type: Optional[str]
         pip_version=None,  # type: Optional[PipVersionValue]
         resolver_version=None,  # type: Optional[ResolverVersion.Value]
-        elide_unused_requires_dist=False,  # type: bool
     ):
         # type: (...) -> Lockfile
 
@@ -96,14 +87,11 @@ class Lockfile(object):
             return req.requirement
 
         resolve_requirements = OrderedSet(extract_requirement(req) for req in requirements)
-
         pip_ver = pip_version or PipVersion.DEFAULT
+
         return cls(
             pex_version=pex_version,
-            style=style,
-            requires_python=SortedTuple(requires_python),
-            target_systems=SortedTuple(target_systems),
-            elide_unused_requires_dist=elide_unused_requires_dist,
+            configuration=lock_configuration,
             pip_version=pip_ver,
             resolver_version=resolver_version or ResolverVersion.default(pip_ver),
             requirements=SortedTuple(resolve_requirements, key=str),
@@ -125,10 +113,12 @@ class Lockfile(object):
                     requires_dist.remove_unused_requires_dist(
                         resolve_requirements,
                         locked_resolve,
-                        requires_python=requires_python,
-                        target_systems=target_systems,
+                        universal_target=lock_configuration.universal_target,
+                        dependency_configuration=DependencyConfiguration.create(
+                            excluded=excluded, overridden=overridden
+                        ),
                     )
-                    if elide_unused_requires_dist
+                    if lock_configuration.elide_unused_requires_dist
                     else locked_resolve
                 )
                 for locked_resolve in locked_resolves
@@ -138,10 +128,7 @@ class Lockfile(object):
         )
 
     pex_version = attr.ib()  # type: str
-    style = attr.ib()  # type: LockStyle.Value
-    requires_python = attr.ib()  # type: SortedTuple[str]
-    target_systems = attr.ib()  # type: SortedTuple[TargetSystem.Value]
-    elide_unused_requires_dist = attr.ib()  # type: bool
+    configuration = attr.ib()  # type: LockConfiguration
     pip_version = attr.ib()  # type: PipVersionValue
     resolver_version = attr.ib()  # type: ResolverVersion.Value
     requirements = attr.ib()  # type: SortedTuple[Requirement]
@@ -157,20 +144,11 @@ class Lockfile(object):
     use_system_time = attr.ib()  # type: bool
     transitive = attr.ib()  # type: bool
     excluded = attr.ib()  # type: SortedTuple[Requirement]
-    overridden = attr.ib()  # type: SortedTuple[Requirement]
+    overridden = attr.ib()  # type: SortedTuple[Override]
     locked_resolves = attr.ib()  # type: SortedTuple[LockedResolve]
     local_project_requirement_mapping = attr.ib(eq=False)  # type: Mapping[str, Requirement]
     source = attr.ib(default=None, eq=False)  # type: Optional[str]
 
-    def lock_configuration(self):
-        # type: () -> LockConfiguration
-        return LockConfiguration(
-            style=self.style,
-            requires_python=self.requires_python,
-            target_systems=self.target_systems,
-            elide_unused_requires_dist=self.elide_unused_requires_dist,
-        )
-
     def build_configuration(self):
         # type: () -> BuildConfiguration
         return BuildConfiguration.create(

pex/resolve/lockfile/pep_751.py

@@ -14,6 +14,7 @@ from pex.compatibility import text, urlparse
 from pex.dependency_configuration import DependencyConfiguration
 from pex.dist_metadata import Constraint, Requirement
 from pex.exceptions import production_assert
+from pex.interpreter_implementation import InterpreterImplementation
 from pex.network_configuration import NetworkConfiguration
 from pex.orderedset import OrderedSet
 from pex.pep_425 import CompatibilityTags, RankedTag
@@ -27,7 +28,6 @@ from pex.resolve.locked_resolve import (
     LockedRequirement,
     LockedResolve,
     Resolved,
-    TargetSystem,
     UnFingerprintedLocalProjectArtifact,
     UnFingerprintedVCSArtifact,
     VCSArtifact,
@@ -38,6 +38,7 @@ from pex.resolve.lockfile.subset import Subset, SubsetResult
 from pex.resolve.requirement_configuration import RequirementConfiguration
 from pex.resolve.resolved_requirement import Pin
 from pex.resolve.resolver_configuration import BuildConfiguration
+from pex.resolve.target_system import TargetSystem, UniversalTarget
 from pex.result import Error, ResultError, try_
 from pex.sorted_tuple import SortedTuple
 from pex.targets import Target, Targets
@@ -175,53 +176,105 @@ def _elide_extras(marker):
     return marker
 
 
-def _to_environment(system):
-    # type: (TargetSystem.Value) -> str
+def _implementation_marker(
+    implementation,  # type: InterpreterImplementation.Value
+    extra_marker=None,  # type: Optional[Marker]
+):
+    # type: (...) -> str
+    platform_python_implementation = "platform_python_implementation == '{implementation}'".format(
+        implementation=implementation
+    )
+    if not extra_marker:
+        return platform_python_implementation
+    return "{platform_python_implementation} and {extra_marker}".format(
+        platform_python_implementation=platform_python_implementation, extra_marker=extra_marker
+    )
+
+
+def _to_environment(
+    system,  # type: TargetSystem.Value
+    implementation=None,  # type: Optional[InterpreterImplementation.Value]
+    extra_marker=None,  # type: Optional[Marker]
+):
+    # type: (...) -> str
+
     if system is TargetSystem.LINUX:
-        return "platform_system == 'Linux'"
+        platform_system = "platform_system == 'Linux'"
     elif system is TargetSystem.MAC:
-        return "platform_system == 'Darwin'"
+        platform_system = "platform_system == 'Darwin'"
     else:
         production_assert(system is TargetSystem.WINDOWS)
-        return "platform_system == 'Windows'"
+        platform_system = "platform_system == 'Windows'"
+
+    if not implementation:
+        if not extra_marker:
+            return platform_system
+        return "{platform_system} and {extra_marker}".format(
+            platform_system=platform_system, extra_marker=extra_marker
+        )
+
+    return "{platform_system} and {platform_python_implementation}".format(
+        platform_system=platform_system,
+        platform_python_implementation=_implementation_marker(
+            implementation, extra_marker=extra_marker
+        ),
+    )
 
 
 def convert(
     root_requirements,  # type: Iterable[Requirement]
     locked_resolve,  # type: LockedResolve
     output,  # type: IO[bytes]
-    requires_python=None,  # type: Optional[str]
-    target_systems=(),  # type: Iterable[TargetSystem.Value]
+    universal_target=None,  # type: Optional[UniversalTarget]
     subset=(),  # type: Iterable[DownloadableArtifact]
     include_dependency_info=True,  # type bool
 ):
     # type: (...) -> None
 
-    locked_resolve = remove_unused_requires_dist(
-        resolve_requirements=root_requirements,
-        locked_resolve=locked_resolve,
-        requires_python=[requires_python] if requires_python else [],
-        target_systems=target_systems,
-    )
-
     pylock = OrderedDict()  # type: OrderedDict[str, Any]
     pylock["lock-version"] = "1.0"  # https://peps.python.org/pep-0751/#lock-version
 
-    if target_systems:
+    if universal_target:
         # https://peps.python.org/pep-0751/#environments
         #
-        # TODO: We just stick to mapping `--target-system` into markers currently but this should
-        #  probably include the full marker needed to rule out invalid installs, like Python 2.7
-        #  attempting to install a lock with only Python 3 wheels.
-        pylock["environments"] = sorted(_to_environment(system) for system in target_systems)
-    if requires_python:
-        # https://peps.python.org/pep-0751/#requires-python
-        #
-        # TODO: This is currently just the `--interpreter-constraint` for `--style universal` locks
-        #  but it should probably be further refined (or purely calculated for non universal locks)
-        #  from locked project requires-python values and even more narrowly by locked projects with
-        #  only wheel artifacts by the wheel tags.
-        pylock["requires-python"] = requires_python
+        # TODO: We just stick to mapping `--target-system` and any `--interpreter-constraint` that
+        #  have an implementation specified into markers currently but this should probably include
+        #  the full marker needed to rule out invalid installs, like Python 2.7 attempting to
+        #  install a lock with only Python 3 wheels.
+        if universal_target.systems:
+            pylock["environments"] = sorted(
+                _to_environment(
+                    system,
+                    implementation=universal_target.implementation,
+                    extra_marker=locked_resolve.marker,
+                )
+                for system in universal_target.systems
+            )
+        elif universal_target.implementation:
+            pylock["environments"] = [
+                _implementation_marker(
+                    universal_target.implementation, extra_marker=locked_resolve.marker
+                )
+            ]
+        elif locked_resolve.marker:
+            pylock["environments"] = [str(locked_resolve.marker)]
+
+        if universal_target.requires_python:
+            if len(universal_target.requires_python) > 1:
+                # TODO(John Sirois): Provide a better error message. We could guide on OR
+                #  to and AND paired with != to remove disjoint portions of the range.
+                raise ValueError(
+                    "Can only convert a lock file with a single interpreter constraint."
+                )
+            requires_python = universal_target.requires_python[0]
+
+            # https://peps.python.org/pep-0751/#requires-python
+            #
+            # TODO: This is currently just any `--interpreter-constraint` specifiers for
+            #  `--style universal` locks but it should probably be further refined (or purely
+            #  calculated for non universal locks) from locked project requires-python values and
+            #  even more narrowly by locked projects with only wheel artifacts by the wheel tags.
+            pylock["requires-python"] = str(requires_python)
 
     # TODO: These 3 assume a `pyproject.toml` is the input source for the lock. It almost never is
     #  for current Pex lock use cases. Figure out if there is anything better that can be done.
@@ -251,6 +304,11 @@ def convert(
         if req.url and isinstance(parse_requirement_string(str(req)), URLRequirement)
     }  # type: Dict[ProjectName, Requirement]
 
+    locked_resolve = remove_unused_requires_dist(
+        resolve_requirements=root_requirements,
+        locked_resolve=locked_resolve,
+        universal_target=universal_target,
+    )
     dependants_by_project_name = defaultdict(
         OrderedSet
     )  # type: DefaultDict[ProjectName, OrderedSet[Tuple[ProjectName, Optional[Marker]]]]
@@ -508,11 +566,12 @@ class ParseContext(object):
         self,
         key,  # type: str
         default=None,  # type: Optional[str]
+        footer_message=None,  # type: Optional[str]
     ):
         # type: (...) -> str
         # The cast is of Python 2. The return type will actually be `unicode` in that case, but it
         # doesn't matter since there will be no further runtime type checks above this call.
-        return cast(str, self.get(key, text, default=default))
+        return cast(str, self.get(key, text, default=default, footer_message=footer_message))
 
     def get_array_of_strings(
         self,
@@ -593,14 +652,16 @@ class ParseContext(object):
         key,  # type: str
         item_type,  # type: Type[_T]
         default=None,  # type: Optional[_T]
+        footer_message=None,  # type: Optional[str]
     ):
         # type: (...) -> _T
         value = self.table.get(key, None)
         if value is None:
             if default is None:
-                raise ResultError(
-                    self.error("A value for {key} is required.".format(key=self.subpath(key)))
-                )
+                msg_lines = ["A value for {key} is required.".format(key=self.subpath(key))]
+                if footer_message:
+                    msg_lines.append(footer_message)
+                raise ResultError(self.error(os.linesep.join(msg_lines)))
             return default
         if not isinstance(value, item_type):
             raise ResultError(
@@ -797,43 +858,11 @@ class PackageIndex(object):
         return self._indexed_packages_by_name.get(project_name)
 
 
-def spec_matches(
-    spec,  # type: Any
-    package_data,  # type: Any
-):
-    # type: (...) -> bool
-
-    if isinstance(spec, dict) and isinstance(package_data, dict):
-        for key, value in spec.items():
-            if not spec_matches(value, package_data.get(key)):
-                return False
-        return True
-
-    if isinstance(spec, list) and isinstance(package_data, list):
-        # All instances of lists in packages are currently array of tables:
-        # + dependencies
-        # + wheels
-        # + attestation-identities
-        #
-        # As such, we consider the list matches if any of its contained tables matches each of the
-        # spec tables. This allows a dependency spec like so to match the torch cpu wheel in a lock
-        # that also includes torch-2.7.0-cp311-none-macosx_11_0_arm64.whl (cuda 12.8):
-        # {name = "torch", wheels = [{ name = "torch-2.7.0+xpu-cp39-cp39-win_amd64.whl" }]}
-        for spec_item in spec:
-            if not any(
-                spec_matches(spec_item, package_data_item) for package_data_item in package_data
-            ):
-                return False
-        return True
-
-    # I have no clue why MyPy can't track this as bool.
-    return cast(bool, spec == package_data)
-
-
 @attr.s
 class PackageParser(object):
     package_index = attr.ib()  # type: PackageIndex
     source = attr.ib()  # type: str
+    created_by = attr.ib()  # type: str
 
     parsed_packages_by_index = attr.ib(factory=dict)  # type: Dict[int, Package]
 
@@ -905,7 +934,22 @@ class PackageParser(object):
             "dependencies", default=[], diagnostic_key="name"
         )
         for dep_idx, dep_parse_context in enumerate(dep_parse_contexts):
-            dep_name = ProjectName(dep_parse_context.get_string("name"))
+            dep_name = ProjectName(
+                dep_parse_context.get_string(
+                    "name",
+                    footer_message=os.linesep.join(
+                        (
+                            "Pex requires dependency tables specify at least a `name`.",
+                            "The pylock.toml spec does not require this however.",
+                            "To subset locks created by {creator}, either they will need to add "
+                            "names for their dependencies or Pex will need to support more "
+                            "sophisticated dependency parsing.".format(creator=self.created_by),
+                            "For more information, see the comments starting here: "
+                            "https://github.com/pex-tool/pex/issues/2885#issuecomment-3263138568",
+                        )
+                    ),
+                )
+            )
 
             package_deps = self.package_index.packages(dep_name)
             if not package_deps:
@@ -915,31 +959,9 @@ class PackageParser(object):
                         project_name=project_name.raw, dep_name=dep_name.raw
                     )
                 )
-
-            deps = [
-                indexed_package
-                for indexed_package in package_deps
-                if spec_matches(dep_parse_context.table, indexed_package.package_data)
-            ]  # type: List[IndexedPackage]
-            if not deps:
-                return dep_parse_context.error(
-                    "No matching {dep_name} package could be found for {project_name} "
-                    "dependencies[{dep_idx}].".format(
-                        dep_name=dep_name.raw, project_name=project_name.raw, dep_idx=dep_idx
-                    )
-                )
-            elif len(deps) > 1:
-                return dep_parse_context.error(
-                    "More than one package matches {project_name} dependencies[{dep_idx}]:\n"
-                    "{matches}".format(
-                        project_name=project_name.raw,
-                        dep_idx=dep_idx,
-                        matches="\n".join(
-                            "+ packages[{index}]".format(index=dep.index) for dep in deps
-                        ),
-                    )
-                )
-            dependencies.append(Dependency(index=deps[0].index, project_name=dep_name))
+            dependencies.extend(
+                Dependency(index=dep.index, project_name=dep_name) for dep in package_deps
+            )
 
         vcs_parse_context = parse_context.get_table("vcs", default={})
         directory_parse_context = parse_context.get_table("directory", default={})
@@ -1342,12 +1364,7 @@ class Pylock(object):
         except TomlDecodeError as e:
             return parse_context.error("Failed to parse TOML", e)
 
-        lock_version = Version(
-            parse_context.get_string(
-                "lock-version",
-                "Pex only supports lock version 1.0 and refuses to guess compatibility.",
-            )
-        )
+        lock_version = Version(parse_context.get_string("lock-version"))
         if lock_version != Version("1.0"):
             return parse_context.error(
                 "Found `lock-version` {version}, but Pex only supports version 1.0.".format(
@@ -1370,7 +1387,9 @@ class Pylock(object):
             "packages", default=[], diagnostic_key="name"
         )
         package_index = PackageIndex.create(packages_data)
-        package_parser = PackageParser(package_index=package_index, source=pylock_toml_path)
+        package_parser = PackageParser(
+            package_index=package_index, source=pylock_toml_path, created_by=created_by
+        )
 
         local_project_requirement_mapping = {}  # type: Dict[str, Requirement]
         packages = []  # type: List[Package]