In Pants, achieving your goals involves understanding how Pants handles goal dependencies and concurrency. Let’s break down your two objectives and explore how to achieve them:

1. Running a check even if there are lint failures

To run check even if lint fails, you need to separate their execution so that a failure in lint doesn’t block check. By default, goals in Pants halt execution when a failure occurs unless explicitly configured otherwise. Here’s how you can handle this:

• Sequential Runs (Independent):

Run the goals independently by invoking them in separate commands:

pants lint && pants check

or even:

pants lint; pants check

• Using the --keep-going Option:

If you want to run them together in a single Pants invocation, you can use the --keep-going option. This flag allows Pants to continue running other goals even if one fails:

pants --keep-going lint check

2. Running check in parallel to lint

To make check and lint run in parallel, you’ll need to leverage the underlying concurrency of Pants, as goals typically run sequentially unless explicitly configured otherwise.

Custom Goal Rule with MultiGet

Creating a custom goal rule is indeed a flexible and powerful solution for this. Here’s how you might define a lintcheck goal that runs lint and check in parallel:

1. Define the Custom Goal Rule:

from pants.engine.rules import goal_rule, MultiGet

from pants.engine.unions import UnionRule

from pants.backend.lint.lint_rules import Lint

from pants.backend.check.check_rules import Check

@goal_rule

async def lintcheck(console, workspace):

lint_result, check_result = await MultiGet(Get(Lint, LintRequest()), Get(Check, CheckRequest()))

console.print_stdout(f"Lint result: {lint_result}")

console.print_stdout(f"Check result: {check_result}")

return ExitCode(0 if lint_result.exit_code == 0 and check_result.exit_code == 0 else 1)

2. Register the Goal:

Add the lintcheck goal in your register.py file:

def rules():

return [

lintcheck,

UnionRule(Goal, Lint),

UnionRule(Goal, Check),

]

With this approach, both lint and check will run concurrently.

Alternative Approach: Use a Plugin

If you want to avoid writing your custom rule but still desire parallelism and independent execution, you can explore whether a plugin or community extension exists to streamline this workflow.

Summary

• To run check despite lint failures: use --keep-going or separate invocations.

• To run them in parallel: define a custom goal using MultiGet, or manage the concurrency within your script/workflow.

Would you like help setting up the custom rule or exploring other optimizations?

keep-going