thailint 0.15.6__py3-none-any.whl → 0.16.0__py3-none-any.whl

src/cli/utils.py

@@ -21,7 +21,6 @@ Implementation: Uses Click decorators for option definitions, deferred imports f
     to support test environments, caches project root in context for efficiency
 """
 
-import logging
 import sys
 from collections.abc import Callable
 from contextlib import suppress
@@ -29,13 +28,11 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any, TypeVar, cast
 
 import click
+from loguru import logger
 
 if TYPE_CHECKING:
     from src.orchestrator.core import Orchestrator
 
-# Configure module logger
-logger = logging.getLogger(__name__)
-
 
 # =============================================================================
 # Common Option Decorators
@@ -132,8 +129,7 @@ def _resolve_explicit_project_root(explicit_root: str, verbose: bool) -> Path:
     # Now resolve after validation
     root = root.resolve()
 
-    if verbose:
-        logger.debug(f"Using explicit project root: {root}")
+    logger.debug(f"Using explicit project root: {root}")
     return root
 
 
@@ -150,8 +146,7 @@ def _infer_root_from_config(config_path: str, verbose: bool) -> Path:
     config_file = Path(config_path).resolve()
     inferred_root = config_file.parent
 
-    if verbose:
-        logger.debug(f"Inferred project root from config path: {inferred_root}")
+    logger.debug(f"Inferred project root from config path: {inferred_root}")
     return inferred_root
 
 
@@ -168,8 +163,7 @@ def _autodetect_project_root(
         Auto-detected project root
     """
     auto_root = get_project_root(None)
-    if verbose:
-        logger.debug(f"Auto-detected project root: {auto_root}")
+    logger.debug(f"Auto-detected project root: {auto_root}")
     return auto_root
 
 
@@ -217,8 +211,7 @@ def _determine_project_root_for_context(ctx: click.Context) -> Path | None:
         return _infer_root_from_config(config_path, verbose)
 
     # No explicit root - return None for auto-detection from target paths
-    if verbose:
-        logger.debug("No explicit project root, will auto-detect from target paths")
+    logger.debug("No explicit project root, will auto-detect from target paths")
     return None
 
 
@@ -262,8 +255,7 @@ def handle_linting_error(error: Exception, verbose: bool) -> None:
         verbose: Whether verbose logging is enabled
     """
     click.echo(f"Error during linting: {error}", err=True)
-    if verbose:
-        logger.exception("Linting failed with exception")
+    logger.exception("Linting failed with exception")
     sys.exit(2)
 
 
@@ -334,8 +326,7 @@ def load_config_file(orchestrator: "Orchestrator", config_file: str, verbose: bo
     # Load config into orchestrator
     orchestrator.config = orchestrator.config_loader.load(config_path)
 
-    if verbose:
-        logger.debug(f"Loaded config from: {config_file}")
+    logger.debug(f"Loaded config from: {config_file}")
 
 
 # =============================================================================

src/core/__init__.py

@@ -6,12 +6,26 @@ power the plugin architecture.
 
 from .base import BaseLintContext, BaseLintRule
 from .registry import RuleRegistry
+from .rule_aliases import (
+    LINTER_ALIASES,
+    RULE_ID_ALIASES,
+    is_deprecated_linter,
+    is_deprecated_rule_id,
+    resolve_linter_name,
+    resolve_rule_id,
+)
 from .types import Severity, Violation
 
 __all__ = [
     "BaseLintContext",
     "BaseLintRule",
+    "LINTER_ALIASES",
+    "RULE_ID_ALIASES",
     "RuleRegistry",
     "Severity",
     "Violation",
+    "is_deprecated_linter",
+    "is_deprecated_rule_id",
+    "resolve_linter_name",
+    "resolve_rule_id",
 ]

src/core/rule_aliases.py

@@ -0,0 +1,84 @@
+"""
+Purpose: Rule ID aliasing system for backward compatibility during rule renaming
+
+Scope: Maps deprecated rule IDs to canonical rule IDs for configuration and filtering
+
+Overview: Provides a mapping system for rule IDs that allows backward compatibility when rules
+    are renamed. Users can continue using deprecated rule IDs in configuration files and ignore
+    directives, which are transparently resolved to their canonical forms. Supports both
+    direct rule ID mapping and linter-level command aliasing. Used by configuration parsing,
+    violation filtering, and ignore directive processing.
+
+Dependencies: None (pure Python module)
+
+Exports: RULE_ID_ALIASES dict, LINTER_ALIASES dict, resolve_rule_id function,
+    resolve_linter_name function
+
+Interfaces: resolve_rule_id(rule_id) -> str, resolve_linter_name(name) -> str
+
+Implementation: Simple dictionary-based lookup with identity fallback for unknown rule IDs
+"""
+
+# Maps deprecated rule IDs to their canonical replacements
+RULE_ID_ALIASES: dict[str, str] = {
+    "print-statements.detected": "improper-logging.print-statement",
+}
+
+# Maps deprecated linter command names to their canonical replacements
+LINTER_ALIASES: dict[str, str] = {
+    "print-statements": "improper-logging",
+}
+
+
+def resolve_rule_id(rule_id: str) -> str:
+    """Resolve a rule ID to its canonical form.
+
+    If the rule ID has been renamed, returns the new canonical name.
+    Otherwise, returns the rule ID unchanged.
+
+    Args:
+        rule_id: The rule ID to resolve (may be deprecated or canonical)
+
+    Returns:
+        The canonical rule ID
+    """
+    return RULE_ID_ALIASES.get(rule_id, rule_id)
+
+
+def resolve_linter_name(name: str) -> str:
+    """Resolve a linter command name to its canonical form.
+
+    If the linter has been renamed, returns the new canonical name.
+    Otherwise, returns the name unchanged.
+
+    Args:
+        name: The linter command name to resolve (may be deprecated or canonical)
+
+    Returns:
+        The canonical linter name
+    """
+    return LINTER_ALIASES.get(name, name)
+
+
+def is_deprecated_rule_id(rule_id: str) -> bool:
+    """Check if a rule ID is deprecated.
+
+    Args:
+        rule_id: The rule ID to check
+
+    Returns:
+        True if the rule ID is deprecated (has an alias)
+    """
+    return rule_id in RULE_ID_ALIASES
+
+
+def is_deprecated_linter(name: str) -> bool:
+    """Check if a linter name is deprecated.
+
+    Args:
+        name: The linter name to check
+
+    Returns:
+        True if the linter name is deprecated (has an alias)
+    """
+    return name in LINTER_ALIASES

src/linter_config/rule_matcher.py

@@ -4,32 +4,46 @@ Purpose: Rule ID matching utilities for ignore directive processing
 Scope: Pattern matching between rule IDs and ignore patterns
 
 Overview: Provides functions for matching rule IDs against ignore patterns. Supports
-    exact matching, wildcard matching (*.suffix), and prefix matching (category matches
-    category.specific). All comparisons are case-insensitive to handle variations in
-    rule ID formatting.
+    exact matching, wildcard matching (*.suffix), prefix matching (category matches
+    category.specific), and alias resolution for backward compatibility with renamed
+    rules. All comparisons are case-insensitive to handle variations in rule ID formatting.
 
-Dependencies: re for regex operations
+Dependencies: re for regex operations, src.core.rule_aliases for alias resolution
 
 Exports: rule_matches, check_bracket_rules, check_space_separated_rules
 
 Interfaces: rule_matches(rule_id, pattern) -> bool for checking if rule matches pattern
 
-Implementation: String-based pattern matching with wildcard and prefix support
+Implementation: String-based pattern matching with wildcard, prefix, and alias support
 """
 
 import re
 
+from src.core.rule_aliases import RULE_ID_ALIASES
+
 
 def rule_matches(rule_id: str, pattern: str) -> bool:
-    """Check if rule ID matches pattern (supports wildcards and prefixes).
+    """Check if rule ID matches pattern (supports wildcards, prefixes, and aliases).
+
+    Supports backward compatibility through alias resolution:
+    - Pattern "print-statements" matches rule_id "improper-logging.print-statement"
+    - Pattern "print-statements.*" matches rule_id "improper-logging.print-statement"
 
     Args:
-        rule_id: Rule ID to check (e.g., "nesting.excessive-depth").
-        pattern: Pattern with optional wildcard (e.g., "nesting.*" or "nesting").
+        rule_id: Rule ID to check (e.g., "improper-logging.print-statement").
+        pattern: Pattern with optional wildcard (e.g., "nesting.*" or "print-statements").
 
     Returns:
         True if rule matches pattern.
     """
+    if _matches_pattern_directly(rule_id, pattern):
+        return True
+
+    return _matches_via_alias(rule_id, pattern)
+
+
+def _matches_pattern_directly(rule_id: str, pattern: str) -> bool:
+    """Check if rule ID matches pattern without alias resolution."""
     rule_id_lower = rule_id.lower()
     pattern_lower = pattern.lower()
 
@@ -46,6 +60,37 @@ def rule_matches(rule_id: str, pattern: str) -> bool:
     return False
 
 
+def _matches_via_alias(rule_id: str, pattern: str) -> bool:
+    """Check if rule ID matches pattern through alias resolution."""
+    pattern_lower = pattern.lower()
+    rule_id_lower = rule_id.lower()
+
+    # Find deprecated IDs that alias to our rule_id and check pattern match
+    return any(
+        _pattern_matches_deprecated_id(pattern_lower, deprecated_id)
+        for deprecated_id, canonical_id in RULE_ID_ALIASES.items()
+        if canonical_id.lower() == rule_id_lower
+    )
+
+
+def _pattern_matches_deprecated_id(pattern_lower: str, deprecated_id: str) -> bool:
+    """Check if pattern matches a deprecated rule ID."""
+    deprecated_id_lower = deprecated_id.lower()
+
+    # Pattern exactly matches deprecated ID
+    if pattern_lower == deprecated_id_lower:
+        return True
+
+    # Pattern is prefix/wildcard that matches deprecated ID's category
+    deprecated_category = deprecated_id.split(".", maxsplit=1)[0].lower()
+    if pattern_lower == deprecated_category:
+        return True
+    if pattern_lower == deprecated_category + ".*":
+        return True
+
+    return False
+
+
 def check_bracket_rules(rules_text: str, rule_id: str) -> bool:
     """Check if bracketed rules match the rule ID.
 

src/linters/print_statements/__init__.py

@@ -1,33 +1,45 @@
 """
 File: src/linters/print_statements/__init__.py
 
-Purpose: Print statements linter package exports and convenience functions
+Purpose: Improper logging linter package exports and convenience functions
 
-Exports: PrintStatementRule class, PrintStatementConfig dataclass, lint() convenience function
+Exports: PrintStatementRule, ConditionalVerboseRule classes, PrintStatementConfig dataclass,
+    lint() convenience function, ImproperLoggingPrintRule alias
 
-Depends: .linter for PrintStatementRule, .config for PrintStatementConfig
+Depends: .linter for PrintStatementRule, .conditional_verbose_rule for ConditionalVerboseRule,
+    .config for PrintStatementConfig
 
 Implements: lint(file_path, config) -> list[Violation] for simple linting operations
 
 Related: src/linters/magic_numbers/__init__.py, src/core/base.py
 
-Overview: Provides the public interface for the print statements linter package. Exports main
-    PrintStatementRule class for use by the orchestrator and PrintStatementConfig for configuration.
-    Includes lint() convenience function that provides a simple API for running the print statements
-    linter on a file without directly interacting with the orchestrator. This module serves as the
-    entry point for users of the print statements linter, hiding implementation details and exposing
-    only the essential components needed for linting operations.
+Overview: Provides the public interface for the improper logging linter package (formerly
+    print-statements). Exports PrintStatementRule for detecting print/console statements and
+    ConditionalVerboseRule for detecting conditional verbose logging anti-patterns. Both rules
+    use rule IDs prefixed with 'improper-logging.' for unified filtering. Includes lint()
+    convenience function for simple API usage without the orchestrator. ImproperLoggingPrintRule
+    is provided as an alias for PrintStatementRule for semantic clarity.
 
-Usage: from src.linters.print_statements import PrintStatementRule, lint
+Usage: from src.linters.print_statements import PrintStatementRule, ConditionalVerboseRule, lint
     violations = lint("path/to/file.py")
 
 Notes: Module-level exports with __all__ definition, convenience function wrapper
 """
 
+from .conditional_verbose_rule import ConditionalVerboseRule
 from .config import PrintStatementConfig
 from .linter import PrintStatementRule
 
-__all__ = ["PrintStatementRule", "PrintStatementConfig", "lint"]
+# Alias for semantic clarity (both detect improper logging patterns)
+ImproperLoggingPrintRule = PrintStatementRule
+
+__all__ = [
+    "PrintStatementRule",
+    "ConditionalVerboseRule",
+    "PrintStatementConfig",
+    "ImproperLoggingPrintRule",
+    "lint",
+]
 
 
 def lint(file_path: str, config: dict | None = None) -> list:

src/linters/print_statements/conditional_verbose_analyzer.py

@@ -0,0 +1,200 @@
+"""
+Purpose: Python AST analysis for finding conditional verbose logging patterns
+
+Scope: Detection of if verbose: logger.*() anti-patterns in Python code
+
+Overview: Provides ConditionalVerboseAnalyzer class that traverses Python AST to find logging calls
+    that are conditionally guarded by verbose flags. Detects patterns like 'if verbose: logger.debug()'
+    or 'if self.verbose: logger.info()' which are anti-patterns because logging levels should be
+    configured at the logger level rather than through code conditionals. Supports detection of
+    various verbose condition patterns including simple names, attribute access, dict access, and
+    method calls on context objects.
+
+Dependencies: ast module for AST parsing and node types
+
+Exports: ConditionalVerboseAnalyzer class, is_verbose_condition function, is_logger_call function
+
+Interfaces: find_conditional_verbose_calls(tree) -> list[tuple[If, Call, int]]
+
+Implementation: AST walk pattern with condition matching for verbose patterns and logger call detection
+"""
+
+import ast
+
+# Logger methods that indicate a logging call
+LOGGER_METHODS = frozenset({"debug", "info", "warning", "error", "critical", "log", "exception"})
+
+# Verbose-related names that typically guard logging
+VERBOSE_NAMES = frozenset({"verbose", "debug", "is_verbose", "is_debug"})
+
+
+def is_verbose_condition(test: ast.expr) -> bool:
+    """Check if an expression is a verbose-like condition.
+
+    Matches patterns like:
+    - verbose
+    - self.verbose
+    - config.verbose
+    - params.verbose
+    - ctx.obj.get("verbose")
+    - ctx.obj["verbose"]
+
+    Args:
+        test: The condition expression to check
+
+    Returns:
+        True if the condition appears to be a verbose check
+    """
+    return (
+        _is_simple_verbose_name(test)
+        or _is_verbose_attribute(test)
+        or _is_verbose_subscript(test)
+        or _is_verbose_dict_get(test)
+    )
+
+
+def _is_simple_verbose_name(test: ast.expr) -> bool:
+    """Check for simple name like 'verbose' or 'debug'."""
+    return isinstance(test, ast.Name) and test.id.lower() in VERBOSE_NAMES
+
+
+def _is_verbose_attribute(test: ast.expr) -> bool:
+    """Check for attribute access like 'self.verbose' or 'config.verbose'."""
+    if not isinstance(test, ast.Attribute):
+        return False
+    return test.attr.lower() in VERBOSE_NAMES
+
+
+def _is_verbose_subscript(test: ast.expr) -> bool:
+    """Check for subscript access like 'ctx.obj["verbose"]'."""
+    if not isinstance(test, ast.Subscript):
+        return False
+    if not isinstance(test.slice, ast.Constant):
+        return False
+    value = test.slice.value
+    return isinstance(value, str) and value.lower() in VERBOSE_NAMES
+
+
+def _is_verbose_dict_get(test: ast.expr) -> bool:
+    """Check for dict.get call like 'ctx.obj.get("verbose")'."""
+    if not isinstance(test, ast.Call):
+        return False
+    if not _is_dict_get_call_with_args(test):
+        return False
+    return _first_arg_is_verbose_string(test.args[0])
+
+
+def _is_dict_get_call_with_args(call: ast.Call) -> bool:
+    """Check if call is a .get() method call with arguments."""
+    if not isinstance(call.func, ast.Attribute):
+        return False
+    if call.func.attr != "get":
+        return False
+    return bool(call.args)
+
+
+def _first_arg_is_verbose_string(arg: ast.expr) -> bool:
+    """Check if argument is a verbose-related string constant."""
+    if not isinstance(arg, ast.Constant):
+        return False
+    value = arg.value
+    return isinstance(value, str) and value.lower() in VERBOSE_NAMES
+
+
+def is_logger_call(node: ast.Call) -> bool:
+    """Check if a Call node is a logger method call.
+
+    Matches patterns like:
+    - logger.debug()
+    - logging.info()
+    - self.logger.warning()
+    - log.error()
+
+    Args:
+        node: The Call node to check
+
+    Returns:
+        True if this appears to be a logging call
+    """
+    if not isinstance(node.func, ast.Attribute):
+        return False
+    return node.func.attr in LOGGER_METHODS
+
+
+def _extract_logger_method(node: ast.Call) -> str:
+    """Extract the logger method name from a call node.
+
+    Args:
+        node: The Call node (must be a logger call)
+
+    Returns:
+        The logger method name (e.g., 'debug', 'info')
+    """
+    if isinstance(node.func, ast.Attribute):
+        return node.func.attr
+    return ""
+
+
+class ConditionalVerboseAnalyzer:
+    """Analyzes Python AST to find conditional verbose logging patterns."""
+
+    def __init__(self) -> None:
+        """Initialize the analyzer."""
+        self.violations: list[tuple[ast.If, ast.Call, int]] = []
+
+    def find_conditional_verbose_calls(
+        self, tree: ast.AST
+    ) -> list[tuple[ast.If, ast.Call, str, int]]:
+        """Find all conditional verbose logging patterns in the AST.
+
+        Looks for if statements with verbose-like conditions that contain
+        logger method calls in their body.
+
+        Args:
+            tree: The AST to analyze
+
+        Returns:
+            List of tuples (if_node, call_node, logger_method, line_number)
+        """
+        verbose_if_nodes = (
+            node
+            for node in ast.walk(tree)
+            if isinstance(node, ast.If) and is_verbose_condition(node.test)
+        )
+
+        results: list[tuple[ast.If, ast.Call, str, int]] = []
+        for if_node in verbose_if_nodes:
+            results.extend(self._extract_logger_call_results(if_node))
+
+        return results
+
+    def _extract_logger_call_results(
+        self, if_node: ast.If
+    ) -> list[tuple[ast.If, ast.Call, str, int]]:
+        """Extract logger call results from a verbose if node."""
+        logger_calls = self._find_logger_calls_in_body(if_node.body)
+        return [
+            (
+                if_node,
+                call_node,
+                _extract_logger_method(call_node),
+                call_node.lineno if hasattr(call_node, "lineno") else if_node.lineno,
+            )
+            for call_node in logger_calls
+        ]
+
+    def _find_logger_calls_in_body(self, body: list[ast.stmt]) -> list[ast.Call]:
+        """Find all logger calls in a list of statements.
+
+        Args:
+            body: List of AST statements
+
+        Returns:
+            List of Call nodes that are logger calls
+        """
+        logger_calls: list[ast.Call] = []
+        for stmt in body:
+            for node in ast.walk(stmt):
+                if isinstance(node, ast.Call) and is_logger_call(node):
+                    logger_calls.append(node)
+        return logger_calls