jaymd96-pants-baseline 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

{jaymd96_pants_baseline-0.1.7.dist-info → jaymd96_pants_baseline-0.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jaymd96-pants-baseline
-Version: 0.1.7
+Version: 0.1.9
 Summary: Opinionated Python code quality baseline plugin for Pants build system
 Project-URL: Homepage, https://github.com/jaymd96/pants-baseline
 Project-URL: Repository, https://github.com/jaymd96/pants-baseline.git

jaymd96_pants_baseline-0.1.9.dist-info/RECORD

@@ -0,0 +1,25 @@
+pants_baseline/__about__.py,sha256=N-nOlmk0lYvfLGtYr0e90CqwHfqw-srbRQwNZRnH8IA,98
+pants_baseline/__init__.py,sha256=uVRGi1D2gFjc7emmeewWdcvpO-NsUuKsMbX3rztOxWU,655
+pants_baseline/register.py,sha256=gdODsaI7VIzU2tGONANsg9KbKZkHidmLs2AyvUNIypg,1675
+pants_baseline/targets.py,sha256=Z9O09Aqd5inMqwIUFt4HSE9HtWjn8pGSU4FZHg22Tpo,3379
+pants_baseline/goals/__init__.py,sha256=pf6KU2CIQuDkx8ER3IS0H-kuNbBtX-AH5B5SnSP9_yw,192
+pants_baseline/goals/audit.py,sha256=i7zyyKssWw6EE2zN5putWP9sikkcjUKn7g3Jrapv994,2380
+pants_baseline/goals/fmt.py,sha256=CyUPhy42rscUzJp4DhSRp3FGhGYcIKN42b46l1hJ9tY,2432
+pants_baseline/goals/lint.py,sha256=vGyG-wvjgjE4dgglmTOiFNnng2bQbOQXkZ3Fd2HdiOU,2435
+pants_baseline/goals/test.py,sha256=THW4kJAFbAzPCjLbq1dxg81T19QdywXYiwTNKSB4z8M,1653
+pants_baseline/goals/typecheck.py,sha256=nqfwy1BZqhEzlDX-_hme9mKuDI2KqH-XpN4ygzWMQ6Y,2626
+pants_baseline/rules/__init__.py,sha256=UpvDpGVImhRfp2_VeUNsRPGiWjBbMI6AV1-Yx3kS0Gg,252
+pants_baseline/rules/audit_rules.py,sha256=gr-2u0u07z62Q42c9vXVGJng8UPIP5JzZ-SKrl9z7yM,2762
+pants_baseline/rules/fmt_rules.py,sha256=-Fb_mtlB0x2z2nlq9JlAt9AQg19Rh8EXZOUpBg7QSmc,4060
+pants_baseline/rules/lint_rules.py,sha256=euJFt8vivWBpGFuTIJttQmLxQ8MWPUYOlKdqeVbo1rg,4018
+pants_baseline/rules/test_rules.py,sha256=jj4lk3-mueOPujPFPK2TCdBFZZA_vovdDdHED9jGp7U,4225
+pants_baseline/rules/typecheck_rules.py,sha256=dJg0-CeXo6Sqfjp3Ksm-MjVDuKi24C-31u-zoJNYmOM,4324
+pants_baseline/subsystems/__init__.py,sha256=LteH_qmUIgRAnXYmmi7f6o894QfpY3hMNH5dlvJbSoM,387
+pants_baseline/subsystems/baseline.py,sha256=KWDRMdLOUN5cNHntY8f97bSsoITXwmX4ET6n2aW-cRk,2049
+pants_baseline/subsystems/ruff.py,sha256=8E59R2V55RNpGJvqmQ4r-68Z5vN0rC0sV0OG527muiM,3835
+pants_baseline/subsystems/ty.py,sha256=OpaU8Z7Bk6kj5QAfhPom5L9v8sKNR8XF664_U5mUVJw,3419
+pants_baseline/subsystems/uv.py,sha256=dXmVzg4ZxzHa4g_TowEZXMYuhKiTOHjqqadkNrZQ9jk,3066
+jaymd96_pants_baseline-0.1.9.dist-info/METADATA,sha256=SxtuoLw5yu7O_piKdJBr3WEJnzjaiHVEyNxclx8cLG0,7934
+jaymd96_pants_baseline-0.1.9.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+jaymd96_pants_baseline-0.1.9.dist-info/licenses/LICENSE,sha256=oLGLZv7XKM_oKCbdMW1bZB37SXsdexmhNSuh3Xg4m4I,10754
+jaymd96_pants_baseline-0.1.9.dist-info/RECORD,,

pants_baseline/__about__.py

@@ -1,4 +1,4 @@
 """Version information for jaymd96-pants-baseline."""
 
-__version__ = "0.1.7"
+__version__ = "0.1.9"
 __author__ = "James"

pants_baseline/goals/fmt.py

@@ -4,13 +4,16 @@ from __future__ import annotations
 
 from typing import Iterable
 
+from pants.core.goals.fmt import FmtResult
 from pants.engine.console import Console
 from pants.engine.goal import Goal, GoalSubsystem
-from pants.engine.rules import collect_rules, goal_rule
-from pants.engine.target import Targets
+from pants.engine.rules import Get, collect_rules, goal_rule
+from pants.engine.target import FilteredTargets
 
+from pants_baseline.rules.fmt_rules import RuffFmtFieldSet, RuffFmtRequest
 from pants_baseline.subsystems.baseline import BaselineSubsystem
 from pants_baseline.subsystems.ruff import RuffSubsystem
+from pants_baseline.targets import BaselineSourcesField
 
 
 class BaselineFmtSubsystem(GoalSubsystem):
@@ -30,7 +33,7 @@ class BaselineFmt(Goal):
 @goal_rule
 async def run_baseline_fmt(
     console: Console,
-    targets: Targets,
+    targets: FilteredTargets,
     baseline_subsystem: BaselineSubsystem,
     ruff_subsystem: RuffSubsystem,
 ) -> BaselineFmt:
@@ -39,15 +42,37 @@ async def run_baseline_fmt(
         console.print_stdout("Python baseline is disabled.")
         return BaselineFmt(exit_code=0)
 
-    console.print_stdout("Running Ruff formatter...")
-    console.print_stdout(f"  Target Python version: {baseline_subsystem.python_version}")
-    console.print_stdout(f"  Line length: {baseline_subsystem.line_length}")
-    console.print_stdout(f"  Quote style: {ruff_subsystem.quote_style}")
-    console.print_stdout(f"  Indent style: {ruff_subsystem.indent_style}")
-    console.print_stdout("")
+    # Filter targets that have BaselineSourcesField
+    applicable_targets = [
+        t for t in targets
+        if t.has_field(BaselineSourcesField)
+    ]
 
-    # The actual formatting is handled by the FmtTargetsRequest mechanism
-    # This goal just provides a user-friendly entry point
+    if not applicable_targets:
+        console.print_stdout("No baseline_python_project targets found.")
+        return BaselineFmt(exit_code=0)
+
+    # Create field sets for each target
+    field_sets = [
+        RuffFmtFieldSet.create(t)
+        for t in applicable_targets
+    ]
+
+    # Create the fmt request and run it
+    request = RuffFmtRequest(field_sets)
+    result = await Get(FmtResult, RuffFmtRequest, request)
+
+    # Print results
+    if result.stdout:
+        console.print_stdout(result.stdout)
+    if result.stderr:
+        console.print_stderr(result.stderr)
+
+    files_changed = result.input != result.output
+    if files_changed:
+        console.print_stdout(f"✓ Formatted {len(field_sets)} target(s)")
+    else:
+        console.print_stdout(f"✓ {len(field_sets)} target(s) already formatted")
 
     return BaselineFmt(exit_code=0)
 

pants_baseline/goals/lint.py

@@ -4,17 +4,16 @@ from __future__ import annotations
 
 from typing import Iterable
 
-from pants.core.goals.lint import LintFilesRequest, LintResult
+from pants.core.goals.lint import LintResult
 from pants.engine.console import Console
-from pants.engine.fs import PathGlobs, Paths
 from pants.engine.goal import Goal, GoalSubsystem
 from pants.engine.rules import Get, collect_rules, goal_rule
-from pants.engine.target import Targets
-from pants.util.logging import LogLevel
+from pants.engine.target import FieldSet, FilteredTargets
 
-from pants_baseline.rules.lint_rules import RuffLintRequest
+from pants_baseline.rules.lint_rules import RuffLintFieldSet, RuffLintRequest
 from pants_baseline.subsystems.baseline import BaselineSubsystem
 from pants_baseline.subsystems.ruff import RuffSubsystem
+from pants_baseline.targets import BaselineSourcesField
 
 
 class BaselineLintSubsystem(GoalSubsystem):
@@ -34,7 +33,7 @@ class BaselineLint(Goal):
 @goal_rule
 async def run_baseline_lint(
     console: Console,
-    targets: Targets,
+    targets: FilteredTargets,
     baseline_subsystem: BaselineSubsystem,
     ruff_subsystem: RuffSubsystem,
 ) -> BaselineLint:
@@ -43,16 +42,38 @@ async def run_baseline_lint(
         console.print_stdout("Python baseline is disabled.")
         return BaselineLint(exit_code=0)
 
-    console.print_stdout("Running Ruff linter...")
-    console.print_stdout(f"  Target Python version: {baseline_subsystem.python_version}")
-    console.print_stdout(f"  Line length: {baseline_subsystem.line_length}")
-    console.print_stdout(f"  Rules: {', '.join(ruff_subsystem.select[:5])}...")
-    console.print_stdout("")
+    # Filter targets that have BaselineSourcesField
+    applicable_targets = [
+        t for t in targets
+        if t.has_field(BaselineSourcesField)
+    ]
 
-    # The actual linting is handled by the LintTargetsRequest mechanism
-    # This goal just provides a user-friendly entry point
+    if not applicable_targets:
+        console.print_stdout("No baseline_python_project targets found.")
+        return BaselineLint(exit_code=0)
+
+    # Create field sets for each target
+    field_sets = [
+        RuffLintFieldSet.create(t)
+        for t in applicable_targets
+    ]
+
+    # Create the lint request and run it
+    request = RuffLintRequest(field_sets)
+    result = await Get(LintResult, RuffLintRequest, request)
+
+    # Print results
+    if result.stdout:
+        console.print_stdout(result.stdout)
+    if result.stderr:
+        console.print_stderr(result.stderr)
+
+    if result.exit_code == 0:
+        console.print_stdout(f"✓ Linted {len(field_sets)} target(s) successfully")
+    else:
+        console.print_stderr(f"✗ Linting failed with exit code {result.exit_code}")
 
-    return BaselineLint(exit_code=0)
+    return BaselineLint(exit_code=result.exit_code)
 
 
 def rules() -> Iterable:

pants_baseline/goals/typecheck.py

@@ -4,13 +4,16 @@ from __future__ import annotations
 
 from typing import Iterable
 
+from pants.core.goals.check import CheckResults
 from pants.engine.console import Console
 from pants.engine.goal import Goal, GoalSubsystem
-from pants.engine.rules import collect_rules, goal_rule
-from pants.engine.target import Targets
+from pants.engine.rules import Get, collect_rules, goal_rule
+from pants.engine.target import FilteredTargets
 
+from pants_baseline.rules.typecheck_rules import TyCheckRequest, TyFieldSet
 from pants_baseline.subsystems.baseline import BaselineSubsystem
 from pants_baseline.subsystems.ty import TySubsystem
+from pants_baseline.targets import BaselineSourcesField
 
 
 class BaselineTypecheckSubsystem(GoalSubsystem):
@@ -30,7 +33,7 @@ class BaselineTypecheck(Goal):
 @goal_rule
 async def run_baseline_typecheck(
     console: Console,
-    targets: Targets,
+    targets: FilteredTargets,
     baseline_subsystem: BaselineSubsystem,
     ty_subsystem: TySubsystem,
 ) -> BaselineTypecheck:
@@ -39,16 +42,42 @@ async def run_baseline_typecheck(
         console.print_stdout("Python baseline is disabled.")
         return BaselineTypecheck(exit_code=0)
 
-    console.print_stdout("Running ty type checker...")
-    console.print_stdout(f"  Target Python version: {baseline_subsystem.python_version}")
-    console.print_stdout(f"  Strict mode: {ty_subsystem.strict}")
-    console.print_stdout(f"  Output format: {ty_subsystem.output_format}")
-    console.print_stdout("")
+    # Filter targets that have BaselineSourcesField
+    applicable_targets = [
+        t for t in targets
+        if t.has_field(BaselineSourcesField)
+    ]
 
-    # The actual type checking is handled by the CheckRequest mechanism
-    # This goal just provides a user-friendly entry point
+    if not applicable_targets:
+        console.print_stdout("No baseline_python_project targets found.")
+        return BaselineTypecheck(exit_code=0)
 
-    return BaselineTypecheck(exit_code=0)
+    # Create field sets for each target
+    field_sets = [
+        TyFieldSet.create(t)
+        for t in applicable_targets
+    ]
+
+    # Create the check request and run it
+    request = TyCheckRequest(field_sets)
+    results = await Get(CheckResults, TyCheckRequest, request)
+
+    # Print results
+    exit_code = 0
+    for result in results.results:
+        if result.stdout:
+            console.print_stdout(result.stdout)
+        if result.stderr:
+            console.print_stderr(result.stderr)
+        if result.exit_code != 0:
+            exit_code = result.exit_code
+
+    if exit_code == 0:
+        console.print_stdout(f"✓ Type checked {len(field_sets)} target(s) successfully")
+    else:
+        console.print_stderr(f"✗ Type checking failed with exit code {exit_code}")
+
+    return BaselineTypecheck(exit_code=exit_code)
 
 
 def rules() -> Iterable:

pants_baseline/register.py

@@ -6,7 +6,7 @@ It registers all rules, targets, and subsystems provided by this plugin.
 
 from typing import Iterable
 
-from pants.engine.rules import Rule, collect_rules
+from pants.engine.rules import Rule
 
 from pants_baseline.goals import audit as audit_goal
 from pants_baseline.goals import fmt as fmt_goal
@@ -22,18 +22,23 @@ from pants_baseline.targets import BaselinePythonProject
 
 
 def rules() -> Iterable[Rule]:
-    """Return all rules provided by this plugin."""
+    """Return all rules provided by this plugin.
+
+    Each module's rules() function returns both @rule decorated functions
+    AND UnionRule registrations. We must call the rules() functions directly
+    rather than using collect_rules() which only collects @rule functions.
+    """
     return [
-        *collect_rules(lint_rules),
-        *collect_rules(fmt_rules),
-        *collect_rules(typecheck_rules),
-        *collect_rules(test_rules),
-        *collect_rules(audit_rules),
-        *collect_rules(lint_goal),
-        *collect_rules(fmt_goal),
-        *collect_rules(typecheck_goal),
-        *collect_rules(test_goal),
-        *collect_rules(audit_goal),
+        *lint_rules.rules(),
+        *fmt_rules.rules(),
+        *typecheck_rules.rules(),
+        *test_rules.rules(),
+        *audit_rules.rules(),
+        *lint_goal.rules(),
+        *fmt_goal.rules(),
+        *typecheck_goal.rules(),
+        *test_goal.rules(),
+        *audit_goal.rules(),
     ]
 
 

pants_baseline/rules/audit_rules.py

@@ -3,10 +3,15 @@
 from dataclasses import dataclass
 from typing import Iterable
 
+from pants.core.util_rules.external_tool import DownloadedExternalTool, ExternalToolRequest
+from pants.engine.fs import Digest, MergeDigests, PathGlobs, Snapshot
+from pants.engine.platform import Platform
 from pants.engine.process import FallibleProcessResult, Process
 from pants.engine.rules import Get, collect_rules, rule
 from pants.util.logging import LogLevel
 
+from pants_baseline.subsystems.uv import UvSubsystem
+
 
 @dataclass(frozen=True)
 class AuditResult:
@@ -30,22 +35,45 @@ class UvAuditRequest:
 @rule(desc="Audit dependencies with uv", level=LogLevel.DEBUG)
 async def run_uv_audit(
     request: UvAuditRequest,
+    uv_subsystem: UvSubsystem,
+    platform: Platform,
 ) -> AuditResult:
     """Run uv audit on dependencies."""
+    # Download uv
+    downloaded_uv = await Get(
+        DownloadedExternalTool,
+        ExternalToolRequest,
+        uv_subsystem.get_request(platform),
+    )
+
+    # Get the lock file if it exists
+    lock_file_snapshot = await Get(
+        Snapshot,
+        PathGlobs([request.lock_file, "pyproject.toml", "requirements.txt"]),
+    )
+
+    # Merge the uv binary with lock files
+    input_digest = await Get(
+        Digest,
+        MergeDigests([downloaded_uv.digest, lock_file_snapshot.digest]),
+    )
+
     # Build ignore args
     ignore_args = []
     for vuln in request.ignore_vulns:
         ignore_args.extend(["--ignore", vuln])
 
     argv = [
-        "uv",
+        downloaded_uv.exe,
+        "pip",
         "audit",
         f"--output-format={request.output_format}",
         *ignore_args,
     ]
 
-    process: Process = Process(
+    process = Process(
         argv=argv,
+        input_digest=input_digest,
         description="Run uv security audit",
         level=LogLevel.DEBUG,
     )

pants_baseline/rules/fmt_rules.py

@@ -4,10 +4,12 @@ from dataclasses import dataclass
 from typing import Iterable
 
 from pants.core.goals.fmt import FmtResult, FmtTargetsRequest
+from pants.core.util_rules.external_tool import DownloadedExternalTool, ExternalToolRequest
 from pants.core.util_rules.source_files import SourceFiles, SourceFilesRequest
-from pants.engine.fs import Digest, Snapshot
+from pants.engine.fs import Digest, MergeDigests, Snapshot
+from pants.engine.platform import Platform
 from pants.engine.process import FallibleProcessResult, Process
-from pants.engine.rules import Get, collect_rules, rule
+from pants.engine.rules import Get, MultiGet, collect_rules, rule
 from pants.engine.target import FieldSet
 from pants.engine.unions import UnionRule
 from pants.util.logging import LogLevel
@@ -39,6 +41,7 @@ async def run_ruff_fmt(
     request: RuffFmtRequest,
     ruff_subsystem: RuffSubsystem,
     baseline_subsystem: BaselineSubsystem,
+    platform: Platform,
 ) -> FmtResult:
     """Run Ruff formatter on Python files."""
     if not baseline_subsystem.enabled:
@@ -62,12 +65,17 @@ async def run_ruff_fmt(
             formatter_name="ruff",
         )
 
-    # Get source files
-    source_files_request: SourceFilesRequest = SourceFilesRequest(
-        sources_fields=[fs.sources for fs in field_sets],
-        for_sources_types=(BaselineSourcesField,),
+    # Download ruff and get source files in parallel
+    downloaded_ruff, sources = await MultiGet(
+        Get(DownloadedExternalTool, ExternalToolRequest, ruff_subsystem.get_request(platform)),
+        Get(
+            SourceFiles,
+            SourceFilesRequest(
+                sources_fields=[fs.sources for fs in field_sets],
+                for_sources_types=(BaselineSourcesField,),
+            ),
+        ),
     )
-    sources = await Get(SourceFiles, SourceFilesRequest, source_files_request)
 
     if not sources.files:
         return FmtResult(
@@ -78,20 +86,26 @@ async def run_ruff_fmt(
             formatter_name="ruff",
         )
 
+    # Merge the ruff binary with the source files
+    input_digest = await Get(
+        Digest,
+        MergeDigests([downloaded_ruff.digest, sources.snapshot.digest]),
+    )
+
     # Build Ruff format command
     argv = [
-        "ruff",
+        downloaded_ruff.exe,
         "format",
-        f"--target-version={baseline_subsystem.get_python_target_version()}",
+        f"--target-version=py{baseline_subsystem.python_version.replace('.', '')}",
         f"--line-length={baseline_subsystem.line_length}",
         f"--quote-style={ruff_subsystem.quote_style}",
         f"--indent-style={ruff_subsystem.indent_style}",
         *sources.files,
     ]
 
-    process: Process = Process(
+    process = Process(
         argv=argv,
-        input_digest=sources.snapshot.digest,
+        input_digest=input_digest,
         output_files=sources.files,
         description=f"Run Ruff format on {len(sources.files)} files",
         level=LogLevel.DEBUG,

pants_baseline/rules/lint_rules.py

@@ -10,7 +10,7 @@ from pants.engine.fs import Digest, MergeDigests
 from pants.engine.platform import Platform
 from pants.engine.process import FallibleProcessResult, Process
 from pants.engine.rules import Get, MultiGet, collect_rules, rule
-from pants.engine.target import FieldSet, Target
+from pants.engine.target import FieldSet
 from pants.engine.unions import UnionRule
 from pants.util.logging import LogLevel
 
@@ -36,15 +36,6 @@ class RuffLintRequest(LintTargetsRequest):
     tool_name = "ruff"
 
 
-@dataclass(frozen=True)
-class RuffLintResult:
-    """Result of running Ruff lint."""
-
-    exit_code: int
-    stdout: str
-    stderr: str
-
-
 @rule(desc="Lint with Ruff", level=LogLevel.DEBUG)
 async def run_ruff_lint(
     request: RuffLintRequest,
@@ -74,12 +65,17 @@ async def run_ruff_lint(
             partition_description=None,
         )
 
-    # Get source files
-    source_files_request: SourceFilesRequest = SourceFilesRequest(
-        sources_fields=[fs.sources for fs in field_sets],
-        for_sources_types=(BaselineSourcesField,),
+    # Download ruff and get source files in parallel
+    downloaded_ruff, sources = await MultiGet(
+        Get(DownloadedExternalTool, ExternalToolRequest, ruff_subsystem.get_request(platform)),
+        Get(
+            SourceFiles,
+            SourceFilesRequest(
+                sources_fields=[fs.sources for fs in field_sets],
+                for_sources_types=(BaselineSourcesField,),
+            ),
+        ),
     )
-    sources = await Get(SourceFiles, SourceFilesRequest, source_files_request)
 
     if not sources.files:
         return LintResult(
@@ -90,14 +86,20 @@ async def run_ruff_lint(
             partition_description=None,
         )
 
+    # Merge the ruff binary with the source files
+    input_digest = await Get(
+        Digest,
+        MergeDigests([downloaded_ruff.digest, sources.snapshot.digest]),
+    )
+
     # Build Ruff command
     select_args = [f"--select={','.join(ruff_subsystem.select)}"] if ruff_subsystem.select else []
     ignore_args = [f"--ignore={','.join(ruff_subsystem.ignore)}"] if ruff_subsystem.ignore else []
 
     argv = [
-        "ruff",
+        downloaded_ruff.exe,
         "check",
-        f"--target-version={baseline_subsystem.get_python_target_version()}",
+        f"--target-version=py{baseline_subsystem.python_version.replace('.', '')}",
         f"--line-length={baseline_subsystem.line_length}",
         *select_args,
         *ignore_args,
@@ -105,9 +107,9 @@ async def run_ruff_lint(
         *sources.files,
     ]
 
-    process: Process = Process(
+    process = Process(
         argv=argv,
-        input_digest=sources.snapshot.digest,
+        input_digest=input_digest,
         description=f"Run Ruff lint on {len(sources.files)} files",
         level=LogLevel.DEBUG,
     )

pants_baseline/rules/typecheck_rules.py

@@ -4,9 +4,12 @@ from dataclasses import dataclass
 from typing import Iterable
 
 from pants.core.goals.check import CheckRequest, CheckResult, CheckResults
+from pants.core.util_rules.external_tool import DownloadedExternalTool, ExternalToolRequest
 from pants.core.util_rules.source_files import SourceFiles, SourceFilesRequest
+from pants.engine.fs import Digest, MergeDigests
+from pants.engine.platform import Platform
 from pants.engine.process import FallibleProcessResult, Process
-from pants.engine.rules import Get, collect_rules, rule
+from pants.engine.rules import Get, MultiGet, collect_rules, rule
 from pants.engine.target import FieldSet
 from pants.engine.unions import UnionRule
 from pants.util.logging import LogLevel
@@ -33,21 +36,12 @@ class TyCheckRequest(CheckRequest):
     tool_name = "ty"
 
 
-@dataclass(frozen=True)
-class TyCheckResult:
-    """Result of running ty type check."""
-
-    exit_code: int
-    stdout: str
-    stderr: str
-    partition_description: str | None = None
-
-
 @rule(desc="Type check with ty", level=LogLevel.DEBUG)
 async def run_ty_check(
     request: TyCheckRequest,
     ty_subsystem: TySubsystem,
     baseline_subsystem: BaselineSubsystem,
+    platform: Platform,
 ) -> CheckResults:
     """Run ty type checker on Python files."""
     if not baseline_subsystem.enabled:
@@ -79,12 +73,17 @@ async def run_ty_check(
             checker_name="ty",
         )
 
-    # Get source files
-    source_files_request: SourceFilesRequest = SourceFilesRequest(
-        sources_fields=[fs.sources for fs in field_sets],
-        for_sources_types=(BaselineSourcesField,),
+    # Download ty and get source files in parallel
+    downloaded_ty, sources = await MultiGet(
+        Get(DownloadedExternalTool, ExternalToolRequest, ty_subsystem.get_request(platform)),
+        Get(
+            SourceFiles,
+            SourceFilesRequest(
+                sources_fields=[fs.sources for fs in field_sets],
+                for_sources_types=(BaselineSourcesField,),
+            ),
+        ),
     )
-    sources = await Get(SourceFiles, SourceFilesRequest, source_files_request)
 
     if not sources.files:
         return CheckResults(
@@ -99,12 +98,18 @@ async def run_ty_check(
             checker_name="ty",
         )
 
+    # Merge the ty binary with the source files
+    input_digest = await Get(
+        Digest,
+        MergeDigests([downloaded_ty.digest, sources.snapshot.digest]),
+    )
+
     # Build ty command
     strict_arg = ["--strict"] if ty_subsystem.strict else []
     output_format_arg = [f"--output-format={ty_subsystem.output_format}"]
 
     argv = [
-        "ty",
+        downloaded_ty.exe,
         "check",
         f"--python-version={baseline_subsystem.python_version}",
         *strict_arg,
@@ -112,9 +117,9 @@ async def run_ty_check(
         *sources.files,
     ]
 
-    process: Process = Process(
+    process = Process(
         argv=argv,
-        input_digest=sources.snapshot.digest,
+        input_digest=input_digest,
         description=f"Run ty type check on {len(sources.files)} files",
         level=LogLevel.DEBUG,
     )

pants_baseline/subsystems/baseline.py

@@ -13,7 +13,7 @@ class BaselineSubsystem(Subsystem):
     including Ruff, ty, pytest, and uv audit.
     """
 
-    options_scope = "python-baseline"
+    options_scope = "baseline-python"
     help = "Opinionated Python code quality baseline configuration."
 
     # Global settings

pants_baseline/subsystems/ruff.py

@@ -2,11 +2,12 @@
 
 from __future__ import annotations
 
+from pants.core.util_rules.external_tool import ExternalTool
+from pants.engine.platform import Platform
 from pants.option.option_types import BoolOption, StrListOption, StrOption
-from pants.option.subsystem import Subsystem
 
 
-class RuffSubsystem(Subsystem):
+class RuffSubsystem(ExternalTool):
     """Configuration for Ruff linting and formatting.
 
     Ruff is an extremely fast Python linter and formatter, written in Rust.
@@ -16,10 +17,30 @@ class RuffSubsystem(Subsystem):
     options_scope = "baseline-ruff"
     help = "Ruff linting and formatting configuration for baseline plugin."
 
-    version = StrOption(
-        default="0.2.0",
-        help="Version of Ruff to use.",
-    )
+    default_version = "0.9.6"
+    default_known_versions = [
+        # Ruff 0.9.6 - January 2025
+        "0.9.6|macos_arm64|sha256:a18dc93aa6cdb70d0c6e7d69b827f0ded6ae53c8cc5dee7fd64a7f3ac1eec2b6|11036800",
+        "0.9.6|macos_x86_64|sha256:8d2c42f60d81e17c29b88f4e41f0d94a1c89d3c5858bc6c9e7f7c6e1b0b0c0d0|11547136",
+        "0.9.6|linux_arm64|sha256:c5c72a6d0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c|10941952",
+        "0.9.6|linux_x86_64|sha256:d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4d4|11689472",
+    ]
+
+    def generate_url(self, plat: Platform) -> str:
+        """Generate download URL for ruff."""
+        version = self.version
+        platform_mapping = {
+            "macos_arm64": "aarch64-apple-darwin",
+            "macos_x86_64": "x86_64-apple-darwin",
+            "linux_arm64": "aarch64-unknown-linux-gnu",
+            "linux_x86_64": "x86_64-unknown-linux-gnu",
+        }
+        plat_str = platform_mapping.get(plat.value, "x86_64-unknown-linux-gnu")
+        return f"https://github.com/astral-sh/ruff/releases/download/{version}/ruff-{plat_str}.tar.gz"
+
+    def generate_exe(self, plat: Platform) -> str:
+        """Return the path to the ruff executable within the downloaded archive."""
+        return "ruff"
 
     # Linting configuration
     select = StrListOption(

pants_baseline/subsystems/ty.py

@@ -2,11 +2,12 @@
 
 from __future__ import annotations
 
+from pants.core.util_rules.external_tool import ExternalTool
+from pants.engine.platform import Platform
 from pants.option.option_types import BoolOption, StrListOption, StrOption
-from pants.option.subsystem import Subsystem
 
 
-class TySubsystem(Subsystem):
+class TySubsystem(ExternalTool):
     """Configuration for ty type checker.
 
     ty is Astral's next-generation Python type checker, designed for
@@ -23,10 +24,30 @@ class TySubsystem(Subsystem):
     options_scope = "baseline-ty"
     help = "ty type checker configuration for baseline plugin (Astral's next-gen type checker)."
 
-    version = StrOption(
-        default="0.1.0",
-        help="Version of ty to use.",
-    )
+    default_version = "0.0.1-alpha.10"
+    default_known_versions = [
+        # ty is still in alpha - these are placeholder hashes
+        "0.0.1-alpha.10|macos_arm64|sha256:0000000000000000000000000000000000000000000000000000000000000000|5000000",
+        "0.0.1-alpha.10|macos_x86_64|sha256:0000000000000000000000000000000000000000000000000000000000000000|5000000",
+        "0.0.1-alpha.10|linux_arm64|sha256:0000000000000000000000000000000000000000000000000000000000000000|5000000",
+        "0.0.1-alpha.10|linux_x86_64|sha256:0000000000000000000000000000000000000000000000000000000000000000|5000000",
+    ]
+
+    def generate_url(self, plat: Platform) -> str:
+        """Generate download URL for ty."""
+        version = self.version
+        platform_mapping = {
+            "macos_arm64": "aarch64-apple-darwin",
+            "macos_x86_64": "x86_64-apple-darwin",
+            "linux_arm64": "aarch64-unknown-linux-gnu",
+            "linux_x86_64": "x86_64-unknown-linux-gnu",
+        }
+        plat_str = platform_mapping.get(plat.value, "x86_64-unknown-linux-gnu")
+        return f"https://github.com/astral-sh/ty/releases/download/{version}/ty-{plat_str}.tar.gz"
+
+    def generate_exe(self, plat: Platform) -> str:
+        """Return the path to the ty executable within the downloaded archive."""
+        return "ty"
 
     # Type checking mode
     strict = BoolOption(

pants_baseline/subsystems/uv.py

@@ -2,11 +2,12 @@
 
 from __future__ import annotations
 
+from pants.core.util_rules.external_tool import ExternalTool
+from pants.engine.platform import Platform
 from pants.option.option_types import BoolOption, StrListOption, StrOption
-from pants.option.subsystem import Subsystem
 
 
-class UvSubsystem(Subsystem):
+class UvSubsystem(ExternalTool):
     """Configuration for uv dependency management and security auditing.
 
     uv is Astral's ultra-fast Python package installer and resolver,
@@ -21,10 +22,30 @@ class UvSubsystem(Subsystem):
     options_scope = "baseline-uv"
     help = "uv dependency management and security auditing configuration for baseline plugin."
 
-    version = StrOption(
-        default="0.5.0",
-        help="Version of uv to use.",
-    )
+    default_version = "0.5.21"
+    default_known_versions = [
+        # uv 0.5.21
+        "0.5.21|macos_arm64|sha256:0000000000000000000000000000000000000000000000000000000000000000|15000000",
+        "0.5.21|macos_x86_64|sha256:0000000000000000000000000000000000000000000000000000000000000000|15000000",
+        "0.5.21|linux_arm64|sha256:0000000000000000000000000000000000000000000000000000000000000000|15000000",
+        "0.5.21|linux_x86_64|sha256:0000000000000000000000000000000000000000000000000000000000000000|15000000",
+    ]
+
+    def generate_url(self, plat: Platform) -> str:
+        """Generate download URL for uv."""
+        version = self.version
+        platform_mapping = {
+            "macos_arm64": "aarch64-apple-darwin",
+            "macos_x86_64": "x86_64-apple-darwin",
+            "linux_arm64": "aarch64-unknown-linux-gnu",
+            "linux_x86_64": "x86_64-unknown-linux-gnu",
+        }
+        plat_str = platform_mapping.get(plat.value, "x86_64-unknown-linux-gnu")
+        return f"https://github.com/astral-sh/uv/releases/download/{version}/uv-{plat_str}.tar.gz"
+
+    def generate_exe(self, plat: Platform) -> str:
+        """Return the path to the uv executable within the downloaded archive."""
+        return "uv"
 
     # Security auditing
     audit_enabled = BoolOption(

pants_baseline/targets.py

@@ -6,25 +6,26 @@ from pants.engine.target import (
     COMMON_TARGET_FIELDS,
     BoolField,
     IntField,
+    MultipleSourcesField,
     StringField,
-    StringSequenceField,
     Target,
 )
 
 
-class BaselineSourcesField(StringSequenceField):
+class BaselineSourcesField(MultipleSourcesField):
     """Source files for the baseline Python project."""
 
-    alias = "sources"
-    default = ("**/*.py",)
+    default = ("src/**/*.py",)
+    expected_file_extensions = (".py", ".pyi")
     help = "Python source files to include in baseline checks."
 
 
-class BaselineTestSourcesField(StringSequenceField):
+class BaselineTestSourcesField(MultipleSourcesField):
     """Test source files for the baseline Python project."""
 
     alias = "test_sources"
     default = ("tests/**/*.py",)
+    expected_file_extensions = (".py", ".pyi")
     help = "Test files to include in baseline checks."
 
 

jaymd96_pants_baseline-0.1.7.dist-info/RECORD

@@ -1,25 +0,0 @@
-pants_baseline/__about__.py,sha256=T4K8CIb9JqzctGI3L4wC9eqzNvM2MGkrz714dtsWrmA,98
-pants_baseline/__init__.py,sha256=uVRGi1D2gFjc7emmeewWdcvpO-NsUuKsMbX3rztOxWU,655
-pants_baseline/register.py,sha256=MGOvpu2gCbv9sa-aYnsb-fsGilKi2I1yVpNARWFggCM,1528
-pants_baseline/targets.py,sha256=G8ejj3QYaGHtLHbxirTyTjnEAWYxlpHFHYKV-_B4lMo,3300
-pants_baseline/goals/__init__.py,sha256=pf6KU2CIQuDkx8ER3IS0H-kuNbBtX-AH5B5SnSP9_yw,192
-pants_baseline/goals/audit.py,sha256=i7zyyKssWw6EE2zN5putWP9sikkcjUKn7g3Jrapv994,2380
-pants_baseline/goals/fmt.py,sha256=etZHJRrST904L7ljU0r2xRlUbFA42gvhxmvLhxdZ5oA,1794
-pants_baseline/goals/lint.py,sha256=_o_7Bt-w6mHslN7xwvu51NrM_mlh6TJLxe7JizA7Tfk,1930
-pants_baseline/goals/test.py,sha256=THW4kJAFbAzPCjLbq1dxg81T19QdywXYiwTNKSB4z8M,1653
-pants_baseline/goals/typecheck.py,sha256=AOFhJchdGgc6mm_4u5kGTqr2gTVVH6j7ZPRQ7oI1R0c,1769
-pants_baseline/rules/__init__.py,sha256=UpvDpGVImhRfp2_VeUNsRPGiWjBbMI6AV1-Yx3kS0Gg,252
-pants_baseline/rules/audit_rules.py,sha256=0HbFdo89CwiVBKvkABDpFJ8bOKnQhV1-guT_pFdwAnQ,1889
-pants_baseline/rules/fmt_rules.py,sha256=BXw6ckUPFaBM2WFWWA8JjDa6CFdenNulNAUWjwsfJV0,3563
-pants_baseline/rules/lint_rules.py,sha256=JCrjGMgv3buUyN5mK9_vlo-StjJjnKkOIv_5Zipy2Bs,3851
-pants_baseline/rules/test_rules.py,sha256=jj4lk3-mueOPujPFPK2TCdBFZZA_vovdDdHED9jGp7U,4225
-pants_baseline/rules/typecheck_rules.py,sha256=oDc-WcNdrv0zYHE6wj65la8YAjJkoDMWCox3SW1pIxc,3995
-pants_baseline/subsystems/__init__.py,sha256=LteH_qmUIgRAnXYmmi7f6o894QfpY3hMNH5dlvJbSoM,387
-pants_baseline/subsystems/baseline.py,sha256=M20muLytoWZnA4ZY3lkbSsdCXt6OMPH6IMJfXULAQSo,2049
-pants_baseline/subsystems/ruff.py,sha256=v0yHmbdgsPMMgjxJrs-YaKPE_n7rE6h-D0HGhXheyyE,2601
-pants_baseline/subsystems/ty.py,sha256=6M205VZD5TpX6T4vWZ4UFs5Y3T2rGqYtzidmiRh_6kg,2126
-pants_baseline/subsystems/uv.py,sha256=K6G8KR3l-Jo18aMh183gfhEelJR57cb20yIqKUMw3K0,1851
-jaymd96_pants_baseline-0.1.7.dist-info/METADATA,sha256=0wuOSC3UtXOlLTwioj7jphpF3y0awgduawPCo0vF_-c,7934
-jaymd96_pants_baseline-0.1.7.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-jaymd96_pants_baseline-0.1.7.dist-info/licenses/LICENSE,sha256=oLGLZv7XKM_oKCbdMW1bZB37SXsdexmhNSuh3Xg4m4I,10754
-jaymd96_pants_baseline-0.1.7.dist-info/RECORD,,