def test_get_field() -> None:
extensions = ("FortranExt1",)
tgt = FortranTarget({FortranExtensions.alias: extensions}, Address("", target_name="lib"))
assert tgt[FortranExtensions].value == extensions
assert tgt.get(FortranExtensions).value == extensions
assert tgt.get(FortranExtensions, default_raw_value=["FortranExt2"]).value == extensions
# Default field value. This happens when the field is registered on the target type, but the
# user does not explicitly set the field in the BUILD file.
default_field_tgt = FortranTarget({}, Address("", target_name="default"))
assert default_field_tgt[FortranExtensions].value == ()
assert default_field_tgt.get(FortranExtensions).value == ()
assert default_field_tgt.get(FortranExtensions, default_raw_value=["FortranExt2"]).value == ()
# Example of a call site applying its own default value instead of the field's default value.
assert default_field_tgt[FortranExtensions].value or 123 == 123
assert (
FortranTarget.class_get_field(FortranExtensions, union_membership=UnionMembership({}))
is FortranExtensions
)
# Field is not registered on the target.
with pytest.raises(KeyError) as exc:
default_field_tgt[UnrelatedField]
assert UnrelatedField.__name__ in str(exc)
with pytest.raises(KeyError) as exc:
FortranTarget.class_get_field(UnrelatedField, union_membership=UnionMembership({}))
assert UnrelatedField.__name__ in str(exc)
assert default_field_tgt.get(UnrelatedField).value == UnrelatedField.default
assert default_field_tgt.get(
UnrelatedField, default_raw_value=not UnrelatedField.default
).value == (not UnrelatedField.default)
def test_targets_with_sources_types() -> None:
class Sources1(Sources):
pass
class Sources2(Sources):
pass
class CodegenSources(Sources):
pass
class Tgt1(Target):
alias = "tgt1"
core_fields = (Sources1,)
class Tgt2(Target):
alias = "tgt2"
core_fields = (Sources2,)
class CodegenTgt(Target):
alias = "codegen_tgt"
core_fields = (CodegenSources,)
class GenSources(GenerateSourcesRequest):
input = CodegenSources
output = Sources1
tgt1 = Tgt1({}, address=Address("tgt1"))
tgt2 = Tgt2({}, address=Address("tgt2"))
codegen_tgt = CodegenTgt({}, address=Address("codegen_tgt"))
result = targets_with_sources_types(
[Sources1],
[tgt1, tgt2, codegen_tgt],
union_membership=UnionMembership({GenerateSourcesRequest: [GenSources]}),
)
assert set(result) == {tgt1, codegen_tgt}
def run_typecheck_rule(
*,
request_types: List[Type[TypecheckRequest]],
targets: List[TargetWithOrigin],
include_sources: bool = True,
) -> Tuple[int, str]:
console = MockConsole(use_colors=False)
union_membership = UnionMembership({TypecheckRequest: request_types})
result: Typecheck = run_rule(
typecheck,
rule_args=[console, TargetsWithOrigins(targets), union_membership],
mock_gets=[
MockGet(
product_type=TypecheckResults,
subject_type=TypecheckRequest,
mock=lambda field_set_collection: field_set_collection.typecheck_results,
),
MockGet(
product_type=FieldSetsWithSources,
subject_type=FieldSetsWithSourcesRequest,
mock=lambda field_sets: FieldSetsWithSources(
field_sets if include_sources else ()
),
),
],
union_membership=union_membership,
)
assert not console.stdout.getvalue()
return result.exit_code, console.stderr.getvalue()
def run_lint_rule(
rule_runner: RuleRunner,
*,
lint_request_types: List[Type[LintRequest]],
targets: List[Target],
per_file_caching: bool,
) -> Tuple[int, str]:
with mock_console(rule_runner.options_bootstrapper) as (console,
stdio_reader):
union_membership = UnionMembership({LintRequest: lint_request_types})
result: Lint = run_rule_with_mocks(
lint,
rule_args=[
console,
Workspace(rule_runner.scheduler, _enforce_effects=False),
Targets(targets),
create_goal_subsystem(LintSubsystem,
per_file_caching=per_file_caching,
per_target_caching=False),
union_membership,
DistDir(relpath=Path("dist")),
],
mock_gets=[
MockGet(
output_type=LintResults,
input_type=LintRequest,
mock=lambda field_set_collection: field_set_collection.
lint_results,
)
],
union_membership=union_membership,
)
assert not stdio_reader.get_stdout()
return result.exit_code, stdio_reader.get_stderr()
def test_has_fields() -> None:
empty_union_membership = UnionMembership({})
tgt = FortranTarget({}, Address("", target_name="lib"))
assert tgt.field_types == (FortranExtensions, FortranVersion)
assert FortranTarget.class_field_types(
union_membership=empty_union_membership) == (
FortranExtensions,
FortranVersion,
)
assert tgt.has_fields([]) is True
assert FortranTarget.class_has_fields(
[], union_membership=empty_union_membership) is True
assert tgt.has_fields([FortranExtensions]) is True
assert tgt.has_field(FortranExtensions) is True
assert (FortranTarget.class_has_fields(
[FortranExtensions], union_membership=empty_union_membership) is True)
assert (FortranTarget.class_has_field(
FortranExtensions, union_membership=empty_union_membership) is True)
assert tgt.has_fields([UnrelatedField]) is False
assert tgt.has_field(UnrelatedField) is False
assert (FortranTarget.class_has_fields(
[UnrelatedField], union_membership=empty_union_membership) is False)
assert (FortranTarget.class_has_field(
UnrelatedField, union_membership=empty_union_membership) is False)
assert tgt.has_fields([FortranExtensions, UnrelatedField]) is False
assert (FortranTarget.class_has_fields(
[FortranExtensions, UnrelatedField],
union_membership=empty_union_membership) is False)
def test_determine_renamed_fields() -> None:
class DeprecatedField(StringField):
alias = "new_name"
deprecated_alias = "old_name"
deprecated_alias_removal_version = "99.9.0.dev0"
class OkayField(StringField):
alias = "okay"
class Tgt(Target):
alias = "tgt"
core_fields = (DeprecatedField, OkayField)
deprecated_alias = "deprecated_tgt"
deprecated_alias_removal_version = "99.9.0.dev0"
class TgtGenerator(TargetGenerator):
alias = "generator"
core_fields = ()
moved_fields = (DeprecatedField, OkayField)
registered_targets = RegisteredTargetTypes.create([Tgt, TgtGenerator])
result = determine_renamed_field_types(registered_targets,
UnionMembership({}))
deprecated_fields = FrozenDict(
{DeprecatedField.deprecated_alias: DeprecatedField.alias})
assert result.target_field_renames == FrozenDict({
k: deprecated_fields
for k in (TgtGenerator.alias, Tgt.alias, Tgt.deprecated_alias)
})
def __init__(
self,
unhydrated_values: Dict[str, Any],
*,
address: Address,
# NB: `union_membership` is only optional to facilitate tests. In production, we should
# always provide this parameter. This should be safe to do because production code should
# rarely directly instantiate Targets and should instead use the engine to request them.
union_membership: Optional[UnionMembership] = None,
) -> None:
self.address = address
self.plugin_fields = self._find_plugin_fields(union_membership
or UnionMembership({}))
field_values = {}
aliases_to_field_types = {
field_type.alias: field_type
for field_type in self.field_types
}
for alias, value in unhydrated_values.items():
if alias not in aliases_to_field_types:
raise InvalidFieldException(
f"Unrecognized field `{alias}={value}` in target {address}. Valid fields for "
f"the target type `{self.alias}`: {sorted(aliases_to_field_types.keys())}.",
)
field_type = aliases_to_field_types[alias]
field_values[field_type] = field_type(value, address=address)
# For undefined fields, mark the raw value as None.
for field_type in set(self.field_types) - set(field_values.keys()):
field_values[field_type] = field_type(raw_value=None,
address=address)
self.field_values = FrozenDict(field_values)
def run_lint_rule(
*,
config_collection_types: List[Type[LinterConfigurations]],
targets: List[TargetWithOrigin],
per_target_caching: bool,
include_sources: bool = True,
) -> Tuple[int, str]:
console = MockConsole(use_colors=False)
union_membership = UnionMembership({LinterConfigurations: config_collection_types})
result: Lint = run_rule(
lint,
rule_args=[
console,
TargetsWithOrigins(targets),
create_goal_subsystem(LintOptions, per_target_caching=per_target_caching),
union_membership,
],
mock_gets=[
MockGet(
product_type=LintResult,
subject_type=LinterConfigurations,
mock=lambda config_collection: config_collection.lint_result,
),
MockGet(
product_type=ConfigurationsWithSources,
subject_type=ConfigurationsWithSourcesRequest,
mock=lambda configs: ConfigurationsWithSources(
configs if include_sources else ()
),
),
],
union_membership=union_membership,
)
return result.exit_code, console.stdout.getvalue()
def mk_scheduler(
self,
tmp_path: Path,
rules,
include_trace_on_error: bool = True,
max_workunit_verbosity: LogLevel = LogLevel.DEBUG,
) -> SchedulerSession:
"""Creates a SchedulerSession for a Scheduler with the given Rules installed."""
build_root = tmp_path / "build_root"
build_root.mkdir(parents=True, exist_ok=True)
local_execution_root_dir = os.path.realpath(safe_mkdtemp())
named_caches_dir = os.path.realpath(safe_mkdtemp())
scheduler = Scheduler(
ignore_patterns=[],
use_gitignore=False,
build_root=build_root.as_posix(),
local_execution_root_dir=local_execution_root_dir,
named_caches_dir=named_caches_dir,
ca_certs_path=None,
rules=rules,
union_membership=UnionMembership({}),
executor=self._executor,
execution_options=DEFAULT_EXECUTION_OPTIONS,
local_store_options=DEFAULT_LOCAL_STORE_OPTIONS,
include_trace_on_error=include_trace_on_error,
)
return scheduler.new_session(
build_id="buildid_for_test",
max_workunit_level=max_workunit_verbosity,
)
def run_typecheck_rule(
*,
request_types: List[Type[TypecheckRequest]],
targets: List[Target],
include_sources: bool = True,
) -> Tuple[int, str]:
union_membership = UnionMembership({TypecheckRequest: request_types})
with mock_console(create_options_bootstrapper()) as (console,
stdio_reader):
result: Typecheck = run_rule_with_mocks(
typecheck,
rule_args=[console, Targets(targets), union_membership],
mock_gets=[
MockGet(
output_type=EnrichedTypecheckResults,
input_type=TypecheckRequest,
mock=lambda field_set_collection: field_set_collection.
typecheck_results,
),
MockGet(
output_type=FieldSetsWithSources,
input_type=FieldSetsWithSourcesRequest,
mock=lambda field_sets: FieldSetsWithSources(
field_sets if include_sources else ()),
),
],
union_membership=union_membership,
)
assert not stdio_reader.get_stdout()
return result.exit_code, stdio_reader.get_stderr()
def test_has_fields() -> None:
empty_union_membership = UnionMembership({})
tgt = FortranTarget({}, address=Address.parse(":lib"))
assert tgt.field_types == (FortranExtensions, FortranSources)
assert FortranTarget.class_field_types(
union_membership=empty_union_membership) == (
FortranExtensions,
FortranSources,
)
assert tgt.has_fields([]) is True
assert FortranTarget.class_has_fields(
[], union_membership=empty_union_membership) is True
assert tgt.has_fields([FortranExtensions]) is True
assert tgt.has_field(FortranExtensions) is True
assert (FortranTarget.class_has_fields(
[FortranExtensions], union_membership=empty_union_membership) is True)
assert (FortranTarget.class_has_field(
FortranExtensions, union_membership=empty_union_membership) is True)
assert tgt.has_fields([UnrelatedField]) is False
assert tgt.has_field(UnrelatedField) is False
assert (FortranTarget.class_has_fields(
[UnrelatedField], union_membership=empty_union_membership) is False)
assert (FortranTarget.class_has_field(
UnrelatedField, union_membership=empty_union_membership) is False)
assert tgt.has_fields([FortranExtensions, UnrelatedField]) is False
assert (FortranTarget.class_has_fields(
[FortranExtensions, UnrelatedField],
union_membership=empty_union_membership) is False)
def create(
cls,
env: Mapping[str, str],
options_bootstrapper: OptionsBootstrapper,
scheduler: Optional[LegacyGraphScheduler] = None,
) -> "LocalPantsRunner":
"""Creates a new LocalPantsRunner instance by parsing options.
By the time this method runs, logging will already have been initialized in either
PantsRunner or DaemonPantsRunner.
:param env: The environment (e.g. os.environ) for this run.
:param options_bootstrapper: The OptionsBootstrapper instance to reuse.
:param scheduler: If being called from the daemon, a warmed scheduler to use.
"""
build_root = get_buildroot()
global_bootstrap_options = options_bootstrapper.bootstrap_options.for_global_scope(
)
options, build_config = LocalPantsRunner.parse_options(
options_bootstrapper)
# Option values are usually computed lazily on demand,
# but command line options are eagerly computed for validation.
for scope in options.scope_to_flags.keys():
options.for_scope(scope)
# Verify configs.
if global_bootstrap_options.verify_config:
options.verify_configs(options_bootstrapper.config)
union_membership = UnionMembership(build_config.union_rules())
# If we're running with the daemon, we'll be handed a warmed Scheduler, which we use
# to initialize a session here.
graph_session = cls._init_graph_session(options_bootstrapper,
build_config, options,
scheduler)
global_options = options.for_global_scope()
specs = SpecsCalculator.create(
options=options,
build_root=build_root,
session=graph_session.scheduler_session,
exclude_patterns=tuple(global_options.exclude_target_regexp),
tags=tuple(global_options.tag),
)
profile_path = env.get("PANTS_PROFILE")
return cls(
build_root=build_root,
options=options,
options_bootstrapper=options_bootstrapper,
build_config=build_config,
specs=specs,
graph_session=graph_session,
union_membership=union_membership,
profile_path=profile_path,
_run_tracker=RunTracker.global_instance(),
)
def run_typecheck_rule(
*,
request_types: Sequence[Type[CheckRequest]],
targets: list[Target],
only: list[str] | None = None,
) -> Tuple[int, str]:
union_membership = UnionMembership({CheckRequest: request_types})
check_subsystem = create_subsystem(CheckSubsystem, only=only or [])
with mock_console(create_options_bootstrapper()) as (console, stdio_reader):
rule_runner = RuleRunner()
result: Check = run_rule_with_mocks(
check,
rule_args=[
console,
Workspace(rule_runner.scheduler, _enforce_effects=False),
Targets(targets),
DistDir(relpath=Path("dist")),
union_membership,
check_subsystem,
],
mock_gets=[
MockGet(
output_type=CheckResults,
input_type=CheckRequest,
mock=lambda field_set_collection: field_set_collection.check_results,
),
],
union_membership=union_membership,
)
assert not stdio_reader.get_stdout()
return result.exit_code, stdio_reader.get_stderr()
def test_add_custom_fields() -> None:
class CustomField(BoolField):
alias: ClassVar = "custom_field"
default: ClassVar = False
union_membership = UnionMembership({FortranTarget.PluginField: [CustomField]})
tgt_values = {CustomField.alias: True}
tgt = FortranTarget(
tgt_values, address=Address.parse(":lib"), union_membership=union_membership
)
assert tgt.field_types == (FortranExtensions, FortranSources, CustomField)
assert tgt.core_fields == (FortranExtensions, FortranSources)
assert tgt.plugin_fields == (CustomField,)
assert tgt.has_field(CustomField) is True
assert FortranTarget.class_field_types(union_membership=union_membership) == (
FortranExtensions,
FortranSources,
CustomField,
)
assert FortranTarget.class_has_field(CustomField, union_membership=union_membership) is True
assert tgt[CustomField].value is True
default_tgt = FortranTarget(
{}, address=Address.parse(":default"), union_membership=union_membership
)
assert default_tgt[CustomField].value is False
def mk_scheduler(
self,
rules,
include_trace_on_error: bool = True,
) -> SchedulerSession:
"""Creates a SchedulerSession for a Scheduler with the given Rules installed."""
work_dir = self._create_work_dir()
build_root = os.path.join(work_dir, "build_root")
os.makedirs(build_root)
local_store_dir = os.path.realpath(safe_mkdtemp())
local_execution_root_dir = os.path.realpath(safe_mkdtemp())
named_caches_dir = os.path.realpath(safe_mkdtemp())
scheduler = Scheduler(
native=self._native,
ignore_patterns=[],
use_gitignore=False,
build_root=build_root,
local_store_dir=local_store_dir,
local_execution_root_dir=local_execution_root_dir,
named_caches_dir=named_caches_dir,
ca_certs_path=None,
rules=rules,
union_membership=UnionMembership({}),
executor=self._executor,
execution_options=DEFAULT_EXECUTION_OPTIONS,
include_trace_on_error=include_trace_on_error,
)
return scheduler.new_session(build_id="buildid_for_test", )
def test_list_single() -> None:
class CustomField(BoolField):
"""My custom field!
Use this field to...
"""
alias = "custom_field"
required = True
tests_target_stdout = run_goal(
union_membership=UnionMembership({FortranTests.PluginField: [CustomField]}),
details_target=FortranTests.alias,
)
assert tests_target_stdout == dedent(
"""\
fortran_tests
-------------
Tests for Fortran code.
This assumes that you use the FRUIT test framework.
Valid fields:
custom_field
type: bool, required
My custom field! Use this field to...
fortran_version
type: str | None, default: None
timeout
type: int | None, default: None
The number of seconds to run before timing out.
"""
)
binary_target_stdout = run_goal(details_target=FortranBinary.alias)
assert binary_target_stdout == dedent(
"""\
fortran_binary
--------------
Valid fields:
archive_format
type: '.tar' | '.tgz' | None, default: '.tgz'
error_behavior
type: 'error' | 'ignore' | 'warn', required
fortran_version
type: str | None, default: None
"""
)
def test_get_field() -> None:
extensions = ("FortranExt1", )
tgt = FortranTarget({FortranExtensions.alias: extensions},
address=Address.parse(":lib"))
assert tgt[FortranExtensions].value == extensions
assert tgt.get(FortranExtensions).value == extensions
assert tgt.get(FortranExtensions,
default_raw_value=["FortranExt2"]).value == extensions
# Default field value. This happens when the field is registered on the target type, but the
# user does not explicitly set the field in the BUILD file.
#
# NB: `default_raw_value` is not used in this case - that parameter is solely used when
# the field is not registered on the target type. To override the default field value, either
# subclass the Field and create a new target, or, in your call site, interpret the result and
# and apply your default.
default_field_tgt = FortranTarget({}, address=Address.parse(":default"))
assert default_field_tgt[FortranExtensions].value == ()
assert default_field_tgt.get(FortranExtensions).value == ()
assert default_field_tgt.get(FortranExtensions,
default_raw_value=["FortranExt2"]).value == ()
# Example of a call site applying its own default value instead of the field's default value.
assert default_field_tgt[FortranExtensions].value or 123 == 123
assert (FortranTarget.class_get_field(FortranExtensions,
union_membership=UnionMembership({}))
is FortranExtensions)
# Field is not registered on the target.
with pytest.raises(KeyError) as exc:
default_field_tgt[UnrelatedField]
assert UnrelatedField.__name__ in str(exc)
with pytest.raises(KeyError) as exc:
FortranTarget.class_get_field(UnrelatedField,
union_membership=UnionMembership({}))
assert UnrelatedField.__name__ in str(exc)
assert default_field_tgt.get(
UnrelatedField).value == UnrelatedField.default
assert default_field_tgt.get(
UnrelatedField,
default_raw_value=not UnrelatedField.default).value == (
not UnrelatedField.default)
def __init__(self, options: Options):
super().__init__(options.for_global_scope().colors)
self._all_help_info = HelpInfoExtracter.get_all_help_info(
options,
# We only care about the options-related help info, so we pass in
# dummy values for the other arguments.
UnionMembership({}),
lambda x: tuple(),
RegisteredTargetTypes({}),
)
def __init__(self, options: Options):
super().__init__(options.for_global_scope().colors)
self._bin_name = options.for_global_scope().pants_bin_name
self._all_help_info = HelpInfoExtracter.get_all_help_info(
options,
# We only care about the options-related help info, so we pass in
# dummy values for union_membership and consumed_scopes_mapper.
UnionMembership({}),
lambda x: tuple(),
)
def single_target_run(
self,
*,
console: MockConsole,
program_text: bytes,
address_spec: str,
) -> Run:
workspace = Workspace(self.scheduler)
interactive_runner = InteractiveRunner(self.scheduler)
class TestBinaryConfiguration(BinaryConfiguration):
required_fields = ()
class TestBinaryTarget(Target):
alias = "binary"
core_fields = ()
address = Address.parse(address_spec)
origin = SingleAddress(address.spec_path, address.target_name)
res = run_rule(
run,
rule_args=[
console,
workspace,
interactive_runner,
BuildRoot(),
TargetsWithOrigins([
TargetWithOrigin(
target=TestBinaryTarget(unhydrated_values={},
address=address),
origin=origin,
)
]),
create_goal_subsystem(RunOptions, args=[]),
create_subsystem(GlobalOptions,
pants_workdir=self.pants_workdir),
UnionMembership(union_rules={
BinaryConfiguration:
OrderedSet([TestBinaryConfiguration])
}),
RegisteredTargetTypes.create([TestBinaryTarget]),
],
mock_gets=[
MockGet(
product_type=CreatedBinary,
subject_type=TestBinaryConfiguration,
mock=lambda _: self.create_mock_binary(program_text),
),
],
)
return cast(Run, res)
def test_union_membership_from_rules() -> None:
@union
class Base:
pass
class A:
pass
class B:
pass
assert UnionMembership.from_rules([UnionRule(Base, A), UnionRule(Base, B)]) == UnionMembership(
{Base: FrozenOrderedSet([A, B])}
)
def run_lint_rule(
rule_runner: RuleRunner,
*,
lint_request_types: Sequence[Type[LintTargetsRequest]],
targets: list[Target],
run_files_linter: bool = False,
batch_size: int = 128,
only: list[str] | None = None,
) -> Tuple[int, str]:
union_membership = UnionMembership({
LintTargetsRequest:
lint_request_types,
LintFilesRequest: [MockFilesRequest] if run_files_linter else [],
})
lint_subsystem = create_goal_subsystem(
LintSubsystem,
batch_size=batch_size,
only=only or [],
)
specs_snapshot = SpecsSnapshot(
rule_runner.make_snapshot_of_empty_files(["f.txt"]))
with mock_console(rule_runner.options_bootstrapper) as (console,
stdio_reader):
result: Lint = run_rule_with_mocks(
lint,
rule_args=[
console,
Workspace(rule_runner.scheduler, _enforce_effects=False),
Targets(targets),
specs_snapshot,
lint_subsystem,
union_membership,
DistDir(relpath=Path("dist")),
],
mock_gets=[
MockGet(
output_type=LintResults,
input_type=LintTargetsRequest,
mock=lambda mock_request: mock_request.lint_results,
),
MockGet(
output_type=LintResults,
input_type=LintFilesRequest,
mock=lambda mock_request: mock_request.lint_results,
),
],
union_membership=union_membership,
)
assert not stdio_reader.get_stdout()
return result.exit_code, stdio_reader.get_stderr()
def run_fmt_rule(
rule_runner: RuleRunner,
*,
language_target_collection_types: List[Type[LanguageFmtTargets]],
targets: List[Target],
result_digest: Digest,
per_file_caching: bool,
include_sources: bool = True,
) -> str:
with mock_console(rule_runner.options_bootstrapper) as (console,
stdio_reader):
union_membership = UnionMembership(
{LanguageFmtTargets: language_target_collection_types})
result: Fmt = run_rule_with_mocks(
fmt,
rule_args=[
console,
Targets(targets),
create_goal_subsystem(FmtSubsystem,
per_file_caching=per_file_caching,
per_target_caching=False),
Workspace(rule_runner.scheduler),
union_membership,
],
mock_gets=[
MockGet(
output_type=LanguageFmtResults,
input_type=LanguageFmtTargets,
mock=lambda language_targets_collection:
language_targets_collection.language_fmt_results(
result_digest),
),
MockGet(
output_type=TargetsWithSources,
input_type=TargetsWithSourcesRequest,
mock=lambda tgts: TargetsWithSources(
tgts if include_sources else ()),
),
MockGet(
output_type=Digest,
input_type=MergeDigests,
mock=lambda _: result_digest,
),
],
union_membership=union_membership,
)
assert result.exit_code == 0
assert not stdio_reader.get_stdout()
return stdio_reader.get_stderr()
def run_fmt_rule(
self,
*,
language_target_collection_types: List[Type[LanguageFmtTargets]],
targets: List[Target],
result_digest: Digest,
per_file_caching: bool,
include_sources: bool = True,
) -> str:
console = MockConsole(use_colors=False)
union_membership = UnionMembership(
{LanguageFmtTargets: language_target_collection_types})
result: Fmt = run_rule(
fmt,
rule_args=[
console,
Targets(targets),
create_goal_subsystem(FmtSubsystem,
per_file_caching=per_file_caching,
per_target_caching=False),
Workspace(self.scheduler),
union_membership,
],
mock_gets=[
MockGet(
product_type=LanguageFmtResults,
subject_type=LanguageFmtTargets,
mock=lambda language_targets_collection:
language_targets_collection.language_fmt_results(
result_digest),
),
MockGet(
product_type=TargetsWithSources,
subject_type=TargetsWithSourcesRequest,
mock=lambda tgts: TargetsWithSources(
tgts if include_sources else ()),
),
MockGet(
product_type=Digest,
subject_type=MergeDigests,
mock=lambda _: result_digest,
),
],
union_membership=union_membership,
)
assert result.exit_code == 0
assert not console.stdout.getvalue()
return cast(str, console.stderr.getvalue())
def create_scheduler(rules, validate=True):
"""Create a Scheduler."""
return Scheduler(
ignore_patterns=[],
use_gitignore=False,
build_root=str(Path.cwd()),
local_execution_root_dir=".",
named_caches_dir="./.pants.d/named_caches",
ca_certs_path=None,
rules=rules,
union_membership=UnionMembership({}),
executor=_EXECUTOR,
execution_options=DEFAULT_EXECUTION_OPTIONS,
local_store_options=DEFAULT_LOCAL_STORE_OPTIONS,
validate_reachability=validate,
)
def create_scheduler(rules, validate=True, native=None):
"""Create a Scheduler."""
native = native or Native()
return Scheduler(
native=native,
ignore_patterns=[],
use_gitignore=False,
build_root=str(Path.cwd()),
local_store_dir="./.pants.d/lmdb_store",
local_execution_root_dir="./.pants.d",
named_caches_dir="./.pants.d/named_caches",
rules=rules,
union_membership=UnionMembership({}),
execution_options=DEFAULT_EXECUTION_OPTIONS,
validate=validate,
)
def run_goal(
*, union_membership: Optional[UnionMembership] = None, details_target: Optional[str] = None
) -> str:
console = MockConsole(use_colors=False)
run_rule(
list_target_types,
rule_args=[
RegisteredTargetTypes.create([FortranBinary, FortranLibrary, FortranTests]),
union_membership or UnionMembership({}),
create_goal_subsystem(
TargetTypesOptions, sep="\\n", output_file=None, details=details_target
),
create_subsystem(GlobalOptions, v1=False),
console,
],
)
return cast(str, console.stdout.getvalue())
def create(cls, options_bootstrapper, full_init=True) -> "PantsDaemon":
"""
:param OptionsBootstrapper options_bootstrapper: The bootstrap options.
:param bool full_init: Whether or not to fully initialize an engine et al for the purposes
of spawning a new daemon. `full_init=False` is intended primarily
for lightweight lifecycle checks (since there is a ~1s overhead to
initialize the engine). See the impl of `maybe_launch` for an example
of the intended usage.
"""
bootstrap_options = options_bootstrapper.bootstrap_options
bootstrap_options_values = bootstrap_options.for_global_scope()
native: Optional[Native] = None
build_root: Optional[str] = None
if full_init:
build_root = get_buildroot()
native = Native()
build_config = BuildConfigInitializer.get(options_bootstrapper)
legacy_graph_scheduler = EngineInitializer.setup_legacy_graph(
native, options_bootstrapper, build_config)
# TODO: https://github.com/pantsbuild/pants/issues/3479
watchman = WatchmanLauncher.create(
bootstrap_options_values).watchman
services = cls._setup_services(
build_root,
bootstrap_options_values,
legacy_graph_scheduler,
native,
watchman,
union_membership=UnionMembership(
build_config.union_rules()),
)
else:
services = PantsServices()
return PantsDaemon(
native=native,
build_root=build_root,
work_dir=bootstrap_options_values.pants_workdir,
log_level=bootstrap_options_values.level,
services=services,
metadata_base_dir=bootstrap_options_values.pants_subprocessdir,
bootstrap_options=bootstrap_options,
)
def run_lint_rule(
rule_runner: RuleRunner,
*,
lint_request_types: List[Type[LintRequest]],
targets: List[Target],
per_file_caching: bool,
include_sources: bool = True,
) -> Tuple[int, str]:
with mock_console(rule_runner.options_bootstrapper) as (console,
stdio_reader):
workspace = Workspace(rule_runner.scheduler)
union_membership = UnionMembership({LintRequest: lint_request_types})
result: Lint = run_rule_with_mocks(
lint,
rule_args=[
console,
workspace,
Targets(targets),
create_goal_subsystem(LintSubsystem,
per_file_caching=per_file_caching,
per_target_caching=False),
union_membership,
],
mock_gets=[
MockGet(
output_type=EnrichedLintResults,
input_type=LintRequest,
mock=lambda field_set_collection: field_set_collection.
lint_results,
),
MockGet(
output_type=FieldSetsWithSources,
input_type=FieldSetsWithSourcesRequest,
mock=lambda field_sets: FieldSetsWithSources(
field_sets if include_sources else ()),
),
MockGet(output_type=Digest,
input_type=MergeDigests,
mock=lambda _: EMPTY_DIGEST),
],
union_membership=union_membership,
)
assert not stdio_reader.get_stdout()
return result.exit_code, stdio_reader.get_stderr()
def run_lint_rule(
self,
*,
lint_request_types: List[Type[LintRequest]],
targets: List[Target],
per_file_caching: bool,
include_sources: bool = True,
) -> Tuple[int, str]:
console = MockConsole(use_colors=False)
workspace = Workspace(self.scheduler)
union_membership = UnionMembership({LintRequest: lint_request_types})
result: Lint = run_rule(
lint,
rule_args=[
console,
workspace,
Targets(targets),
create_goal_subsystem(
LintSubsystem, per_file_caching=per_file_caching, per_target_caching=False
),
union_membership,
],
mock_gets=[
MockGet(
product_type=LintResults,
subject_type=LintRequest,
mock=lambda field_set_collection: field_set_collection.lint_results,
),
MockGet(
product_type=FieldSetsWithSources,
subject_type=FieldSetsWithSourcesRequest,
mock=lambda field_sets: FieldSetsWithSources(
field_sets if include_sources else ()
),
),
MockGet(
product_type=Digest, subject_type=MergeDigests, mock=lambda _: EMPTY_DIGEST
),
],
union_membership=union_membership,
)
assert not console.stdout.getvalue()
return result.exit_code, console.stderr.getvalue()
