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(),
]
