def rules():
return [
*collect_rules(),
UnionRule(TypecheckRequest, MyPyRequest),
*pants_bin.rules(),
*pex_from_targets.rules(),
]
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 rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
rules=[
*repl_rules(),
*ipython_subsystem_rules(),
*python_repl.rules(),
*pex_from_targets.rules(),
*local_dists.rules(),
*target_types_rules(),
QueryRule(Process, (PexProcess, )),
],
target_types=[
PythonSourcesGeneratorTarget,
ProtobufSourceTarget,
PythonSourceTarget,
PythonRequirementTarget,
],
)
rule_runner.write_files({
"src/python/foo.proto":
'syntax = "proto3";message Foo {}',
"src/python/lib.py":
"from foo import Foo\nclass SomeClass:\n pass\n",
"src/python/BUILD":
("protobuf_source(name='proto', source='foo.proto')\n"
"python_sources(dependencies=[':proto'])"),
})
return rule_runner
def rules():
return [
*collect_rules(),
UnionRule(AWSLambdaFieldSet, PythonAwsLambdaFieldSet),
UnionRule(PackageFieldSet, PythonAwsLambdaFieldSet),
*pex_from_targets.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 test_runtime_package_dependencies() -> None:
rule_runner = RuleRunner(
rules=[
build_runtime_package_dependencies,
*pex_from_targets.rules(),
*package_pex_binary.rules(),
*python_target_type_rules(),
QueryRule(BuiltPackageDependencies,
[BuildPackageDependenciesRequest]),
],
target_types=[PythonSourcesGeneratorTarget, PexBinary],
)
rule_runner.set_options(args=[],
env_inherit={"PATH", "PYENV_ROOT", "HOME"})
rule_runner.write_files({
"src/py/main.py":
"",
"src/py/BUILD":
dedent("""\
python_sources()
pex_binary(name='main', entry_point='main.py')
"""),
})
# Include an irrelevant target that cannot be built with `./pants package`.
input_field = RuntimePackageDependenciesField(["src/py", "src/py:main"],
Address("fake"))
result = rule_runner.request(
BuiltPackageDependencies,
[BuildPackageDependenciesRequest(input_field)])
assert len(result) == 1
built_package = result[0]
snapshot = rule_runner.request(Snapshot, [built_package.digest])
assert snapshot.files == ("src.py/main.pex", )
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 rules():
return [
*collect_rules(),
UnionRule(DistBuildEnvironmentRequest,
MyPycDistBuildEnvironmentRequest),
PythonDistribution.register_plugin_field(UsesMyPycField),
*pex_from_targets.rules(),
]
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*pex_from_targets.rules(),
QueryRule(PexRequest, (PexFromTargetsRequest, )),
],
target_types=[PythonSourcesGeneratorTarget, PythonRequirementTarget],
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*pex_from_targets.rules(),
QueryRule(PexRequest, (PexFromTargetsRequest, )),
],
target_types=[PythonLibrary, PythonRequirementLibrary],
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*repl_rules(),
*python_repl.rules(),
*pex_from_targets.rules(),
QueryRule(Process, (PexProcess, )),
],
target_types=[PythonLibrary, ProtobufLibrary],
)
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=[
*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=[
*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:
rule_runner = RuleRunner(
preserve_tmpdirs=True,
rules=[
*config_files_rules(),
*pex_from_targets.rules(),
*rules(),
QueryRule(PublishProcesses, [PublishPythonPackageRequest]),
],
target_types=[PythonSourcesGeneratorTarget, PythonDistribution],
objects={"python_artifact": PythonArtifact},
)
return set_options(rule_runner)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
create_coverage_config,
*pytest_runner.rules(),
*pex_from_targets.rules(),
*dependency_inference_rules.rules(), # For conftest detection.
*distdir.rules(),
*binary.rules(),
*package_pex_binary.rules(),
get_filtered_environment,
QueryRule(TestResult, (PythonTestFieldSet,)),
QueryRule(TestDebugRequest, (PythonTestFieldSet,)),
],
target_types=[PexBinary, PythonLibrary, PythonTests, PythonRequirementLibrary],
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*pex_from_targets.rules(),
*target_types_rules.rules(),
QueryRule(PexRequest, (PexFromTargetsRequest,)),
QueryRule(GlobalRequirementConstraints, ()),
QueryRule(ChosenPythonResolve, [ChosenPythonResolveRequest]),
],
target_types=[
PythonSourcesGeneratorTarget,
PythonRequirementTarget,
PythonSourceTarget,
PythonTestTarget,
],
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
*shunit2_test_runner.rules(),
*source_files.rules(),
*pex_from_targets.rules(),
*package_pex_binary.rules(),
*python_target_type_rules(),
build_runtime_package_dependencies,
get_filtered_environment,
QueryRule(TestResult, [Shunit2FieldSet]),
QueryRule(TestDebugRequest, [Shunit2FieldSet]),
QueryRule(Shunit2Runner, [Shunit2RunnerRequest]),
],
target_types=[ShellLibrary, Shunit2Tests, PythonLibrary, PexBinary],
)
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
target_types=[
PythonSourcesGeneratorTarget, PythonSourceTarget, FileTarget,
ResourceTarget
],
rules=[
*pex_from_targets.rules(),
*rules(),
QueryRule(DockerComponent, [DockerPythonSourcesFS]),
QueryRule(DockerComponent, [DockerFilesFS]),
QueryRule(DockerComponent, [DockerResourcesFS]),
QueryRule(DockerComponent, [DockerRelocatedFilesFS]),
],
)
return rule_runner
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
rules=[
*config_files_rules(),
*pex_from_targets.rules(),
*rules(),
QueryRule(PublishProcesses, [PublishToPyPiRequest]),
],
target_types=[PythonSourcesGeneratorTarget, PythonDistribution],
objects={"python_artifact": PythonArtifact},
)
rule_runner.set_options(
[],
env_inherit={"PATH", "PYENV_ROOT", "HOME"},
env={"TWINE_PASSWORD_PYPI": "secret"},
)
return rule_runner
def rules():
return (
*coverage_py.rules(),
*tailor.rules(),
*ancestor_files.rules(),
*python_sources.rules(),
*dependency_inference_rules.rules(),
*pex.rules(),
*pex_cli.rules(),
*pex_environment.rules(),
*pex_from_targets.rules(),
*pytest_runner.rules(),
*package_pex_binary.rules(),
*python_native_code.rules(),
*repl.rules(),
*run_pex_binary.rules(),
*target_types_rules.rules(),
*setup_py.rules(),
)
def rule_runner() -> RuleRunner:
return RuleRunner(
rules=[
build_runtime_package_dependencies,
create_or_update_coverage_config,
*pytest_runner.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(),
QueryRule(TestResult, (PythonTestFieldSet, )),
QueryRule(TestDebugRequest, (PythonTestFieldSet, )),
],
target_types=[
PexBinary, PythonLibrary, PythonTests, PythonRequirementLibrary
],
)
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
rules=[
*package_pex_binary.rules(),
*pex_from_targets.rules(),
*target_types_rules.rules(),
*core_target_types_rules(),
QueryRule(BuiltPackage, [PexBinaryFieldSet]),
],
target_types=[
FileTarget,
FilesGeneratorTarget,
PexBinary,
PythonRequirementTarget,
PythonSourcesGeneratorTarget,
RelocatedFiles,
ResourcesGeneratorTarget,
],
)
rule_runner.set_options([], env_inherit={"PATH", "PYENV_ROOT", "HOME"})
return rule_runner
def rule_runner() -> RuleRunner:
rule_runner = RuleRunner(
rules=[
*repl_rules(),
*ipython_subsystem_rules(),
*python_repl.rules(),
*pex_from_targets.rules(),
*local_dists.rules(),
QueryRule(Process, (PexProcess, )),
],
target_types=[PythonLibrary, ProtobufLibrary],
)
rule_runner.write_files({
"src/python/foo.proto":
'syntax = "proto3";message Foo {}',
"src/python/lib.py":
"from foo import Foo\nclass SomeClass:\n pass\n",
"src/python/BUILD":
("protobuf_library(name='proto')\npython_library(dependencies=[':proto'])"
),
})
return rule_runner
def rules():
return [
*collect_rules(),
UnionRule(LintRequest, PylintRequest),
*pex_from_targets.rules(),
]
def rules():
return [
*collect_rules(),
UnionRule(PackageFieldSet, PythonGoogleCloudFunctionFieldSet),
*pex_from_targets.rules(),
]
def test_url_assets(asset_type) -> None:
rule_runner = RuleRunner(
rules=[
*target_type_rules(),
*pex_from_targets.rules(),
*package_pex_binary.rules(),
*run_pex_binary.rules(),
*python_target_type_rules.rules(),
*run.rules(),
],
target_types=[
FileTarget, ResourceTarget, PythonSourceTarget, PexBinary
],
objects={"http_source": HTTPSource},
)
http_source_info = (
'url="https://raw.githubusercontent.com/python/cpython/7e46ae33bd522cf8331052c3c8835f9366599d8d/Lib/antigravity.py",'
"len=500,"
'sha256="8a5ee63e1b79ba2733e7ff4290b6eefea60e7f3a1ccb6bb519535aaf92b44967"'
)
rule_runner.write_files({
"assets/BUILD":
dedent(f"""\
{asset_type}(
name='antigravity',
source=http_source(
{http_source_info},
),
)
{asset_type}(
name='antigravity_renamed',
source=http_source(
{http_source_info},
filename="antigravity_renamed.py",
),
)
"""),
"app/app.py":
textwrap.dedent("""\
import pathlib
assets_path = pathlib.Path(__file__).parent.parent / "assets"
for path in assets_path.iterdir():
print(path.name)
assert "https://xkcd.com/353/" in path.read_text()
"""),
"app/BUILD":
textwrap.dedent("""\
python_source(
source="app.py",
dependencies=[
"assets:antigravity",
"assets:antigravity_renamed",
]
)
pex_binary(name="app.py", entry_point='app.py')
"""),
})
with mock_console(rule_runner.options_bootstrapper) as (console,
stdout_reader):
rule_runner.run_goal_rule(
run.Run,
args=["app/app.py"],
env_inherit={"PATH", "PYENV_ROOT", "HOME"},
)
stdout = stdout_reader.get_stdout()
assert "antigravity.py" in stdout
assert "antigravity_renamed.py" in stdout
def test_archive() -> None:
"""Integration test for the `archive` target type.
This tests some edges:
* Using both `files` and `relocated_files`.
* An `archive` containing another `archive`.
"""
rule_runner = RuleRunner(
rules=[
*target_type_rules(),
*pex_from_targets.rules(),
*package_pex_binary.rules(),
*python_target_type_rules.rules(),
QueryRule(BuiltPackage, [ArchiveFieldSet]),
],
target_types=[
ArchiveTarget, FilesGeneratorTarget, RelocatedFiles, PexBinary
],
)
rule_runner.set_options([], env_inherit={"PATH", "PYENV_ROOT", "HOME"})
rule_runner.write_files({
"resources/d1.json":
"{'k': 1}",
"resources/d2.json":
"{'k': 2}",
"resources/BUILD":
dedent("""\
files(name='original_files', sources=['*.json'])
relocated_files(
name='relocated_files',
files_targets=[':original_files'],
src="resources",
dest="data",
)
"""),
"project/app.py":
"print('hello world!')",
"project/BUILD":
"pex_binary(entry_point='app.py')",
"BUILD":
dedent("""\
archive(
name="archive1",
packages=["project"],
files=["resources:original_files"],
format="zip",
)
archive(
name="archive2",
packages=[":archive1"],
files=["resources:relocated_files"],
format="tar",
output_path="output/archive2.tar",
)
"""),
})
def get_archive(target_name: str) -> FileContent:
tgt = rule_runner.get_target(Address("", target_name=target_name))
built_package = rule_runner.request(BuiltPackage,
[ArchiveFieldSet.create(tgt)])
digest_contents = rule_runner.request(DigestContents,
[built_package.digest])
assert len(digest_contents) == 1
return digest_contents[0]
def assert_archive1_is_valid(zip_bytes: bytes) -> None:
io = BytesIO()
io.write(zip_bytes)
with zipfile.ZipFile(io) as zf:
assert set(zf.namelist()) == {
"resources/d1.json",
"resources/d2.json",
"project/project.pex",
}
with zf.open("resources/d1.json", "r") as f:
assert f.read() == b"{'k': 1}"
with zf.open("resources/d2.json", "r") as f:
assert f.read() == b"{'k': 2}"
archive1 = get_archive("archive1")
assert_archive1_is_valid(archive1.content)
archive2 = get_archive("archive2")
assert archive2.path == "output/archive2.tar"
io = BytesIO()
io.write(archive2.content)
io.seek(0)
with tarfile.open(fileobj=io, mode="r:") as tf:
assert set(
tf.getnames()) == {"data/d1.json", "data/d2.json", "archive1.zip"}
def get_file(fp: str) -> bytes:
reader = tf.extractfile(fp)
assert reader is not None
return reader.read()
assert get_file("data/d1.json") == b"{'k': 1}"
assert get_file("data/d2.json") == b"{'k': 2}"
assert_archive1_is_valid(get_file("archive1.zip"))
def rules():
return [
*collect_rules(),
UnionRule(CheckRequest, MyPyRequest),
*pex_from_targets.rules(),
]
