def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
build_runtime_package_dependencies,
create_or_update_coverage_config,
*pytest_runner.rules(),
*pytest_subsystem_rules(),
*pex_from_targets.rules(),
*dependency_inference_rules.rules(),
*distdir.rules(),
*config_files.rules(),
*package_pex_binary.rules(),
get_filtered_environment,
*target_types_rules.rules(),
*local_dists.rules(),
*setup_py.rules(),
*setuptools_rules(),
QueryRule(TestResult, (PythonTestFieldSet, )),
QueryRule(TestDebugRequest, (PythonTestFieldSet, )),
],
target_types=[
PexBinary,
PythonSourcesGeneratorTarget,
PythonTestsGeneratorTarget,
PythonTestUtilsGeneratorTarget,
PythonRequirementTarget,
PythonDistribution,
],
objects={"python_artifact": PythonArtifact},
)
def create_rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
rules=[
*core_target_types_rules(),
*dependencies.rules(),
*docker_binary.rules(),
*docker_build_args.rules(),
*docker_build_context.rules(),
*docker_build_env.rules(),
*dockerfile.rules(),
*dockerfile_parser.rules(),
*package_image.rules(),
*package_pex_binary.rules(),
*pex_from_targets.rules(),
*shell_target_types_rules(),
*target_types_rules.rules(),
package.find_all_packageable_targets,
QueryRule(BuiltPackage, [PexBinaryFieldSet]),
QueryRule(DockerBuildContext, (DockerBuildContextRequest, )),
],
target_types=[
DockerImageTarget,
FilesGeneratorTarget,
PexBinary,
ShellSourcesGeneratorTarget,
ShellSourceTarget,
],
)
return rule_runner
def rules():
return (
*ancestor_files.rules(),
*coverage_py.rules(),
*dependency_inference_rules.rules(),
*export.rules(),
*ipython.rules(),
*local_dists.rules(),
*lockfile.rules(),
*package_pex_binary.rules(),
*pex.rules(),
*pex_cli.rules(),
*pex_environment.rules(),
*pex_from_targets.rules(),
*pytest.rules(),
*pytest_runner.rules(),
*python_native_code.rules(),
*python_sources.rules(),
*repl.rules(),
*run_pex_binary.rules(),
*setup_py.rules(),
*setuptools.rules(),
*tailor.rules(),
*target_types_rules.rules(),
# Macros.
*deprecation_fixers.rules(),
*pipenv_requirements.rules(),
*poetry_requirements.rules(),
*python_requirements.rules(),
)
def assert_sources(
expected_files,
expected_packages,
expected_namespace_packages,
expected_package_data,
addrs,
):
rule_runner = create_setup_py_rule_runner(
rules=[
get_sources,
get_owned_dependencies,
get_exporting_owner,
*target_types_rules.rules(),
*python_sources.rules(),
QueryRule(OwnedDependencies, (DependencyOwner,)),
QueryRule(DistBuildSources, (DistBuildChrootRequest,)),
]
)
rule_runner.write_files(
{
"src/python/foo/bar/baz/BUILD": textwrap.dedent(
"""
python_sources(name='baz1', sources=['baz1.py'])
python_sources(name='baz2', sources=['baz2.py'])
"""
),
"src/python/foo/bar/baz/baz1.py": "",
"src/python/foo/bar/baz/baz2.py": "",
"src/python/foo/bar/__init__.py": _namespace_decl,
"src/python/foo/qux/BUILD": "python_sources()",
"src/python/foo/qux/__init__.py": "",
"src/python/foo/qux/qux.py": "",
"src/python/foo/resources/BUILD": 'resource(source="js/code.js")',
"src/python/foo/resources/js/code.js": "",
"src/python/foo/__init__.py": "",
# We synthesize an owner for the addrs, so we have something to put in SetupPyChrootRequest.
"src/python/foo/BUILD": textwrap.dedent(
f"""
python_distribution(
name="dist",
dependencies=["{'","'.join(addr.spec for addr in addrs)}"],
provides=setup_py(name="foo", version="3.2.1"),
)
"""
),
}
)
owner_tgt = rule_runner.get_target(Address("src/python/foo", target_name="dist"))
srcs = rule_runner.request(
DistBuildSources,
[DistBuildChrootRequest(ExportedTarget(owner_tgt), py2=False)],
)
chroot_snapshot = rule_runner.request(Snapshot, [srcs.digest])
assert sorted(expected_files) == sorted(chroot_snapshot.files)
assert sorted(expected_packages) == sorted(srcs.packages)
assert sorted(expected_namespace_packages) == sorted(srcs.namespace_packages)
assert expected_package_data == dict(srcs.package_data)
def exporting_owner_rule_runner() -> RuleRunner:
return create_setup_py_rule_runner(
rules=[
get_exporting_owner,
*target_types_rules.rules(),
QueryRule(ExportedTarget, (OwnedDependency,)),
]
)
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=[
*count_loc.rules(),
*external_tool.rules(),
*target_types_rules.rules(),
],
target_types=[PythonSourcesGeneratorTarget, ElixirTarget],
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*tailor.rules(),
*target_types_rules.rules(),
QueryRule(PutativeTargets, (PutativePythonTargetsRequest, AllOwnedSources)),
],
target_types=[PexBinary],
)
def test_infer_python_conftests() -> None:
rule_runner = RuleRunner(
rules=[
*ancestor_files.rules(),
*target_types_rules.rules(),
*core_target_types_rules(),
infer_python_conftest_dependencies,
SubsystemRule(PythonInferSubsystem),
QueryRule(InferredDependencies, (InferConftestDependencies,)),
],
target_types=[PythonTestsGeneratorTarget, PythonTestUtilsGeneratorTarget],
objects={"parametrize": Parametrize},
)
rule_runner.set_options(
[
"--source-root-patterns=src/python",
"--python-resolves={'a': '', 'b': ''}",
"--python-default-resolve=a",
"--python-enable-resolves",
],
env_inherit={"PATH", "PYENV_ROOT", "HOME"},
)
rule_runner.write_files(
{
"src/python/root/conftest.py": "",
"src/python/root/BUILD": "python_test_utils(resolve=parametrize('a', 'b'))",
"src/python/root/mid/conftest.py": "",
"src/python/root/mid/BUILD": "python_test_utils()",
"src/python/root/mid/leaf/conftest.py": "",
"src/python/root/mid/leaf/this_is_a_test.py": "",
"src/python/root/mid/leaf/BUILD": "python_test_utils()\npython_tests(name='tests')",
}
)
def run_dep_inference(address: Address) -> InferredDependencies:
target = rule_runner.get_target(address)
return rule_runner.request(
InferredDependencies,
[InferConftestDependencies(target[PythonSourceField])],
)
assert run_dep_inference(
Address(
"src/python/root/mid/leaf", target_name="tests", relative_file_path="this_is_a_test.py"
)
) == InferredDependencies(
[
Address(
"src/python/root", relative_file_path="conftest.py", parameters={"resolve": "a"}
),
Address("src/python/root/mid", relative_file_path="conftest.py"),
Address("src/python/root/mid/leaf", relative_file_path="conftest.py"),
],
)
def test_no_dist_type_selected() -> None:
rule_runner = RuleRunner(
rules=[
determine_explicitly_provided_setup_kwargs,
generate_chroot,
generate_setup_py,
determine_finalized_setup_kwargs,
get_sources,
get_requirements,
get_owned_dependencies,
get_exporting_owner,
package_python_dist,
*dists.rules(),
*python_sources.rules(),
*target_types_rules.rules(),
SubsystemRule(SetupPyGeneration),
QueryRule(BuiltPackage, (PythonDistributionFieldSet,)),
],
target_types=[PythonDistribution],
objects={"setup_py": PythonArtifact},
)
rule_runner.write_files(
{
"src/python/aaa/BUILD": textwrap.dedent(
"""
python_distribution(
name='aaa',
provides=setup_py(name='aaa', version='2.2.2'),
wheel=False,
sdist=False
)
"""
),
}
)
address = Address("src/python/aaa", target_name="aaa")
with pytest.raises(ExecutionError) as exc_info:
rule_runner.request(
BuiltPackage,
inputs=[
PythonDistributionFieldSet(
address=address,
provides=PythonProvidesField(
PythonArtifact(name="aaa", version="2.2.2"), address
),
)
],
)
assert 1 == len(exc_info.value.wrapped_exceptions)
wrapped_exception = exc_info.value.wrapped_exceptions[0]
assert isinstance(wrapped_exception, NoDistTypeSelected)
assert (
"In order to package src/python/aaa:aaa at least one of 'wheel' or 'sdist' must be `True`."
== str(wrapped_exception)
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*pylint_rules(),
*subsystem.rules(),
*config_files.rules(),
*target_types_rules.rules(),
QueryRule(LintResults, [PylintRequest]),
],
target_types=[PythonLibrary, PythonRequirementLibrary],
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*pylint_rules(),
*subsystem.rules(),
*config_files.rules(),
*target_types_rules.rules(),
QueryRule(LintResults, [PylintRequest]),
],
target_types=[PythonSourcesGeneratorTarget, PythonRequirementTarget],
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*rules(),
*target_types_rules.rules(),
],
target_types=[
PythonSourcesGeneratorTarget, PythonRequirementTarget,
SpecialDepsTarget
],
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*package_pex_binary.rules(),
*pex_from_targets.rules(),
*target_types_rules.rules(),
*core_target_types_rules(),
QueryRule(BuiltPackage, [PexBinaryFieldSet]),
],
target_types=[PexBinary, Files, RelocatedFiles, Resources],
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=(*py_constraints_rules(), *target_types_rules.rules()),
target_types=[
FileTarget,
PythonSourcesGeneratorTarget,
PythonTestsGeneratorTarget,
PythonSourceTarget,
PythonTestTarget,
],
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*nodejs.rules(),
*source_files.rules(),
*config_files.rules(),
*target_types_rules.rules(),
QueryRule(ProcessResult, [nodejs.NpxProcess]),
],
target_types=[JSSourcesGeneratorTarget],
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*docformatter_rules(),
*docformatter_subsystem_rules(),
*source_files.rules(),
*target_types_rules.rules(),
QueryRule(FmtResult, (DocformatterRequest, )),
QueryRule(SourceFiles, (SourceFilesRequest, )),
],
target_types=[PythonSourcesGeneratorTarget],
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*flake8_rules(),
*flake8_subsystem_rules(),
*python_sources.rules(),
*config_files.rules(),
*target_types_rules.rules(),
QueryRule(LintResults, [Flake8Request]),
],
target_types=[PythonSourcesGeneratorTarget],
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*local_dists.rules(),
*setup_py_rules(),
*setuptools_rules(),
*target_types_rules.rules(),
QueryRule(LocalDistsPex, (LocalDistsPexRequest, )),
],
target_types=[PythonLibrary, PythonDistribution],
objects={"python_artifact": PythonArtifact},
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*subsystem_rules(),
*skip_field.rules(),
*python_sources.rules(),
*target_types_rules.rules(),
QueryRule(Flake8FirstPartyPlugins, []),
QueryRule(GeneratePythonLockfile, [Flake8LockfileSentinel]),
],
target_types=[PythonSourcesGeneratorTarget, GenericTarget, PythonRequirementTarget],
)
def test_infer_python_inits() -> None:
rule_runner = RuleRunner(
rules=[
*ancestor_files.rules(),
*target_types_rules.rules(),
*core_target_types_rules(),
infer_python_init_dependencies,
SubsystemRule(PythonInferSubsystem),
QueryRule(InferredDependencies, (InferInitDependencies, )),
],
target_types=[PythonSourcesGeneratorTarget],
)
rule_runner.set_options(
["--python-infer-inits", "--source-root-patterns=src/python"],
env_inherit={"PATH", "PYENV_ROOT", "HOME"},
)
rule_runner.write_files({
"src/python/root/__init__.py": "",
"src/python/root/BUILD": "python_sources()",
"src/python/root/mid/__init__.py": "",
"src/python/root/mid/BUILD": "python_sources()",
"src/python/root/mid/leaf/__init__.py": "",
"src/python/root/mid/leaf/f.py": "",
"src/python/root/mid/leaf/BUILD": "python_sources()",
"src/python/type_stub/__init__.pyi": "",
"src/python/type_stub/foo.pyi": "",
"src/python/type_stub/BUILD": "python_sources()",
})
def run_dep_inference(address: Address) -> InferredDependencies:
target = rule_runner.get_target(address)
return rule_runner.request(
InferredDependencies,
[InferInitDependencies(target[PythonSourceField])],
)
assert run_dep_inference(
Address(
"src/python/root/mid/leaf",
relative_file_path="f.py")) == InferredDependencies([
Address("src/python/root", relative_file_path="__init__.py"),
Address("src/python/root/mid",
relative_file_path="__init__.py"),
Address("src/python/root/mid/leaf",
relative_file_path="__init__.py"),
], )
assert run_dep_inference(
Address("src/python/type_stub",
relative_file_path="foo.pyi")) == InferredDependencies([
Address("src/python/type_stub",
relative_file_path="__init__.pyi")
])
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*flake8_rules(),
*flake8_subsystem_rules(),
*source_files.rules(),
*config_files.rules(),
*target_types_rules.rules(),
QueryRule(LintResults, [Flake8Request]),
],
target_types=[PythonLibrary],
)
def test_pex_binary_targets() -> None:
rule_runner = RuleRunner(
rules=[
*target_types_rules.rules(),
*import_rules(),
*python_sources.rules(),
QueryRule(_TargetParametrizations, [_TargetParametrizationsRequest]),
],
target_types=[PexBinariesGeneratorTarget],
)
rule_runner.write_files(
{
"src/py/BUILD": dedent(
"""\
pex_binaries(
name="pexes",
entry_points=[
"f1.py",
"f2:foo",
"subdir.f.py",
"subdir.f:main",
],
overrides={
'f2:foo': {'tags': ['overridden']},
'subdir.f.py': {'tags': ['overridden']},
}
)
"""
),
}
)
def gen_pex_binary_tgt(entry_point: str, tags: list[str] | None = None) -> PexBinary:
return PexBinary(
{PexEntryPointField.alias: entry_point, Tags.alias: tags},
Address("src/py", target_name="pexes", generated_name=entry_point.replace(":", "-")),
residence_dir="src/py",
)
result = rule_runner.request(
_TargetParametrizations,
[
_TargetParametrizationsRequest(
Address("src/py", target_name="pexes"), description_of_origin="tests"
)
],
).parametrizations.values()
assert set(result) == {
gen_pex_binary_tgt("f1.py"),
gen_pex_binary_tgt("f2:foo", tags=["overridden"]),
gen_pex_binary_tgt("subdir.f.py", tags=["overridden"]),
gen_pex_binary_tgt("subdir.f:main"),
}
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*export.rules(),
*pex_from_targets.rules(),
*target_types_rules.rules(),
*distdir.rules(),
QueryRule(Targets, [AddressSpecs]),
QueryRule(ExportResults, [ExportVenvsRequest]),
],
target_types=[PythonRequirementTarget],
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*bandit_rules(),
*bandit_subsystem_rules(),
*source_files.rules(),
*config_files.rules(),
*target_types_rules.rules(),
QueryRule(LintResults, (BanditRequest, )),
],
target_types=[PythonLibrary],
)
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:
return RuleRunner(
rules=[
*isort_rules(),
*isort_subsystem_rules(),
*source_files.rules(),
*config_files.rules(),
*target_types_rules.rules(),
QueryRule(FmtResult, (IsortRequest,)),
QueryRule(SourceFiles, (SourceFilesRequest,)),
],
target_types=[PythonSourcesGeneratorTarget],
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*context_rules(),
*core_target_types_rules(),
*package_pex_binary.rules(),
*pex_from_targets.rules(),
*target_types_rules.rules(),
QueryRule(BuiltPackage, [PexBinaryFieldSet]),
QueryRule(DockerBuildContext, (DockerBuildContextRequest, )),
],
target_types=[DockerImage, Files, PexBinary],
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*clangformat_rules(),
*skip_field.rules(),
*source_files.rules(),
*config_files.rules(),
*target_types_rules.rules(),
QueryRule(FmtResult, (ClangFormatRequest, )),
QueryRule(SourceFiles, (SourceFilesRequest, )),
],
target_types=[CCSourcesGeneratorTarget],
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*pyupgrade_rules(),
*pyupgrade_subsystem_rules(),
*source_files.rules(),
*config_files.rules(),
*target_types_rules.rules(),
QueryRule(LintResults, (PyUpgradeRequest, )),
QueryRule(FmtResult, (PyUpgradeRequest, )),
QueryRule(SourceFiles, (SourceFilesRequest, )),
],
target_types=[PythonSourcesGeneratorTarget],
)
