jaymd96-pants-baseline 0.1.7__tar.gz → 0.1.8__tar.gz

{jaymd96_pants_baseline-0.1.7 → jaymd96_pants_baseline-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jaymd96-pants-baseline
-Version: 0.1.7
+Version: 0.1.8
 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.7 → jaymd96_pants_baseline-0.1.8}/src/pants_baseline/__about__.py

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

jaymd96_pants_baseline-0.1.8/src/pants_baseline/goals/fmt.py

@@ -0,0 +1,82 @@
+"""Format goal for Ruff formatting."""
+
+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 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):
+    """Subsystem for the baseline-fmt goal."""
+
+    name = "baseline-fmt"
+    help = "Run Ruff formatting with baseline configuration."
+
+
+class BaselineFmt(Goal):
+    """Goal to run Ruff formatting."""
+
+    subsystem_cls = BaselineFmtSubsystem
+    environment_behavior = Goal.EnvironmentBehavior.LOCAL_ONLY
+
+
+@goal_rule
+async def run_baseline_fmt(
+    console: Console,
+    targets: FilteredTargets,
+    baseline_subsystem: BaselineSubsystem,
+    ruff_subsystem: RuffSubsystem,
+) -> BaselineFmt:
+    """Run Ruff formatting on all targets."""
+    if not baseline_subsystem.enabled:
+        console.print_stdout("Python baseline is disabled.")
+        return BaselineFmt(exit_code=0)
+
+    # Filter targets that have BaselineSourcesField
+    applicable_targets = [
+        t for t in targets
+        if t.has_field(BaselineSourcesField)
+    ]
+
+    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)
+
+
+def rules() -> Iterable:
+    """Return all fmt goal rules."""
+    return collect_rules()

jaymd96_pants_baseline-0.1.8/src/pants_baseline/goals/lint.py

@@ -0,0 +1,81 @@
+"""Lint goal for Ruff linting."""
+
+from __future__ import annotations
+
+from typing import Iterable
+
+from pants.core.goals.lint import LintResult
+from pants.engine.console import Console
+from pants.engine.goal import Goal, GoalSubsystem
+from pants.engine.rules import Get, collect_rules, goal_rule
+from pants.engine.target import FieldSet, FilteredTargets
+
+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):
+    """Subsystem for the baseline-lint goal."""
+
+    name = "baseline-lint"
+    help = "Run Ruff linting with baseline configuration."
+
+
+class BaselineLint(Goal):
+    """Goal to run Ruff linting."""
+
+    subsystem_cls = BaselineLintSubsystem
+    environment_behavior = Goal.EnvironmentBehavior.LOCAL_ONLY
+
+
+@goal_rule
+async def run_baseline_lint(
+    console: Console,
+    targets: FilteredTargets,
+    baseline_subsystem: BaselineSubsystem,
+    ruff_subsystem: RuffSubsystem,
+) -> BaselineLint:
+    """Run Ruff linting on all targets."""
+    if not baseline_subsystem.enabled:
+        console.print_stdout("Python baseline is disabled.")
+        return BaselineLint(exit_code=0)
+
+    # Filter targets that have BaselineSourcesField
+    applicable_targets = [
+        t for t in targets
+        if t.has_field(BaselineSourcesField)
+    ]
+
+    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=result.exit_code)
+
+
+def rules() -> Iterable:
+    """Return all lint goal rules."""
+    return collect_rules()

jaymd96_pants_baseline-0.1.8/src/pants_baseline/goals/typecheck.py

@@ -0,0 +1,85 @@
+"""Type check goal for ty type checking."""
+
+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 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):
+    """Subsystem for the baseline-typecheck goal."""
+
+    name = "baseline-typecheck"
+    help = "Run ty type checking with baseline configuration."
+
+
+class BaselineTypecheck(Goal):
+    """Goal to run ty type checking."""
+
+    subsystem_cls = BaselineTypecheckSubsystem
+    environment_behavior = Goal.EnvironmentBehavior.LOCAL_ONLY
+
+
+@goal_rule
+async def run_baseline_typecheck(
+    console: Console,
+    targets: FilteredTargets,
+    baseline_subsystem: BaselineSubsystem,
+    ty_subsystem: TySubsystem,
+) -> BaselineTypecheck:
+    """Run ty type checking on all targets."""
+    if not baseline_subsystem.enabled:
+        console.print_stdout("Python baseline is disabled.")
+        return BaselineTypecheck(exit_code=0)
+
+    # Filter targets that have BaselineSourcesField
+    applicable_targets = [
+        t for t in targets
+        if t.has_field(BaselineSourcesField)
+    ]
+
+    if not applicable_targets:
+        console.print_stdout("No baseline_python_project targets found.")
+        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:
+    """Return all typecheck goal rules."""
+    return collect_rules()

{jaymd96_pants_baseline-0.1.7 → jaymd96_pants_baseline-0.1.8}/src/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,
     )

{jaymd96_pants_baseline-0.1.7 → jaymd96_pants_baseline-0.1.8}/src/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,

{jaymd96_pants_baseline-0.1.7 → jaymd96_pants_baseline-0.1.8}/src/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,
     )

{jaymd96_pants_baseline-0.1.7 → jaymd96_pants_baseline-0.1.8}/src/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,
     )

{jaymd96_pants_baseline-0.1.7 → jaymd96_pants_baseline-0.1.8}/src/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

{jaymd96_pants_baseline-0.1.7 → jaymd96_pants_baseline-0.1.8}/src/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(

{jaymd96_pants_baseline-0.1.7 → jaymd96_pants_baseline-0.1.8}/src/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(

{jaymd96_pants_baseline-0.1.7 → jaymd96_pants_baseline-0.1.8}/src/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(

{jaymd96_pants_baseline-0.1.7 → jaymd96_pants_baseline-0.1.8}/src/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/src/pants_baseline/goals/fmt.py

@@ -1,57 +0,0 @@
-"""Format goal for Ruff formatting."""
-
-from __future__ import annotations
-
-from typing import Iterable
-
-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_baseline.subsystems.baseline import BaselineSubsystem
-from pants_baseline.subsystems.ruff import RuffSubsystem
-
-
-class BaselineFmtSubsystem(GoalSubsystem):
-    """Subsystem for the baseline-fmt goal."""
-
-    name = "baseline-fmt"
-    help = "Run Ruff formatting with baseline configuration."
-
-
-class BaselineFmt(Goal):
-    """Goal to run Ruff formatting."""
-
-    subsystem_cls = BaselineFmtSubsystem
-    environment_behavior = Goal.EnvironmentBehavior.LOCAL_ONLY
-
-
-@goal_rule
-async def run_baseline_fmt(
-    console: Console,
-    targets: Targets,
-    baseline_subsystem: BaselineSubsystem,
-    ruff_subsystem: RuffSubsystem,
-) -> BaselineFmt:
-    """Run Ruff formatting on all targets."""
-    if not baseline_subsystem.enabled:
-        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("")
-
-    # The actual formatting is handled by the FmtTargetsRequest mechanism
-    # This goal just provides a user-friendly entry point
-
-    return BaselineFmt(exit_code=0)
-
-
-def rules() -> Iterable:
-    """Return all fmt goal rules."""
-    return collect_rules()

jaymd96_pants_baseline-0.1.7/src/pants_baseline/goals/lint.py

@@ -1,60 +0,0 @@
-"""Lint goal for Ruff linting."""
-
-from __future__ import annotations
-
-from typing import Iterable
-
-from pants.core.goals.lint import LintFilesRequest, 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_baseline.rules.lint_rules import RuffLintRequest
-from pants_baseline.subsystems.baseline import BaselineSubsystem
-from pants_baseline.subsystems.ruff import RuffSubsystem
-
-
-class BaselineLintSubsystem(GoalSubsystem):
-    """Subsystem for the baseline-lint goal."""
-
-    name = "baseline-lint"
-    help = "Run Ruff linting with baseline configuration."
-
-
-class BaselineLint(Goal):
-    """Goal to run Ruff linting."""
-
-    subsystem_cls = BaselineLintSubsystem
-    environment_behavior = Goal.EnvironmentBehavior.LOCAL_ONLY
-
-
-@goal_rule
-async def run_baseline_lint(
-    console: Console,
-    targets: Targets,
-    baseline_subsystem: BaselineSubsystem,
-    ruff_subsystem: RuffSubsystem,
-) -> BaselineLint:
-    """Run Ruff linting on all targets."""
-    if not baseline_subsystem.enabled:
-        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("")
-
-    # The actual linting is handled by the LintTargetsRequest mechanism
-    # This goal just provides a user-friendly entry point
-
-    return BaselineLint(exit_code=0)
-
-
-def rules() -> Iterable:
-    """Return all lint goal rules."""
-    return collect_rules()

jaymd96_pants_baseline-0.1.7/src/pants_baseline/goals/typecheck.py

@@ -1,56 +0,0 @@
-"""Type check goal for ty type checking."""
-
-from __future__ import annotations
-
-from typing import Iterable
-
-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_baseline.subsystems.baseline import BaselineSubsystem
-from pants_baseline.subsystems.ty import TySubsystem
-
-
-class BaselineTypecheckSubsystem(GoalSubsystem):
-    """Subsystem for the baseline-typecheck goal."""
-
-    name = "baseline-typecheck"
-    help = "Run ty type checking with baseline configuration."
-
-
-class BaselineTypecheck(Goal):
-    """Goal to run ty type checking."""
-
-    subsystem_cls = BaselineTypecheckSubsystem
-    environment_behavior = Goal.EnvironmentBehavior.LOCAL_ONLY
-
-
-@goal_rule
-async def run_baseline_typecheck(
-    console: Console,
-    targets: Targets,
-    baseline_subsystem: BaselineSubsystem,
-    ty_subsystem: TySubsystem,
-) -> BaselineTypecheck:
-    """Run ty type checking on all targets."""
-    if not baseline_subsystem.enabled:
-        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("")
-
-    # The actual type checking is handled by the CheckRequest mechanism
-    # This goal just provides a user-friendly entry point
-
-    return BaselineTypecheck(exit_code=0)
-
-
-def rules() -> Iterable:
-    """Return all typecheck goal rules."""
-    return collect_rules()