def backend_rules():
return [example_rule, RootRule(RootType)]
def rules(cls):
return (
*super().rules(),
*awslambda_python_rules(),
RootRule(PythonAwsLambdaFieldSet),
)
def rules(cls):
return (super().rules() + [
RootRule(JavacVersionExecutionRequest),
get_javac_version_output,
] + create_cat_stdout_rules() + create_javac_compile_rules())
class D:
def __repr__(self):
return "D()"
def noop(*args):
pass
class SubA(A):
def __repr__(self):
return "SubA()"
_suba_root_rules = [RootRule(SubA)]
_this_is_not_a_type = 3
class ExampleOptions(GoalSubsystem):
"""An example."""
name = "example"
class Example(Goal):
subsystem_cls = ExampleOptions
@goal_rule
def rules(cls):
return super().rules() + [
get_owned_dependencies,
get_exporting_owner,
RootRule(DependencyOwner),
]
def rules(cls):
return [*source_root.rules(), RootRule(Address)]
def create_interactive_runner_rules():
return [RootRule(InteractiveRunner)]
def rules(cls):
return (*super().rules(), *black_rules(),
RootRule(BlackConfigurations))
def rules(cls):
return (*super().rules(), RootRule(Addresses), RootRule(WrappedTarget))
def mk_scheduler_in_example_fs(self, rules):
rules = list(rules) + create_fs_rules() + [
RootRule(ExecuteProcessRequest)
]
return self.mk_scheduler(rules=rules,
project_tree=self.mk_example_fs_tree())
def rules(cls):
return (
*super().rules(),
*pex_rules(),
RootRule(PexRequest),
)
def setup_graph_extended(
options_bootstrapper: OptionsBootstrapper,
build_configuration: BuildConfiguration,
execution_options: ExecutionOptions,
native: Native,
*,
pants_ignore_patterns: List[str],
use_gitignore: bool,
local_store_dir: str,
local_execution_root_dir: str,
named_caches_dir: str,
build_root: Optional[str] = None,
include_trace_on_error: bool = True,
) -> GraphScheduler:
build_root = build_root or get_buildroot()
build_configuration = build_configuration or BuildConfigInitializer.get(
options_bootstrapper)
rules = build_configuration.rules
union_membership = UnionMembership.from_rules(
build_configuration.union_rules)
registered_target_types = RegisteredTargetTypes.create(
build_configuration.target_types)
bootstrap_options = options_bootstrapper.bootstrap_options.for_global_scope(
)
execution_options = execution_options or DEFAULT_EXECUTION_OPTIONS
@rule
def parser_singleton() -> Parser:
return Parser(
target_type_aliases=registered_target_types.aliases,
object_aliases=build_configuration.registered_aliases,
)
@rule
def build_configuration_singleton() -> BuildConfiguration:
return build_configuration
@rule
def registered_target_types_singleton() -> RegisteredTargetTypes:
return registered_target_types
@rule
def union_membership_singleton() -> UnionMembership:
return union_membership
@rule
def build_root_singleton() -> BuildRoot:
return cast(BuildRoot, BuildRoot.instance)
# Create a Scheduler containing graph and filesystem rules, with no installed goals.
rules = FrozenOrderedSet((
*collect_rules(locals()),
RootRule(Console),
*build_files.rules(),
*fs.rules(),
*graph.rules(),
*uuid.rules(),
*options_parsing.rules(),
*process.rules(),
*create_platform_rules(),
*changed_rules(),
*rules,
))
goal_map = EngineInitializer._make_goal_map_from_rules(rules)
def ensure_absolute_path(v: str) -> str:
return Path(v).resolve().as_posix()
scheduler = Scheduler(
native=native,
ignore_patterns=pants_ignore_patterns,
use_gitignore=use_gitignore,
build_root=build_root,
local_store_dir=ensure_absolute_path(local_store_dir),
local_execution_root_dir=ensure_absolute_path(
local_execution_root_dir),
named_caches_dir=ensure_absolute_path(named_caches_dir),
rules=rules,
union_membership=union_membership,
execution_options=execution_options,
include_trace_on_error=include_trace_on_error,
visualize_to_dir=bootstrap_options.native_engine_visualize_to,
)
return GraphScheduler(scheduler, goal_map)
def test_ruleset_with_selector_only_provided_as_root_subject(self):
rules = [RootRule(B), TaskRule(A, [Select(B)], noop)]
create_scheduler(rules)
def rules(cls):
return super().rules() + [inject_init, RootRule(Snapshot)]
def rules(cls):
return (*super().rules(), *target_rules(),
RootRule(HydrateSourcesRequest))
def rules(cls): return super().rules() + [RootRule(MessageToGoalRule), workspace_goal_rule]
def rules(cls):
return (*super().rules(), RootRule(AddressInput))
def rules():
return [*collect_rules(), RootRule(MaybeExtractable)]
def rules(cls):
# Required for sources_for:
return [RootRule(SourcesField)]
def create_process_rules():
"""Intrinsically replaced on the rust side."""
return [execute_process_noop, RootRule(ExecuteProcessRequest)]
def test_ruleset_with_selector_only_provided_as_root_subject(self):
rules = [RootRule(B), TaskRule(A, [Select(B)], noop)]
validator = self.create_validator({}, rules)
validator.assert_ruleset_valid()
def rules():
return [*collect_rules(), RootRule(SourceFilesRequest)]
def rules(cls):
return super().rules() + [
get_ancestor_init_py,
RootRule(HydratedTargets),
RootRule(SourceRootConfig),
]
def rules(cls):
return (*super().rules(), *importable_python_sources_rules(),
RootRule(HydratedTargets))
def rules(cls):
return super().rules() + [
get_exporting_owner,
RootRule(OwnedDependency),
]
def setup_legacy_graph_extended(
pants_ignore_patterns: List[str],
use_gitignore: bool,
local_store_dir,
build_file_imports_behavior: BuildFileImportsBehavior,
options_bootstrapper: OptionsBootstrapper,
build_configuration: BuildConfiguration,
build_root: Optional[str] = None,
native: Optional[Native] = None,
glob_match_error_behavior:
GlobMatchErrorBehavior = GlobMatchErrorBehavior.warn,
build_ignore_patterns=None,
exclude_target_regexps=None,
subproject_roots=None,
include_trace_on_error: bool = True,
execution_options: Optional[ExecutionOptions] = None,
) -> LegacyGraphScheduler:
"""Construct and return the components necessary for LegacyBuildGraph construction.
:param local_store_dir: The directory to use for storing the engine's LMDB store in.
:param build_file_imports_behavior: How to behave if a BUILD file being parsed tries to use
import statements.
:param build_root: A path to be used as the build root. If None, then default is used.
:param native: An instance of the native-engine subsystem.
:param options_bootstrapper: A `OptionsBootstrapper` object containing bootstrap options.
:param build_configuration: The `BuildConfiguration` object to get build file aliases from.
:param glob_match_error_behavior: How to behave if a glob specified for a target's sources or
bundles does not expand to anything.
:param list build_ignore_patterns: A list of paths ignore patterns used when searching for BUILD
files, usually taken from the '--build-ignore' global option.
:param list exclude_target_regexps: A list of regular expressions for excluding targets.
:param list subproject_roots: Paths that correspond with embedded build roots
under the current build root.
:param include_trace_on_error: If True, when an error occurs, the error message will include
the graph trace.
:param execution_options: Option values for (remote) process execution.
"""
build_root = build_root or get_buildroot()
build_configuration = build_configuration or BuildConfigInitializer.get(
options_bootstrapper)
bootstrap_options = options_bootstrapper.bootstrap_options.for_global_scope(
)
build_file_aliases = build_configuration.registered_aliases()
rules = build_configuration.rules()
symbol_table = _legacy_symbol_table(build_file_aliases)
# TODO: register this with the SymbolTable/LegacyPythonCallbacksParser so that the aliases
# exposed by the Target API are interpreted correctly.
registered_target_types = RegisteredTargetTypes.create(
build_configuration.targets())
execution_options = execution_options or DEFAULT_EXECUTION_OPTIONS
# Register "literal" subjects required for these rules.
parser = LegacyPythonCallbacksParser(symbol_table, build_file_aliases,
build_file_imports_behavior)
address_mapper = AddressMapper(
parser=parser,
build_ignore_patterns=build_ignore_patterns,
exclude_target_regexps=exclude_target_regexps,
subproject_roots=subproject_roots,
)
@rule
def glob_match_error_behavior_singleton() -> GlobMatchErrorBehavior:
return glob_match_error_behavior
@rule
def build_configuration_singleton() -> BuildConfiguration:
return build_configuration
@rule
def symbol_table_singleton() -> SymbolTable:
return symbol_table
@rule
def registered_target_types_singleton() -> RegisteredTargetTypes:
return registered_target_types
@rule
def union_membership_singleton() -> UnionMembership:
return UnionMembership(build_configuration.union_rules())
@rule
def build_root_singleton() -> BuildRoot:
return cast(BuildRoot, BuildRoot.instance)
# Create a Scheduler containing graph and filesystem rules, with no installed goals. The
# LegacyBuildGraph will explicitly request the products it needs.
rules = (
RootRule(Console),
glob_match_error_behavior_singleton,
build_configuration_singleton,
symbol_table_singleton,
registered_target_types_singleton,
union_membership_singleton,
build_root_singleton,
*create_legacy_graph_tasks(),
*create_fs_rules(),
*create_interactive_runner_rules(),
*create_process_rules(),
*create_platform_rules(),
*create_graph_rules(address_mapper),
*create_options_parsing_rules(),
*structs_rules(),
*changed_rules(),
*binary_tool_rules(),
*binary_util_rules(),
*rules,
)
goal_map = EngineInitializer._make_goal_map_from_rules(rules)
union_rules = build_configuration.union_rules()
scheduler = Scheduler(
native=native,
ignore_patterns=pants_ignore_patterns,
use_gitignore=use_gitignore,
build_root=build_root,
local_store_dir=local_store_dir,
rules=rules,
union_rules=union_rules,
execution_options=execution_options,
include_trace_on_error=include_trace_on_error,
visualize_to_dir=bootstrap_options.native_engine_visualize_to,
)
return LegacyGraphScheduler(scheduler, build_file_aliases, goal_map)
def create_javac_compile_rules():
return [
javac_compile_process_result,
RootRule(JavacCompileRequest),
]
def setup_legacy_graph_extended(
pants_ignore_patterns,
workdir,
local_store_dir,
build_file_imports_behavior,
options_bootstrapper,
build_configuration,
build_root=None,
native=None,
glob_match_error_behavior=None,
build_ignore_patterns=None,
exclude_target_regexps=None,
subproject_roots=None,
include_trace_on_error=True,
execution_options=None,
):
"""Construct and return the components necessary for LegacyBuildGraph construction.
:param list pants_ignore_patterns: A list of path ignore patterns for FileSystemProjectTree,
usually taken from the '--pants-ignore' global option.
:param str workdir: The pants workdir.
:param local_store_dir: The directory to use for storing the engine's LMDB store in.
:param build_file_imports_behavior: How to behave if a BUILD file being parsed tries to use
import statements. Valid values: "allow", "warn", "error".
:type build_file_imports_behavior: string
:param str build_root: A path to be used as the build root. If None, then default is used.
:param Native native: An instance of the native-engine subsystem.
:param options_bootstrapper: A `OptionsBootstrapper` object containing bootstrap options.
:type options_bootstrapper: :class:`pants.options.options_bootstrapper.OptionsBootstrapper`
:param build_configuration: The `BuildConfiguration` object to get build file aliases from.
:type build_configuration: :class:`pants.build_graph.build_configuration.BuildConfiguration`
:param glob_match_error_behavior: How to behave if a glob specified for a target's sources or
bundles does not expand to anything.
:type glob_match_error_behavior: :class:`pants.option.global_options.GlobMatchErrorBehavior`
:param list build_ignore_patterns: A list of paths ignore patterns used when searching for BUILD
files, usually taken from the '--build-ignore' global option.
:param list exclude_target_regexps: A list of regular expressions for excluding targets.
:param list subproject_roots: Paths that correspond with embedded build roots
under the current build root.
:param bool include_trace_on_error: If True, when an error occurs, the error message will
include the graph trace.
:param execution_options: Option values for (remote) process execution.
:type execution_options: :class:`pants.option.global_options.ExecutionOptions`
:returns: A LegacyGraphScheduler.
"""
build_root = build_root or get_buildroot()
build_configuration = build_configuration or BuildConfigInitializer.get(options_bootstrapper)
bootstrap_options = options_bootstrapper.bootstrap_options.for_global_scope()
build_file_aliases = build_configuration.registered_aliases()
rules = build_configuration.rules()
symbol_table = LegacySymbolTable(build_file_aliases)
project_tree = FileSystemProjectTree(build_root, pants_ignore_patterns)
execution_options = execution_options or DEFAULT_EXECUTION_OPTIONS
# Register "literal" subjects required for these rules.
parser = LegacyPythonCallbacksParser(
symbol_table,
build_file_aliases,
build_file_imports_behavior
)
address_mapper = AddressMapper(parser=parser,
build_ignore_patterns=build_ignore_patterns,
exclude_target_regexps=exclude_target_regexps,
subproject_roots=subproject_roots)
# Create a Scheduler containing graph and filesystem rules, with no installed goals. The
# LegacyBuildGraph will explicitly request the products it needs.
rules = (
[
RootRule(Console),
SingletonRule.from_instance(GlobMatchErrorBehavior.create(glob_match_error_behavior)),
SingletonRule.from_instance(build_configuration),
SingletonRule(SymbolTable, symbol_table),
] +
create_legacy_graph_tasks() +
create_fs_rules() +
create_process_rules() +
create_graph_rules(address_mapper) +
create_options_parsing_rules() +
# TODO: This should happen automatically, but most tests (e.g. tests/python/pants_test/auth) fail if it's not here:
python_test_runner.rules() +
rules
)
goal_map = EngineInitializer._make_goal_map_from_rules(rules)
scheduler = Scheduler(
native,
project_tree,
workdir,
local_store_dir,
rules,
execution_options,
include_trace_on_error=include_trace_on_error,
visualize_to_dir=bootstrap_options.native_engine_visualize_to,
)
return LegacyGraphScheduler(scheduler, symbol_table, goal_map)
def create_cat_stdout_rules():
return [
cat_files_process_result_concatted,
RootRule(CatExecutionRequest),
]
def rules(cls):
return (*super().rules(), *black_rules(), RootRule(BlackFieldSets))
