def rules():
return (
*lockfile.rules(),
*pex.rules(),
*publish.rules(),
*user_lockfiles.rules(),
)
def rules():
return [
*collect_rules(),
UnionRule(PythonFmtRequest, DocformatterRequest),
UnionRule(LintRequest, DocformatterRequest),
*pex.rules(),
]
def rules():
return [
*collect_rules(),
*extract_pex.rules(),
*pex.rules(),
UnionRule(GenerateSourcesRequest, GeneratePythonFromProtobufRequest),
]
def rules():
return [
*collect_rules(),
UnionRule(FmtRequest, PyUpgradeRequest),
UnionRule(LintTargetsRequest, PyUpgradeRequest),
*pex.rules(),
]
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 rules():
return [
*collect_rules(),
UnionRule(FmtRequest, AutoflakeRequest),
UnionRule(LintTargetsRequest, AutoflakeRequest),
*pex.rules(),
]
def rules():
return [
*collect_rules(),
UnionRule(LintRequest, BanditRequest),
*pex.rules(),
*stripped_source_files.rules(),
]
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
rules=[
*dockerfile.rules(),
*dockerfile_parser.rules(),
package.find_all_packageable_targets,
*package_image.rules(),
*package_pex_binary.rules(),
*package_go_binary.rules(),
*pex.rules(),
inject_docker_dependencies,
py_target_types_rules.generate_targets_from_pex_binaries,
UnionRule(GenerateTargetsRequest, py_target_types_rules.GenerateTargetsFromPexBinaries),
QueryRule(InjectedDependencies, (InjectDockerDependencies,)),
],
target_types=[
DockerImageTarget,
PexBinary,
PexBinariesGeneratorTarget,
GoBinaryTarget,
],
)
rule_runner.set_options(
[],
env_inherit={"PATH", "PYENV_ROOT", "HOME"},
)
return rule_runner
def run_yapf(
build_content: str,
*,
extra_args: list[str] | None = None) -> tuple[GoalRuleResult, str]:
"""Returns the Goal's result and contents of the BUILD file after execution."""
rule_runner = RuleRunner(
rules=(
format_build_file_with_yapf,
update_build_files,
*config_files.rules(),
*pex.rules(),
SubsystemRule(Yapf),
SubsystemRule(UpdateBuildFilesSubsystem),
UnionRule(RewrittenBuildFileRequest, FormatWithYapfRequest),
),
target_types=[GenericTarget],
)
rule_runner.write_files({"BUILD": build_content})
goal_result = rule_runner.run_goal_rule(
UpdateBuildFilesGoal,
args=["--update-build-files-formatter=yapf", "::"],
global_args=extra_args or (),
env_inherit=BLACK_ENV_INHERIT,
)
rewritten_build = Path(rule_runner.build_root, "BUILD").read_text()
return goal_result, rewritten_build
def rule_runner() -> RuleRunner:
return RuleRunner(rules=[
*extract_pex.rules(),
*pex.rules(),
QueryRule(Pex, [PexRequest]),
QueryRule(ExtractedPexDistributions, [Pex]),
])
def rules():
return [
*collect_rules(),
UnionRule(FmtRequest, DocformatterRequest),
UnionRule(LintTargetsRequest, DocformatterRequest),
*pex.rules(),
]
def rules():
return [
*collect_rules(),
UnionRule(FmtRequest, BlackRequest),
UnionRule(LintTargetsRequest, BlackRequest),
*pex.rules(),
]
def rules():
return [
*collect_rules(),
UnionRule(PythonFmtRequest, YapfRequest),
UnionRule(LintRequest, YapfRequest),
*pex.rules(),
]
def rules():
return [
*collect_rules(),
UnionRule(PythonFmtRequest, IsortRequest),
UnionRule(LintRequest, IsortRequest),
*pex.rules(),
*stripped_source_files.rules(),
]
def rules():
return (
*collect_rules(),
*lockfile.rules(),
*pex.rules(),
UnionRule(GenerateToolLockfileSentinel,
DockerfileParserLockfileSentinel),
)
def rule_runner() -> RuleRunner:
return RuleRunner(rules=[
*pex.rules(),
*external_tool.rules(),
*archive.rules(),
QueryRule(Pex, [PexRequest]),
QueryRule(Process, [PexProcess]),
QueryRule(ProcessResult, [Process]),
])
def rules():
return (
*pex.rules(),
*publish.rules(),
*vcs_versioning.rules(),
*setuptools_scm.rules(),
*export_codegen_goal.rules(),
*twine.rules(),
)
def rules():
return [
*collect_rules(),
*pex.rules(),
UnionRule(GenerateSourcesRequest, GenerateJavaFromProtobufRequest),
ProtobufSourceTarget.register_plugin_field(PrefixedJvmJdkField),
ProtobufSourcesGeneratorTarget.register_plugin_field(
PrefixedJvmJdkField),
]
def test_lockfile_generation() -> None:
rule_runner = RuleRunner(rules=[
*lockfile_rules(),
*pex.rules(),
QueryRule(GenerateLockfileResult, [GeneratePythonLockfile]),
])
rule_runner.set_options([], env_inherit=PYTHON_BOOTSTRAP_ENV)
def generate(*, use_pex: bool) -> str:
result = rule_runner.request(
GenerateLockfileResult,
[
GeneratePythonLockfile(
requirements=FrozenOrderedSet(["ansicolors==1.1.8"]),
interpreter_constraints=InterpreterConstraints(),
resolve_name="test",
lockfile_dest="test.lock",
use_pex=use_pex,
)
],
)
digest_contents = rule_runner.request(DigestContents, [result.digest])
assert len(digest_contents) == 1
return digest_contents[0].content.decode()
pex_header = dedent("""\
// This lockfile was autogenerated by Pants. To regenerate, run:
//
// ./pants generate-lockfiles --resolve=test
//
// --- BEGIN PANTS LOCKFILE METADATA: DO NOT EDIT OR REMOVE ---
// {
// "version": 2,
// "valid_for_interpreter_constraints": [],
// "generated_with_requirements": [
// "ansicolors==1.1.8"
// ]
// }
// --- END PANTS LOCKFILE METADATA ---
""")
pex_lock = generate(use_pex=True)
assert pex_lock.startswith(pex_header)
lock_entry = json.loads(strip_prefix(pex_lock, pex_header))
reqs = lock_entry["locked_resolves"][0]["locked_requirements"]
assert len(reqs) == 1
assert reqs[0]["project_name"] == "ansicolors"
assert reqs[0]["version"] == "1.1.8"
poetry_lock = generate(use_pex=False)
assert poetry_lock.startswith(
"# This lockfile was autogenerated by Pants.")
assert poetry_lock.rstrip().endswith(
dedent("""\
ansicolors==1.1.8 \\
--hash=sha256:00d2dde5a675579325902536738dd27e4fac1fd68f773fe36c21044eb559e187 \\
--hash=sha256:99f94f5e3348a0bcd43c82e5fc4414013ccc19d70bd939ad71e0133ce9c372e0"""
))
def rules(cls):
return (
*super().rules(),
*pex.rules(),
*external_tool.rules(),
*archive.rules(),
QueryRule(Pex, (PexRequest,)),
QueryRule(Process, (PexProcess,)),
QueryRule(ProcessResult, (Process,)),
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*import_parser.rules(),
*stripped_source_files.rules(),
*pex.rules(),
QueryRule(ParsedPythonImports, [ParsePythonImportsRequest]),
],
target_types=[PythonLibrary],
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*docker_rules(),
*pex.rules(),
*source_files_rules(),
QueryRule(BuiltPackage, [DockerFieldSet]),
],
target_types=[DockerImageTarget],
)
def rules():
return (
*collect_rules(),
*pex.rules(),
UnionRule(RewrittenBuildFileRequest, RenameDeprecatedTargetsRequest),
UnionRule(RewrittenBuildFileRequest, RenameDeprecatedFieldsRequest),
# NB: We want this to come at the end so that running Black or Yapf happens
# after all our deprecation fixers.
UnionRule(RewrittenBuildFileRequest, FormatWithBlackRequest),
UnionRule(RewrittenBuildFileRequest, FormatWithYapfRequest),
)
def import_rules():
return [
infer_python_dependencies_via_imports,
*pex.rules(),
*import_parser.rules(),
*module_mapper.rules(),
*stripped_source_files.rules(),
SubsystemRule(PythonInferSubsystem),
SubsystemRule(PythonSetup),
UnionRule(InferDependenciesRequest, InferPythonImportDependencies),
]
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*parse_python_dependencies.rules(),
*stripped_source_files.rules(),
*pex.rules(),
QueryRule(ParsedPythonDependencies,
[ParsePythonDependenciesRequest]),
],
target_types=[PythonSourceTarget],
)
def black_rule_runner() -> RuleRunner:
return RuleRunner(
rules=(
format_build_file_with_black,
update_build_files,
*config_files.rules(),
*pex.rules(),
SubsystemRule(Black),
SubsystemRule(UpdateBuildFilesSubsystem),
UnionRule(RewrittenBuildFileRequest, FormatWithBlackRequest),
)
)
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(rules=[
*pex.rules(),
*external_tool.rules(),
QueryRule(Pex, [PexRequest]),
QueryRule(ProcessResult, [PexProcess]),
])
rule_runner.set_options(
["--backend-packages=pants.backend.python"],
env_inherit={"PATH", "PYENV_ROOT", "HOME"},
)
return rule_runner
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*config_files.rules(),
*docker_rules(),
*external_tool.rules(),
*hadolint_rules(),
*pex.rules(),
*source_files.rules(),
QueryRule(LintResults, [HadolintRequest]),
],
target_types=[DockerImageTarget],
)
def test_poetry_lockfile_generation() -> None:
rule_runner = RuleRunner(rules=[
*lockfile_rules(),
*pex.rules(),
QueryRule(GenerateLockfileResult, [GeneratePythonLockfile]),
])
rule_runner.set_options([], env_inherit=PYTHON_BOOTSTRAP_ENV)
poetry_lock = _generate(rule_runner=rule_runner, use_pex=False)
assert poetry_lock.startswith(
"# This lockfile was autogenerated by Pants.")
assert poetry_lock.rstrip().endswith(
dedent("""\
ansicolors==1.1.8 \\
--hash=sha256:00d2dde5a675579325902536738dd27e4fac1fd68f773fe36c21044eb559e187 \\
--hash=sha256:99f94f5e3348a0bcd43c82e5fc4414013ccc19d70bd939ad71e0133ce9c372e0"""
))
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
rules=[
*dockerfile.rules(),
*dockerfile_parser.rules(),
*package_image.rules(),
*package_pex_binary.rules(),
*pex.rules(),
inject_docker_dependencies,
QueryRule(InjectedDependencies, (InjectDockerDependencies, )),
],
target_types=[DockerImageTarget, PexBinary],
)
rule_runner.set_options(
[],
env_inherit={"PATH", "PYENV_ROOT", "HOME"},
)
return rule_runner
