def rule_runner() -> RuleRunner: return RuleRunner( rules=[ *protobuf_rules(), *protobuf_subsystem_rules(), *additional_fields.rules(), *stripped_source_files.rules(), *target_types_rules(), QueryRule(HydratedSources, [HydrateSourcesRequest]), QueryRule(GeneratedSources, [GeneratePythonFromProtobufRequest]), ], target_types=[ProtobufSourcesGeneratorTarget], )
def rules(): return [ *additional_fields.rules(), *python_protobuf_subsystem.rules(), *python_rules(), *python_protobuf_module_mapper.rules(), *protobuf_dependency_inference.rules(), *protobuf_tailor.rules(), *export_codegen_goal.rules(), *protobuf_target_rules(), *module_mapper.rules(), *stripped_source_files.rules(), ]
def rules(cls): return ( *super().rules(), *protobuf_rules(), *additional_fields.rules(), *source_files.rules(), *stripped_source_files.rules(), QueryRule(HydratedSources, (HydrateSourcesRequest, OptionsBootstrapper)), QueryRule( GeneratedSources, (GeneratePythonFromProtobufRequest, OptionsBootstrapper)), )
def rule_runner() -> RuleRunner: return RuleRunner( rules=[ *stripped_source_files.rules(), *module_mapper_rules(), *python_protobuf_module_mapper.rules(), *target_types_rules.rules(), *protobuf_target_type_rules(), QueryRule(FirstPartyPythonModuleMapping, []), QueryRule(ThirdPartyPythonModuleMapping, []), QueryRule(PythonModuleOwners, [PythonModule]), ], target_types=[PythonLibrary, PythonRequirementLibrary, ProtobufLibrary], )
def rules(cls): return ( *super().rules(), *repl_rules(), *python_repl.rules(), *pex.rules(), *archive.rules(), *external_tool.rules(), *python_sources.rules(), *pex_from_targets.rules(), *stripped_source_files.rules(), *ancestor_files.rules(), RootRule(PythonRepl), )
def rules(cls): return ( *super().rules(), *stripped_source_files.rules(), *source_files.rules(), map_first_party_modules_to_addresses, map_module_to_address, map_third_party_modules_to_addresses, QueryRule(FirstPartyModuleToAddressMapping, (OptionsBootstrapper, )), QueryRule(ThirdPartyModuleToAddressMapping, (OptionsBootstrapper, )), QueryRule(PythonModuleOwner, (PythonModule, OptionsBootstrapper)), )
def rule_runner() -> RuleRunner: return RuleRunner( target_types=[HelmChartTarget, HelmUnitTestTestTarget], rules=[ *external_tool.rules(), *tool.rules(), *chart.rules(), *test_rules(), *stripped_source_files.rules(), *source_root_rules(), *target_types_rules(), QueryRule(TestResult, (HelmUnitTestFieldSet,)), ], )
def rules(cls): return ( *super().rules(), *repl_rules(), *python_repl.rules(), *pex.rules(), *archive.rules(), *external_tool.rules(), *python_sources.rules(), *pex_from_targets.rules(), *stripped_source_files.rules(), *ancestor_files.rules(), QueryRule(Process, (PexProcess, OptionsBootstrapper)), )
def rules(cls): return ( *super().rules(), *stripped_source_files.rules(), *source_files.rules(), *dependency_inference_rules(), all_roots, QueryRule(InferredDependencies, (InferPythonDependencies, OptionsBootstrapper)), QueryRule(InferredDependencies, (InferInitDependencies, OptionsBootstrapper)), QueryRule(InferredDependencies, (InferConftestDependencies, OptionsBootstrapper)), )
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( target_types=[HelmChartTarget], rules=[ *config_files.rules(), *external_tool.rules(), *chart.rules(), *sources.rules(), *tool.rules(), *process.rules(), *stripped_source_files.rules(), SubsystemRule(HelmSubsystem), QueryRule(HelmChart, (HelmChartRequest, )), ], )
def rule_runner() -> RuleRunner: return RuleRunner( target_types=[HelmChartTarget], rules=[ *config_files.rules(), *external_tool.rules(), *tool.rules(), *chart.rules(), *package.rules(), *stripped_source_files.rules(), *source_root_rules(), *sources.rules(), SubsystemRule(HelmSubsystem), QueryRule(BuiltPackage, [HelmPackageFieldSet]), ], )
def rules(): return [ *avro_rules(), *avro_java_rules(), # Re-export rules necessary to avoid rule graph errors. *config_files.rules(), *classpath.rules(), *coursier_fetch.rules(), *jvm_tool.rules(), *source_files.rules(), *util_rules(), *jdk_rules.rules(), *stripped_source_files.rules(), *compile.rules(), *lockfile.rules(), ]
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 rule_runner() -> RuleRunner: rule_runner = RuleRunner( target_types=[HelmChartTarget], rules=[ *config_files.rules(), *chart.rules(), *external_tool.rules(), *helm_lint_rules(), *tool.rules(), *stripped_source_files.rules(), *source_root_rules(), *sources.rules(), SubsystemRule(HelmSubsystem), QueryRule(LintResults, (HelmLintRequest, )), ], ) return rule_runner
def rules(): return [ *thrift_rules(), *scrooge_rules(), *scrooge_java_rules(), # Re-export rules necessary to avoid rule graph errors. *config_files.rules(), *classpath.rules(), *coursier_fetch_rules(), *coursier_setup_rules(), *external_tool_rules(), *source_files.rules(), *scalac_rules(), *util_rules(), *jdk_rules(), *scala_target_types.rules(), *stripped_source_files.rules(), ]
def rules(): return [ *scala_protobuf_rules.rules(), *protobuf_target_types.rules(), *protobuf_dependency_inference.rules(), # Re-export rules necessary to avoid rule graph errors. *config_files.rules(), *classpath.rules(), *coursier_fetch_rules(), *coursier_setup_rules(), *external_tool_rules(), *source_files.rules(), *scalac_rules(), *util_rules(), *jdk_rules(), *scala_target_types.rules(), *stripped_source_files.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 rule_runner() -> RuleRunner: return RuleRunner( rules=[ *stripped_source_files.rules(), *module_mapper_rules(), *python_protobuf_module_mapper.rules(), *target_types_rules.rules(), *protobuf_additional_fields_rules(), *protobuf_target_type_rules(), QueryRule(FirstPartyPythonModuleMapping, []), QueryRule(ThirdPartyPythonModuleMapping, []), QueryRule(PythonModuleOwners, [PythonModuleOwnersRequest]), ], target_types=[ PythonSourceTarget, PythonSourcesGeneratorTarget, PythonRequirementTarget, ProtobufSourcesGeneratorTarget, ], )
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 rule_runner() -> RuleRunner: rule_runner = RuleRunner( rules=[ *config_files.rules(), *coursier_fetch_rules(), *lockfile.rules(), *classpath.rules(), *coursier_setup_rules(), *external_tool_rules(), *java_dep_inf_rules(), *scala_dep_inf_rules(), *javac_rules(), *jdk_rules.rules(), *scalac_rules(), *source_files.rules(), *scala_target_types_rules(), *java_target_types_rules(), *util_rules(), *testutil.rules(), *protobuf_rules(), *stripped_source_files.rules(), *protobuf_target_types_rules(), QueryRule(Classpath, (Addresses,)), QueryRule(RenderedClasspath, (Addresses,)), QueryRule(UnexpandedTargets, (Addresses,)), QueryRule(HydratedSources, [HydrateSourcesRequest]), QueryRule(GeneratedSources, [GenerateJavaFromProtobufRequest]), ], target_types=[ JavaSourcesGeneratorTarget, JvmArtifactTarget, ProtobufSourceTarget, ProtobufSourcesGeneratorTarget, ScalaSourcesGeneratorTarget, ], ) rule_runner.set_options(args=[], env_inherit=PYTHON_BOOTSTRAP_ENV) return rule_runner
def jvm_rule_runner() -> RuleRunner: rule_runner = RuleRunner( rules=[ *bsp_rules(), *java_bsp_rules(), *scala_bsp_rules(), *config_files.rules(), *coursier_fetch_rules(), *lockfile.rules(), *classpath.rules(), *coursier_setup_rules(), *external_tool_rules(), *scala_dep_inf_rules(), *javac_rules(), *jdk_rules.rules(), *scalac_rules(), *source_files.rules(), *scala_target_types_rules(), *java_target_types_rules(), *util_rules(), *testutil.rules(), *stripped_source_files.rules(), ], target_types=[ JavaSourcesGeneratorTarget, JvmArtifactTarget, ScalatestTestsGeneratorTarget, ], ) rule_runner.set_options( args=[ "--experimental-bsp-groups-config-files=bsp-groups.toml", ], env_inherit=PYTHON_BOOTSTRAP_ENV, ) return rule_runner
def rules(): return [ # goals *fmt.rules(), *lint.rules(), *package.rules(), *repl.rules(), *run.rules(), *test.rules(), *typecheck.rules(), *tailor.rules(), # util_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(), *stats_aggregator.rules(), ]
def rule_runner() -> RuleRunner: return RuleRunner(rules=[ *stripped_source_files.rules(), QueryRule(StrippedSourceFiles, (SourceFiles, OptionsBootstrapper)), ])
def test_find_protobuf_python_requirement() -> None: rule_runner = RuleRunner( rules=[ *python_protobuf_subsystem.rules(), *target_types.rules(), *module_mapper.rules(), *stripped_source_files.rules(), QueryRule(InjectedDependencies, (InjectPythonProtobufDependencies, )), ], target_types=[ProtobufSourcesGeneratorTarget, PythonRequirementTarget], ) rule_runner.write_files({ "codegen/dir/f.proto": "", "codegen/dir/BUILD": "protobuf_sources(grpc=True)" }) rule_runner.set_options([ "--python-resolves={'python-default': '', 'another': ''}", "--python-enable-resolves" ]) proto_tgt = rule_runner.get_target( Address("codegen/dir", relative_file_path="f.proto")) request = InjectPythonProtobufDependencies(proto_tgt[Dependencies]) # Start with no relevant requirements. with engine_error(MissingPythonCodegenRuntimeLibrary, contains="protobuf"): rule_runner.request(InjectedDependencies, [request]) rule_runner.write_files( {"proto1/BUILD": "python_requirement(requirements=['protobuf'])"}) with engine_error(MissingPythonCodegenRuntimeLibrary, contains="grpcio"): rule_runner.request(InjectedDependencies, [request]) # If exactly one, match it. rule_runner.write_files( {"grpc1/BUILD": "python_requirement(requirements=['grpc'])"}) assert rule_runner.request(InjectedDependencies, [request]) == InjectedDependencies( [Address("proto1"), Address("grpc1")]) # Multiple is fine if from other resolve. rule_runner.write_files({ "another_resolve/BUILD": ("python_requirement(name='r1', requirements=['protobuf'], resolve='another')\n" "python_requirement(name='r2', requirements=['grpc'], resolve='another')\n" ) }) assert rule_runner.request(InjectedDependencies, [request]) == InjectedDependencies( [Address("proto1"), Address("grpc1")]) # If multiple from the same resolve, error. rule_runner.write_files( {"grpc2/BUILD": "python_requirement(requirements=['grpc'])"}) with engine_error(AmbiguousPythonCodegenRuntimeLibrary, contains="['grpc1:grpc1', 'grpc2:grpc2']"): rule_runner.request(InjectedDependencies, [request]) rule_runner.write_files( {"proto2/BUILD": "python_requirement(requirements=['protobuf'])"}) with engine_error(AmbiguousPythonCodegenRuntimeLibrary, contains="['proto1:proto1', 'proto2:proto2']"): rule_runner.request(InjectedDependencies, [request])
def rules(): return ( *collect_rules(), *stripped_source_files.rules(), UnionRule(InferDependenciesRequest, InferCCDependenciesRequest), )
def rule_runner() -> RuleRunner: return RuleRunner(rules=[ *stripped_source_files.rules(), QueryRule(SourceFiles, (SourceFilesRequest, )), QueryRule(StrippedSourceFiles, (SourceFiles, )), ])
def test_infer_python_imports() -> None: rule_runner = RuleRunner( rules=[ *stripped_source_files.rules(), *module_mapper.rules(), infer_python_dependencies, SubsystemRule(PythonInference), QueryRule(InferredDependencies, (InferPythonDependencies, )), ], target_types=[PythonLibrary, PythonRequirementLibrary], ) rule_runner.add_to_build_file( "3rdparty/python", dedent("""\ python_requirement_library( name='Django', requirements=['Django==1.21'], ) """), ) # If there's a `.py` and `.pyi` file for the same module, we should infer a dependency on both. rule_runner.create_file("src/python/str_import/subdir/f.py") rule_runner.create_file("src/python/str_import/subdir/f.pyi") rule_runner.add_to_build_file("src/python/str_import/subdir", "python_library()") rule_runner.create_file("src/python/util/dep.py") rule_runner.add_to_build_file("src/python/util", "python_library()") rule_runner.create_file( "src/python/app.py", dedent("""\ import django from util.dep import Demo from util import dep """), ) rule_runner.create_file( "src/python/f2.py", dedent("""\ import typing # Import from another file in the same target. from app import main # Dynamic string import. importlib.import_module('str_import.subdir.f') """), ) rule_runner.add_to_build_file("src/python", "python_library()") def run_dep_inference( address: Address, *, enable_string_imports: bool = False) -> InferredDependencies: args = [ "--backend-packages=pants.backend.python", "--source-root-patterns=src/python" ] if enable_string_imports: args.append("--python-infer-string-imports") rule_runner.set_options(args) target = rule_runner.get_target(address) return rule_runner.request( InferredDependencies, [InferPythonDependencies(target[PythonSources])], ) normal_address = Address("src/python") assert run_dep_inference(normal_address) == InferredDependencies( [ Address("3rdparty/python", target_name="Django"), Address("src/python", relative_file_path="app.py"), Address("src/python/util", relative_file_path="dep.py", target_name="util"), ], sibling_dependencies_inferrable=True, ) generated_subtarget_address = Address("src/python", relative_file_path="f2.py", target_name="python") assert run_dep_inference( generated_subtarget_address) == InferredDependencies( [ Address("src/python", relative_file_path="app.py", target_name="python") ], sibling_dependencies_inferrable=True, ) assert run_dep_inference( generated_subtarget_address, enable_string_imports=True) == InferredDependencies( [ Address("src/python", relative_file_path="app.py", target_name="python"), Address("src/python/str_import/subdir", relative_file_path="f.py"), Address("src/python/str_import/subdir", relative_file_path="f.pyi"), ], sibling_dependencies_inferrable=True, )
def rules(): return [ *collect_rules(), *stripped_source_files.rules(), ]