def rules():
return [
# goals
*check.rules(),
*export.rules(),
*fmt.rules(),
*lint.rules(),
*update_build_files.rules(),
*package.rules(),
*publish.rules(),
*repl.rules(),
*run.rules(),
*tailor.rules(),
*test.rules(),
# util_rules
*anonymous_telemetry.rules(),
*archive.rules(),
*config_files.rules(),
*python_binaries.rules(),
*distdir.rules(),
*external_tool.rules(),
*pants_bin.rules(),
*source_files.rules(),
*source_root.rules(),
*stats_aggregator.rules(),
*stripped_source_files.rules(),
*subprocess_environment.rules(),
*target_type_rules(),
]
def rules():
return [
# goals
*fmt.rules(),
*lint.rules(),
*package.rules(),
*repl.rules(),
*run.rules(),
*test.rules(),
*typecheck.rules(),
*tailor.rules(),
# util_rules
*config_files.rules(),
*distdir.rules(),
*filter_empty_sources.rules(),
*pants_bin.rules(),
*source_files.rules(),
*stripped_source_files.rules(),
*archive.rules(),
*external_tool.rules(),
*subprocess_environment.rules(),
*source_root.rules(),
*target_type_rules(),
*anonymous_telemetry.rules(),
*stats_aggregator.rules(),
]
def __init__(
self,
*,
rules: Optional[Iterable] = None,
target_types: Optional[Iterable[Type[Target]]] = None,
objects: Optional[Dict[str, Any]] = None,
context_aware_object_factories: Optional[Dict[str, Any]] = None,
) -> None:
self.build_root = os.path.realpath(mkdtemp(suffix="_BUILD_ROOT"))
safe_mkdir(self.build_root, clean=True)
safe_mkdir(self.pants_workdir)
BuildRoot().path = self.build_root
# TODO: Redesign rule registration for tests to be more ergonomic and to make this less
# special-cased.
all_rules = (
*(rules or ()),
*source_root.rules(),
*pants_environment.rules(),
QueryRule(WrappedTarget, (Address,)),
)
build_config_builder = BuildConfiguration.Builder()
build_config_builder.register_aliases(
BuildFileAliases(
objects=objects, context_aware_object_factories=context_aware_object_factories
)
)
build_config_builder.register_rules(all_rules)
build_config_builder.register_target_types(target_types or ())
self.build_config = build_config_builder.create()
options_bootstrapper = create_options_bootstrapper()
global_options = options_bootstrapper.bootstrap_options.for_global_scope()
local_store_dir = global_options.local_store_dir
local_execution_root_dir = global_options.local_execution_root_dir
named_caches_dir = global_options.named_caches_dir
graph_session = EngineInitializer.setup_graph_extended(
pants_ignore_patterns=[],
use_gitignore=False,
local_store_dir=local_store_dir,
local_execution_root_dir=local_execution_root_dir,
named_caches_dir=named_caches_dir,
native=Native(),
options_bootstrapper=options_bootstrapper,
build_root=self.build_root,
build_configuration=self.build_config,
execution_options=ExecutionOptions.from_bootstrap_options(global_options),
).new_session(
build_id="buildid_for_test",
session_values=SessionValues(
{OptionsBootstrapper: options_bootstrapper, PantsEnvironment: PantsEnvironment()}
),
should_report_workunits=True,
)
self.scheduler = graph_session.scheduler_session
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*thrift_rules(),
*apache_thrift_rules(),
*apache_thrift_java_rules(),
*source_files.rules(),
*source_root.rules(),
*graph.rules(),
*stripped_source_files.rules(),
QueryRule(HydratedSources, [HydrateSourcesRequest]),
QueryRule(GeneratedSources, [GenerateJavaFromThriftRequest]),
],
target_types=[ThriftSourcesGeneratorTarget],
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*thrift_rules(),
*apache_thrift_rules(),
*apache_thrift_python_rules(),
*source_files.rules(),
*source_root.rules(),
*graph.rules(),
*stripped_source_files.rules(),
*module_mapper.rules(),
QueryRule(HydratedSources, [HydrateSourcesRequest]),
QueryRule(GeneratedSources, [GeneratePythonFromThriftRequest]),
],
target_types=[ThriftSourcesGeneratorTarget, PythonRequirementTarget],
)
def rules():
return [
# goals
*binary.rules(),
*fmt.rules(),
*lint.rules(),
*repl.rules(),
*run.rules(),
*test.rules(),
# util_rules
*determine_source_files.rules(),
*distdir.rules(),
*filter_empty_sources.rules(),
*strip_source_roots.rules(),
*archive.rules(),
*external_tool.rules(),
*source_root.rules(),
]
def rules():
return [
# goals
*binary.rules(),
*fmt.rules(),
*lint.rules(),
*repl.rules(),
*run.rules(),
*test.rules(),
*typecheck.rules(),
# util_rules
*distdir.rules(),
*filter_empty_sources.rules(),
*pants_bin.rules(),
*source_files.rules(),
*stripped_source_files.rules(),
*archive.rules(),
*external_tool.rules(),
*source_root.rules(),
]
def __init__(
self,
*,
rules: Iterable | None = None,
target_types: Iterable[type[Target]] | None = None,
objects: dict[str, Any] | None = None,
context_aware_object_factories: dict[str, Any] | None = None,
isolated_local_store: bool = False,
preserve_tmpdirs: bool = False,
ca_certs_path: str | None = None,
bootstrap_args: Iterable[str] = (),
) -> None:
bootstrap_args = [*bootstrap_args]
root_dir: Path | None = None
if preserve_tmpdirs:
root_dir = Path(mkdtemp(prefix="RuleRunner."))
print(
f"Preserving rule runner temporary directories at {root_dir}.",
file=sys.stderr)
bootstrap_args.extend([
"--no-process-execution-local-cleanup",
f"--local-execution-root-dir={root_dir}",
])
build_root = (root_dir / "BUILD_ROOT").resolve()
build_root.mkdir()
self.build_root = str(build_root)
else:
self.build_root = os.path.realpath(
safe_mkdtemp(prefix="_BUILD_ROOT"))
safe_mkdir(self.pants_workdir)
BuildRoot().path = self.build_root
# TODO: Redesign rule registration for tests to be more ergonomic and to make this less
# special-cased.
all_rules = (
*(rules or ()),
*source_root.rules(),
QueryRule(WrappedTarget, [Address]),
QueryRule(UnionMembership, []),
)
build_config_builder = BuildConfiguration.Builder()
build_config_builder.register_aliases(
BuildFileAliases(
objects=objects,
context_aware_object_factories=context_aware_object_factories))
build_config_builder.register_rules("_dummy_for_test_", all_rules)
build_config_builder.register_target_types("_dummy_for_test_",
target_types or ())
self.build_config = build_config_builder.create()
self.environment = CompleteEnvironment({})
self.options_bootstrapper = create_options_bootstrapper(
args=bootstrap_args)
options = self.options_bootstrapper.full_options(self.build_config)
global_options = self.options_bootstrapper.bootstrap_options.for_global_scope(
)
dynamic_remote_options, _ = DynamicRemoteOptions.from_options(
options, self.environment)
local_store_options = LocalStoreOptions.from_options(global_options)
if isolated_local_store:
if root_dir:
lmdb_store_dir = root_dir / "lmdb_store"
lmdb_store_dir.mkdir()
store_dir = str(lmdb_store_dir)
else:
store_dir = safe_mkdtemp(prefix="lmdb_store.")
local_store_options = dataclasses.replace(local_store_options,
store_dir=store_dir)
local_execution_root_dir = global_options.local_execution_root_dir
named_caches_dir = global_options.named_caches_dir
graph_session = EngineInitializer.setup_graph_extended(
pants_ignore_patterns=GlobalOptions.compute_pants_ignore(
self.build_root, global_options),
use_gitignore=False,
local_store_options=local_store_options,
local_execution_root_dir=local_execution_root_dir,
named_caches_dir=named_caches_dir,
build_root=self.build_root,
build_configuration=self.build_config,
executor=_EXECUTOR,
execution_options=ExecutionOptions.from_options(
global_options, dynamic_remote_options),
ca_certs_path=ca_certs_path,
engine_visualize_to=None,
).new_session(
build_id="buildid_for_test",
session_values=SessionValues({
OptionsBootstrapper: self.options_bootstrapper,
CompleteEnvironment: self.environment,
}),
)
self.scheduler = graph_session.scheduler_session
def rules(cls):
return [
*source_root.rules(),
QueryRule(WrappedTarget, (Address, OptionsBootstrapper))
]
def rules(cls):
return [
*source_root.rules(),
*pants_environment.rules(),
QueryRule(WrappedTarget, (Address, )),
]
def rules(cls):
return [*source_root.rules(), RootRule(Address)]
def rules(cls):
return [*source_root.rules(), RootRule(SourcesField)]
def __init__(
self,
*,
rules: Iterable | None = None,
target_types: Iterable[type[Target]] | None = None,
objects: dict[str, Any] | None = None,
context_aware_object_factories: dict[str, Any] | None = None,
isolated_local_store: bool = False,
ca_certs_path: str | None = None,
) -> None:
self.build_root = os.path.realpath(mkdtemp(suffix="_BUILD_ROOT"))
safe_mkdir(self.build_root, clean=True)
safe_mkdir(self.pants_workdir)
BuildRoot().path = self.build_root
# TODO: Redesign rule registration for tests to be more ergonomic and to make this less
# special-cased.
all_rules = (
*(rules or ()),
*source_root.rules(),
*pants_environment.rules(),
QueryRule(WrappedTarget, [Address]),
QueryRule(UnionMembership, []),
)
build_config_builder = BuildConfiguration.Builder()
build_config_builder.register_aliases(
BuildFileAliases(
objects=objects,
context_aware_object_factories=context_aware_object_factories))
build_config_builder.register_rules(all_rules)
build_config_builder.register_target_types(target_types or ())
self.build_config = build_config_builder.create()
self.options_bootstrapper = create_options_bootstrapper()
options = self.options_bootstrapper.full_options(self.build_config)
global_options = self.options_bootstrapper.bootstrap_options.for_global_scope(
)
local_store_dir = (os.path.realpath(safe_mkdtemp())
if isolated_local_store else
global_options.local_store_dir)
local_execution_root_dir = global_options.local_execution_root_dir
named_caches_dir = global_options.named_caches_dir
graph_session = EngineInitializer.setup_graph_extended(
pants_ignore_patterns=GlobalOptions.compute_pants_ignore(
self.build_root, global_options),
use_gitignore=False,
local_store_dir=local_store_dir,
local_execution_root_dir=local_execution_root_dir,
named_caches_dir=named_caches_dir,
native=Native(),
build_root=self.build_root,
build_configuration=self.build_config,
executor=_EXECUTOR,
execution_options=ExecutionOptions.from_options(options),
ca_certs_path=ca_certs_path,
native_engine_visualize_to=None,
).new_session(
build_id="buildid_for_test",
session_values=SessionValues({
OptionsBootstrapper: self.options_bootstrapper,
PantsEnvironment: PantsEnvironment(),
}),
)
self.scheduler = graph_session.scheduler_session
