def mock_find_valid_field_sets(
_: TargetRootsToFieldSetsRequest, ) -> TargetRootsToFieldSets:
if not valid_targets:
return TargetRootsToFieldSets({})
return TargetRootsToFieldSets(
{tgt: [field_set.create(tgt)]
for tgt in targets})
async def find_valid_field_sets_for_target_roots(
request: TargetRootsToFieldSetsRequest,
targets_with_origins: TargetsWithOrigins,
union_membership: UnionMembership,
registered_target_types: RegisteredTargetTypes,
) -> TargetRootsToFieldSets:
field_sets_per_target = await Get(
FieldSetsPerTarget,
FieldSetsPerTargetRequest(
request.field_set_superclass, (two.target for two in targets_with_origins)
),
)
targets_to_valid_field_sets = {}
for tgt_with_origin, field_sets in zip(targets_with_origins, field_sets_per_target.collection):
if field_sets:
targets_to_valid_field_sets[tgt_with_origin] = field_sets
if request.error_if_no_applicable_targets and not targets_to_valid_field_sets:
raise NoApplicableTargetsException.create_from_field_sets(
TargetsWithOrigins(targets_with_origins),
field_set_types=union_membership.union_rules[request.field_set_superclass],
goal_description=request.goal_description,
union_membership=union_membership,
registered_target_types=registered_target_types,
)
result = TargetRootsToFieldSets(targets_to_valid_field_sets)
if not request.expect_single_field_set:
return result
if len(result.targets) > 1:
raise TooManyTargetsException(result.targets, goal_description=request.goal_description)
if len(result.field_sets) > 1:
raise AmbiguousImplementationsException(
result.targets[0], result.field_sets, goal_description=request.goal_description
)
return result
def single_target_run(
rule_runner: RuleRunner,
address: Address,
*,
program_text: bytes,
) -> Run:
workspace = Workspace(rule_runner.scheduler, _enforce_effects=False)
class TestRunFieldSet(RunFieldSet):
required_fields = ()
class TestBinaryTarget(Target):
alias = "binary"
core_fields = ()
target = TestBinaryTarget({}, address)
field_set = TestRunFieldSet.create(target)
with mock_console(rule_runner.options_bootstrapper) as (console, _):
res = run_rule_with_mocks(
run,
rule_args=[
create_goal_subsystem(RunSubsystem, args=[], cleanup=True),
create_subsystem(GlobalOptions,
pants_workdir=rule_runner.pants_workdir,
process_cleanup=True),
workspace,
BuildRoot(),
rule_runner.environment,
],
mock_gets=[
MockGet(
output_type=TargetRootsToFieldSets,
input_type=TargetRootsToFieldSetsRequest,
mock=lambda _: TargetRootsToFieldSets(
{target: [field_set]}),
),
MockGet(
output_type=WrappedTarget,
input_type=WrappedTargetRequest,
mock=lambda _: WrappedTarget(target),
),
MockGet(
output_type=RunRequest,
input_type=TestRunFieldSet,
mock=lambda _: create_mock_run_request(
rule_runner, program_text),
),
MockEffect(
output_type=InteractiveProcessResult,
input_type=InteractiveProcess,
mock=rule_runner.run_interactive_process,
),
],
)
return cast(Run, res)
def single_target_run(
rule_runner: RuleRunner,
address: Address,
console: MockConsole,
*,
program_text: bytes,
) -> Run:
workspace = Workspace(rule_runner.scheduler)
interactive_runner = InteractiveRunner(rule_runner.scheduler)
class TestRunFieldSet(RunFieldSet):
required_fields = ()
class TestBinaryTarget(Target):
alias = "binary"
core_fields = ()
target = TestBinaryTarget({}, address=address)
target_with_origin = TargetWithOrigin(
target, AddressLiteralSpec(address.spec_path, address.target_name))
field_set = TestRunFieldSet.create(target)
res = run_rule_with_mocks(
run,
rule_args=[
create_goal_subsystem(RunSubsystem, args=[]),
create_subsystem(GlobalOptions,
pants_workdir=rule_runner.pants_workdir),
console,
interactive_runner,
workspace,
BuildRoot(),
],
mock_gets=[
MockGet(
output_type=TargetRootsToFieldSets,
input_type=TargetRootsToFieldSetsRequest,
mock=lambda _: TargetRootsToFieldSets(
{target_with_origin: [field_set]}),
),
MockGet(
output_type=RunRequest,
input_type=TestRunFieldSet,
mock=lambda _: create_mock_run_request(rule_runner,
program_text),
),
],
)
return cast(Run, res)
async def find_valid_field_sets_for_target_roots(
request: TargetRootsToFieldSetsRequest,
specs: Specs,
union_membership: UnionMembership,
registered_target_types: RegisteredTargetTypes,
) -> TargetRootsToFieldSets:
# NB: This must be in an `await Get`, rather than the rule signature, to avoid a rule graph
# issue.
targets = await Get(Targets, Specs, specs)
field_sets_per_target = await Get(
FieldSetsPerTarget,
FieldSetsPerTargetRequest(request.field_set_superclass, targets))
targets_to_applicable_field_sets = {}
for tgt, field_sets in zip(targets, field_sets_per_target.collection):
if field_sets:
targets_to_applicable_field_sets[tgt] = field_sets
# Possibly warn or error if no targets were applicable.
if not targets_to_applicable_field_sets:
no_applicable_exception = NoApplicableTargetsException.create_from_field_sets(
targets,
specs,
union_membership,
registered_target_types,
field_set_types=union_membership.union_rules[
request.field_set_superclass],
goal_description=request.goal_description,
)
if request.no_applicable_targets_behavior == NoApplicableTargetsBehavior.error:
raise no_applicable_exception
if request.no_applicable_targets_behavior == NoApplicableTargetsBehavior.warn:
logger.warning(str(no_applicable_exception))
result = TargetRootsToFieldSets(targets_to_applicable_field_sets)
if not request.expect_single_field_set:
return result
if len(result.targets) > 1:
raise TooManyTargetsException(
result.targets, goal_description=request.goal_description)
if len(result.field_sets) > 1:
raise AmbiguousImplementationsException(
result.targets[0],
result.field_sets,
goal_description=request.goal_description)
return result
async def find_valid_field_sets_for_target_roots(
request: TargetRootsToFieldSetsRequest,
specs: Specs,
union_membership: UnionMembership,
registered_target_types: RegisteredTargetTypes,
) -> TargetRootsToFieldSets:
# NB: This must be in an `await Get`, rather than the rule signature, to avoid a rule graph
# issue.
targets = await Get(FilteredTargets, Specs, specs)
field_sets_per_target = await Get(
FieldSetsPerTarget,
FieldSetsPerTargetRequest(request.field_set_superclass, targets))
targets_to_applicable_field_sets = {}
for tgt, field_sets in zip(targets, field_sets_per_target.collection):
if field_sets:
targets_to_applicable_field_sets[tgt] = field_sets
# Possibly warn or error if no targets were applicable.
if not targets_to_applicable_field_sets:
no_applicable_exception = NoApplicableTargetsException.create_from_field_sets(
targets,
specs,
union_membership,
registered_target_types,
field_set_types=union_membership[request.field_set_superclass],
goal_description=request.goal_description,
)
if request.no_applicable_targets_behavior == NoApplicableTargetsBehavior.error:
raise no_applicable_exception
# We squelch the warning if the specs came from change detection or only from globs,
# since in that case we interpret the user's intent as "if there are relevant matching
# targets, act on them". But we still want to warn if the specs were literal, or empty.
#
# No need to check `specs.ignores` here, as change detection will not set that. Likewise,
# we don't want an ignore spec to trigger this warning, even if it was a literal.
empty_ok = specs.includes.from_change_detection or (
specs.includes and not specs.includes.address_literals
and not specs.includes.file_literals)
if (request.no_applicable_targets_behavior
== NoApplicableTargetsBehavior.warn and not empty_ok):
logger.warning(str(no_applicable_exception))
if request.num_shards > 0:
sharded_targets_to_applicable_field_sets = {
tgt: value
for tgt, value in targets_to_applicable_field_sets.items()
if request.is_in_shard(tgt.address.spec)
}
result = TargetRootsToFieldSets(
sharded_targets_to_applicable_field_sets)
else:
result = TargetRootsToFieldSets(targets_to_applicable_field_sets)
if not request.expect_single_field_set:
return result
if len(result.targets) > 1:
raise TooManyTargetsException(
result.targets, goal_description=request.goal_description)
if len(result.field_sets) > 1:
raise AmbiguousImplementationsException(
result.targets[0],
result.field_sets,
goal_description=request.goal_description)
return result