jaymd96-pants-baseline 0.2.2__tar.gz → 0.2.13__tar.gz

{jaymd96_pants_baseline-0.2.2 → jaymd96_pants_baseline-0.2.13}/PKG-INFO

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

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

{jaymd96_pants_baseline-0.2.2 → jaymd96_pants_baseline-0.2.13}/src/pants_baseline/register.py

@@ -2,22 +2,19 @@
 
 This module is the entry point for the Pants plugin system.
 It registers all rules, targets, and subsystems provided by this plugin.
+
+This plugin integrates with Pants' built-in lint, fmt, and check goals
+rather than providing custom goals.
 """
 
-from typing import Iterable
+from typing import Iterable, Type
 
 from pants.engine.rules import Rule
+from pants.option.subsystem import Subsystem
 
-from pants_baseline.goals import audit as audit_goal
-from pants_baseline.goals import fmt as fmt_goal
-from pants_baseline.goals import lint as lint_goal
-from pants_baseline.goals import test as test_goal
-from pants_baseline.goals import typecheck as typecheck_goal
-from pants_baseline.rules import audit_rules, fmt_rules, lint_rules, test_rules, typecheck_rules
+from pants_baseline.rules import fmt_rules, lint_rules
 from pants_baseline.subsystems.baseline import BaselineSubsystem
 from pants_baseline.subsystems.ruff import RuffSubsystem
-from pants_baseline.subsystems.ty import TySubsystem
-from pants_baseline.subsystems.uv import UvSubsystem
 from pants_baseline.targets import BaselinePythonProject
 
 
@@ -29,19 +26,20 @@ def rules() -> Iterable[Rule]:
     rather than using collect_rules() which only collects @rule functions.
     """
     return [
+        # Tool rules (integrate with Pants built-in lint/fmt goals)
         *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(),
     ]
 
 
 def target_types() -> Iterable[type]:
     """Return all custom target types provided by this plugin."""
     return [BaselinePythonProject]
+
+
+def subsystems() -> Iterable[Type[Subsystem]]:
+    """Return all subsystems provided by this plugin."""
+    return [
+        BaselineSubsystem,
+        RuffSubsystem,
+    ]

{jaymd96_pants_baseline-0.2.2 → jaymd96_pants_baseline-0.2.13}/src/pants_baseline/rules/audit_rules.py

@@ -3,11 +3,13 @@
 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.core.util_rules.external_tool import download_external_tool
+from pants.engine.fs import MergeDigests, PathGlobs
+from pants.engine.internals.selectors import concurrently
+from pants.engine.intrinsics import merge_digests, execute_process, path_globs_to_digest
 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.process import Process
+from pants.engine.rules import collect_rules, implicitly, rule
 from pants.util.logging import LogLevel
 
 from pants_baseline.subsystems.uv import UvSubsystem
@@ -39,23 +41,20 @@ async def run_uv_audit(
     platform: Platform,
 ) -> AuditResult:
     """Run uv audit on dependencies."""
-    # Download uv
-    downloaded_uv = await Get(
-        DownloadedExternalTool,
-        ExternalToolRequest,
-        uv_subsystem.get_request(platform),
+    # Download uv and get lock files in parallel using new intrinsics
+    downloaded_uv_get = download_external_tool(uv_subsystem.get_request(platform))
+    lock_file_digest_get = path_globs_to_digest(
+        PathGlobs([request.lock_file, "pyproject.toml", "requirements.txt"])
     )
 
-    # Get the lock file if it exists
-    lock_file_snapshot = await Get(
-        Snapshot,
-        PathGlobs([request.lock_file, "pyproject.toml", "requirements.txt"]),
+    downloaded_uv, lock_file_digest = await concurrently(
+        downloaded_uv_get,
+        lock_file_digest_get,
     )
 
     # Merge the uv binary with lock files
-    input_digest = await Get(
-        Digest,
-        MergeDigests([downloaded_uv.digest, lock_file_snapshot.digest]),
+    input_digest = await merge_digests(
+        MergeDigests([downloaded_uv.digest, lock_file_digest]),
     )
 
     # Build ignore args
@@ -78,7 +77,7 @@ async def run_uv_audit(
         level=LogLevel.DEBUG,
     )
 
-    result = await Get(FallibleProcessResult, Process, process)
+    result = await execute_process(process, **implicitly())
 
     stdout = result.stdout.decode()
     stderr = result.stderr.decode()

jaymd96_pants_baseline-0.2.13/src/pants_baseline/rules/fmt_rules.py

@@ -0,0 +1,108 @@
+"""Rules for Ruff formatting."""
+
+from dataclasses import dataclass
+from typing import Any, Iterable
+
+from pants.core.goals.fmt import FmtResult, FmtTargetsRequest
+from pants.core.util_rules.external_tool import DownloadedExternalTool, download_external_tool
+from pants.core.util_rules.partitions import PartitionerType
+from pants.engine.fs import Digest, MergeDigests
+from pants.engine.intrinsics import merge_digests
+from pants.engine.platform import Platform
+from pants.engine.process import FallibleProcessResult, Process, execute_process_or_raise
+from pants.engine.rules import collect_rules, implicitly, rule
+from pants.engine.target import FieldSet
+from pants.util.logging import LogLevel
+from pants.util.meta import classproperty
+
+from pants.backend.python.target_types import PythonSourceField
+
+from pants_baseline.subsystems.baseline import BaselineSubsystem
+from pants_baseline.subsystems.ruff import RuffSubsystem
+
+
+@dataclass(frozen=True)
+class RuffFmtFieldSet(FieldSet):
+    """Field set for Ruff formatting."""
+
+    required_fields = (PythonSourceField,)
+
+    sources: PythonSourceField
+
+
+class RuffFmtRequest(FmtTargetsRequest):
+    """Request to run Ruff formatting."""
+
+    field_set_type = RuffFmtFieldSet
+    tool_subsystem = RuffSubsystem
+    partitioner_type = PartitionerType.DEFAULT_SINGLE_PARTITION
+
+    @classproperty
+    def tool_name(cls) -> str:
+        return "baseline-ruff-fmt"
+
+    @classproperty
+    def tool_id(cls) -> str:
+        return "baseline-ruff-fmt"
+
+
+@rule(desc="Format with Ruff", level=LogLevel.DEBUG)
+async def run_ruff_fmt(
+    request: RuffFmtRequest.Batch[RuffFmtFieldSet, Any],
+    ruff_subsystem: RuffSubsystem,
+    baseline_subsystem: BaselineSubsystem,
+    platform: Platform,
+) -> FmtResult:
+    """Run Ruff formatter on Python files."""
+    if ruff_subsystem.skip:
+        return FmtResult.skip(request, formatter_name="baseline-ruff-fmt")
+
+    if not baseline_subsystem.enabled:
+        return FmtResult.skip(request, formatter_name="baseline-ruff-fmt")
+
+    snapshot = request.snapshot
+    if not snapshot.files:
+        return FmtResult.skip(request, formatter_name="baseline-ruff-fmt")
+
+    # Download ruff
+    downloaded_ruff: DownloadedExternalTool = await download_external_tool(
+        ruff_subsystem.get_request(platform)
+    )
+
+    # Merge the ruff binary with the source files
+    input_digest: Digest = await merge_digests(
+        MergeDigests([downloaded_ruff.digest, snapshot.digest]),
+    )
+
+    # Build Ruff format command
+    # Note: quote-style and indent-style are config file options only in ruff 0.9+
+    argv = [
+        downloaded_ruff.exe,
+        "format",
+        f"--target-version=py{baseline_subsystem.python_version.replace('.', '')}",
+        f"--line-length={baseline_subsystem.line_length}",
+        *snapshot.files,
+    ]
+
+    result: FallibleProcessResult = await execute_process_or_raise(
+        **implicitly(
+            Process(
+                argv=argv,
+                input_digest=input_digest,
+                output_files=snapshot.files,
+                description=f"Run Ruff format on {len(snapshot.files)} files",
+                level=LogLevel.DEBUG,
+            )
+        )
+    )
+
+    # FmtResult.create() is async and takes 2 args in Pants 2.30+
+    return await FmtResult.create(request, result)
+
+
+def rules() -> Iterable:
+    """Return all format rules."""
+    return [
+        *collect_rules(),
+        *RuffFmtRequest.rules(),
+    ]

jaymd96_pants_baseline-0.2.13/src/pants_baseline/rules/lint_rules.py

@@ -0,0 +1,124 @@
+"""Rules for Ruff linting."""
+
+from dataclasses import dataclass
+from typing import Any, Iterable
+
+from pants.core.goals.lint import LintResult, LintTargetsRequest
+from pants.core.util_rules.external_tool import DownloadedExternalTool, download_external_tool
+from pants.core.util_rules.partitions import PartitionerType
+from pants.core.util_rules.source_files import SourceFiles, SourceFilesRequest, determine_source_files
+from pants.engine.fs import Digest, MergeDigests
+from pants.engine.intrinsics import execute_process, merge_digests
+from pants.engine.platform import Platform
+from pants.engine.process import Process
+from pants.engine.rules import collect_rules, implicitly, rule
+from pants.engine.target import FieldSet
+from pants.util.logging import LogLevel
+from pants.util.meta import classproperty
+
+from pants.backend.python.target_types import PythonSourceField
+
+from pants_baseline.subsystems.baseline import BaselineSubsystem
+from pants_baseline.subsystems.ruff import RuffSubsystem
+
+
+@dataclass(frozen=True)
+class RuffLintFieldSet(FieldSet):
+    """Field set for Ruff linting."""
+
+    required_fields = (PythonSourceField,)
+
+    sources: PythonSourceField
+
+
+class RuffLintRequest(LintTargetsRequest):
+    """Request to run Ruff linting."""
+
+    field_set_type = RuffLintFieldSet
+    tool_subsystem = RuffSubsystem
+    partitioner_type = PartitionerType.DEFAULT_SINGLE_PARTITION
+
+    @classproperty
+    def tool_name(cls) -> str:
+        return "baseline-ruff"
+
+    @classproperty
+    def tool_id(cls) -> str:
+        return "baseline-ruff"
+
+
+@rule(desc="Lint with Ruff", level=LogLevel.DEBUG)
+async def run_ruff_lint(
+    request: RuffLintRequest.Batch[RuffLintFieldSet, Any],
+    ruff_subsystem: RuffSubsystem,
+    baseline_subsystem: BaselineSubsystem,
+    platform: Platform,
+) -> LintResult:
+    """Run Ruff linter on Python files."""
+    if ruff_subsystem.skip:
+        return LintResult.create(request, exit_code=0, stdout="", stderr="", strip_chroot_path=True)
+
+    if not baseline_subsystem.enabled:
+        return LintResult.create(request, exit_code=0, stdout="", stderr="", strip_chroot_path=True)
+
+    field_sets = list(request.elements)
+
+    if not field_sets:
+        return LintResult.create(request, exit_code=0, stdout="No targets to lint", stderr="", strip_chroot_path=True)
+
+    # Download ruff and get source files
+    downloaded_ruff: DownloadedExternalTool = await download_external_tool(
+        ruff_subsystem.get_request(platform)
+    )
+    sources: SourceFiles = await determine_source_files(
+        SourceFilesRequest(
+            sources_fields=[fs.sources for fs in field_sets],
+            for_sources_types=(PythonSourceField,),
+        )
+    )
+
+    if not sources.files:
+        return LintResult.create(request, exit_code=0, stdout="No files to lint", stderr="", strip_chroot_path=True)
+
+    # Merge the ruff binary with the source files
+    input_digest: Digest = await merge_digests(
+        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 []
+
+    # Build Ruff check command
+    # Note: line-length is a config file option only in ruff 0.9+
+    argv = [
+        downloaded_ruff.exe,
+        "check",
+        f"--target-version=py{baseline_subsystem.python_version.replace('.', '')}",
+        *select_args,
+        *ignore_args,
+        "--output-format=concise",
+        *sources.files,
+    ]
+
+    # execute_process returns FallibleProcessResult which LintResult.create accepts directly
+    process_result = await execute_process(
+        Process(
+            argv=argv,
+            input_digest=input_digest,
+            description=f"Run Ruff lint on {len(sources.files)} files",
+            level=LogLevel.DEBUG,
+        ),
+        **implicitly(),
+    )
+
+    # LintResult.create() takes 2 args in Pants 2.30+
+    return LintResult.create(request, process_result)
+
+
+def rules() -> Iterable:
+    """Return all lint rules."""
+    return [
+        *collect_rules(),
+        *RuffLintRequest.rules(),
+    ]

{jaymd96_pants_baseline-0.2.2 → jaymd96_pants_baseline-0.2.13}/src/pants_baseline/rules/test_rules.py

@@ -5,8 +5,10 @@ from typing import Iterable
 
 from pants.core.goals.test import TestRequest, TestResult
 from pants.core.util_rules.source_files import SourceFiles, SourceFilesRequest
-from pants.engine.process import FallibleProcessResult, Process
-from pants.engine.rules import Get, collect_rules, rule
+from pants.engine.internals.selectors import concurrently
+from pants.engine.intrinsics import execute_process
+from pants.engine.process import Process
+from pants.engine.rules import collect_rules, implicitly, rule
 from pants.engine.target import FieldSet
 from pants.engine.unions import UnionRule
 from pants.util.logging import LogLevel
@@ -70,19 +72,20 @@ async def run_pytest(
             output_setting=None,
         )
 
-    # Get test source files
-    test_source_files_request: SourceFilesRequest = SourceFilesRequest(
+    # Get test and source files in parallel using new intrinsics
+    test_source_files_request = 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)
-
-    # Get source files for coverage
-    source_files_request: SourceFilesRequest = SourceFilesRequest(
+    source_files_request = SourceFilesRequest(
         sources_fields=[fs.sources for fs in field_sets],
         for_sources_types=(BaselineSourcesField,),
     )
-    sources = await Get(SourceFiles, SourceFilesRequest, source_files_request)
+
+    test_sources, sources = await concurrently(
+        implicitly(test_source_files_request, SourceFiles),
+        implicitly(source_files_request, SourceFiles),
+    )
 
     if not test_sources.files:
         return TestResult(
@@ -119,14 +122,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 execute_process(process, **implicitly())
 
     return TestResult(
         exit_code=result.exit_code,

{jaymd96_pants_baseline-0.2.2 → jaymd96_pants_baseline-0.2.13}/src/pants_baseline/rules/typecheck_rules.py

@@ -4,12 +4,14 @@ 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.external_tool import download_external_tool
 from pants.core.util_rules.source_files import SourceFiles, SourceFilesRequest
-from pants.engine.fs import Digest, MergeDigests
+from pants.engine.fs import MergeDigests
+from pants.engine.internals.selectors import concurrently
+from pants.engine.intrinsics import merge_digests, execute_process
 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.process import Process
+from pants.engine.rules import collect_rules, implicitly, rule
 from pants.engine.target import FieldSet, Target
 from pants.engine.unions import UnionRule
 from pants.util.logging import LogLevel
@@ -78,16 +80,16 @@ async def run_ty_check(
             checker_name="ty",
         )
 
-    # 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,),
-            ),
-        ),
+    # Download ty and get source files in parallel using new intrinsics
+    downloaded_ty_get = download_external_tool(ty_subsystem.get_request(platform))
+    sources_get = SourceFilesRequest(
+        sources_fields=[fs.sources for fs in field_sets],
+        for_sources_types=(BaselineSourcesField,),
+    )
+
+    downloaded_ty, sources = await concurrently(
+        downloaded_ty_get,
+        implicitly(sources_get, SourceFiles),
     )
 
     if not sources.files:
@@ -104,8 +106,7 @@ async def run_ty_check(
         )
 
     # Merge the ty binary with the source files
-    input_digest = await Get(
-        Digest,
+    input_digest = await merge_digests(
         MergeDigests([downloaded_ty.digest, sources.snapshot.digest]),
     )
 
@@ -129,7 +130,7 @@ async def run_ty_check(
         level=LogLevel.DEBUG,
     )
 
-    result = await Get(FallibleProcessResult, Process, process)
+    result = await execute_process(process, **implicitly())
 
     return CheckResults(
         results=[

{jaymd96_pants_baseline-0.2.2 → jaymd96_pants_baseline-0.2.13}/src/pants_baseline/subsystems/baseline.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from pants.engine.rules import collect_rules
 from pants.option.option_types import BoolOption, IntOption, StrListOption, StrOption
 from pants.option.subsystem import Subsystem
 
@@ -72,3 +73,8 @@ class BaselineSubsystem(Subsystem):
         """Return Python version in format suitable for tools (e.g., 'py311')."""
         version = self.python_version.replace(".", "")
         return f"py{version}"
+
+
+def rules():
+    """Return rules for the baseline subsystem."""
+    return collect_rules()

{jaymd96_pants_baseline-0.2.2 → jaymd96_pants_baseline-0.2.13}/src/pants_baseline/subsystems/ruff.py

@@ -4,7 +4,10 @@ from __future__ import annotations
 
 from pants.core.util_rules.external_tool import ExternalTool
 from pants.engine.platform import Platform
+from pants.engine.rules import collect_rules
+from pants.engine.unions import UnionRule
 from pants.option.option_types import BoolOption, SkipOption, StrListOption, StrOption
+from pants.core.goals.generate_lockfiles import ExportableTool
 
 
 class RuffSubsystem(ExternalTool):
@@ -19,11 +22,11 @@ class RuffSubsystem(ExternalTool):
 
     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",
+        # Ruff 0.9.6 - Format: version|platform|sha256_hash|file_size_bytes
+        "0.9.6|macos_arm64|a3132eb5e3d95f36d378144082276fbed0309789dadb19d8a4c41ec5e80451fb|11124436",
+        "0.9.6|macos_x86_64|ec88c095036b25e95391ea202fcc9496d565f4e43152db10785eb9757ea0815d|11663591",
+        "0.9.6|linux_arm64|cf796c953def5a7102002372893942fac875ac718355698a4a70405104dfbb6c|11946730",
+        "0.9.6|linux_x86_64|bed850f15d4d5aaaef2b6a131bfecd5b9d7d3191596249d07e576bd9fd37078e|12511815",
     ]
 
     def generate_url(self, plat: Platform) -> str:
@@ -40,7 +43,14 @@ class RuffSubsystem(ExternalTool):
 
     def generate_exe(self, plat: Platform) -> str:
         """Return the path to the ruff executable within the downloaded archive."""
-        return "ruff"
+        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"ruff-{plat_str}/ruff"
 
     # Skip option required by Pants for tool subsystems
     skip = SkipOption("lint", "fmt")
@@ -112,3 +122,11 @@ class RuffSubsystem(ExternalTool):
         ],
         help="Rules to skip in __init__.py files.",
     )
+
+
+def rules():
+    """Return rules for the Ruff subsystem."""
+    return (
+        *collect_rules(),
+        UnionRule(ExportableTool, RuffSubsystem),
+    )

{jaymd96_pants_baseline-0.2.2 → jaymd96_pants_baseline-0.2.13}/src/pants_baseline/subsystems/ty.py

@@ -2,8 +2,11 @@
 
 from __future__ import annotations
 
+from pants.core.goals.generate_lockfiles import ExportableTool
 from pants.core.util_rules.external_tool import ExternalTool
 from pants.engine.platform import Platform
+from pants.engine.rules import collect_rules
+from pants.engine.unions import UnionRule
 from pants.option.option_types import BoolOption, StrListOption, StrOption
 
 
@@ -99,3 +102,11 @@ class TySubsystem(ExternalTool):
         default="text",
         help="Output format for type errors ('text', 'json', 'github').",
     )
+
+
+def rules():
+    """Return rules for the ty subsystem."""
+    return (
+        *collect_rules(),
+        UnionRule(ExportableTool, TySubsystem),
+    )

{jaymd96_pants_baseline-0.2.2 → jaymd96_pants_baseline-0.2.13}/src/pants_baseline/subsystems/uv.py

@@ -2,8 +2,11 @@
 
 from __future__ import annotations
 
+from pants.core.goals.generate_lockfiles import ExportableTool
 from pants.core.util_rules.external_tool import ExternalTool
 from pants.engine.platform import Platform
+from pants.engine.rules import collect_rules
+from pants.engine.unions import UnionRule
 from pants.option.option_types import BoolOption, StrListOption, StrOption
 
 
@@ -85,3 +88,11 @@ class UvSubsystem(ExternalTool):
         default=[],
         help="Additional arguments to pass to uv commands.",
     )
+
+
+def rules():
+    """Return rules for the uv subsystem."""
+    return (
+        *collect_rules(),
+        UnionRule(ExportableTool, UvSubsystem),
+    )

jaymd96_pants_baseline-0.2.2/src/pants_baseline/rules/fmt_rules.py

@@ -1,139 +0,0 @@
-"""Rules for Ruff formatting."""
-
-from dataclasses import dataclass
-from typing import Iterable
-
-from pants.core.goals.fmt import FmtResult, FmtTargetsRequest
-from pants.core.util_rules.partitions import 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, MergeDigests, Snapshot
-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.util.logging import LogLevel
-
-from pants_baseline.subsystems.baseline import BaselineSubsystem
-from pants_baseline.subsystems.ruff import RuffSubsystem
-from pants_baseline.targets import BaselineSourcesField, SkipFormatField
-
-
-@dataclass(frozen=True)
-class RuffFmtFieldSet(FieldSet):
-    """Field set for Ruff formatting."""
-
-    required_fields = (BaselineSourcesField,)
-
-    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_subsystem = RuffSubsystem
-    partitioner_type = PartitionerType.DEFAULT_SINGLE_PARTITION
-
-
-@rule(desc="Format with Ruff", level=LogLevel.DEBUG)
-async def run_ruff_fmt(
-    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=snapshot,
-            output=snapshot,
-            stdout="",
-            stderr="",
-            formatter_name="ruff",
-        )
-
-    if not field_sets:
-        return FmtResult(
-            input=snapshot,
-            output=snapshot,
-            stdout="No targets to format",
-            stderr="",
-            formatter_name="ruff",
-        )
-
-    # 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,),
-            ),
-        ),
-    )
-
-    if not sources.files:
-        return FmtResult(
-            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 = [
-        downloaded_ruff.exe,
-        "format",
-        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(
-        argv=argv,
-        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)
-
-    output_digest: Digest = result.output_digest
-    output_snapshot = await Get(Snapshot, Digest, output_digest)
-
-    return FmtResult(
-        input=sources.snapshot,
-        output=output_snapshot,
-        stdout=result.stdout.decode(),
-        stderr=result.stderr.decode(),
-        formatter_name="ruff",
-    )
-
-
-def rules() -> Iterable:
-    """Return all format rules."""
-    return [
-        *collect_rules(),
-        *RuffFmtRequest.rules(),
-    ]

jaymd96_pants_baseline-0.2.2/src/pants_baseline/rules/lint_rules.py

@@ -1,138 +0,0 @@
-"""Rules for Ruff linting."""
-
-from dataclasses import dataclass
-from typing import Iterable
-
-from pants.core.goals.lint import LintResult, LintTargetsRequest
-from pants.core.util_rules.external_tool import DownloadedExternalTool, ExternalToolRequest
-from pants.core.util_rules.partitions import Partitions, PartitionerType
-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.util.logging import LogLevel
-
-from pants_baseline.subsystems.baseline import BaselineSubsystem
-from pants_baseline.subsystems.ruff import RuffSubsystem
-from pants_baseline.targets import BaselineSourcesField, SkipLintField
-
-
-@dataclass(frozen=True)
-class RuffLintFieldSet(FieldSet):
-    """Field set for Ruff linting."""
-
-    required_fields = (BaselineSourcesField,)
-
-    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_subsystem = RuffSubsystem
-    partitioner_type = PartitionerType.DEFAULT_SINGLE_PARTITION
-
-
-@rule(desc="Lint with Ruff", level=LogLevel.DEBUG)
-async def run_ruff_lint(
-    request: RuffLintRequest.Batch,
-    ruff_subsystem: RuffSubsystem,
-    baseline_subsystem: BaselineSubsystem,
-    platform: Platform,
-) -> LintResult:
-    """Run Ruff linter on Python files."""
-    if not baseline_subsystem.enabled:
-        return LintResult(
-            exit_code=0,
-            stdout="",
-            stderr="",
-            linter_name="ruff",
-            partition_description=None,
-        )
-
-    field_sets = request.elements
-
-    if not field_sets:
-        return LintResult(
-            exit_code=0,
-            stdout="No targets to lint",
-            stderr="",
-            linter_name="ruff",
-            partition_description=None,
-        )
-
-    # 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,),
-            ),
-        ),
-    )
-
-    if not sources.files:
-        return LintResult(
-            exit_code=0,
-            stdout="No files to lint",
-            stderr="",
-            linter_name="ruff",
-            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 = [
-        downloaded_ruff.exe,
-        "check",
-        f"--target-version=py{baseline_subsystem.python_version.replace('.', '')}",
-        f"--line-length={baseline_subsystem.line_length}",
-        *select_args,
-        *ignore_args,
-        "--output-format=text",
-        *sources.files,
-    ]
-
-    process = Process(
-        argv=argv,
-        input_digest=input_digest,
-        description=f"Run Ruff lint on {len(sources.files)} files",
-        level=LogLevel.DEBUG,
-    )
-
-    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=request.partition_metadata,
-    )
-
-
-def rules() -> Iterable:
-    """Return all lint rules."""
-    return [
-        *collect_rules(),
-        *RuffLintRequest.rules(),
-    ]