fix issue with optional fields in dependency validator

docs/notes/2.32.x.md

@@ -71,6 +71,8 @@ The `runtime` field of [`aws_python_lambda_layer`](https://www.pantsbuild.org/2.
 
 The `grpc-python-plugin` tool now uses an updated `v1.73.1` plugin built from  <https://github.com/nhurden/protoc-gen-grpc-python-prebuilt]. This also brings `macos_arm64` support.
 
+Fixed a bug in how dependencies are validated which prevented resolve-specific interpreter constraints from taking effect when `[python].default_to_resolve_interpreter_constraints` was enabled. Instead, code would fall back to the global interpreter constraints which is not correct when `default_to_resolve_interpreter_constraints` is in use.
+
 #### Shell
 
 #### Javascript

src/python/pants/backend/python/goals/export_integration_test.py

@@ -48,6 +48,7 @@ def build_config(
         "python": {
             "enable_resolves": True,
             "interpreter_constraints": [f"=={platform.python_version()}"],
+            "default_resolve": "a",
             "resolves": {
                 "a": "3rdparty/a.lock",
                 "b": "3rdparty/b.lock",

src/python/pants/backend/python/goals/export_test.py

@@ -110,6 +110,7 @@ def test_export_venv_new_codepath(
         [
             *pants_args_for_python_lockfiles,
             f"--python-interpreter-constraints=['=={current_interpreter}']",
+            "--python-default-resolve=a",
             "--python-resolves={'a': 'lock.txt', 'b': 'lock.txt'}",
             "--export-resolve=a",
             "--export-resolve=b",

src/python/pants/backend/python/target_types_test.py

@@ -10,6 +10,7 @@
 import pytest
 
 from pants.backend.python import target_types_rules
+from pants.backend.python.dependency_inference import rules as python_dependency_inference_rules
 from pants.backend.python.dependency_inference.rules import import_rules
 from pants.backend.python.macros.python_artifact import PythonArtifact
 from pants.backend.python.target_types import (
@@ -21,16 +22,20 @@
     PexEntryPointField,
     PexExecutableField,
     PexScriptField,
+    PythonDependenciesField,
     PythonDistribution,
     PythonRequirementsField,
     PythonRequirementTarget,
+    PythonResolveField,
     PythonSourcesGeneratorTarget,
+    PythonSourceTarget,
     ResolvedPexEntryPoint,
     ResolvePexEntryPointRequest,
     ResolvePythonDistributionEntryPointsRequest,
     normalize_module_mapping,
 )
 from pants.backend.python.target_types_rules import (
+    DependencyValidationFieldSet,
     InferPexBinaryEntryPointDependency,
     InferPythonDistributionDependencies,
     PexBinaryEntryPointDependencyInferenceFieldSet,
@@ -40,10 +45,12 @@
 from pants.backend.python.util_rules import python_sources
 from pants.core.goals.generate_lockfiles import UnrecognizedResolveNamesError
 from pants.core.util_rules.unowned_dependency_behavior import UnownedDependencyError
-from pants.engine.addresses import Address
+from pants.engine.addresses import Address, Addresses
 from pants.engine.internals.graph import _TargetParametrizations, _TargetParametrizationsRequest
+from pants.engine.internals.parametrize import Parametrize
 from pants.engine.internals.scheduler import ExecutionError
 from pants.engine.target import (
+    DependenciesRequest,
     InferredDependencies,
     InvalidFieldException,
     InvalidFieldTypeException,
@@ -610,3 +617,102 @@ def gen_pex_binary_tgt(entry_point: str, tags: list[str] | None = None) -> PexBi
         gen_pex_binary_tgt("subdir.f.py", tags=["overridden"]),
         gen_pex_binary_tgt("subdir.f:main"),
     }
+
+
+def test_python_dependency_validation_with_parametrized_resolve_repro() -> None:
+    rule_runner = RuleRunner(
+        rules=[
+            *target_types_rules.rules(),
+            *python_sources.rules(),
+            *python_dependency_inference_rules.rules(),
+            QueryRule(_TargetParametrizations, [_TargetParametrizationsRequest]),
+            QueryRule(Addresses, [DependenciesRequest]),
+        ],
+        target_types=[PythonSourceTarget, PythonSourcesGeneratorTarget],
+        objects={"parametrize": Parametrize},
+    )
+    rule_runner.write_files(
+        {
+            "pants.toml": dedent(
+                """\
+                [python]
+                enable_resolves = true
+                default_resolve = "a"
+                interpreter_constraints = ["==3.11.*", "==3.14.*"]
+                interpreter_versions_universe = ["3.11", "3.14"]
+                default_to_resolve_interpreter_constraints = true
+
+                [python.resolves]
+                "a" = "a.lock"
+                "b" = "b.lock"
+
+                [python.resolves_to_interpreter_constraints]
+                "a" = ["==3.11.*"]
+                "b" = ["==3.14.*"]
+
+                [python-infer]
+                imports = true
+
+                [source]
+                root_patterns = ["/src/python"]
+                """
+            ),
+            "src/python/pkg/base.py": "class Base:\n    pass\n",
+            "src/python/pkg/derived.py": (
+                "from pkg.base import Base\n\nclass Derived(Base):\n    pass\n"
+            ),
+            "src/python/pkg/BUILD": dedent(
+                """\
+                python_sources(
+                    sources=["base.py", "derived.py"],
+                    **parametrize("b", resolve="b"),
+                    **parametrize("a", resolve="a"),
+                    overrides={
+                        "derived.py": {
+                            "dependencies": ["./base.py"],
+                        },
+                    },
+                )
+                """
+            ),
+        }
+    )
+    rule_runner.set_options(["--pants-config-files=['pants.toml']"])
+    generated_targets = [
+        tgt
+        for tgt in rule_runner.request(
+            _TargetParametrizations,
+            [
+                _TargetParametrizationsRequest(
+                    Address("src/python/pkg"), description_of_origin="tests"
+                )
+            ],
+        ).parametrizations.values()
+        if isinstance(tgt, PythonSourceTarget)
+    ]
+    assert len(generated_targets) == 4
+    base_a = next(
+        tgt
+        for tgt in generated_targets
+        if tgt.address.relative_file_path == "base.py"
+        and tgt.address.parameters.get("parametrize") == "a"
+    )
+    derived_a = next(
+        tgt
+        for tgt in generated_targets
+        if tgt.address.relative_file_path == "derived.py"
+        and tgt.address.parameters.get("parametrize") == "a"
+    )
+
+    # The generated targets have the correct resolve.
+    assert base_a[PythonResolveField].value == "a"
+    assert derived_a[PythonResolveField].value == "a"
+    validation_field_set = DependencyValidationFieldSet.create(derived_a)
+    assert validation_field_set.resolve is not None
+    assert validation_field_set.resolve.value == "a"
+
+    resolved = rule_runner.request(
+        Addresses,
+        [DependenciesRequest(derived_a[PythonDependenciesField])],
+    )
+    assert tuple(resolved) == (base_a.address,)

src/python/pants/backend/python/util_rules/local_dists_pep660_test.py

@@ -95,6 +95,7 @@ def test_sort_all_python_distributions_by_resolve(rule_runner: PythonRuleRunner)
     rule_runner.set_options(
         [
             "--python-enable-resolves=True",
+            "--python-default-resolve=a",
             "--python-resolves={'a': 'lock.txt', 'b': 'lock.txt'}",
             # Turn off lockfile validation to make the test simpler.
             "--python-invalid-lockfile-behavior=ignore",

src/python/pants/engine/target.py

@@ -19,6 +19,7 @@
 from enum import Enum
 from operator import attrgetter
 from pathlib import PurePath
+from types import UnionType
 from typing import (
     AbstractSet,
     Any,
@@ -27,8 +28,11 @@
     Protocol,
     Self,
     TypeVar,
+    Union,
     cast,
     final,
+    get_args,
+    get_origin,
     get_type_hints,
 )
 
@@ -1475,11 +1479,28 @@ def create(cls: type[_FS], tgt: Target) -> _FS:
     @final
     @memoized_classproperty
     def fields(cls) -> FrozenDict[str, type[Field]]:
+        def field_type_from_annotation(annotation: Any) -> type[Field] | None:
+            if isinstance(annotation, type) and issubclass(annotation, Field):
+                return annotation
+
+            origin = get_origin(annotation)
+            if origin not in (Union, UnionType):
+                return None
+
+            field_types = [
+                arg
+                for arg in get_args(annotation)
+                if isinstance(arg, type) and issubclass(arg, Field)
+            ]
+            if len(field_types) != 1:
+                return None
+            return field_types[0]
+
         return FrozenDict(
             (
                 (name, field_type)
-                for name, field_type in get_type_hints(cls).items()
-                if isinstance(field_type, type) and issubclass(field_type, Field)
+                for name, annotation in get_type_hints(cls).items()
+                if (field_type := field_type_from_annotation(annotation)) is not None
             )
         )
 

src/python/pants/engine/target_test.py

@@ -643,6 +643,12 @@ class OptionalFieldSet(FieldSet):
         def opt_out(cls, tgt: Target) -> bool:
             return tgt.get(OptOutField).value is True
 
+    @dataclass(frozen=True)
+    class OptionalUnionFieldSet(FieldSet):
+        required_fields = ()
+
+        optional: OptionalField | None = None
+
     required_addr = Address("", target_name="required")
     required_tgt = TargetWithRequired({RequiredField.alias: "configured"}, required_addr)
     optional_addr = Address("", target_name="unrelated")
@@ -682,6 +688,13 @@ def opt_out(cls, tgt: Target) -> bool:
 
     assert OptionalFieldSet.create(optional_tgt).optional.value == "configured"
     assert OptionalFieldSet.create(no_fields_tgt).optional.value == OptionalField.default
+    assert OptionalUnionFieldSet.fields == FrozenDict({"optional": OptionalField})
+    optional_union_field = OptionalUnionFieldSet.create(optional_tgt).optional
+    assert optional_union_field is not None
+    assert optional_union_field.value == "configured"
+    default_union_field = OptionalUnionFieldSet.create(no_fields_tgt).optional
+    assert default_union_field is not None
+    assert default_union_field.value == OptionalField.default
 
 
 # -----------------------------------------------------------------------------------------------