thailint 0.2.0__py3-none-any.whl → 0.15.3__py3-none-any.whl

src/linters/lbyl/python_analyzer.py

@@ -0,0 +1,215 @@
+"""
+Purpose: Coordinate LBYL pattern detection and violation generation
+
+Scope: Orchestrates multiple pattern detectors and converts results to violations
+
+Overview: Provides PythonLBYLAnalyzer class that coordinates all LBYL pattern detectors
+    and converts detected patterns into Violation objects. Handles AST parsing with
+    graceful syntax error handling, runs enabled detectors based on configuration toggles,
+    and aggregates violations from all detectors. Serves as the main analysis engine
+    called by LBYLRule.
+
+Dependencies: ast module, LBYLConfig, pattern detectors, violation_builder functions
+
+Exports: PythonLBYLAnalyzer
+
+Interfaces: analyze(code: str, file_path: str, config: LBYLConfig) -> list[Violation]
+
+Implementation: Detector coordination with config-driven pattern selection using
+    generic detector runner for code reuse
+"""
+
+import ast
+from collections.abc import Callable
+from typing import Any, TypeVar
+
+from src.core.types import Violation
+
+from .config import LBYLConfig
+from .pattern_detectors.base import BaseLBYLDetector, LBYLPattern
+from .pattern_detectors.dict_key_detector import DictKeyDetector, DictKeyPattern
+from .pattern_detectors.division_check_detector import (
+    DivisionCheckDetector,
+    DivisionCheckPattern,
+)
+from .pattern_detectors.file_exists_detector import FileExistsDetector, FileExistsPattern
+from .pattern_detectors.hasattr_detector import HasattrDetector, HasattrPattern
+from .pattern_detectors.isinstance_detector import IsinstanceDetector, IsinstancePattern
+from .pattern_detectors.len_check_detector import LenCheckDetector, LenCheckPattern
+from .pattern_detectors.none_check_detector import NoneCheckDetector, NoneCheckPattern
+from .pattern_detectors.string_validator_detector import (
+    StringValidatorDetector,
+    StringValidatorPattern,
+)
+from .violation_builder import (
+    build_dict_key_violation,
+    build_division_check_violation,
+    build_file_exists_violation,
+    build_hasattr_violation,
+    build_isinstance_violation,
+    build_len_check_violation,
+    build_none_check_violation,
+    build_string_validator_violation,
+)
+
+PatternT = TypeVar("PatternT", bound=LBYLPattern)
+
+
+def _parse_python_code(code: str) -> ast.Module | None:
+    """Parse Python code into AST, returning None if empty or invalid."""
+    if not code or not code.strip():
+        return None
+    try:
+        return ast.parse(code)
+    except SyntaxError:
+        return None
+
+
+def _run_detector(
+    detector: BaseLBYLDetector[PatternT],
+    tree: ast.Module,
+    file_path: str,
+    converter: Callable[[PatternT, str], Violation],
+    pattern_type: type[PatternT],
+) -> list[Violation]:
+    """Run a detector and convert patterns to violations."""
+    return [
+        converter(p, file_path) for p in detector.find_patterns(tree) if isinstance(p, pattern_type)
+    ]
+
+
+def _build_dict_key(pattern: DictKeyPattern, file_path: str) -> Violation:
+    """Convert DictKeyPattern to Violation."""
+    return build_dict_key_violation(
+        file_path=file_path,
+        line=pattern.line_number,
+        column=pattern.column,
+        dict_name=pattern.dict_name,
+        key_expression=pattern.key_expression,
+    )
+
+
+def _build_division_check(pattern: DivisionCheckPattern, file_path: str) -> Violation:
+    """Convert DivisionCheckPattern to Violation."""
+    return build_division_check_violation(
+        file_path=file_path,
+        line=pattern.line_number,
+        column=pattern.column,
+        divisor_name=pattern.divisor_name,
+        operation=pattern.operation,
+    )
+
+
+def _build_file_exists(pattern: FileExistsPattern, file_path: str) -> Violation:
+    """Convert FileExistsPattern to Violation."""
+    return build_file_exists_violation(
+        file_path=file_path,
+        line=pattern.line_number,
+        column=pattern.column,
+        path_expression=pattern.file_path_expression,
+        check_type=pattern.check_type,
+    )
+
+
+def _build_hasattr(pattern: HasattrPattern, file_path: str) -> Violation:
+    """Convert HasattrPattern to Violation."""
+    return build_hasattr_violation(
+        file_path=file_path,
+        line=pattern.line_number,
+        column=pattern.column,
+        object_name=pattern.object_name,
+        attribute_name=pattern.attribute_name,
+    )
+
+
+def _build_isinstance(pattern: IsinstancePattern, file_path: str) -> Violation:
+    """Convert IsinstancePattern to Violation."""
+    return build_isinstance_violation(
+        file_path=file_path,
+        line=pattern.line_number,
+        column=pattern.column,
+        object_name=pattern.object_name,
+        type_name=pattern.type_name,
+    )
+
+
+def _build_len_check(pattern: LenCheckPattern, file_path: str) -> Violation:
+    """Convert LenCheckPattern to Violation."""
+    return build_len_check_violation(
+        file_path=file_path,
+        line=pattern.line_number,
+        column=pattern.column,
+        collection_name=pattern.collection_name,
+        index_expression=pattern.index_expression,
+    )
+
+
+def _build_none_check(pattern: NoneCheckPattern, file_path: str) -> Violation:
+    """Convert NoneCheckPattern to Violation."""
+    return build_none_check_violation(
+        file_path=file_path,
+        line=pattern.line_number,
+        column=pattern.column,
+        variable_name=pattern.variable_name,
+    )
+
+
+def _build_string_validator(pattern: StringValidatorPattern, file_path: str) -> Violation:
+    """Convert StringValidatorPattern to Violation."""
+    return build_string_validator_violation(
+        file_path=file_path,
+        line=pattern.line_number,
+        column=pattern.column,
+        string_name=pattern.string_name,
+        validator_method=pattern.validator_method,
+        conversion_func=pattern.conversion_func,
+    )
+
+
+class PythonLBYLAnalyzer:
+    """Coordinates LBYL pattern detection for Python code."""
+
+    def __init__(self) -> None:
+        """Initialize the analyzer with pattern detectors."""
+        # Each tuple: (detector, converter, pattern_type)
+        self._detector_configs: list[
+            tuple[BaseLBYLDetector[Any], Callable[..., Violation], type]
+        ] = [
+            (DictKeyDetector(), _build_dict_key, DictKeyPattern),
+            (DivisionCheckDetector(), _build_division_check, DivisionCheckPattern),
+            (FileExistsDetector(), _build_file_exists, FileExistsPattern),
+            (HasattrDetector(), _build_hasattr, HasattrPattern),
+            (IsinstanceDetector(), _build_isinstance, IsinstancePattern),
+            (LenCheckDetector(), _build_len_check, LenCheckPattern),
+            (NoneCheckDetector(), _build_none_check, NoneCheckPattern),
+            (StringValidatorDetector(), _build_string_validator, StringValidatorPattern),
+        ]
+
+    def analyze(self, code: str, file_path: str, config: LBYLConfig) -> list[Violation]:
+        """Analyze Python code for LBYL patterns."""
+        tree = _parse_python_code(code)
+        if tree is None:
+            return []
+        return self._run_enabled_detectors(tree, file_path, config)
+
+    def _run_enabled_detectors(
+        self, tree: ast.Module, file_path: str, config: LBYLConfig
+    ) -> list[Violation]:
+        """Run all enabled pattern detectors and collect violations."""
+        # Map detector types to their config flags
+        enabled_flags = {
+            DictKeyDetector: config.detect_dict_key,
+            DivisionCheckDetector: config.detect_division_check,
+            FileExistsDetector: config.detect_file_exists,
+            HasattrDetector: config.detect_hasattr,
+            IsinstanceDetector: config.detect_isinstance,
+            LenCheckDetector: config.detect_len_check,
+            NoneCheckDetector: config.detect_none_check,
+            StringValidatorDetector: config.detect_string_validation,
+        }
+
+        violations: list[Violation] = []
+        for detector, converter, pattern_type in self._detector_configs:
+            if enabled_flags.get(type(detector), False):
+                violations.extend(_run_detector(detector, tree, file_path, converter, pattern_type))
+        return violations

src/linters/lbyl/violation_builder.py

@@ -0,0 +1,354 @@
+"""
+Purpose: Build Violation objects with EAFP suggestions for LBYL patterns
+
+Scope: Creates violations for detected LBYL anti-patterns with fix suggestions
+
+Overview: Provides module-level functions that create Violation objects for LBYL
+    anti-patterns detected in Python code. Each violation includes the rule ID, location,
+    descriptive message, and an EAFP suggestion showing how to refactor the code using
+    try/except. Supports dict key check, hasattr, isinstance, file exists, len check,
+    None check, string validator, and division zero-check patterns.
+
+Dependencies: src.core.types for Violation, src.core.base for BaseLintContext
+
+Exports: build_dict_key_violation, build_hasattr_violation, build_isinstance_violation,
+    build_file_exists_violation, build_len_check_violation, create_syntax_error_violation,
+    build_none_check_violation, build_string_validator_violation, build_division_check_violation
+
+Interfaces: Module functions for building LBYL violations
+
+Implementation: Factory functions for each violation type with descriptive suggestions
+
+Suppressions:
+    too-many-arguments, too-many-positional-arguments: build_string_validator_violation
+        requires 6 parameters (file_path, line, column, string_name, validator_method,
+        conversion_func) to create accurate violation messages and suggestions
+"""
+
+from src.core.base import BaseLintContext
+from src.core.types import Violation
+
+
+def build_dict_key_violation(
+    file_path: str,
+    line: int,
+    column: int,
+    dict_name: str,
+    key_expression: str,
+) -> Violation:
+    """Build a violation for dict key LBYL pattern.
+
+    Args:
+        file_path: Path to the file containing the violation
+        line: Line number (1-indexed)
+        column: Column number (0-indexed)
+        dict_name: Name of the dict being checked
+        key_expression: Expression used as key
+
+    Returns:
+        Violation object with EAFP suggestion
+    """
+    message = (
+        f"LBYL pattern: 'if {key_expression} in {dict_name}' followed by "
+        f"'{dict_name}[{key_expression}]'"
+    )
+
+    suggestion = (
+        f"Use EAFP: 'with suppress(KeyError): value = {dict_name}[{key_expression}]' "
+        f"or 'try: ... except KeyError: ...'"
+    )
+
+    return Violation(
+        rule_id="lbyl.dict-key-check",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=message,
+        suggestion=suggestion,
+    )
+
+
+def build_hasattr_violation(
+    file_path: str,
+    line: int,
+    column: int,
+    object_name: str,
+    attribute_name: str,
+) -> Violation:
+    """Build a violation for hasattr LBYL pattern.
+
+    Args:
+        file_path: Path to the file containing the violation
+        line: Line number (1-indexed)
+        column: Column number (0-indexed)
+        object_name: Name of the object being checked
+        attribute_name: Name of the attribute being checked
+
+    Returns:
+        Violation object with EAFP suggestion
+    """
+    message = (
+        f"LBYL pattern: 'if hasattr({object_name}, '{attribute_name}')' followed by "
+        f"'{object_name}.{attribute_name}'"
+    )
+
+    suggestion = f"Use EAFP: 'try: {object_name}.{attribute_name} except AttributeError: ...'"
+
+    return Violation(
+        rule_id="lbyl.hasattr-check",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=message,
+        suggestion=suggestion,
+    )
+
+
+def build_isinstance_violation(
+    file_path: str,
+    line: int,
+    column: int,
+    object_name: str,
+    type_name: str,
+) -> Violation:
+    """Build a violation for isinstance LBYL pattern.
+
+    Args:
+        file_path: Path to the file containing the violation
+        line: Line number (1-indexed)
+        column: Column number (0-indexed)
+        object_name: Name of the object being checked
+        type_name: Name of the type being checked against
+
+    Returns:
+        Violation object with EAFP suggestion
+    """
+    message = (
+        f"LBYL pattern: 'if isinstance({object_name}, {type_name})' before type-specific operation"
+    )
+
+    suggestion = (
+        "Consider EAFP: 'try: ... except (TypeError, AttributeError): ...' "
+        "instead of isinstance check"
+    )
+
+    return Violation(
+        rule_id="lbyl.isinstance-check",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=message,
+        suggestion=suggestion,
+    )
+
+
+def create_syntax_error_violation(error: SyntaxError, context: BaseLintContext) -> Violation:
+    """Create a violation for a syntax error.
+
+    Args:
+        error: The SyntaxError from parsing
+        context: Lint context with file information
+
+    Returns:
+        Violation indicating syntax error
+    """
+    file_path = str(context.file_path) if context.file_path else "unknown"
+    line = error.lineno or 1
+    column = error.offset or 0
+
+    return Violation(
+        rule_id="lbyl.syntax-error",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=f"Syntax error: {error.msg}",
+        suggestion="Fix the syntax error before running LBYL analysis",
+    )
+
+
+def build_file_exists_violation(
+    file_path: str,
+    line: int,
+    column: int,
+    path_expression: str,
+    check_type: str,
+) -> Violation:
+    """Build a violation for file exists LBYL pattern.
+
+    Args:
+        file_path: Path to the file containing the violation
+        line: Line number (1-indexed)
+        column: Column number (0-indexed)
+        path_expression: Expression representing the file path being checked
+        check_type: Type of check ("os.path.exists", "Path.exists", "exists")
+
+    Returns:
+        Violation object with EAFP suggestion
+    """
+    message = (
+        f"LBYL pattern: 'if {check_type}({path_expression})' followed by "
+        f"file operation on '{path_expression}'"
+    )
+
+    suggestion = (
+        f"Use EAFP: 'try: with open({path_expression}) as f: ... except FileNotFoundError: ...'"
+    )
+
+    return Violation(
+        rule_id="lbyl.file-exists-check",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=message,
+        suggestion=suggestion,
+    )
+
+
+def build_len_check_violation(
+    file_path: str,
+    line: int,
+    column: int,
+    collection_name: str,
+    index_expression: str,
+) -> Violation:
+    """Build a violation for len check LBYL pattern.
+
+    Args:
+        file_path: Path to the file containing the violation
+        line: Line number (1-indexed)
+        column: Column number (0-indexed)
+        collection_name: Name of the collection being checked
+        index_expression: Expression used as index
+
+    Returns:
+        Violation object with EAFP suggestion
+    """
+    message = (
+        f"LBYL pattern: 'if len({collection_name}) > {index_expression}' followed by "
+        f"'{collection_name}[...]'"
+    )
+
+    suggestion = (
+        f"Use EAFP: 'try: value = {collection_name}[{index_expression}] except IndexError: ...'"
+    )
+
+    return Violation(
+        rule_id="lbyl.len-check",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=message,
+        suggestion=suggestion,
+    )
+
+
+def build_none_check_violation(
+    file_path: str,
+    line: int,
+    column: int,
+    variable_name: str,
+) -> Violation:
+    """Build a violation for None check LBYL pattern.
+
+    Args:
+        file_path: Path to the file containing the violation
+        line: Line number (1-indexed)
+        column: Column number (0-indexed)
+        variable_name: Name of the variable being checked for None
+
+    Returns:
+        Violation object with EAFP suggestion
+    """
+    message = (
+        f"LBYL pattern: 'if {variable_name} is not None' followed by '{variable_name}.<method>()'"
+    )
+
+    suggestion = (
+        f"Use EAFP: 'try: {variable_name}.<method>() except AttributeError: ...' "
+        f"or check if None is a valid state to handle differently"
+    )
+
+    return Violation(
+        rule_id="lbyl.none-check",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=message,
+        suggestion=suggestion,
+    )
+
+
+def build_string_validator_violation(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    file_path: str,
+    line: int,
+    column: int,
+    string_name: str,
+    validator_method: str,
+    conversion_func: str,
+) -> Violation:
+    """Build a violation for string validator LBYL pattern.
+
+    Args:
+        file_path: Path to the file containing the violation
+        line: Line number (1-indexed)
+        column: Column number (0-indexed)
+        string_name: Name of the string being validated
+        validator_method: Validation method used (isnumeric, isdigit, etc.)
+        conversion_func: Conversion function used (int, float)
+
+    Returns:
+        Violation object with EAFP suggestion
+    """
+    message = (
+        f"LBYL pattern: 'if {string_name}.{validator_method}()' followed by "
+        f"'{conversion_func}({string_name})'"
+    )
+
+    suggestion = f"Use EAFP: 'try: value = {conversion_func}({string_name}) except ValueError: ...'"
+
+    return Violation(
+        rule_id="lbyl.string-validator",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=message,
+        suggestion=suggestion,
+    )
+
+
+def build_division_check_violation(
+    file_path: str,
+    line: int,
+    column: int,
+    divisor_name: str,
+    operation: str,
+) -> Violation:
+    """Build a violation for division zero-check LBYL pattern.
+
+    Args:
+        file_path: Path to the file containing the violation
+        line: Line number (1-indexed)
+        column: Column number (0-indexed)
+        divisor_name: Name of the divisor being checked for zero
+        operation: Division operation used (/, //, %, /=, //=, %=)
+
+    Returns:
+        Violation object with EAFP suggestion
+    """
+    message = (
+        f"LBYL pattern: 'if {divisor_name} != 0' followed by "
+        f"'{operation}' operation with '{divisor_name}'"
+    )
+
+    suggestion = (
+        f"Use EAFP: 'try: result = ... {operation} {divisor_name} except ZeroDivisionError: ...'"
+    )
+
+    return Violation(
+        rule_id="lbyl.division-check",
+        file_path=file_path,
+        line=line,
+        column=column,
+        message=message,
+        suggestion=suggestion,
+    )

src/linters/magic_numbers/__init__.py

@@ -0,0 +1,48 @@
+"""
+Purpose: Magic numbers linter package exports and convenience functions
+
+Scope: Public API for magic numbers linter module
+
+Overview: Provides the public interface for the magic numbers linter package. Exports main
+    MagicNumberRule class for use by the orchestrator and MagicNumberConfig for configuration.
+    Includes lint() convenience function that provides a simple API for running the magic numbers
+    linter on a file or directory without directly interacting with the orchestrator. This module
+    serves as the entry point for users of the magic numbers linter, hiding implementation details
+    and exposing only the essential components needed for linting operations.
+
+Dependencies: .linter for MagicNumberRule, .config for MagicNumberConfig
+
+Exports: MagicNumberRule class, MagicNumberConfig dataclass, lint() convenience function
+
+Interfaces: lint(path, config) -> list[Violation] for simple linting operations
+
+Implementation: Module-level exports with __all__ definition, convenience function wrapper
+"""
+
+from .config import MagicNumberConfig
+from .linter import MagicNumberRule
+
+__all__ = ["MagicNumberRule", "MagicNumberConfig", "lint"]
+
+
+def lint(file_path: str, config: dict | None = None) -> list:
+    """Convenience function for linting a file for magic numbers.
+
+    Args:
+        file_path: Path to the file to lint
+        config: Optional configuration dictionary
+
+    Returns:
+        List of violations found
+    """
+    from pathlib import Path
+
+    from src.orchestrator.core import FileLintContext
+
+    rule = MagicNumberRule()
+    context = FileLintContext(
+        path=Path(file_path),
+        lang="python",
+    )
+
+    return rule.check(context)

src/linters/magic_numbers/config.py

@@ -0,0 +1,82 @@
+"""
+Purpose: Configuration schema for magic numbers linter
+
+Scope: MagicNumberConfig dataclass with allowed_numbers and max_small_integer settings
+
+Overview: Defines configuration schema for magic numbers linter. Provides MagicNumberConfig dataclass
+    with allowed_numbers set (default includes common acceptable numbers like -1, 0, 1, 2, 3, 4, 5, 10, 100, 1000)
+    and max_small_integer threshold (default 10) for range() contexts. Supports per-file and per-directory
+    config overrides through from_dict class method. Validates that configuration values are appropriate
+    types. Integrates with orchestrator's configuration system to allow users to customize allowed numbers
+    via .thailint.yaml configuration files.
+
+Dependencies: dataclasses for class definition, typing for type hints
+
+Exports: MagicNumberConfig dataclass
+
+Interfaces: MagicNumberConfig(allowed_numbers: set, max_small_integer: int, enabled: bool),
+    from_dict class method for loading configuration from dictionary
+
+Implementation: Dataclass with validation and defaults, matches reference implementation patterns
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class MagicNumberConfig:
+    """Configuration for magic numbers linter."""
+
+    enabled: bool = True
+    allowed_numbers: set[int | float] = field(
+        default_factory=lambda: {-1, 0, 1, 2, 3, 4, 5, 10, 100, 1000}
+    )
+    max_small_integer: int = 10
+    ignore: list[str] = field(default_factory=list)
+
+    def __post_init__(self) -> None:
+        """Validate configuration values."""
+        if self.max_small_integer <= 0:
+            raise ValueError(f"max_small_integer must be positive, got {self.max_small_integer}")
+
+    @classmethod
+    def from_dict(cls, config: dict[str, Any], language: str | None = None) -> "MagicNumberConfig":
+        """Load configuration from dictionary with language-specific overrides.
+
+        Args:
+            config: Dictionary containing configuration values
+            language: Programming language (python, typescript, javascript)
+                for language-specific settings
+
+        Returns:
+            MagicNumberConfig instance with values from dictionary
+        """
+        # Get language-specific config if available
+        if language and language in config:
+            lang_config = config[language]
+            allowed_numbers = set(
+                lang_config.get(
+                    "allowed_numbers",
+                    config.get("allowed_numbers", {-1, 0, 1, 2, 3, 4, 5, 10, 100, 1000}),
+                )
+            )
+            max_small_integer = lang_config.get(
+                "max_small_integer", config.get("max_small_integer", 10)
+            )
+        else:
+            allowed_numbers = set(
+                config.get("allowed_numbers", {-1, 0, 1, 2, 3, 4, 5, 10, 100, 1000})
+            )
+            max_small_integer = config.get("max_small_integer", 10)
+
+        ignore_patterns = config.get("ignore", [])
+        if not isinstance(ignore_patterns, list):
+            ignore_patterns = []
+
+        return cls(
+            enabled=config.get("enabled", True),
+            allowed_numbers=allowed_numbers,
+            max_small_integer=max_small_integer,
+            ignore=ignore_patterns,
+        )