jaymd96-pants-baseline 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

{jaymd96_pants_baseline-0.1.2.dist-info → jaymd96_pants_baseline-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jaymd96-pants-baseline
-Version: 0.1.2
+Version: 0.2.0
 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
@@ -21,6 +21,8 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Build Tools
 Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: <4,>=3.11
+Provides-Extra: claude
+Requires-Dist: jaymd96-pants-claude-plugins>=0.2.0; extra == 'claude'
 Provides-Extra: dev
 Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
 Requires-Dist: pytest>=7.4.0; extra == 'dev'
@@ -54,7 +56,7 @@ backend_packages = [
 ]
 
 plugins = [
-    "jaymd96-pants-baseline==0.1.0",
+    "jaymd96-pants-baseline==0.2.0",
 ]
 ```
 
@@ -308,7 +310,7 @@ backend_packages = [
     "pants.backend.python",
     "pants_baseline",
 ]
-plugins = ["jaymd96-pants-baseline==0.1.0"]
+plugins = ["jaymd96-pants-baseline==0.2.0"]
 
 [python]
 interpreter_constraints = ["CPython>=3.13,<4"]
@@ -346,6 +348,37 @@ strict = true
 | MyPy/Pyright | ty |
 | pip-audit | uv audit |
 
+## Claude Code Integration
+
+This plugin bundles recommended [Claude Code](https://claude.ai/code) plugins for enhanced AI-assisted development workflows.
+
+### Install Bundled Claude Plugins
+
+When combined with [jaymd96-pants-claude-plugins](https://github.com/jaymd96/pants-claude-plugins):
+
+```toml
+# pants.toml
+[GLOBAL]
+plugins = [
+    "jaymd96-pants-baseline==0.2.0",
+    "jaymd96-pants-claude-plugins>=0.2.0",
+]
+backend_packages = [
+    "pants_baseline",
+    "pants_claude_plugins",
+]
+```
+
+Then run:
+
+```bash
+pants claude-install --include-bundled ::
+```
+
+This automatically installs:
+- **github** - GitHub integration for PR workflows and issue management
+- **commit-commands** - Git workflow commands for commits, pushes, and PRs
+
 ## Development
 
 ### Setup

jaymd96_pants_baseline-0.2.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+pants_baseline/__about__.py,sha256=wxKDEvde9_K-nhyadAqBTbIh_mR7ckFwDJRU14BkV8A,98
+pants_baseline/__init__.py,sha256=uVRGi1D2gFjc7emmeewWdcvpO-NsUuKsMbX3rztOxWU,655
+pants_baseline/bundled_claude_plugins.py,sha256=jfNzFrvZBvv8Iz1XMLomgIa993ZYH_DMNOk-apFs8-g,926
+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=O-JQVk565H8w6jlsG-cqndzNaig3alepqTV0zKhfyDw,4174
+pants_baseline/rules/lint_rules.py,sha256=rYsbaPyYNDVDJn_dF91ews8iskcj2QoqnzZInLxkIzc,4219
+pants_baseline/rules/test_rules.py,sha256=jj4lk3-mueOPujPFPK2TCdBFZZA_vovdDdHED9jGp7U,4225
+pants_baseline/rules/typecheck_rules.py,sha256=XmL6uIXwjphB1YDVMrCM6A_Wa_1H-gHuLg8x59v_YQo,4499
+pants_baseline/subsystems/__init__.py,sha256=LteH_qmUIgRAnXYmmi7f6o894QfpY3hMNH5dlvJbSoM,387
+pants_baseline/subsystems/baseline.py,sha256=KWDRMdLOUN5cNHntY8f97bSsoITXwmX4ET6n2aW-cRk,2049
+pants_baseline/subsystems/ruff.py,sha256=NW0AFv59-j6ANkZG8LjvuXPzWBD4yDsEr7Pb6eZbdck,3941
+pants_baseline/subsystems/ty.py,sha256=OpaU8Z7Bk6kj5QAfhPom5L9v8sKNR8XF664_U5mUVJw,3419
+pants_baseline/subsystems/uv.py,sha256=dXmVzg4ZxzHa4g_TowEZXMYuhKiTOHjqqadkNrZQ9jk,3066
+jaymd96_pants_baseline-0.2.0.dist-info/METADATA,sha256=XsPPcHLtQ4TdFAAjbezNEDcPhcw_Hj7t68NiNwlfcIc,8764
+jaymd96_pants_baseline-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+jaymd96_pants_baseline-0.2.0.dist-info/licenses/LICENSE,sha256=oLGLZv7XKM_oKCbdMW1bZB37SXsdexmhNSuh3Xg4m4I,10754
+jaymd96_pants_baseline-0.2.0.dist-info/RECORD,,

pants_baseline/__about__.py

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

pants_baseline/bundled_claude_plugins.py

@@ -0,0 +1,29 @@
+"""Bundled Claude Code plugins for pants-baseline.
+
+These plugins are automatically discovered and installed when users run:
+    pants claude-install --include-bundled ::
+
+This requires the jaymd96-pants-claude-plugins package to be installed.
+"""
+
+# Marketplaces to add before installing plugins
+# The demo marketplace contains commit-commands and other workflow plugins
+BUNDLED_MARKETPLACES = [
+    "anthropics/claude-code",  # Demo plugins marketplace
+]
+
+# Claude Code plugins to install
+BUNDLED_CLAUDE_PLUGINS = [
+    {
+        "plugin": "github",
+        "marketplace": "claude-plugins-official",
+        "scope": "project",
+        "description": "GitHub integration for PR workflows and issue management",
+    },
+    {
+        "plugin": "commit-commands",
+        "marketplace": "anthropics-claude-code",
+        "scope": "project",
+        "description": "Git workflow commands for commits, pushes, and PRs",
+    },
+]

pants_baseline/goals/audit.py

@@ -1,7 +1,5 @@
 """Audit goal for uv security scanning."""
 
-from __future__ import annotations
-
 from typing import Iterable
 
 from pants.engine.console import Console
@@ -25,6 +23,7 @@ class BaselineAudit(Goal):
     """Goal to run uv security audit."""
 
     subsystem_cls = BaselineAuditSubsystem
+    environment_behavior = Goal.EnvironmentBehavior.LOCAL_ONLY
 
 
 @goal_rule
@@ -49,12 +48,12 @@ async def run_baseline_audit(
         console.print_stdout(f"  Ignoring: {', '.join(uv_subsystem.audit_ignore_vulns)}")
     console.print_stdout("")
 
-    audit_request = UvAuditRequest(
+    audit_request: UvAuditRequest = UvAuditRequest(
         lock_file=uv_subsystem.lock_file,
         ignore_vulns=tuple(uv_subsystem.audit_ignore_vulns),
         output_format=uv_subsystem.output_format,
     )
-    result = await Get(AuditResult, {UvAuditRequest: audit_request})
+    result = await Get(AuditResult, UvAuditRequest, audit_request)
 
     if result.stdout:
         console.print_stdout(result.stdout)

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):
@@ -24,12 +27,13 @@ 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,
+    targets: FilteredTargets,
     baseline_subsystem: BaselineSubsystem,
     ruff_subsystem: RuffSubsystem,
 ) -> BaselineFmt:
@@ -38,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):
@@ -28,12 +27,13 @@ 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,
+    targets: FilteredTargets,
     baseline_subsystem: BaselineSubsystem,
     ruff_subsystem: RuffSubsystem,
 ) -> BaselineLint:
@@ -42,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/test.py

@@ -23,6 +23,7 @@ class BaselineTest(Goal):
     """Goal to run pytest tests."""
 
     subsystem_cls = BaselineTestSubsystem
+    environment_behavior = Goal.EnvironmentBehavior.LOCAL_ONLY
 
 
 @goal_rule

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):
@@ -24,12 +27,13 @@ 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,
+    targets: FilteredTargets,
     baseline_subsystem: BaselineSubsystem,
     ty_subsystem: TySubsystem,
 ) -> BaselineTypecheck:
@@ -38,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,22 +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),
-        *BaselineSubsystem.rules(),
-        *RuffSubsystem.rules(),
-        *TySubsystem.rules(),
-        *UvSubsystem.rules(),
+        *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

@@ -1,14 +1,17 @@
 """Rules for uv security auditing."""
 
-from __future__ import annotations
-
 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:
@@ -32,15 +35,37 @@ 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,
@@ -48,11 +73,12 @@ async def run_uv_audit(
 
     process = Process(
         argv=argv,
+        input_digest=input_digest,
         description="Run uv security audit",
         level=LogLevel.DEBUG,
     )
 
-    result = await Get(FallibleProcessResult, {Process: process})
+    result = await Get(FallibleProcessResult, Process, process)
 
     stdout = result.stdout.decode()
     stderr = result.stderr.decode()

pants_baseline/rules/fmt_rules.py

@@ -1,17 +1,16 @@
 """Rules for Ruff formatting."""
 
-from __future__ import annotations
-
 from dataclasses import dataclass
 from typing import Iterable
 
-from pants.core.goals.fmt import FmtResult, FmtTargetsRequest
+from pants.core.goals.fmt import FmtResult, FmtTargetsRequest, PartitionerType
+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.target import FieldSet
-from pants.engine.unions import UnionRule
+from pants.engine.rules import Get, MultiGet, collect_rules, rule
+from pants.engine.target import FieldSet, Target
 from pants.util.logging import LogLevel
 
 from pants_baseline.subsystems.baseline import BaselineSubsystem
@@ -28,63 +27,81 @@ class RuffFmtFieldSet(FieldSet):
     sources: BaselineSourcesField
     skip_fmt: SkipFormatField
 
+    @classmethod
+    def opt_out(cls, tgt: Target) -> bool:
+        """Allow targets to opt out of formatting."""
+        return tgt.get(SkipFormatField).value
+
 
 class RuffFmtRequest(FmtTargetsRequest):
     """Request to run Ruff formatting."""
 
     field_set_type = RuffFmtFieldSet
-    tool_name = "ruff"
+    tool_subsystem = RuffSubsystem
+    partitioner_type = PartitionerType.DEFAULT_SINGLE_PARTITION
 
 
 @rule(desc="Format with Ruff", level=LogLevel.DEBUG)
 async def run_ruff_fmt(
-    request: RuffFmtRequest,
+    request: RuffFmtRequest.Batch,
     ruff_subsystem: RuffSubsystem,
     baseline_subsystem: BaselineSubsystem,
+    platform: Platform,
 ) -> FmtResult:
     """Run Ruff formatter on Python files."""
+    field_sets = request.elements
+    snapshot = request.snapshot
+
     if not baseline_subsystem.enabled:
         return FmtResult(
-            input=request.snapshot,
-            output=request.snapshot,
+            input=snapshot,
+            output=snapshot,
             stdout="",
             stderr="",
             formatter_name="ruff",
         )
 
-    # Filter out skipped targets
-    field_sets = [fs for fs in request.field_sets if not fs.skip_fmt.value]
-
     if not field_sets:
         return FmtResult(
-            input=request.snapshot,
-            output=request.snapshot,
+            input=snapshot,
+            output=snapshot,
             stdout="No targets to format",
             stderr="",
             formatter_name="ruff",
         )
 
-    # Get source files
-    source_files_request = 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(
-            input=request.snapshot,
-            output=request.snapshot,
+            input=snapshot,
+            output=snapshot,
             stdout="No files to format",
             stderr="",
             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}",
@@ -93,15 +110,16 @@ async def run_ruff_fmt(
 
     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,
     )
 
-    result = await Get(FallibleProcessResult, {Process: process})
+    result = await Get(FallibleProcessResult, Process, process)
 
-    output_snapshot = await Get(Snapshot, {Digest: result.output_digest})
+    output_digest: Digest = result.output_digest
+    output_snapshot = await Get(Snapshot, Digest, output_digest)
 
     return FmtResult(
         input=sources.snapshot,
@@ -116,5 +134,5 @@ def rules() -> Iterable:
     """Return all format rules."""
     return [
         *collect_rules(),
-        UnionRule(FmtTargetsRequest, RuffFmtRequest),
+        *RuffFmtRequest.rules(),
     ]

pants_baseline/rules/lint_rules.py

@@ -1,19 +1,17 @@
 """Rules for Ruff linting."""
 
-from __future__ import annotations
-
 from dataclasses import dataclass
 from typing import Iterable
 
-from pants.core.goals.lint import LintResult, LintTargetsRequest
+from pants.core.goals.lint import LintResult, LintTargetsRequest, PartitionerType
 from pants.core.util_rules.external_tool import DownloadedExternalTool, ExternalToolRequest
+from pants.core.util_rules.partitions import Partitions
 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, MultiGet, collect_rules, rule
 from pants.engine.target import FieldSet, Target
-from pants.engine.unions import UnionRule
 from pants.util.logging import LogLevel
 
 from pants_baseline.subsystems.baseline import BaselineSubsystem
@@ -30,26 +28,23 @@ class RuffLintFieldSet(FieldSet):
     sources: BaselineSourcesField
     skip_lint: SkipLintField
 
+    @classmethod
+    def opt_out(cls, tgt: Target) -> bool:
+        """Allow targets to opt out of linting."""
+        return tgt.get(SkipLintField).value
+
 
 class RuffLintRequest(LintTargetsRequest):
     """Request to run Ruff linting."""
 
     field_set_type = RuffLintFieldSet
-    tool_name = "ruff"
-
-
-@dataclass(frozen=True)
-class RuffLintResult:
-    """Result of running Ruff lint."""
-
-    exit_code: int
-    stdout: str
-    stderr: str
+    tool_subsystem = RuffSubsystem
+    partitioner_type = PartitionerType.DEFAULT_SINGLE_PARTITION
 
 
 @rule(desc="Lint with Ruff", level=LogLevel.DEBUG)
 async def run_ruff_lint(
-    request: RuffLintRequest,
+    request: RuffLintRequest.Batch,
     ruff_subsystem: RuffSubsystem,
     baseline_subsystem: BaselineSubsystem,
     platform: Platform,
@@ -64,8 +59,7 @@ async def run_ruff_lint(
             partition_description=None,
         )
 
-    # Filter out skipped targets
-    field_sets = [fs for fs in request.field_sets if not fs.skip_lint.value]
+    field_sets = request.elements
 
     if not field_sets:
         return LintResult(
@@ -76,12 +70,17 @@ async def run_ruff_lint(
             partition_description=None,
         )
 
-    # Get source files
-    source_files_request = 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(
@@ -92,14 +91,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,
@@ -109,19 +114,19 @@ async def run_ruff_lint(
 
     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,
     )
 
-    result = await Get(FallibleProcessResult, {Process: process})
+    result = await Get(FallibleProcessResult, Process, process)
 
     return LintResult(
         exit_code=result.exit_code,
         stdout=result.stdout.decode(),
         stderr=result.stderr.decode(),
         linter_name="ruff",
-        partition_description=None,
+        partition_description=request.partition_metadata,
     )
 
 
@@ -129,5 +134,5 @@ def rules() -> Iterable:
     """Return all lint rules."""
     return [
         *collect_rules(),
-        UnionRule(LintTargetsRequest, RuffLintRequest),
+        *RuffLintRequest.rules(),
     ]

pants_baseline/rules/test_rules.py

@@ -1,7 +1,5 @@
 """Rules for pytest testing with coverage."""
 
-from __future__ import annotations
-
 from dataclasses import dataclass
 from typing import Iterable
 
@@ -73,18 +71,18 @@ async def run_pytest(
         )
 
     # Get test source files
-    test_source_files_request = SourceFilesRequest(
+    test_source_files_request: SourceFilesRequest = SourceFilesRequest(
         sources_fields=[fs.test_sources for fs in field_sets],
         for_sources_types=(BaselineTestSourcesField,),
     )
-    test_sources = await Get(SourceFiles, {SourceFilesRequest: test_source_files_request})
+    test_sources = await Get(SourceFiles, SourceFilesRequest, test_source_files_request)
 
     # Get source files for coverage
-    source_files_request = SourceFilesRequest(
+    source_files_request: SourceFilesRequest = SourceFilesRequest(
         sources_fields=[fs.sources for fs in field_sets],
         for_sources_types=(BaselineSourcesField,),
     )
-    sources = await Get(SourceFiles, {SourceFilesRequest: source_files_request})
+    sources = await Get(SourceFiles, SourceFilesRequest, source_files_request)
 
     if not test_sources.files:
         return TestResult(
@@ -121,14 +119,14 @@ async def run_pytest(
         *test_sources.files,
     ]
 
-    process = Process(
+    process: Process = Process(
         argv=argv,
         input_digest=test_sources.snapshot.digest,
         description=f"Run pytest on {len(test_sources.files)} test files",
         level=LogLevel.DEBUG,
     )
 
-    result = await Get(FallibleProcessResult, {Process: process})
+    result = await Get(FallibleProcessResult, Process, process)
 
     return TestResult(
         exit_code=result.exit_code,

pants_baseline/rules/typecheck_rules.py

@@ -1,15 +1,16 @@
 """Rules for ty type checking."""
 
-from __future__ import annotations
-
 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.target import FieldSet
+from pants.engine.rules import Get, MultiGet, collect_rules, rule
+from pants.engine.target import FieldSet, Target
 from pants.engine.unions import UnionRule
 from pants.util.logging import LogLevel
 
@@ -27,6 +28,11 @@ class TyFieldSet(FieldSet):
     sources: BaselineSourcesField
     skip_typecheck: SkipTypecheckField
 
+    @classmethod
+    def opt_out(cls, tgt: Target) -> bool:
+        """Allow targets to opt out of type checking."""
+        return tgt.get(SkipTypecheckField).value
+
 
 class TyCheckRequest(CheckRequest):
     """Request to run ty type checking."""
@@ -35,21 +41,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:
@@ -81,12 +78,17 @@ async def run_ty_check(
             checker_name="ty",
         )
 
-    # Get source files
-    source_files_request = 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(
@@ -101,12 +103,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,
@@ -116,12 +124,12 @@ async def run_ty_check(
 
     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,
     )
 
-    result = await Get(FallibleProcessResult, {Process: process})
+    result = await Get(FallibleProcessResult, Process, process)
 
     return CheckResults(
         results=[

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.option.option_types import BoolOption, StrListOption, StrOption
-from pants.option.subsystem import Subsystem
+from pants.core.util_rules.external_tool import ExternalTool
+from pants.engine.platform import Platform
+from pants.option.option_types import BoolOption, SkipOption, StrListOption, StrOption
 
 
-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,33 @@ 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"
+
+    # Skip option required by Pants for tool subsystems
+    skip = SkipOption("lint", "fmt")
 
     # 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.2.dist-info/RECORD

@@ -1,25 +0,0 @@
-pants_baseline/__about__.py,sha256=emEUrAUfvUyL9_8_zLXhpGfpLneSXOrp3muo2ermC_k,98
-pants_baseline/__init__.py,sha256=uVRGi1D2gFjc7emmeewWdcvpO-NsUuKsMbX3rztOxWU,655
-pants_baseline/register.py,sha256=AnQrzGYcPY4f7jMvgDVvs9bo-oY1XgOAwEO3fo813yg,1656
-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=pzw1iczFb2yZKUXzQ9oggXUikv3uoZ-Nc5tVFJeTRLA,2339
-pants_baseline/goals/fmt.py,sha256=QNeQHBqR-wdLKE0oTkI3jtE3sFOmOp4EP0VXGkmG6Gg,1731
-pants_baseline/goals/lint.py,sha256=hvIRPd-zfh5zC6Q_RvEWSbqJyszGEtvCpPdKwrTe0Vo,1867
-pants_baseline/goals/test.py,sha256=cUSE7NyuXaEtZnBe22MqPAu-Fqjtn5oCpttmeU1XIk4,1590
-pants_baseline/goals/typecheck.py,sha256=LuuOW3lvzOhgsNf5-W0SC1jvNnI5Nt4ZQAGwOPg6ZoA,1706
-pants_baseline/rules/__init__.py,sha256=UpvDpGVImhRfp2_VeUNsRPGiWjBbMI6AV1-Yx3kS0Gg,252
-pants_baseline/rules/audit_rules.py,sha256=aauxy-yjah19EVBjWDOcwsRvQAIhsAtLg5VOKCbsRaM,1918
-pants_baseline/rules/fmt_rules.py,sha256=dxUyDcRHPPk04_q2ITDKu8VEvHV-vDFDaY99YCvE_yk,3534
-pants_baseline/rules/lint_rules.py,sha256=BKoGyfO66hSnieMkZ8f0ghpoVQR0eSIZtZglmCPkPEA,3862
-pants_baseline/rules/test_rules.py,sha256=gZug806LGT2Vr_GFhUdjAaRrg9RbVda-_78XhXcr0f0,4218
-pants_baseline/rules/typecheck_rules.py,sha256=JxkvJ6lJn_UvDF4IMMmmBAPWiw6kms_hTrdUE_EAzs8,4006
-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.2.dist-info/METADATA,sha256=iahXBTWMePOuc64POXU-cljsgB4nyDv2eT1ALiXmrIM,7934
-jaymd96_pants_baseline-0.1.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-jaymd96_pants_baseline-0.1.2.dist-info/licenses/LICENSE,sha256=oLGLZv7XKM_oKCbdMW1bZB37SXsdexmhNSuh3Xg4m4I,10754
-jaymd96_pants_baseline-0.1.2.dist-info/RECORD,,