def rule_runner() -> RuleRunner: rule_runner = RuleRunner( preserve_tmpdirs=True, rules=[ *classpath.rules(), *config_files.rules(), *coursier_fetch_rules(), *coursier_setup_rules(), *jdk_util_rules(), *non_jvm_dependencies_rules(), *scalac_rules(), *scalatest_rules(), *scala_target_types_rules(), *scalac_rules(), *source_files.rules(), *system_binaries.rules(), *target_types_rules(), *util_rules(), QueryRule(CoarsenedTargets, (Addresses, )), QueryRule(TestResult, (ScalatestTestFieldSet, )), QueryRule(Scalatest, ()), ], target_types=[ JvmArtifactTarget, FileTarget, FilesGeneratorTarget, RelocatedFiles, ScalaSourcesGeneratorTarget, ScalatestTestsGeneratorTarget, ], ) rule_runner.set_options(args=[], env_inherit=PYTHON_BOOTSTRAP_ENV) return rule_runner
def rule_runner() -> RuleRunner: rule_runner = RuleRunner( rules=[ *scala_lockfile_rules(), *scala_dep_inf_rules.rules(), *jdk_rules.rules(), *coursier_fetch_rules(), *coursier_jvm_tool_rules(), *lockfile.rules(), *coursier_setup_rules(), *external_tool.rules(), *source_files.rules(), *util_rules(), *system_binaries.rules(), *graph.rules(), *build_files.rules(), *target_types.rules(), QueryRule(UserGenerateLockfiles, (RequestedJVMUserResolveNames,)), QueryRule(GenerateLockfileResult, (GenerateJvmLockfile,)), ], target_types=[JvmArtifactTarget, ScalaSourceTarget, ScalaSourcesGeneratorTarget], ) rule_runner.set_options( [ '--scala-version-for-resolve={"foo":"2.13.8"}', '--jvm-resolves={"foo": "foo/foo.lock"}', ], env_inherit={"PATH"}, ) return rule_runner
def rules(): return [ # goals *check.rules(), *export.rules(), *fmt.rules(), *generate_lockfiles.rules(), *lint.rules(), *update_build_files.rules(), *package.rules(), *publish.rules(), *repl.rules(), *run.rules(), *tailor.rules(), *test.rules(), *bsp_rules(), # util_rules *anonymous_telemetry.rules(), *archive.rules(), *config_files.rules(), *distdir.rules(), *external_tool.rules(), *git.rules(), *source_files.rules(), *source_root.rules(), *stats_aggregator.rules(), *stripped_source_files.rules(), *subprocess_environment.rules(), *system_binaries.rules(), *target_type_rules(), ]
def rule_runner() -> RuleRunner: rule_runner = RuleRunner( rules=[ *system_binaries.rules(), *config_files.rules(), *jvm_tool.rules(), *source_files.rules(), *javac_rules(), *javac_check_rules(), *util_rules(), *target_types_rules(), *lockfile.rules(), *jdk_rules.rules(), *java_dep_inf_rules(), *source_files.rules(), *testutil.rules(), QueryRule(CheckResults, (JavacCheckRequest, )), QueryRule(ClasspathEntry, (CompileJavaSourceRequest, )), QueryRule(CoarsenedTargets, (Addresses, )), QueryRule(FallibleClasspathEntry, (CompileJavaSourceRequest, )), QueryRule(RenderedClasspath, (CompileJavaSourceRequest, )), ], target_types=[JavaSourcesGeneratorTarget, JvmArtifactTarget], ) rule_runner.set_options([], env_inherit=PYTHON_BOOTSTRAP_ENV) return rule_runner
def rule_runner() -> RuleRunner: rule_runner = RuleRunner( rules=[ *config_files.rules(), *jvm_tool.rules(), *java_dep_inference_rules(), *java_target_rules(), *java_util_rules(), *javac_rules(), *java_symbol_mapper.rules(), *source_files.rules(), *scala_parser.rules(), *scala_symbol_mapper.rules(), *scala_dep_inference_rules.rules(), *scala_target_types.rules(), *system_binaries.rules(), *util_rules(), QueryRule(Addresses, (DependenciesRequest, )), ], target_types=[ JavaSourcesGeneratorTarget, JavaSourceTarget, ScalaSourcesGeneratorTarget, ScalaSourceTarget, ], ) rule_runner.set_options(args=[], env_inherit=PYTHON_BOOTSTRAP_ENV) return rule_runner
def rule_runner() -> RuleRunner: rule_runner = RuleRunner( rules=[ *coursier_fetch_rules(), *coursier_setup_rules(), *config_files.rules(), *jvm_tool.rules(), *system_binaries.rules(), *jdk_rules.rules(), *kotlin_check_rules(), *kotlinc_rules(), *kotlinc_plugins.rules(), *kotlin_dep_inf_rules(), *source_files.rules(), *target_types_rules(), *testutil.rules(), *util_rules(), QueryRule(CheckResults, (KotlincCheckRequest, )), QueryRule(CoarsenedTargets, (Addresses, )), QueryRule(FallibleClasspathEntry, (CompileKotlinSourceRequest, )), QueryRule(RenderedClasspath, (CompileKotlinSourceRequest, )), QueryRule(ClasspathEntry, (CompileKotlinSourceRequest, )), ], target_types=[ JvmArtifactTarget, KotlinSourcesGeneratorTarget, KotlincPluginTarget ], ) rule_runner.set_options(args=[], env_inherit=PYTHON_BOOTSTRAP_ENV) return rule_runner
def rule_runner() -> RuleRunner: rule_runner = RuleRunner( rules=[ *config_files.rules(), *jvm_tool.rules(), *dep_inference_rules(), *java_target_rules(), *java_util_rules(), *javac_rules(), *source_files.rules(), *system_binaries.rules(), *util_rules(), QueryRule(Addresses, [DependenciesRequest]), QueryRule(ThirdPartySymbolMapping, []), ], objects={"parametrize": Parametrize}, target_types=[ JavaSourceTarget, JavaSourcesGeneratorTarget, JunitTestsGeneratorTarget, JvmArtifactTarget, ], ) rule_runner.set_options(args=[], env_inherit=PYTHON_BOOTSTRAP_ENV) return rule_runner
def rules(): return [ *collect_rules(), *system_binaries.rules(), QueryRule(RenderedClasspath, (Classpath, )), QueryRule(RenderedClasspath, (ClasspathEntry, )), QueryRule(CoarsenedTargets, (Addresses, )), ]
def rule_runner() -> RuleRunner: return RuleRunner(rules=[ *system_binaries.rules(), python_binary_version, QueryRule(PythonBinaryVersion, []), QueryRule(BinaryPaths, [BinaryPathRequest]), QueryRule(BinaryShims, [BinaryShimsRequest]), QueryRule(DigestContents, [Digest]), ])
def rule_runner() -> RuleRunner: return RuleRunner( rules=[ *archive.rules(), *system_binaries.rules(), QueryRule(Digest, [CreateArchive]), QueryRule(ExtractedArchive, [Digest]), ], )
def test_python_interpreter_search_path_file_entries() -> None: rule_runner = RuleRunner(rules=[ *system_binaries.rules(), QueryRule(PythonBinary, input_types=()) ]) current_python = os.path.realpath(sys.executable) rule_runner.set_options(args=[ f"--python-bootstrap-search-path=[{current_python!r}]", f"--python-bootstrap-names=[{os.path.basename(current_python)!r}]", ]) python_binary = rule_runner.request(PythonBinary, inputs=()) assert current_python == python_binary.path
def rule_runner() -> RuleRunner: rule_runner = RuleRunner(rules=[ *config_files.rules(), *source_files.rules(), *coursier_setup_rules(), *coursier_fetch_rules(), *external_tool_rules(), *util_rules(), *jdk_rules(), *system_binaries.rules(), QueryRule(BashBinary, ()), QueryRule(InternalJdk, ()), QueryRule(ProcessResult, (JvmProcess, )), ], ) rule_runner.set_options(args=[], env_inherit=PYTHON_BOOTSTRAP_ENV) return rule_runner
def test_relocated_relocated_files() -> None: rule_runner = RuleRunner( rules=[ *target_type_rules(), *archive.rules(), *source_files.rules(), *system_binaries.rules(), QueryRule(GeneratedSources, [RelocateFilesViaCodegenRequest]), QueryRule(TransitiveTargets, [TransitiveTargetsRequest]), QueryRule(SourceFiles, [SourceFilesRequest]), ], target_types=[FilesGeneratorTarget, RelocatedFiles], ) rule_runner.write_files({ "original_prefix/file.txt": "", "BUILD": dedent("""\ files(name="original", sources=["original_prefix/file.txt"]) relocated_files( name="relocated", files_targets=[":original"], src="original_prefix", dest="intermediate_prefix", ) relocated_files( name="double_relocated", files_targets=[":relocated"], src="intermediate_prefix", dest="final_prefix", ) """), }) tgt = rule_runner.get_target(Address("", target_name="double_relocated")) result = rule_runner.request( GeneratedSources, [RelocateFilesViaCodegenRequest(EMPTY_SNAPSHOT, tgt)]) assert result.snapshot.files == ("final_prefix/file.txt", )
def rules(): return [ *kotlinc.rules(), *kotlinc_plugins.rules(), *check.rules(), *tailor.rules(), *classpath.rules(), *lockfile.rules(), *coursier_fetch.rules(), *coursier_setup.rules(), *dep_inf_rules(), *jvm_util_rules.rules(), *jdk_rules.rules(), *target_types_rules(), *jvm_tool.rules(), *resources.rules(), *system_binaries.rules(), *source_files.rules(), *deploy_jar.rules(), *run_deploy_jar.rules(), *war.rules(), *jvm_junit_rules(), *kotlin_junit_rules(), ]
def rules(): return [ *collect_rules(), *system_binaries.rules(), ]
def setup_graph_extended( build_configuration: BuildConfiguration, execution_options: ExecutionOptions, *, executor: PyExecutor, pants_ignore_patterns: list[str], use_gitignore: bool, local_store_options: LocalStoreOptions, local_execution_root_dir: str, named_caches_dir: str, use_deprecated_python_macros: bool, ca_certs_path: str | None = None, build_root: str | None = None, include_trace_on_error: bool = True, engine_visualize_to: str | None = None, watch_filesystem: bool = True, ) -> GraphScheduler: build_root_path = build_root or get_buildroot() rules = build_configuration.rules union_membership: UnionMembership registered_target_types = RegisteredTargetTypes.create( build_configuration.target_types) execution_options = execution_options or DEFAULT_EXECUTION_OPTIONS @rule def parser_singleton() -> Parser: return Parser( build_root=build_root_path, target_type_aliases=registered_target_types.aliases, object_aliases=build_configuration.registered_aliases, use_deprecated_python_macros=use_deprecated_python_macros, ) @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()), *build_files.rules(), *fs.rules(), *environment.rules(), *desktop.rules(), *graph.rules(), *options_parsing.rules(), *process.rules(), *system_binaries.rules(), *platform.rules(), *changed_rules(), *streaming_workunit_handler_rules(), *specs_calculator.rules(), *rules, )) goal_map = EngineInitializer._make_goal_map_from_rules(rules) union_membership = UnionMembership.from_rules(( *build_configuration.union_rules, *(r for r in rules if isinstance(r, UnionRule)), )) rules = FrozenOrderedSet(( *rules, # Install queries for each Goal. *(QueryRule(goal_type, GraphSession.goal_param_types) for goal_type in goal_map.values()), # Install queries for each request/response pair used by the BSP support. # Note: These are necessary because the BSP support is a built-in goal that makes # synchronous requests into the engine. *(QueryRule(impl.response_type, (impl.request_type, Workspace)) for impl in union_membership.get(BSPHandlerMapping)), QueryRule(Snapshot, [PathGlobs]), # Used by the SchedulerService. )) def ensure_absolute_path(v: str) -> str: return Path(v).resolve().as_posix() def ensure_optional_absolute_path(v: str | None) -> str | None: if v is None: return None return ensure_absolute_path(v) scheduler = Scheduler( ignore_patterns=pants_ignore_patterns, use_gitignore=use_gitignore, build_root=build_root_path, local_execution_root_dir=ensure_absolute_path( local_execution_root_dir), named_caches_dir=ensure_absolute_path(named_caches_dir), ca_certs_path=ensure_optional_absolute_path(ca_certs_path), rules=rules, union_membership=union_membership, executor=executor, execution_options=execution_options, local_store_options=local_store_options, include_trace_on_error=include_trace_on_error, visualize_to_dir=engine_visualize_to, watch_filesystem=watch_filesystem, ) return GraphScheduler(scheduler, goal_map)
def rules(): return ( *collect_rules(), *pex_rules(), *system_binaries.rules(), )
def test_relocated_files() -> None: rule_runner = RuleRunner( rules=[ *target_type_rules(), *archive.rules(), *source_files.rules(), *system_binaries.rules(), QueryRule(GeneratedSources, [RelocateFilesViaCodegenRequest]), QueryRule(TransitiveTargets, [TransitiveTargetsRequest]), QueryRule(SourceFiles, [SourceFilesRequest]), ], target_types=[FilesGeneratorTarget, RelocatedFiles], ) def assert_prefix_mapping( *, original: str, src: str, dest: str, expected: str, ) -> None: rule_runner.write_files({ original: "", "BUILD": dedent(f"""\ files(name="original", sources=[{repr(original)}]) relocated_files( name="relocated", files_targets=[":original"], src={repr(src)}, dest={repr(dest)}, ) """), }) tgt = rule_runner.get_target(Address("", target_name="relocated")) result = rule_runner.request( GeneratedSources, [RelocateFilesViaCodegenRequest(EMPTY_SNAPSHOT, tgt)]) assert result.snapshot.files == (expected, ) # We also ensure that when looking at the transitive dependencies of the `relocated_files` # target and then getting all the code of that closure, we only end up with the relocated # files. If we naively marked the original files targets as a typical `Dependencies` field, # we would hit this issue. transitive_targets = rule_runner.request( TransitiveTargets, [TransitiveTargetsRequest([tgt.address])]) all_sources = rule_runner.request( SourceFiles, [ SourceFilesRequest( (tgt.get(SourcesField) for tgt in transitive_targets.closure), enable_codegen=True, for_sources_types=(FileSourceField, ), ) ], ) assert all_sources.snapshot.files == (expected, ) # No-op. assert_prefix_mapping(original="old_prefix/f.ext", src="", dest="", expected="old_prefix/f.ext") assert_prefix_mapping( original="old_prefix/f.ext", src="old_prefix", dest="old_prefix", expected="old_prefix/f.ext", ) # Remove prefix. assert_prefix_mapping(original="old_prefix/f.ext", src="old_prefix", dest="", expected="f.ext") assert_prefix_mapping(original="old_prefix/subdir/f.ext", src="old_prefix", dest="", expected="subdir/f.ext") # Add prefix. assert_prefix_mapping(original="f.ext", src="", dest="new_prefix", expected="new_prefix/f.ext") assert_prefix_mapping( original="old_prefix/f.ext", src="", dest="new_prefix", expected="new_prefix/old_prefix/f.ext", ) # Replace prefix. assert_prefix_mapping( original="old_prefix/f.ext", src="old_prefix", dest="new_prefix", expected="new_prefix/f.ext", ) assert_prefix_mapping( original="old_prefix/f.ext", src="old_prefix", dest="new_prefix/subdir", expected="new_prefix/subdir/f.ext", ) # Replace prefix, but preserve a common start. assert_prefix_mapping( original="common_prefix/foo/f.ext", src="common_prefix/foo", dest="common_prefix/bar", expected="common_prefix/bar/f.ext", ) assert_prefix_mapping( original="common_prefix/subdir/f.ext", src="common_prefix/subdir", dest="common_prefix", expected="common_prefix/f.ext", )
def rules(): return [ *collect_rules(), *subprocess_environment.rules(), *system_binaries.rules(), ]