thailint 0.12.0__py3-none-any.whl → 0.14.0__py3-none-any.whl

src/linters/lazy_ignores/violation_builder.py

@@ -0,0 +1,131 @@
+"""
+Purpose: Build agent-friendly violation messages for lazy-ignores linter
+
+Scope: Violation construction for unjustified ignores and orphaned header suppressions
+
+Overview: Provides functions to construct Violation objects with AI-agent-friendly error
+    messages. Messages include explicit guidance for adding Suppressions section entries to
+    file headers and emphasize the requirement for human approval before adding suppressions.
+    Designed to help AI coding assistants understand the proper workflow for handling linting
+    suppressions rather than blindly adding ignore directives.
+
+Dependencies: src.core.types for Violation dataclass
+
+Exports: build_unjustified_violation, build_orphaned_violation
+
+Interfaces: Two builder functions returning Violation objects
+
+Implementation: Template-based message construction with rule ID formatting
+"""
+
+from src.core.types import Severity, Violation
+
+
+def build_unjustified_violation(
+    file_path: str,
+    line: int,
+    column: int,
+    rule_id: str,
+    raw_text: str,
+) -> Violation:
+    """Create violation for an ignore directive without header justification.
+
+    Args:
+        file_path: Path to the file containing the violation.
+        line: Line number where the ignore was found (1-indexed).
+        column: Column number where the ignore starts (0-indexed).
+        rule_id: The rule ID(s) being suppressed (e.g., "PLR0912").
+        raw_text: The raw ignore directive text found in code.
+
+    Returns:
+        Violation object with agent-friendly guidance message.
+    """
+    message = (
+        f"Unjustified suppression found: {raw_text} "
+        f"(ASK PERMISSION before adding Suppressions header)"
+    )
+
+    suggestion = _build_unjustified_suggestion(rule_id)
+
+    return Violation(
+        rule_id="lazy-ignores.unjustified",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=message,
+        severity=Severity.ERROR,
+        suggestion=suggestion,
+    )
+
+
+def _build_unjustified_suggestion(rule_id: str) -> str:
+    """Build the suggestion text for unjustified violations.
+
+    Args:
+        rule_id: The rule ID(s) being suppressed.
+
+    Returns:
+        Formatted suggestion string with header instructions.
+    """
+    # Handle multiple rules (e.g., "PLR0912, PLR0915")
+    rule_ids = [r.strip() for r in rule_id.split(",")]
+
+    suppression_entries = "\n".join(f"    {rid}: [Your justification here]" for rid in rule_ids)
+
+    return f"""To fix, add an entry to the file header Suppressions section:
+
+    Suppressions:
+{suppression_entries}
+
+IMPORTANT: Adding suppressions requires human approval.
+Do not add this entry without explicit permission from a human reviewer.
+Ask first, then add if approved."""
+
+
+def build_orphaned_violation(
+    file_path: str,
+    header_line: int,
+    rule_id: str,
+    justification: str,
+) -> Violation:
+    """Create violation for a header entry without matching code ignore.
+
+    Args:
+        file_path: Path to the file containing the orphaned entry.
+        header_line: Line number of the suppression in the header (1-indexed).
+        rule_id: The orphaned rule ID from the header.
+        justification: The justification text from the header.
+
+    Returns:
+        Violation object suggesting removal of the orphaned entry.
+    """
+    message = f"Orphaned suppression in header: {rule_id}: {justification}"
+
+    suggestion = _build_orphaned_suggestion(rule_id)
+
+    return Violation(
+        rule_id="lazy-ignores.orphaned",
+        file_path=file_path,
+        line=header_line,
+        column=0,
+        message=message,
+        severity=Severity.ERROR,
+        suggestion=suggestion,
+    )
+
+
+def _build_orphaned_suggestion(rule_id: str) -> str:
+    """Build the suggestion text for orphaned violations.
+
+    Args:
+        rule_id: The orphaned rule ID.
+
+    Returns:
+        Formatted suggestion string with removal instructions.
+    """
+    return f"""This rule is declared in the Suppressions section but no matching
+ignore directive was found in the code.
+
+Either:
+1. Remove the entry for {rule_id} from the Suppressions section if the ignore was removed from code
+2. Add the ignore directive if it's missing from the code"""

src/linters/lbyl/__init__.py

@@ -0,0 +1,29 @@
+"""
+Purpose: LBYL (Look Before You Leap) linter package exports
+
+Scope: Detect LBYL anti-patterns in Python code and suggest EAFP alternatives
+
+Overview: Package providing LBYL pattern detection for Python code. Identifies common
+    anti-patterns where explicit checks are performed before operations (e.g., if key in
+    dict before dict[key]) and suggests EAFP (Easier to Ask Forgiveness than Permission)
+    alternatives using try/except blocks. Supports 8 pattern types including dict key
+    checking, hasattr, isinstance, file exists, length checks, None checks, string
+    validation, and division safety checks.
+
+Dependencies: ast module for Python parsing, src.core for base classes
+
+Exports: LBYLConfig, LBYLPattern, BaseLBYLDetector
+
+Interfaces: LBYLConfig.from_dict() for YAML configuration loading
+
+Implementation: AST-based pattern detection with configurable pattern toggles
+"""
+
+from .config import LBYLConfig
+from .pattern_detectors.base import BaseLBYLDetector, LBYLPattern
+
+__all__ = [
+    "LBYLConfig",
+    "LBYLPattern",
+    "BaseLBYLDetector",
+]

src/linters/lbyl/config.py

@@ -0,0 +1,63 @@
+"""
+Purpose: Configuration dataclass for LBYL linter
+
+Scope: Pattern toggles, ignore patterns, and validation
+
+Overview: Provides LBYLConfig dataclass with pattern-specific toggles for each LBYL
+    pattern type (dict_key, hasattr, isinstance, file_exists, len_check, none_check,
+    string_validation, division_check). Some patterns like isinstance and none_check
+    are disabled by default due to many valid use cases. Configuration can be loaded
+    from dictionary (YAML) with sensible defaults.
+
+Dependencies: dataclasses, typing
+
+Exports: LBYLConfig
+
+Interfaces: LBYLConfig.from_dict() for YAML configuration loading
+
+Implementation: Dataclass with factory defaults and conservative default settings
+
+Suppressions:
+    too-many-instance-attributes: Configuration dataclass requires many toggles
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class LBYLConfig:  # pylint: disable=too-many-instance-attributes
+    """Configuration for LBYL linter."""
+
+    enabled: bool = True
+
+    # Pattern toggles
+    detect_dict_key: bool = True
+    detect_hasattr: bool = True
+    detect_isinstance: bool = False  # Disabled - many valid uses for type narrowing
+    detect_file_exists: bool = True
+    detect_len_check: bool = True
+    detect_none_check: bool = False  # Disabled - many valid uses
+    detect_string_validation: bool = True
+    detect_division_check: bool = True
+
+    # File patterns to ignore
+    ignore: list[str] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, config: dict[str, Any], language: str | None = None) -> "LBYLConfig":
+        """Load configuration from dictionary."""
+        # Language parameter reserved for future multi-language support
+        _ = language
+        return cls(
+            enabled=config.get("enabled", True),
+            detect_dict_key=config.get("detect_dict_key", True),
+            detect_hasattr=config.get("detect_hasattr", True),
+            detect_isinstance=config.get("detect_isinstance", False),
+            detect_file_exists=config.get("detect_file_exists", True),
+            detect_len_check=config.get("detect_len_check", True),
+            detect_none_check=config.get("detect_none_check", False),
+            detect_string_validation=config.get("detect_string_validation", True),
+            detect_division_check=config.get("detect_division_check", True),
+            ignore=config.get("ignore", []),
+        )

src/linters/lbyl/pattern_detectors/__init__.py

@@ -0,0 +1,25 @@
+"""
+Purpose: Pattern detector exports for LBYL linter
+
+Scope: All AST-based pattern detectors for LBYL anti-pattern detection
+
+Overview: Exports pattern detector classes for the LBYL linter. Each detector is an
+    AST NodeVisitor that identifies specific LBYL anti-patterns. Detectors include
+    dict key checking, hasattr, isinstance, file exists, length checks, None checks,
+    string validation, and division safety checks.
+
+Dependencies: ast module, base detector class
+
+Exports: BaseLBYLDetector, LBYLPattern
+
+Interfaces: find_patterns(tree: ast.AST) -> list[LBYLPattern]
+
+Implementation: Modular detector pattern for extensible LBYL detection
+"""
+
+from .base import BaseLBYLDetector, LBYLPattern
+
+__all__ = [
+    "BaseLBYLDetector",
+    "LBYLPattern",
+]

src/linters/lbyl/pattern_detectors/base.py

@@ -0,0 +1,46 @@
+"""
+Purpose: Base class for LBYL pattern detectors
+
+Scope: Abstract base providing common detector interface
+
+Overview: Defines BaseLBYLDetector abstract class that all pattern detectors extend.
+    Inherits from ast.NodeVisitor for AST traversal. Defines LBYLPattern base dataclass
+    for representing detected patterns with line number and column information. Each
+    concrete detector implements find_patterns() to identify specific LBYL anti-patterns.
+
+Dependencies: abc, ast, dataclasses
+
+Exports: BaseLBYLDetector, LBYLPattern
+
+Interfaces: find_patterns(tree: ast.AST) -> list[LBYLPattern]
+
+Implementation: Abstract base with NodeVisitor pattern for extensibility
+"""
+
+import ast
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+
+@dataclass
+class LBYLPattern:
+    """Base pattern data for detected LBYL anti-patterns."""
+
+    line_number: int
+    column: int
+
+
+class BaseLBYLDetector(ast.NodeVisitor, ABC):
+    """Base class for LBYL pattern detectors."""
+
+    @abstractmethod
+    def find_patterns(self, tree: ast.AST) -> list[LBYLPattern]:
+        """Find LBYL patterns in AST.
+
+        Args:
+            tree: Python AST to analyze
+
+        Returns:
+            List of detected LBYL patterns
+        """
+        raise NotImplementedError