Python rules Exemples

Exemple #1

Fichier : tffmt.py Projet : patricklaw/pants

def rules():
    return [
        *collect_rules(),
        *external_tool.rules(),
        *tool_rules(),
        UnionRule(TerraformFmtRequest, TffmtRequest),
    ]

Exemple #2

def rule_runner() -> RuleRunner:
    rule_runner = RuleRunner(
        rules=[
            *scala_lockfile_rules(),
            *scala_dep_inf_rules.rules(),
            *jdk_rules.rules(),
            *coursier_fetch_rules(),
            *coursier_jvm_tool_rules(),
            *lockfile.rules(),
            *coursier_setup_rules(),
            *external_tool.rules(),
            *source_files.rules(),
            *util_rules(),
            *system_binaries.rules(),
            *graph.rules(),
            *build_files.rules(),
            *target_types.rules(),
            QueryRule(UserGenerateLockfiles, (RequestedJVMUserResolveNames,)),
            QueryRule(GenerateLockfileResult, (GenerateJvmLockfile,)),
        ],
        target_types=[JvmArtifactTarget, ScalaSourceTarget, ScalaSourcesGeneratorTarget],
    )
    rule_runner.set_options(
        [
            '--scala-version-for-resolve={"foo":"2.13.8"}',
            '--jvm-resolves={"foo": "foo/foo.lock"}',
        ],
        env_inherit={"PATH"},
    )
    return rule_runner

Exemple #3

def rules():
    return [
        # goals
        *fmt.rules(),
        *lint.rules(),
        *package.rules(),
        *repl.rules(),
        *run.rules(),
        *test.rules(),
        *typecheck.rules(),
        *tailor.rules(),
        # util_rules
        *config_files.rules(),
        *distdir.rules(),
        *filter_empty_sources.rules(),
        *pants_bin.rules(),
        *source_files.rules(),
        *stripped_source_files.rules(),
        *archive.rules(),
        *external_tool.rules(),
        *subprocess_environment.rules(),
        *source_root.rules(),
        *target_type_rules(),
        *anonymous_telemetry.rules(),
        *stats_aggregator.rules(),
    ]

Exemple #4

def rules():
    return [
        # goals
        *check.rules(),
        *export.rules(),
        *fmt.rules(),
        *lint.rules(),
        *update_build_files.rules(),
        *package.rules(),
        *publish.rules(),
        *repl.rules(),
        *run.rules(),
        *tailor.rules(),
        *test.rules(),
        # util_rules
        *anonymous_telemetry.rules(),
        *archive.rules(),
        *config_files.rules(),
        *python_binaries.rules(),
        *distdir.rules(),
        *external_tool.rules(),
        *pants_bin.rules(),
        *source_files.rules(),
        *source_root.rules(),
        *stats_aggregator.rules(),
        *stripped_source_files.rules(),
        *subprocess_environment.rules(),
        *target_type_rules(),
    ]

Exemple #5

def rules():
    return [
        *collect_rules(),
        *external_tool.rules(),
        *tool_rules(),
        UnionRule(LintRequest, ValidateRequest),
        SubsystemRule(TerraformValidateSubsystem),
    ]

Exemple #6

def rule_runner() -> RuleRunner:
    return RuleRunner(rules=[
        *external_tool.rules(),
        *tool.rules(),
        *process.rules(),
        *unittest.rules(),
        QueryRule(ProcessResult, (HelmProcess, )),
    ])

Exemple #7

 def rules(cls):
     return (
         *super().rules(),
         *pex.rules(),
         *external_tool.rules(),
         *archive.rules(),
         RootRule(PexRequest),
     )

Exemple #8

Fichier : count_loc_test.py Projet : codealchemy/pants

def rule_runner() -> RuleRunner:
    return RuleRunner(
        rules=[
            *count_loc.rules(),
            *external_tool.rules(),
            *target_types_rules.rules(),
        ],
        target_types=[PythonSourcesGeneratorTarget, ElixirTarget],
    )

Exemple #9

def rule_runner() -> RuleRunner:
    return RuleRunner(
        target_types=[TerraformModuleTarget, TerraformModulesGeneratorTarget],
        rules=[
            *external_tool.rules(),
            *target_gen.rules(),
            QueryRule(_TargetParametrizations, [Address]),
        ],
    )

Exemple #10

Fichier : test_plugin_resolver.py Projet : gatesn/pants

def rule_runner() -> RuleRunner:
    return RuleRunner(rules=[
        *pex.rules(),
        *external_tool.rules(),
        *archive.rules(),
        QueryRule(Pex, [PexRequest]),
        QueryRule(Process, [PexProcess]),
        QueryRule(ProcessResult, [Process]),
    ])

Exemple #11

Fichier : rules_integration_test.py Projet : wiwa/pants

 def rules(cls):
     return (
         *super().rules(),
         *protobuf_rules(),
         *archive.rules(),
         *determine_source_files.rules(),
         *external_tool.rules(),
         RootRule(GeneratePythonFromProtobufRequest),
     )

Exemple #12

Fichier : test_plugin_resolver.py Projet : matze999/pants

 def rules(cls):
     return (
         *super().rules(),
         *pex.rules(),
         *external_tool.rules(),
         *archive.rules(),
         QueryRule(Pex, (PexRequest, OptionsBootstrapper)),
         QueryRule(Process, (PexProcess, OptionsBootstrapper)),
         QueryRule(ProcessResult, (Process, )),
     )

Exemple #13

Fichier : target_gen_test.py Projet : hephex/pants

def rule_runner() -> RuleRunner:
    return RuleRunner(
        target_types=[TerraformModuleTarget, TerraformModulesGeneratorTarget],
        rules=[
            *external_tool.rules(),
            *target_gen.rules(),
            QueryRule(GeneratedTargets,
                      [GenerateTerraformModuleTargetsRequest]),
        ],
    )

Exemple #14

Fichier : build_integration_test.py Projet : rhysyngsun/pants

def rule_runner() -> RuleRunner:
    return RuleRunner(
        target_types=[GoBinary, GoPackage],
        rules=[
            *external_tool.rules(),
            *source_files.rules(),
            *build.rules(),
            QueryRule(BuiltPackage, (GoBinaryFieldSet, )),
        ],
    )

Exemple #15

def rule_runner() -> RuleRunner:
    rule_runner = RuleRunner(
        rules=[
            *external_tool.rules(),
            *sdk.rules(),
            *import_analysis.rules(),
            QueryRule(GoStdLibImports, []),
        ],
    )
    return rule_runner

Exemple #16

def rule_runner() -> RuleRunner:
    return RuleRunner(
        rules=[
            *external_tool.rules(),
            *publish.rules(),
            *tool.rules(),
            QueryRule(PublishProcesses, [PublishHelmChartRequest]),
            QueryRule(HelmBinary, []),
        ],
        target_types=[HelmChartTarget],
    )

Exemple #17

def rule_runner() -> RuleRunner:
    return RuleRunner(
        rules=[
            *hadolint_rules(),
            *config_files.rules(),
            *external_tool.rules(),
            *source_files.rules(),
            QueryRule(LintResults, [HadolintRequest]),
        ],
        target_types=[DockerImageTarget],
    )

Exemple #18

Fichier : dependency_inference_test.py Projet : rhysyngsun/pants

def rule_runner() -> RuleRunner:
    return RuleRunner(
        rules=[
            *dependency_inference.rules(),
            *external_tool.rules(),
            QueryRule(ShellMapping, []),
            QueryRule(ParsedShellImports, [ParseShellImportsRequest]),
            QueryRule(InferredDependencies, [InferShellDependencies]),
        ],
        target_types=[ShellLibrary],
    )

Exemple #19

def rule_runner() -> RuleRunner:
    return RuleRunner(
        rules=[
            *shellcheck_rules(),
            *config_files.rules(),
            *external_tool.rules(),
            *source_files.rules(),
            QueryRule(LintResults, [ShellcheckRequest]),
        ],
        target_types=[ShellLibrary],
    )

Exemple #20

Fichier : rules_integration_test.py Projet : codealchemy/pants

def rule_runner() -> RuleRunner:
    return RuleRunner(
        rules=[
            *buf_rules(),
            *config_files.rules(),
            *external_tool.rules(),
            *stripped_source_files.rules(),
            *target_types_rules(),
            QueryRule(LintResults, [BufRequest]),
        ],
        target_types=[ProtobufSourcesGeneratorTarget],
    )

Exemple #21

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

Exemple #22

def rule_runner() -> RuleRunner:
    return RuleRunner(
        rules=[
            *shfmt_rules(),
            *config_files.rules(),
            *external_tool.rules(),
            *source_files.rules(),
            *target_types_rules(),
            QueryRule(FmtResult, [ShfmtRequest]),
            QueryRule(SourceFiles, [SourceFilesRequest]),
        ],
        target_types=[ShellSourcesGeneratorTarget],
    )

Exemple #23

def rule_runner() -> RuleRunner:
    return RuleRunner(
        rules=[
            *buf_rules(),
            *config_files.rules(),
            *external_tool.rules(),
            *source_files.rules(),
            *target_types_rules(),
            QueryRule(FmtResult, [BufFormatRequest]),
            QueryRule(SourceFiles, [SourceFilesRequest]),
        ],
        target_types=[ProtobufSourcesGeneratorTarget],
    )

Exemple #24

Fichier : rules_integration_test.py Projet : rhysyngsun/pants

def rule_runner() -> RuleRunner:
    return RuleRunner(
        target_types=[GoBinary, GoPackage],
        rules=[
            *external_tool.rules(),
            *fmt.rules(),
            *gofmt_rules(),
            *source_files.rules(),
            QueryRule(LintResults, (GofmtRequest, )),
            QueryRule(FmtResult, (GofmtRequest, )),
            QueryRule(SourceFiles, (SourceFilesRequest, )),
        ],
    )

Exemple #25

def rule_runner() -> RuleRunner:
    return RuleRunner(
        target_types=[TerraformModuleTarget],
        rules=[
            *external_tool.rules(),
            *check.rules(),
            *tool.rules(),
            *style.rules(),
            *source_files.rules(),
            QueryRule(CheckResults, (TerraformCheckRequest, )),
            QueryRule(SourceFiles, (SourceFilesRequest, )),
        ],
    )

Exemple #26

def rule_runner() -> RuleRunner:
    return RuleRunner(
        target_types=[TerraformModule],
        rules=[
            *external_tool.rules(),
            *fmt.rules(),
            *validate.rules(),
            *tool.rules(),
            *source_files.rules(),
            QueryRule(LintResults, (ValidateRequest, )),
            QueryRule(SourceFiles, (SourceFilesRequest, )),
        ],
    )

Exemple #27

def rule_runner() -> RuleRunner:
    rule_runner = RuleRunner(
        target_types=[TerraformModule, TerraformModules],
        rules=[
            *external_tool.rules(),
            *source_files.rules(),
            *target_gen.rules(),
            QueryRule(GeneratedTargets,
                      [GenerateTerraformModuleTargetsRequest]),
        ],
    )
    rule_runner.set_options(
        ["--backend-packages=pants.backend.experimental.terraform"])
    return rule_runner

Exemple #28

def rule_runner() -> RuleRunner:
    return RuleRunner(
        target_types=[],
        rules=[
            *config_files.rules(),
            *external_tool.rules(),
            *tool.rules(),
            *process.rules(),
            QueryRule(HelmBinary, ()),
            QueryRule(HelmSubsystem, ()),
            QueryRule(Process, (HelmProcess, )),
            QueryRule(ProcessResult, (HelmProcess, )),
        ],
    )

Exemple #29

def rule_runner() -> RuleRunner:
    return RuleRunner(
        target_types=[HelmChartTarget, HelmUnitTestTestTarget],
        rules=[
            *external_tool.rules(),
            *tool.rules(),
            *chart.rules(),
            *test_rules(),
            *stripped_source_files.rules(),
            *source_root_rules(),
            *target_types_rules(),
            QueryRule(TestResult, (HelmUnitTestFieldSet,)),
        ],
    )

Exemple #30

Fichier : repl_integration_test.py Projet : Spacerat/pants

 def rules(cls):
     return (
         *super().rules(),
         *repl_rules(),
         *python_repl.rules(),
         *pex.rules(),
         *archive.rules(),
         *external_tool.rules(),
         *python_sources.rules(),
         *pex_from_targets.rules(),
         *strip_source_roots.rules(),
         *ancestor_files.rules(),
         RootRule(PythonRepl),
     )