jaymd96-pants-baseline 0.1.0__py3-none-any.whl

pants_baseline/rules/lint_rules.py

@@ -0,0 +1,135 @@
+"""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.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, 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
+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
+
+
+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
+
+
+@rule(desc="Lint with Ruff", level=LogLevel.DEBUG)
+async def run_ruff_lint(
+    request: RuffLintRequest,
+    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,
+        )
+
+    # Filter out skipped targets
+    field_sets = [fs for fs in request.field_sets if not fs.skip_lint.value]
+
+    if not field_sets:
+        return LintResult(
+            exit_code=0,
+            stdout="No targets to lint",
+            stderr="",
+            linter_name="ruff",
+            partition_description=None,
+        )
+
+    # Get source files
+    sources = await 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,
+        )
+
+    # 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",
+        "check",
+        f"--target-version={baseline_subsystem.get_python_target_version()}",
+        f"--line-length={baseline_subsystem.line_length}",
+        *select_args,
+        *ignore_args,
+        "--output-format=text",
+        *sources.files,
+    ]
+
+    process = Process(
+        argv=argv,
+        input_digest=sources.snapshot.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=None,
+    )
+
+
+def rules() -> Iterable:
+    """Return all lint rules."""
+    return [
+        *collect_rules(),
+        UnionRule(LintTargetsRequest, RuffLintRequest),
+    ]

pants_baseline/rules/test_rules.py

@@ -0,0 +1,153 @@
+"""Rules for pytest testing with coverage."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+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.target import FieldSet
+from pants.engine.unions import UnionRule
+from pants.util.logging import LogLevel
+
+from pants_baseline.subsystems.baseline import BaselineSubsystem
+from pants_baseline.targets import (
+    BaselineSourcesField,
+    BaselineTestSourcesField,
+    CoverageThresholdField,
+    SkipTestField,
+)
+
+
+@dataclass(frozen=True)
+class PytestFieldSet(FieldSet):
+    """Field set for pytest testing."""
+
+    required_fields = (BaselineTestSourcesField,)
+
+    sources: BaselineSourcesField
+    test_sources: BaselineTestSourcesField
+    coverage_threshold: CoverageThresholdField
+    skip_test: SkipTestField
+
+
+class PytestTestRequest(TestRequest):
+    """Request to run pytest tests."""
+
+    field_set_type = PytestFieldSet
+    tool_name = "pytest"
+
+
+@rule(desc="Test with pytest", level=LogLevel.DEBUG)
+async def run_pytest(
+    request: PytestTestRequest,
+    baseline_subsystem: BaselineSubsystem,
+) -> TestResult:
+    """Run pytest on test files with coverage."""
+    if not baseline_subsystem.enabled:
+        return TestResult(
+            exit_code=0,
+            stdout="",
+            stderr="",
+            stdout_digest=None,
+            stderr_digest=None,
+            address=None,
+            output_setting=None,
+        )
+
+    # Filter out skipped targets
+    field_sets = [fs for fs in request.field_sets if not fs.skip_test.value]
+
+    if not field_sets:
+        return TestResult(
+            exit_code=0,
+            stdout="No targets to test",
+            stderr="",
+            stdout_digest=None,
+            stderr_digest=None,
+            address=None,
+            output_setting=None,
+        )
+
+    # Get test source files
+    test_sources = await Get(
+        SourceFiles,
+        SourceFilesRequest(
+            sources_fields=[fs.test_sources for fs in field_sets],
+            for_sources_types=(BaselineTestSourcesField,),
+        ),
+    )
+
+    # Get source files for coverage
+    sources = await Get(
+        SourceFiles,
+        SourceFilesRequest(
+            sources_fields=[fs.sources for fs in field_sets],
+            for_sources_types=(BaselineSourcesField,),
+        ),
+    )
+
+    if not test_sources.files:
+        return TestResult(
+            exit_code=0,
+            stdout="No test files found",
+            stderr="",
+            stdout_digest=None,
+            stderr_digest=None,
+            address=None,
+            output_setting=None,
+        )
+
+    # Get coverage threshold from first field set (or use default)
+    coverage_threshold = (
+        field_sets[0].coverage_threshold.value
+        if field_sets
+        else baseline_subsystem.coverage_threshold
+    )
+
+    # Build pytest command with coverage
+    src_root = ",".join(baseline_subsystem.src_roots)
+
+    argv = [
+        "pytest",
+        "-v",
+        "--strict-markers",
+        "--strict-config",
+        "-ra",
+        "--tb=short",
+        f"--cov={src_root}",
+        "--cov-report=term-missing",
+        f"--cov-fail-under={coverage_threshold}",
+        "--cov-branch",
+        *test_sources.files,
+    ]
+
+    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)
+
+    return TestResult(
+        exit_code=result.exit_code,
+        stdout=result.stdout.decode(),
+        stderr=result.stderr.decode(),
+        stdout_digest=None,
+        stderr_digest=None,
+        address=None,
+        output_setting=None,
+    )
+
+
+def rules() -> Iterable:
+    """Return all test rules."""
+    return [
+        *collect_rules(),
+        UnionRule(TestRequest, PytestTestRequest),
+    ]

pants_baseline/rules/typecheck_rules.py

@@ -0,0 +1,146 @@
+"""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.source_files import SourceFiles, SourceFilesRequest
+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.util.logging import LogLevel
+
+from pants_baseline.subsystems.baseline import BaselineSubsystem
+from pants_baseline.subsystems.ty import TySubsystem
+from pants_baseline.targets import BaselineSourcesField, SkipTypecheckField
+
+
+@dataclass(frozen=True)
+class TyFieldSet(FieldSet):
+    """Field set for ty type checking."""
+
+    required_fields = (BaselineSourcesField,)
+
+    sources: BaselineSourcesField
+    skip_typecheck: SkipTypecheckField
+
+
+class TyCheckRequest(CheckRequest):
+    """Request to run ty type checking."""
+
+    field_set_type = TyFieldSet
+    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,
+) -> CheckResults:
+    """Run ty type checker on Python files."""
+    if not baseline_subsystem.enabled:
+        return CheckResults(
+            results=[
+                CheckResult(
+                    exit_code=0,
+                    stdout="",
+                    stderr="",
+                    partition_description=None,
+                )
+            ],
+            checker_name="ty",
+        )
+
+    # Filter out skipped targets
+    field_sets = [fs for fs in request.field_sets if not fs.skip_typecheck.value]
+
+    if not field_sets:
+        return CheckResults(
+            results=[
+                CheckResult(
+                    exit_code=0,
+                    stdout="No targets to type check",
+                    stderr="",
+                    partition_description=None,
+                )
+            ],
+            checker_name="ty",
+        )
+
+    # Get source files
+    sources = await Get(
+        SourceFiles,
+        SourceFilesRequest(
+            sources_fields=[fs.sources for fs in field_sets],
+            for_sources_types=(BaselineSourcesField,),
+        ),
+    )
+
+    if not sources.files:
+        return CheckResults(
+            results=[
+                CheckResult(
+                    exit_code=0,
+                    stdout="No files to type check",
+                    stderr="",
+                    partition_description=None,
+                )
+            ],
+            checker_name="ty",
+        )
+
+    # Build ty command
+    strict_arg = ["--strict"] if ty_subsystem.strict else []
+    output_format_arg = [f"--output-format={ty_subsystem.output_format}"]
+
+    argv = [
+        "ty",
+        "check",
+        f"--python-version={baseline_subsystem.python_version}",
+        *strict_arg,
+        *output_format_arg,
+        *sources.files,
+    ]
+
+    process = Process(
+        argv=argv,
+        input_digest=sources.snapshot.digest,
+        description=f"Run ty type check on {len(sources.files)} files",
+        level=LogLevel.DEBUG,
+    )
+
+    result = await Get(FallibleProcessResult, Process, process)
+
+    return CheckResults(
+        results=[
+            CheckResult(
+                exit_code=result.exit_code,
+                stdout=result.stdout.decode(),
+                stderr=result.stderr.decode(),
+                partition_description=None,
+            )
+        ],
+        checker_name="ty",
+    )
+
+
+def rules() -> Iterable:
+    """Return all type check rules."""
+    return [
+        *collect_rules(),
+        UnionRule(CheckRequest, TyCheckRequest),
+    ]

pants_baseline/subsystems/__init__.py

@@ -0,0 +1,13 @@
+"""Subsystems for Python Baseline plugin configuration."""
+
+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
+
+__all__ = [
+    "BaselineSubsystem",
+    "RuffSubsystem",
+    "TySubsystem",
+    "UvSubsystem",
+]

pants_baseline/subsystems/baseline.py

@@ -0,0 +1,74 @@
+"""Main baseline subsystem for coordinating all quality tools."""
+
+from __future__ import annotations
+
+from pants.option.option_types import BoolOption, IntOption, StrListOption, StrOption
+from pants.option.subsystem import Subsystem
+
+
+class BaselineSubsystem(Subsystem):
+    """Configuration for the Python Baseline quality framework.
+
+    This subsystem provides global configuration for all baseline tools
+    including Ruff, ty, pytest, and uv audit.
+    """
+
+    options_scope = "python-baseline"
+    help = "Opinionated Python code quality baseline configuration."
+
+    # Global settings
+    enabled = BoolOption(
+        default=True,
+        help="Whether to enable the Python baseline checks globally.",
+    )
+
+    python_version = StrOption(
+        default="3.11",
+        help="Target Python version for all tools (e.g., '3.11', '3.12').",
+    )
+
+    line_length = IntOption(
+        default=120,
+        help="Maximum line length for formatting and linting.",
+    )
+
+    src_roots = StrListOption(
+        default=["src"],
+        help="Source root directories for Python code.",
+    )
+
+    test_roots = StrListOption(
+        default=["tests"],
+        help="Test root directories.",
+    )
+
+    exclude_patterns = StrListOption(
+        default=[
+            ".venv",
+            ".git",
+            "__pycache__",
+            "dist",
+            "build",
+            ".pytest_cache",
+            ".ruff_cache",
+            "migrations",
+        ],
+        help="Patterns to exclude from all baseline checks.",
+    )
+
+    # Coverage threshold
+    coverage_threshold = IntOption(
+        default=80,
+        help="Minimum code coverage percentage required.",
+    )
+
+    # Strictness level
+    strict_mode = BoolOption(
+        default=True,
+        help="Enable strict mode for all tools (more rigorous checks).",
+    )
+
+    def get_python_target_version(self) -> str:
+        """Return Python version in format suitable for tools (e.g., 'py311')."""
+        version = self.python_version.replace(".", "")
+        return f"py{version}"

pants_baseline/subsystems/ruff.py

@@ -0,0 +1,90 @@
+"""Ruff subsystem for linting and formatting configuration."""
+
+from __future__ import annotations
+
+from pants.option.option_types import BoolOption, StrListOption, StrOption
+from pants.option.subsystem import Subsystem
+
+
+class RuffSubsystem(Subsystem):
+    """Configuration for Ruff linting and formatting.
+
+    Ruff is an extremely fast Python linter and formatter, written in Rust.
+    It replaces Black, isort, Flake8, and many other tools in a single binary.
+    """
+
+    options_scope = "ruff"
+    help = "Ruff linting and formatting configuration."
+
+    version = StrOption(
+        default="0.2.0",
+        help="Version of Ruff to use.",
+    )
+
+    # Linting configuration
+    select = StrListOption(
+        default=[
+            "E",      # pycodestyle errors
+            "W",      # pycodestyle warnings
+            "F",      # pyflakes
+            "I",      # isort
+            "N",      # pep8-naming
+            "UP",     # pyupgrade
+            "B",      # flake8-bugbear
+            "C4",     # flake8-comprehensions
+            "SIM",    # flake8-simplify
+            "ASYNC",  # flake8-async
+            "DTZ",    # flake8-datetimez
+            "PIE",    # flake8-pie
+            "RUF",    # Ruff-specific rules
+        ],
+        help="Rule codes to enable for linting.",
+    )
+
+    ignore = StrListOption(
+        default=[
+            "E501",   # line too long (handled by formatter)
+            "W292",   # blank line at end of file
+        ],
+        help="Rule codes to ignore.",
+    )
+
+    # Formatting configuration
+    quote_style = StrOption(
+        default="double",
+        help="Quote style for formatting ('double' or 'single').",
+    )
+
+    indent_style = StrOption(
+        default="space",
+        help="Indentation style ('space' or 'tab').",
+    )
+
+    # Auto-fix
+    fix = BoolOption(
+        default=True,
+        help="Automatically fix auto-fixable issues.",
+    )
+
+    unsafe_fixes = BoolOption(
+        default=False,
+        help="Allow unsafe fixes that may change code behavior.",
+    )
+
+    # Per-file ignores (common patterns)
+    skip_tests_rules = StrListOption(
+        default=[
+            "F401",   # unused imports OK in tests
+            "F811",   # redefined function OK in tests
+            "S101",   # assert OK in tests
+        ],
+        help="Rules to skip in test files.",
+    )
+
+    skip_init_rules = StrListOption(
+        default=[
+            "F401",   # unused imports (exports)
+            "F403",   # star imports OK for namespace
+        ],
+        help="Rules to skip in __init__.py files.",
+    )

pants_baseline/subsystems/ty.py

@@ -0,0 +1,80 @@
+"""ty subsystem for type checking configuration."""
+
+from __future__ import annotations
+
+from pants.option.option_types import BoolOption, StrListOption, StrOption
+from pants.option.subsystem import Subsystem
+
+
+class TySubsystem(Subsystem):
+    """Configuration for ty type checker.
+
+    ty is Astral's next-generation Python type checker, designed for
+    exceptional performance (10-60x faster than MyPy, 80x faster than
+    Pyright on incremental edits).
+
+    Features:
+    - LSP-first architecture for IDE integration
+    - Incremental checking optimized for real-time feedback
+    - First-class intersection types and reachability analysis
+    - Rust implementation with obsessive performance focus
+    """
+
+    options_scope = "ty"
+    help = "ty type checker configuration (Astral's next-gen type checker)."
+
+    version = StrOption(
+        default="0.1.0",
+        help="Version of ty to use.",
+    )
+
+    # Type checking mode
+    strict = BoolOption(
+        default=True,
+        help="Enable strict type checking mode.",
+    )
+
+    # Error reporting
+    report_missing_imports = BoolOption(
+        default=True,
+        help="Report errors for missing imports.",
+    )
+
+    report_unused_imports = BoolOption(
+        default=True,
+        help="Report errors for unused imports.",
+    )
+
+    report_unused_variables = BoolOption(
+        default=True,
+        help="Report errors for unused variables.",
+    )
+
+    # Include/exclude paths
+    include = StrListOption(
+        default=["src", "tests"],
+        help="Directories to include in type checking.",
+    )
+
+    exclude = StrListOption(
+        default=[
+            ".venv",
+            ".git",
+            "__pycache__",
+            "dist",
+            "build",
+        ],
+        help="Patterns to exclude from type checking.",
+    )
+
+    # Type stub handling
+    stub_path = StrOption(
+        default="",
+        help="Path to custom type stubs directory.",
+    )
+
+    # Output format
+    output_format = StrOption(
+        default="text",
+        help="Output format for type errors ('text', 'json', 'github').",
+    )