def rule_runner() -> RuleRunner: return RuleRunner( rules=[ *tailor.rules(), QueryRule(PutativeTargets, [PutativeShellTargetsRequest, AllOwnedSources]), ], target_types=[], )
def rule_runner() -> RuleRunner: return RuleRunner( rules=[ *debian_rules(), *target_types_rules.rules(), QueryRule(BuiltPackage, (DebianPackageFieldSet, )), ], target_types=[DebianPackage], )
def rule_runner() -> RuleRunner: return RuleRunner( rules=[ *tailor_rules(), QueryRule(PutativeTargets, (PutativeProtobufTargetsRequest, AllOwnedSources)), ], target_types=[], )
def rule_runner() -> RuleRunner: return RuleRunner( rules=[ *tailor.rules(), *target_types_rules.rules(), QueryRule(PutativeTargets, (PutativePythonTargetsRequest, AllOwnedSources)), ], target_types=[PexBinary], )
def rules(cls): return ( *super().rules(), get_requirements, get_owned_dependencies, get_exporting_owner, QueryRule(ExportedTargetRequirements, (DependencyOwner, OptionsBootstrapper)), )
def rule_runner() -> RuleRunner: return RuleRunner( rules=[ *tailor.rules(), *source_files.rules(), *pants_bin.rules(), extract_build_file_options, find_fortran_targets, infer_fortran_module_dependency, UnionRule(PutativeTargetsRequest, PutativeFortranTargetsRequest), QueryRule(PutativeTargets, (MockPutativeFortranModuleRequest, )), QueryRule(UniquelyNamedPutativeTargets, (PutativeTargets, )), QueryRule(DisjointSourcePutativeTarget, (PutativeTarget, )), QueryRule(EditedBuildFiles, (EditBuildFilesRequest, )), QueryRule(AllOwnedSources, ()), ], target_types=[FortranLibraryTarget, FortranTestsTarget], )
def rule_runner() -> RuleRunner: return RuleRunner( rules=[ *mypy_rules(), *dependency_inference_rules.rules(), # Used for import inference. QueryRule(TypecheckResults, (MyPyRequest,)), ], target_types=[PythonLibrary, PythonRequirementLibrary], )
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 test_platform_on_local_epr_result() -> None: rule_runner = RuleRunner( rules=[QueryRule(FallibleProcessResultWithPlatform, (Process, ))]) this_platform = Platform.current process = Process(argv=("/bin/echo", "test"), description="Run some program that will exit cleanly.") result = rule_runner.request_product(FallibleProcessResultWithPlatform, [process]) assert result.exit_code == 0 assert result.platform == this_platform
def rule_runner() -> RuleRunner: rule_runner = RuleRunner( rules=[ *external_tool.rules(), *sdk.rules(), *import_analysis.rules(), QueryRule(GoStdLibImports, []), ], ) return rule_runner
def rule_runner() -> RuleRunner: rule_runner = RuleRunner( rules=[ *tailor.rules(), QueryRule(PutativeTargets, (PutativeJavaTargetsRequest, AllOwnedSources)), ], target_types=[JavaSourcesGeneratorTarget, JunitTestsGeneratorTarget], ) rule_runner.set_options(["--backend-packages=pants.backend.experimental.java"]) return rule_runner
def rule_runner() -> RuleRunner: return RuleRunner( target_types=[TerraformModuleTarget, TerraformModulesGeneratorTarget], rules=[ *external_tool.rules(), *target_gen.rules(), QueryRule(GeneratedTargets, [GenerateTerraformModuleTargetsRequest]), ], )
def rules(cls): return ( *super().rules(), get_sources, *source_files.rules(), *stripped_source_files.rules(), *python_sources.rules(), QueryRule(SetupPySources, (SetupPySourcesRequest, OptionsBootstrapper)), )
def test_multiple_depend_on_same_rule(self): @rule def a_from_suba(suba: SubA) -> A: pass @rule def b_from_a(a: A) -> B: pass @rule def c_from_a(a: A) -> C: pass rules = [ a_from_suba, b_from_a, c_from_a, QueryRule(A, (SubA,)), QueryRule(B, (SubA,)), QueryRule(C, (SubA,)), ] fullgraph = self.create_full_graph(rules) assert_equal_graph_output( self, dedent( f"""\ digraph {{ // queries: Query(A for SubA), Query(B for SubA), Query(C for SubA) // root entries {fmt_non_param_edge(A, SubA)} {fmt_non_param_edge(A, SubA, RuleFormatRequest(a_from_suba))} {fmt_non_param_edge(B, SubA)} {fmt_non_param_edge(B, SubA, RuleFormatRequest(b_from_a))} {fmt_non_param_edge(C, SubA)} {fmt_non_param_edge(C, SubA, RuleFormatRequest(c_from_a))} // internal entries {fmt_non_param_edge(b_from_a, SubA, RuleFormatRequest(a_from_suba))} {fmt_non_param_edge(c_from_a, SubA, RuleFormatRequest(a_from_suba))} {fmt_param_edge(SubA, SubA, RuleFormatRequest(a_from_suba))} }}""" ).strip(), fullgraph, )
def rule_runner() -> RuleRunner: rule_runner = RuleRunner( target_types=[TerraformModuleTarget], rules=[ *external_tool.rules(), *source_files.rules(), *pex_rules(), *dependency_inference.rules(), QueryRule(InferredDependencies, [InferTerraformModuleDependenciesRequest]), QueryRule(HydratedSources, [HydrateSourcesRequest]), QueryRule(ProcessResult, [ParseTerraformModuleSources]), ], ) rule_runner.set_options( ["--backend-packages=pants.backend.experimental.terraform"], env_inherit={"PATH", "PYENV_ROOT", "HOME"}, ) return rule_runner
def rule_runner() -> RuleRunner: rule_runner = RuleRunner( rules=[ *go_mod.rules(), *first_party_pkg.rules(), *sdk.rules(), *third_party_pkg.rules(), *target_type_rules.rules(), *build_pkg.rules(), *link.rules(), *assembly.rules(), QueryRule(FallibleFirstPartyPkgAnalysis, [FirstPartyPkgAnalysisRequest]), QueryRule(FallibleFirstPartyPkgDigest, [FirstPartyPkgDigestRequest]), QueryRule(FirstPartyPkgImportPath, [FirstPartyPkgImportPathRequest]), ], target_types=[GoModTarget, GoPackageTarget, ResourcesGeneratorTarget], ) rule_runner.set_options([], env_inherit={"PATH"}) return rule_runner
def rule_runner() -> RuleRunner: rule_runner = RuleRunner( rules=[ *sdk.rules(), *assembly.rules(), *build_pkg.rules(), *import_analysis.rules(), *go_mod.rules(), *first_party_pkg.rules(), *link.rules(), *third_party_pkg.rules(), *target_type_rules.rules(), QueryRule(BuiltGoPackage, [BuildGoPackageRequest]), QueryRule(FallibleBuiltGoPackage, [BuildGoPackageRequest]), ], target_types=[GoModTarget], ) rule_runner.set_options([], env_inherit={"PATH"}) return rule_runner
def rule_runner() -> RuleRunner: return RuleRunner( target_types=[GoBinary, GoPackage], rules=[ *external_tool.rules(), *source_files.rules(), *build.rules(), QueryRule(BuiltPackage, (GoBinaryFieldSet, )), ], )
def rule_runner() -> RuleRunner: return RuleRunner( target_types=[ HelmChartTarget, ResourcesGeneratorTarget, FilesGeneratorTarget ], rules=[ *sources.rules(), *stripped_source_files.rules(), QueryRule(HelmChartSourceFiles, (HelmChartSourceFilesRequest, )), ], )
def rule_runner() -> RuleRunner: rule_runner = RuleRunner( rules=[ *sdk.rules(), *third_party_pkg.rules(), *first_party_pkg.rules(), *load_go_binary.rules(), *build_pkg.rules(), *import_analysis.rules(), *link.rules(), *assembly.rules(), *target_type_rules.rules(), *go_mod.rules(), QueryRule(AllThirdPartyPackages, [AllThirdPartyPackagesRequest]), QueryRule(ThirdPartyPkgAnalysis, [ThirdPartyPkgAnalysisRequest]), ], target_types=[GoModTarget], ) rule_runner.set_options([], env_inherit={"PATH"}) return rule_runner
def test_run_export_rule() -> None: rule_runner = RuleRunner( rules=[ UnionRule(ExportRequest, MockExportRequest), QueryRule(Digest, [CreateDigest]), QueryRule(Environment, [EnvironmentRequest]), QueryRule(InteractiveProcessResult, [InteractiveProcess]), ], target_types=[MockTarget], ) exit_code, stdout = run_export_rule(rule_runner, [make_target("foo/bar", "baz")]) assert exit_code == 0 assert "Wrote mock export for foo/bar:baz to dist/export/mock" in stdout for filename in ["bar", "bar1", "bar2"]: expected_dist_path = os.path.join(rule_runner.build_root, "dist", "export", "mock", "foo", filename) assert os.path.isfile(expected_dist_path) with open(expected_dist_path, "rb") as fp: assert fp.read() == b"BAR"
def assert_digest(self, filespecs_or_globs, expected_files): with self.mk_project_tree() as project_tree: scheduler = self.mk_scheduler( rules=[*fs_rules(), QueryRule(Snapshot, (PathGlobs, ))], project_tree=project_tree) result = self.execute(scheduler, Snapshot, self.path_globs(filespecs_or_globs))[0] # Confirm all expected files were digested. assert set(expected_files) == set(result.files) assert result.digest.fingerprint is not None
def rule_runner() -> RuleRunner: rule_runner = RuleRunner( rules=[ *sdk.rules(), *go_mod.rules(), QueryRule(GoModInfo, [GoModInfoRequest]), ], target_types=[GoModTarget], ) rule_runner.set_options([], env_inherit={"PATH"}) return rule_runner
def rule_runner() -> RuleRunner: rule_runner = RuleRunner( rules=[ *go_mod.rules(), *first_party_pkg.rules(), *third_party_pkg.rules(), *sdk.rules(), *target_type_rules.rules(), *build_pkg.rules(), *link.rules(), *assembly.rules(), QueryRule(Addresses, [DependenciesRequest]), QueryRule(GoBinaryMainPackage, [GoBinaryMainPackageRequest]), QueryRule(InjectedDependencies, [InjectGoBinaryMainDependencyRequest]), ], target_types=[GoModTarget, GoBinaryTarget, GenericTarget], ) rule_runner.set_options([], env_inherit={"PATH"}) return rule_runner
def rule_runner() -> RuleRunner: rule_runner = RuleRunner( rules=[ *config_files.rules(), *external_tool_rules(), *source_files.rules(), *protobuf_target_types_rules(), *protobuf_dependency_inference.rules(), *stripped_source_files.rules(), *go_protobuf_rules(), *sdk.rules(), *target_types.rules(), # Rules needed to run Go unit test. *test.rules(), *assembly.rules(), *build_pkg.rules(), *build_pkg_target.rules(), *first_party_pkg.rules(), *go_mod.rules(), *link.rules(), *sdk.rules(), *target_type_rules.rules(), *tests_analysis.rules(), *third_party_pkg.rules(), QueryRule(HydratedSources, [HydrateSourcesRequest]), QueryRule(GeneratedSources, [GenerateGoFromProtobufRequest]), QueryRule(DigestContents, (Digest, )), QueryRule(TestResult, (GoTestFieldSet, )), ], target_types=[ GoModTarget, GoPackageTarget, ProtobufSourceTarget, ProtobufSourcesGeneratorTarget, ], ) rule_runner.set_options( [], env_inherit=PYTHON_BOOTSTRAP_ENV, ) return rule_runner
def rules(cls): return ( *super().rules(), generate_chroot, get_sources, get_requirements, get_owned_dependencies, get_exporting_owner, *python_sources.rules(), QueryRule(SetupPyChroot, (SetupPyChrootRequest, OptionsBootstrapper)), )
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: return RuleRunner( target_types=[ HelmChartTarget, HelmUnitTestTestsGeneratorTarget, HelmUnitTestTestTarget ], rules=[ *target_types_rules(), *inject_deps_rules(), QueryRule(InjectedDependencies, (InjectHelmUnitTestChartDependencyRequest, )), ], )
def rule_runner() -> RuleRunner: return RuleRunner( rules=[ *mypy_rules(), *mypy_subystem_rules(), *dependency_inference_rules.rules(), # Used for import inference. *pants_bin.rules(), *config_files.rules(), *target_types_rules.rules(), QueryRule(CheckResults, (MyPyRequest,)), ], target_types=[PythonSourcesGeneratorTarget, PythonRequirementTarget], )
def rule_runner() -> RuleRunner: rule_runner = RuleRunner( target_types=[TerraformModule, TerraformModules], rules=[ *external_tool.rules(), *source_files.rules(), *target_gen.rules(), QueryRule(GeneratedTargets, [GenerateTerraformModuleTargetsRequest]), ], ) rule_runner.set_options( ["--backend-packages=pants.backend.experimental.terraform"]) return rule_runner