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