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