22285099215

Committed 22 Feb 2026 08:52PM UTC coverage: 75.854% (-17.1%) from 92.936%

Build # 22285099215

Build Type

Pull #23121

github

Committed by

web-flow

Commit Message

Merge c7299df9c into ba8359840

Pull Request Pull Request #23121: fix issue with optional fields in dependency validator

Run Details

28 of 29 new or added lines in 2 files covered. (96.55%)

11174 existing lines in 400 files now uncovered.

53694 of 70786 relevant lines covered (75.85%)

1.88 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

62.0

/src/python/pants/bsp/util_rules/resources.py

# Copyright 2022 Pants project contributors (see CONTRIBUTORS.md).
# Licensed under the Apache License, Version 2.0 (see LICENSE).
from __future__ import annotations

import logging
from collections import defaultdict
from collections.abc import Sequence
from dataclasses import dataclass
from typing import TypeVar

from pants.bsp.protocol import BSPHandlerMapping
from pants.bsp.spec.resources import ResourcesItem, ResourcesParams, ResourcesResult
from pants.bsp.util_rules.targets import (
    BSPBuildTargetInternal,
    BSPResourcesRequest,
    BSPResourcesResult,
    get_bsp_resources,
    resolve_bsp_build_target_addresses,
    resolve_bsp_build_target_identifier,
)
from pants.engine.fs import Workspace
from pants.engine.internals.native_engine import EMPTY_DIGEST, MergeDigests
from pants.engine.internals.selectors import concurrently
from pants.engine.intrinsics import merge_digests
from pants.engine.rules import _uncacheable_rule, collect_rules, implicitly, rule
from pants.engine.target import FieldSet
from pants.engine.unions import UnionMembership, UnionRule

_logger = logging.getLogger(__name__)

_FS = TypeVar("_FS", bound=FieldSet)


class ResourcesRequestHandlerMapping(BSPHandlerMapping):
    method_name = "buildTarget/resources"
    request_type = ResourcesParams
    response_type = ResourcesResult


@dataclass(frozen=True)
class ResourcesForOneBSPTargetRequest:
    bsp_target: BSPBuildTargetInternal


@rule
async def resources_bsp_target(
    request: ResourcesForOneBSPTargetRequest,
    union_membership: UnionMembership,
) -> BSPResourcesResult:
    targets = await resolve_bsp_build_target_addresses(request.bsp_target, **implicitly())
    resources_request_types: Sequence[type[BSPResourcesRequest]] = union_membership.get(
        BSPResourcesRequest
    )
    field_sets_by_request_type: dict[type[BSPResourcesRequest], set[FieldSet]] = defaultdict(set)
    for target in targets:
        for resources_request_type in resources_request_types:
            field_set_type = resources_request_type.field_set_type
            if field_set_type.is_applicable(target):
                field_set = field_set_type.create(target)
                field_sets_by_request_type[resources_request_type].add(field_set)

    resources_results = await concurrently(
        get_bsp_resources(
            **implicitly(
                {
                    resources_request_type(
                        bsp_target=request.bsp_target, field_sets=tuple(field_sets)
                    ): BSPResourcesRequest
                }
            )
        )
        for resources_request_type, field_sets in field_sets_by_request_type.items()
    )

    resources = tuple(sorted({resource for rr in resources_results for resource in rr.resources}))

    output_digest = await merge_digests(
        MergeDigests([rr.output_digest for rr in resources_results])
    )

    return BSPResourcesResult(
        resources=resources,
        output_digest=output_digest,
    )


@_uncacheable_rule
async def bsp_resources_request(
    request: ResourcesParams,
    workspace: Workspace,
) -> ResourcesResult:
    bsp_targets = await concurrently(
        resolve_bsp_build_target_identifier(bsp_target_id, **implicitly())
        for bsp_target_id in request.targets
    )

    resources_results = await concurrently(
        resources_bsp_target(
            ResourcesForOneBSPTargetRequest(
                bsp_target=bsp_target,
            ),
            **implicitly(),
        )
        for bsp_target in bsp_targets
    )

    # TODO: Need to determine how resources are expected to be exposed. Directories? Individual files?
    # Initially, it looks like loose directories.
    output_digest = await merge_digests(MergeDigests([r.output_digest for r in resources_results]))
    if output_digest != EMPTY_DIGEST:
        workspace.write_digest(output_digest, path_prefix=".pants.d/bsp")

    return ResourcesResult(
        tuple(
            ResourcesItem(
                target,
                rr.resources,
            )
            for target, rr in zip(request.targets, resources_results)
        )
    )


def rules():
    return (
        *collect_rules(),
        UnionRule(BSPHandlerMapping, ResourcesRequestHandlerMapping),
    )

1	# Copyright 2022 Pants project contributors (see CONTRIBUTORS.md).
2	# Licensed under the Apache License, Version 2.0 (see LICENSE).
3	from __future__ import annotations	1✔
4
5	import logging	1✔
6	from collections import defaultdict	1✔
7	from collections.abc import Sequence	1✔
8	from dataclasses import dataclass	1✔
9	from typing import TypeVar	1✔
10
11	from pants.bsp.protocol import BSPHandlerMapping	1✔
12	from pants.bsp.spec.resources import ResourcesItem, ResourcesParams, ResourcesResult	1✔
13	from pants.bsp.util_rules.targets import (	1✔
14	BSPBuildTargetInternal,
15	BSPResourcesRequest,
16	BSPResourcesResult,
17	get_bsp_resources,
18	resolve_bsp_build_target_addresses,
19	resolve_bsp_build_target_identifier,
20	)
21	from pants.engine.fs import Workspace	1✔
22	from pants.engine.internals.native_engine import EMPTY_DIGEST, MergeDigests	1✔
23	from pants.engine.internals.selectors import concurrently	1✔
24	from pants.engine.intrinsics import merge_digests	1✔
25	from pants.engine.rules import _uncacheable_rule, collect_rules, implicitly, rule	1✔
26	from pants.engine.target import FieldSet	1✔
27	from pants.engine.unions import UnionMembership, UnionRule	1✔
28
29	_logger = logging.getLogger(__name__)	1✔
30
31	_FS = TypeVar("_FS", bound=FieldSet)	1✔
32
33
34	class ResourcesRequestHandlerMapping(BSPHandlerMapping):	1✔
35	method_name = "buildTarget/resources"	1✔
36	request_type = ResourcesParams	1✔
37	response_type = ResourcesResult	1✔
38
39
40	@dataclass(frozen=True)	1✔
41	class ResourcesForOneBSPTargetRequest:	1✔
42	bsp_target: BSPBuildTargetInternal	1✔
43
44
45	@rule	1✔
46	async def resources_bsp_target(	1✔
47	request: ResourcesForOneBSPTargetRequest,
48	union_membership: UnionMembership,
49	) -> BSPResourcesResult:
UNCOV 50	targets = await resolve_bsp_build_target_addresses(request.bsp_target, **implicitly())	×
UNCOV 51	resources_request_types: Sequence[type[BSPResourcesRequest]] = union_membership.get(	×
52	BSPResourcesRequest
53	)
UNCOV 54	field_sets_by_request_type: dict[type[BSPResourcesRequest], set[FieldSet]] = defaultdict(set)	×
UNCOV 55	for target in targets:	×
UNCOV 56	for resources_request_type in resources_request_types:	×
UNCOV 57	field_set_type = resources_request_type.field_set_type	×
UNCOV 58	if field_set_type.is_applicable(target):	×
UNCOV 59	field_set = field_set_type.create(target)	×
UNCOV 60	field_sets_by_request_type[resources_request_type].add(field_set)	×
61
UNCOV 62	resources_results = await concurrently(	×
63	get_bsp_resources(
64	**implicitly(
65	{
66	resources_request_type(
67	bsp_target=request.bsp_target, field_sets=tuple(field_sets)
68	): BSPResourcesRequest
69	}
70	)
71	)
72	for resources_request_type, field_sets in field_sets_by_request_type.items()
73	)
74
UNCOV 75	resources = tuple(sorted({resource for rr in resources_results for resource in rr.resources}))	×
76
UNCOV 77	output_digest = await merge_digests(	×
78	MergeDigests([rr.output_digest for rr in resources_results])
79	)
80
UNCOV 81	return BSPResourcesResult(	×
82	resources=resources,
83	output_digest=output_digest,
84	)
85
86
87	@_uncacheable_rule	1✔
88	async def bsp_resources_request(	1✔
89	request: ResourcesParams,
90	workspace: Workspace,
91	) -> ResourcesResult:
UNCOV 92	bsp_targets = await concurrently(	×
93	resolve_bsp_build_target_identifier(bsp_target_id, **implicitly())
94	for bsp_target_id in request.targets
95	)
96
UNCOV 97	resources_results = await concurrently(	×
98	resources_bsp_target(
99	ResourcesForOneBSPTargetRequest(
100	bsp_target=bsp_target,
101	),
102	**implicitly(),
103	)
104	for bsp_target in bsp_targets
105	)
106
107	# TODO: Need to determine how resources are expected to be exposed. Directories? Individual files?
108	# Initially, it looks like loose directories.
UNCOV 109	output_digest = await merge_digests(MergeDigests([r.output_digest for r in resources_results]))	×
UNCOV 110	if output_digest != EMPTY_DIGEST:	×
UNCOV 111	workspace.write_digest(output_digest, path_prefix=".pants.d/bsp")	×
112
UNCOV 113	return ResourcesResult(	×
114	tuple(
115	ResourcesItem(
116	target,
117	rr.resources,
118	)
119	for target, rr in zip(request.targets, resources_results)
120	)
121	)
122
123
124	def rules():	1✔
125	return (	1✔
126	*collect_rules(),
127	UnionRule(BSPHandlerMapping, ResourcesRequestHandlerMapping),
128	)

pantsbuild / pants / 22285099215

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous