19549135539

Committed 20 Nov 2025 07:36PM UTC coverage: 78.566% (-1.7%) from 80.302%

Build # 19549135539

Build Type

Pull #22901

github

Committed by

web-flow

Commit Message

Merge 9e21d48a2 into 730539e91

Pull Request Pull Request #22901: Support large numbers of input files to Pyright.

Run Details

11 of 24 new or added lines in 2 files covered. (45.83%)

1039 existing lines in 59 files now uncovered.

73994 of 94181 relevant lines covered (78.57%)

3.17 hits per line

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

62.5

/src/python/pants/backend/shell/goals/package.py

# Copyright 2025 Pants project contributors (see CONTRIBUTORS.md).
# Licensed under the Apache License, Version 2.0 (see LICENSE).

from __future__ import annotations

import dataclasses
from dataclasses import dataclass

from pants.backend.shell.target_types import (
    ShellCommandCommandField,
    ShellCommandPackageDependenciesField,
    SkipShellCommandPackageField,
)
from pants.backend.shell.util_rules import shell_command
from pants.backend.shell.util_rules.shell_command import (
    ShellCommandProcessFromTargetRequest,
    prepare_process_request_from_target,
)
from pants.core.environments.target_types import EnvironmentField
from pants.core.goals.package import (
    BuiltPackage,
    BuiltPackageArtifact,
    OutputPathField,
    PackageFieldSet,
)
from pants.core.util_rules.adhoc_process_support import AdhocProcessRequest
from pants.core.util_rules.adhoc_process_support import rules as adhoc_process_support_rules
from pants.core.util_rules.adhoc_process_support import run_prepared_adhoc_process
from pants.engine.fs import EMPTY_DIGEST, AddPrefix, Digest
from pants.engine.internals.graph import resolve_target
from pants.engine.intrinsics import add_prefix, get_digest_entries
from pants.engine.process import ProcessCacheScope
from pants.engine.rules import collect_rules, implicitly, rule
from pants.engine.target import Target, WrappedTargetRequest
from pants.engine.unions import UnionRule
from pants.util.logging import LogLevel


@dataclass(frozen=True)
class PackageShellCommandFieldSet(PackageFieldSet):
    required_fields = (
        ShellCommandCommandField,
        ShellCommandPackageDependenciesField,
    )

    environment: EnvironmentField
    output_path: OutputPathField

    @classmethod
    def opt_out(cls, tgt: Target) -> bool:
        return tgt.get(SkipShellCommandPackageField).value


@rule(desc="Package with shell command", level=LogLevel.DEBUG)
async def package_shell_command(
    field_set: PackageShellCommandFieldSet,
) -> BuiltPackage:
    wrapped_tgt = await resolve_target(
        WrappedTargetRequest(field_set.address, description_of_origin="<infallible>"),
        **implicitly(),
    )
    target = wrapped_tgt.target

    shell_process = await prepare_process_request_from_target(
        ShellCommandProcessFromTargetRequest(target), **implicitly()
    )

    shell_process = dataclasses.replace(
        shell_process,
        cache_scope=shell_process.cache_scope or ProcessCacheScope.SUCCESSFUL,
    )

    result = await run_prepared_adhoc_process(**implicitly({shell_process: AdhocProcessRequest}))

    if result.process_result.exit_code != 0:
        raise ValueError(
            f"The `{target.alias}` at `{field_set.address}` failed with exit code {result.process_result.exit_code}.\n\n"
            f"stdout:\n\n{result.process_result.stdout.decode(errors='ignore')}\n\n"
            f"stderr:\n\n{result.process_result.stderr.decode(errors='ignore')}"
        )

    if result.adjusted_digest == EMPTY_DIGEST:
        raise ValueError(
            f"The `{target.alias}` at `{field_set.address}` did not produce or capture any output. "
            "The `package` goal is expected to produce output."
        )

    # Apply the output path for the artifacts.
    output_path = field_set.output_path.value_or_default(file_ending=None)
    output_digest: Digest
    if output_path:
        output_digest = await add_prefix(AddPrefix(result.adjusted_digest, output_path))
    else:
        output_digest = result.adjusted_digest

    output_digest_entries = await get_digest_entries(result.adjusted_digest)
    file_paths = sorted(e.path for e in output_digest_entries)
    artifacts = tuple(BuiltPackageArtifact(relpath=path) for path in file_paths)
    return BuiltPackage(output_digest, artifacts)


def rules():
    return (
        *collect_rules(),
        *shell_command.rules(),
        *adhoc_process_support_rules(),
        UnionRule(PackageFieldSet, PackageShellCommandFieldSet),
    )

1	# Copyright 2025 Pants project contributors (see CONTRIBUTORS.md).
2	# Licensed under the Apache License, Version 2.0 (see LICENSE).
3
4	from __future__ import annotations	3✔
5
6	import dataclasses	3✔
7	from dataclasses import dataclass	3✔
8
9	from pants.backend.shell.target_types import (	3✔
10	ShellCommandCommandField,
11	ShellCommandPackageDependenciesField,
12	SkipShellCommandPackageField,
13	)
14	from pants.backend.shell.util_rules import shell_command	3✔
15	from pants.backend.shell.util_rules.shell_command import (	3✔
16	ShellCommandProcessFromTargetRequest,
17	prepare_process_request_from_target,
18	)
19	from pants.core.environments.target_types import EnvironmentField	3✔
20	from pants.core.goals.package import (	3✔
21	BuiltPackage,
22	BuiltPackageArtifact,
23	OutputPathField,
24	PackageFieldSet,
25	)
26	from pants.core.util_rules.adhoc_process_support import AdhocProcessRequest	3✔
27	from pants.core.util_rules.adhoc_process_support import rules as adhoc_process_support_rules	3✔
28	from pants.core.util_rules.adhoc_process_support import run_prepared_adhoc_process	3✔
29	from pants.engine.fs import EMPTY_DIGEST, AddPrefix, Digest	3✔
30	from pants.engine.internals.graph import resolve_target	3✔
31	from pants.engine.intrinsics import add_prefix, get_digest_entries	3✔
32	from pants.engine.process import ProcessCacheScope	3✔
33	from pants.engine.rules import collect_rules, implicitly, rule	3✔
34	from pants.engine.target import Target, WrappedTargetRequest	3✔
35	from pants.engine.unions import UnionRule	3✔
36	from pants.util.logging import LogLevel	3✔
37
38
39	@dataclass(frozen=True)	3✔
40	class PackageShellCommandFieldSet(PackageFieldSet):	3✔
41	required_fields = (	3✔
42	ShellCommandCommandField,
43	ShellCommandPackageDependenciesField,
44	)
45
46	environment: EnvironmentField	3✔
47	output_path: OutputPathField	3✔
48
49	@classmethod	3✔
50	def opt_out(cls, tgt: Target) -> bool:	3✔
UNCOV 51	return tgt.get(SkipShellCommandPackageField).value	×
52
53
54	@rule(desc="Package with shell command", level=LogLevel.DEBUG)	3✔
55	async def package_shell_command(	3✔
56	field_set: PackageShellCommandFieldSet,
57	) -> BuiltPackage:
58	wrapped_tgt = await resolve_target(	×
59	WrappedTargetRequest(field_set.address, description_of_origin="<infallible>"),
60	**implicitly(),
61	)
62	target = wrapped_tgt.target	×
63
64	shell_process = await prepare_process_request_from_target(	×
65	ShellCommandProcessFromTargetRequest(target), **implicitly()
66	)
67
68	shell_process = dataclasses.replace(	×
69	shell_process,
70	cache_scope=shell_process.cache_scope or ProcessCacheScope.SUCCESSFUL,
71	)
72
73	result = await run_prepared_adhoc_process(**implicitly({shell_process: AdhocProcessRequest}))	×
74
75	if result.process_result.exit_code != 0:	×
76	raise ValueError(	×
77	f"The `{target.alias}` at `{field_set.address}` failed with exit code {result.process_result.exit_code}.\n\n"
78	f"stdout:\n\n{result.process_result.stdout.decode(errors='ignore')}\n\n"
79	f"stderr:\n\n{result.process_result.stderr.decode(errors='ignore')}"
80	)
81
82	if result.adjusted_digest == EMPTY_DIGEST:	×
83	raise ValueError(	×
84	f"The `{target.alias}` at `{field_set.address}` did not produce or capture any output. "
85	"The `package` goal is expected to produce output."
86	)
87
88	# Apply the output path for the artifacts.
89	output_path = field_set.output_path.value_or_default(file_ending=None)	×
90	output_digest: Digest
91	if output_path:	×
92	output_digest = await add_prefix(AddPrefix(result.adjusted_digest, output_path))	×
93	else:
94	output_digest = result.adjusted_digest	×
95
96	output_digest_entries = await get_digest_entries(result.adjusted_digest)	×
97	file_paths = sorted(e.path for e in output_digest_entries)	×
98	artifacts = tuple(BuiltPackageArtifact(relpath=path) for path in file_paths)	×
99	return BuiltPackage(output_digest, artifacts)	×
100
101
102	def rules():	3✔
103	return (	3✔
104	*collect_rules(),
105	*shell_command.rules(),
106	*adhoc_process_support_rules(),
107	UnionRule(PackageFieldSet, PackageShellCommandFieldSet),
108	)

pantsbuild / pants / 19549135539

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