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

src/linters/print_statements/python_analyzer.py

@@ -10,9 +10,9 @@ Overview: Provides PythonPrintStatementAnalyzer class that traverses Python AST
     Returns structured data about each print call including the AST node, parent context,
     and line number for violation reporting. Handles both simple print() and builtins.print() calls.
 
-Dependencies: ast module for AST parsing and node types
+Dependencies: ast module for AST parsing and node types, analyzers.ast_utils
 
-Exports: PythonPrintStatementAnalyzer class
+Exports: PythonPrintStatementAnalyzer class, is_print_call function, is_main_if_block function
 
 Interfaces: find_print_calls(tree) -> list[tuple[Call, AST | None, int]], is_in_main_block(node) -> bool
 
@@ -21,8 +21,87 @@ Implementation: AST walk pattern with parent map for context detection and __mai
 
 import ast
 
+from src.analyzers.ast_utils import build_parent_map
 
-class PythonPrintStatementAnalyzer:  # thailint: ignore[srp]
+# --- Pure helper functions for print call detection ---
+
+
+def is_print_call(node: ast.Call) -> bool:
+    """Check if a Call node is calling print().
+
+    Args:
+        node: The Call node to check
+
+    Returns:
+        True if this is a print() call
+    """
+    return _is_simple_print(node) or _is_builtins_print(node)
+
+
+def _is_simple_print(node: ast.Call) -> bool:
+    """Check for simple print() call."""
+    return isinstance(node.func, ast.Name) and node.func.id == "print"
+
+
+def _is_builtins_print(node: ast.Call) -> bool:
+    """Check for builtins.print() call."""
+    if not isinstance(node.func, ast.Attribute):
+        return False
+    if node.func.attr != "print":
+        return False
+    return isinstance(node.func.value, ast.Name) and node.func.value.id == "builtins"
+
+
+# --- Pure helper functions for __main__ block detection ---
+
+
+def is_main_if_block(node: ast.AST) -> bool:
+    """Check if node is an `if __name__ == "__main__":` statement.
+
+    Args:
+        node: AST node to check
+
+    Returns:
+        True if this is a __main__ if block
+    """
+    if not isinstance(node, ast.If):
+        return False
+    if not isinstance(node.test, ast.Compare):
+        return False
+    return _is_main_comparison(node.test)
+
+
+def _is_main_comparison(test: ast.Compare) -> bool:
+    """Check if comparison is __name__ == '__main__'."""
+    if not _is_name_identifier(test.left):
+        return False
+    if not _has_single_eq_operator(test):
+        return False
+    return _compares_to_main(test)
+
+
+def _is_name_identifier(node: ast.expr) -> bool:
+    """Check if node is the __name__ identifier."""
+    return isinstance(node, ast.Name) and node.id == "__name__"
+
+
+def _has_single_eq_operator(test: ast.Compare) -> bool:
+    """Check if comparison has single == operator."""
+    return len(test.ops) == 1 and isinstance(test.ops[0], ast.Eq)
+
+
+def _compares_to_main(test: ast.Compare) -> bool:
+    """Check if comparison is to '__main__' string."""
+    if len(test.comparators) != 1:
+        return False
+    comparator = test.comparators[0]
+    return isinstance(comparator, ast.Constant) and comparator.value == "__main__"
+
+
+# --- Analyzer class with stateful parent tracking ---
+
+
+class PythonPrintStatementAnalyzer:
     """Analyzes Python AST to find print() calls."""
 
     def __init__(self) -> None:
@@ -40,24 +119,10 @@ class PythonPrintStatementAnalyzer:  # thailint: ignore[srp]
             List of tuples (node, parent, line_number)
         """
         self.print_calls = []
-        self.parent_map = {}
-        self._build_parent_map(tree)
+        self.parent_map = build_parent_map(tree)
         self._collect_print_calls(tree)
         return self.print_calls
 
-    def _build_parent_map(self, node: ast.AST, parent: ast.AST | None = None) -> None:
-        """Build a map of nodes to their parents.
-
-        Args:
-            node: Current AST node
-            parent: Parent of current node
-        """
-        if parent is not None:
-            self.parent_map[node] = parent
-
-        for child in ast.iter_child_nodes(node):
-            self._build_parent_map(child, node)
-
     def _collect_print_calls(self, tree: ast.AST) -> None:
         """Walk tree and collect all print() calls.
 
@@ -65,34 +130,11 @@ class PythonPrintStatementAnalyzer:  # thailint: ignore[srp]
             tree: AST to traverse
         """
         for node in ast.walk(tree):
-            if isinstance(node, ast.Call) and self._is_print_call(node):
+            if isinstance(node, ast.Call) and is_print_call(node):
                 parent = self.parent_map.get(node)
                 line_number = node.lineno if hasattr(node, "lineno") else 0
                 self.print_calls.append((node, parent, line_number))
 
-    def _is_print_call(self, node: ast.Call) -> bool:
-        """Check if a Call node is calling print().
-
-        Args:
-            node: The Call node to check
-
-        Returns:
-            True if this is a print() call
-        """
-        return self._is_simple_print(node) or self._is_builtins_print(node)
-
-    def _is_simple_print(self, node: ast.Call) -> bool:
-        """Check for simple print() call."""
-        return isinstance(node.func, ast.Name) and node.func.id == "print"
-
-    def _is_builtins_print(self, node: ast.Call) -> bool:
-        """Check for builtins.print() call."""
-        if not isinstance(node.func, ast.Attribute):
-            return False
-        if node.func.attr != "print":
-            return False
-        return isinstance(node.func.value, ast.Name) and node.func.value.id == "builtins"
-
     def is_in_main_block(self, node: ast.AST) -> bool:
         """Check if node is within `if __name__ == "__main__":` block.
 
@@ -105,45 +147,7 @@ class PythonPrintStatementAnalyzer:  # thailint: ignore[srp]
         current = node
         while current in self.parent_map:
             parent = self.parent_map[current]
-            if self._is_main_if_block(parent):
+            if is_main_if_block(parent):
                 return True
             current = parent
         return False
-
-    def _is_main_if_block(self, node: ast.AST) -> bool:
-        """Check if node is an `if __name__ == "__main__":` statement.
-
-        Args:
-            node: AST node to check
-
-        Returns:
-            True if this is a __main__ if block
-        """
-        if not isinstance(node, ast.If):
-            return False
-        if not isinstance(node.test, ast.Compare):
-            return False
-        return self._is_main_comparison(node.test)
-
-    def _is_main_comparison(self, test: ast.Compare) -> bool:
-        """Check if comparison is __name__ == '__main__'."""
-        if not self._is_name_identifier(test.left):
-            return False
-        if not self._has_single_eq_operator(test):
-            return False
-        return self._compares_to_main(test)
-
-    def _is_name_identifier(self, node: ast.expr) -> bool:
-        """Check if node is the __name__ identifier."""
-        return isinstance(node, ast.Name) and node.id == "__name__"
-
-    def _has_single_eq_operator(self, test: ast.Compare) -> bool:
-        """Check if comparison has single == operator."""
-        return len(test.ops) == 1 and isinstance(test.ops[0], ast.Eq)
-
-    def _compares_to_main(self, test: ast.Compare) -> bool:
-        """Check if comparison is to '__main__' string."""
-        if len(test.comparators) != 1:
-            return False
-        comparator = test.comparators[0]
-        return isinstance(comparator, ast.Constant) and comparator.value == "__main__"

src/linters/print_statements/typescript_analyzer.py

@@ -18,32 +18,23 @@ Exports: TypeScriptPrintStatementAnalyzer class
 Interfaces: find_console_calls(root_node, methods) -> list[tuple[Node, str, int]]
 
 Implementation: Tree-sitter node traversal with call_expression and member_expression pattern matching
+
 """
 
 import logging
-from typing import Any
 
-from src.analyzers.typescript_base import TypeScriptBaseAnalyzer
+from src.analyzers.typescript_base import (
+    TREE_SITTER_AVAILABLE,
+    Node,
+    TypeScriptBaseAnalyzer,
+)
 
 logger = logging.getLogger(__name__)
 
-# dry: ignore-block - tree-sitter import pattern (common across TypeScript analyzers)
-try:
-    from tree_sitter import Node
-
-    TREE_SITTER_AVAILABLE = True
-except ImportError:
-    TREE_SITTER_AVAILABLE = False
-    Node = Any  # type: ignore
-
 
 class TypeScriptPrintStatementAnalyzer(TypeScriptBaseAnalyzer):
     """Analyzes TypeScript/JavaScript code for console.* calls using Tree-sitter."""
 
-    def __init__(self) -> None:  # pylint: disable=useless-parent-delegation
-        """Initialize the TypeScript print statement analyzer."""
-        super().__init__()  # Sets self.tree_sitter_available from base class
-
     def find_console_calls(self, root_node: Node, methods: set[str]) -> list[tuple[Node, str, int]]:
         """Find all console.* calls matching the specified methods.
 

src/linters/srp/heuristics.py

@@ -84,7 +84,7 @@ def has_property_decorator(func_node: ast.FunctionDef | ast.AsyncFunctionDef) ->
     Returns:
         True if function has @property decorator
     """
-    for decorator in func_node.decorator_list:
-        if isinstance(decorator, ast.Name) and decorator.id == "property":
-            return True
-    return False
+    return any(
+        isinstance(decorator, ast.Name) and decorator.id == "property"
+        for decorator in func_node.decorator_list
+    )

src/linters/srp/linter.py

@@ -16,9 +16,13 @@ Exports: SRPRule class
 Interfaces: SRPRule.check(context) -> list[Violation], properties for rule metadata
 
 Implementation: Composition pattern with helper classes, heuristic-based SRP analysis
+
+Suppressions:
+    - type:ignore[return-value]: Generic TypeScript analyzer return type variance
 """
 
 from src.core.base import BaseLintContext, MultiLanguageLintRule
+from src.core.constants import Language
 from src.core.linter_utils import load_linter_config
 from src.core.types import Violation
 from src.linter_config.ignore import get_ignore_parser
@@ -100,10 +104,10 @@ class SRPRule(MultiLanguageLintRule):
         Returns:
             List of violations found
         """
-        if context.language == "python":
+        if context.language == Language.PYTHON:
             return self._check_python(context, config)
 
-        if context.language in ("typescript", "javascript"):
+        if context.language in (Language.TYPESCRIPT, Language.JAVASCRIPT):
             return self._check_typescript(context, config)
 
         return []
@@ -133,10 +137,7 @@ class SRPRule(MultiLanguageLintRule):
             return False
 
         file_path = str(context.file_path)
-        for pattern in config.ignore:
-            if pattern in file_path:
-                return True
-        return False
+        return any(pattern in file_path for pattern in config.ignore)
 
     def _check_python(self, context: BaseLintContext, config: SRPConfig) -> list[Violation]:
         """Check Python code for SRP violations.
@@ -170,13 +171,12 @@ class SRPRule(MultiLanguageLintRule):
         Returns:
             List of violations
         """
-        violations = []
         valid_metrics = (m for m in metrics_list if isinstance(m, dict))
-        for metrics in valid_metrics:
-            violation = self._create_violation_if_needed(metrics, config, context)
-            if violation:
-                violations.append(violation)
-        return violations
+        return [
+            violation
+            for metrics in valid_metrics
+            if (violation := self._create_violation_if_needed(metrics, config, context))
+        ]
 
     def _create_violation_if_needed(
         self,

src/linters/srp/violation_builder.py

@@ -29,10 +29,6 @@ from src.core.violation_builder import BaseViolationBuilder, ViolationInfo
 class ViolationBuilder(BaseViolationBuilder):
     """Builds SRP violations with messages and suggestions."""
 
-    def __init__(self) -> None:  # pylint: disable=useless-parent-delegation
-        """Initialize the violation builder."""
-        super().__init__()  # Inherits from BaseViolationBuilder
-
     def build_violation(
         self,
         metrics: dict[str, Any],

src/linters/stateless_class/linter.py

@@ -20,13 +20,20 @@ Interfaces: StatelessClassRule.check(context) -> list[Violation]
 
 Implementation: Composition pattern delegating analysis to specialized analyzer with
     config loading and comprehensive ignore checking
+
+Suppressions:
+    - B101: Type narrowing assertion after _should_analyze guard (can't fail)
+    - srp,dry: Rule class coordinates analyzer, config, and ignore checking. Method count
+        exceeds limit due to comprehensive 5-level ignore system support.
 """
 
 from pathlib import Path
 
 from src.core.base import BaseLintContext, BaseLintRule
+from src.core.constants import HEADER_SCAN_LINES, IgnoreDirective, Language
 from src.core.types import Severity, Violation
 from src.linter_config.ignore import get_ignore_parser
+from src.linter_config.rule_matcher import rule_matches
 
 from .config import StatelessClassConfig
 from .python_analyzer import ClassInfo, StatelessClassAnalyzer
@@ -67,20 +74,29 @@ class StatelessClassRule(BaseLintRule):  # thailint: ignore[srp,dry]
             return []
 
         config = self._load_config(context)
-        if not config.enabled:
-            return []
-
-        if self._is_file_ignored(context, config):
+        if not config.enabled or self._should_skip_file(context, config):
             return []
 
-        if self._has_file_level_ignore(context):
-            return []
+        # _should_analyze ensures file_content is set
+        assert context.file_content is not None  # nosec B101
 
         analyzer = StatelessClassAnalyzer(min_methods=config.min_methods)
-        stateless_classes = analyzer.analyze(context.file_content)  # type: ignore[arg-type]
+        stateless_classes = analyzer.analyze(context.file_content)
 
         return self._filter_ignored_violations(stateless_classes, context)
 
+    def _should_skip_file(self, context: BaseLintContext, config: StatelessClassConfig) -> bool:
+        """Check if file should be skipped due to ignore patterns or directives.
+
+        Args:
+            context: Lint context
+            config: Configuration
+
+        Returns:
+            True if file should be skipped
+        """
+        return self._is_file_ignored(context, config) or self._has_file_level_ignore(context)
+
     def _should_analyze(self, context: BaseLintContext) -> bool:
         """Check if context should be analyzed.
 
@@ -90,7 +106,7 @@ class StatelessClassRule(BaseLintRule):  # thailint: ignore[srp,dry]
         Returns:
             True if should analyze
         """
-        return context.language == "python" and context.file_content is not None
+        return context.language == Language.PYTHON and context.file_content is not None
 
     def _load_config(self, context: BaseLintContext) -> StatelessClassConfig:
         """Load configuration from context.
@@ -129,10 +145,7 @@ class StatelessClassRule(BaseLintRule):  # thailint: ignore[srp,dry]
             return False
 
         file_path = Path(context.file_path)
-        for pattern in config.ignore:
-            if self._matches_pattern(file_path, pattern):
-                return True
-        return False
+        return any(self._matches_pattern(file_path, pattern) for pattern in config.ignore)
 
     def _matches_pattern(self, file_path: Path, pattern: str) -> bool:
         """Check if file path matches a glob pattern.
@@ -162,12 +175,9 @@ class StatelessClassRule(BaseLintRule):  # thailint: ignore[srp,dry]
         if not context.file_content:
             return False
 
-        # Check first 10 lines for ignore-file directive
-        lines = context.file_content.splitlines()[:10]
-        for line in lines:
-            if self._is_file_ignore_directive(line):
-                return True
-        return False
+        # Check first lines for ignore-file directive
+        lines = context.file_content.splitlines()[:HEADER_SCAN_LINES]
+        return any(self._is_file_ignore_directive(line) for line in lines)
 
     def _is_file_ignore_directive(self, line: str) -> bool:
         """Check if line is a file-level ignore directive.
@@ -218,23 +228,7 @@ class StatelessClassRule(BaseLintRule):  # thailint: ignore[srp,dry]
         Returns:
             True if pattern matches this rule
         """
-        rule_id_lower = self.rule_id.lower()
-        pattern_lower = rule_pattern.lower()
-
-        # Exact match
-        if rule_id_lower == pattern_lower:
-            return True
-
-        # Prefix match: stateless-class matches stateless-class.violation
-        if rule_id_lower.startswith(pattern_lower + "."):
-            return True
-
-        # Wildcard match: stateless-class.* matches stateless-class.violation
-        if pattern_lower.endswith("*"):
-            prefix = pattern_lower[:-1]
-            return rule_id_lower.startswith(prefix)
-
-        return False
+        return rule_matches(self.rule_id, rule_pattern)
 
     def _filter_ignored_violations(
         self, classes: list[ClassInfo], context: BaseLintContext
@@ -330,7 +324,7 @@ class StatelessClassRule(BaseLintRule):  # thailint: ignore[srp,dry]
             return True
 
         # Rule-specific ignore
-        return self._matches_rule_ignore(line, "ignore")
+        return self._matches_rule_ignore(line, IgnoreDirective.IGNORE)
 
     def _create_violation(self, info: ClassInfo, context: BaseLintContext) -> Violation:
         """Create violation from class info.

src/linters/stateless_class/python_analyzer.py

@@ -145,10 +145,10 @@ def _has_constructor(class_node: ast.ClassDef) -> bool:
         True if class has constructor
     """
     constructor_names = ("__init__", "__new__")
-    for item in class_node.body:
-        if isinstance(item, ast.FunctionDef) and item.name in constructor_names:
-            return True
-    return False
+    return any(
+        isinstance(item, ast.FunctionDef) and item.name in constructor_names
+        for item in class_node.body
+    )
 
 
 def _is_exception_case(class_node: ast.ClassDef) -> bool:
@@ -174,10 +174,7 @@ def _inherits_from_abc_or_protocol(class_node: ast.ClassDef) -> bool:
     Returns:
         True if inherits from ABC or Protocol
     """
-    for base in class_node.bases:
-        if _get_base_name(base) in ("ABC", "Protocol"):
-            return True
-    return False
+    return any(_get_base_name(base) in ("ABC", "Protocol") for base in class_node.bases)
 
 
 def _get_base_name(base: ast.expr) -> str:
@@ -205,10 +202,7 @@ def _has_class_attributes(class_node: ast.ClassDef) -> bool:
     Returns:
         True if class has class attributes
     """
-    for item in class_node.body:
-        if isinstance(item, (ast.Assign, ast.AnnAssign)):
-            return True
-    return False
+    return any(isinstance(item, (ast.Assign, ast.AnnAssign)) for item in class_node.body)
 
 
 def _has_instance_attributes(class_node: ast.ClassDef) -> bool:
@@ -220,10 +214,10 @@ def _has_instance_attributes(class_node: ast.ClassDef) -> bool:
     Returns:
         True if any method assigns to self
     """
-    for item in class_node.body:
-        if isinstance(item, ast.FunctionDef) and _method_has_self_assignment(item):
-            return True
-    return False
+    return any(
+        isinstance(item, ast.FunctionDef) and _method_has_self_assignment(item)
+        for item in class_node.body
+    )
 
 
 def _method_has_self_assignment(method: ast.FunctionDef) -> bool:
@@ -235,10 +229,7 @@ def _method_has_self_assignment(method: ast.FunctionDef) -> bool:
     Returns:
         True if method assigns to self
     """
-    for node in ast.walk(method):
-        if _is_self_attribute_assignment(node):
-            return True
-    return False
+    return any(_is_self_attribute_assignment(node) for node in ast.walk(method))
 
 
 def _is_self_attribute_assignment(node: ast.AST) -> bool:

src/linters/stringly_typed/config.py

@@ -18,11 +18,10 @@ Exports: StringlyTypedConfig dataclass, default constants
 Interfaces: StringlyTypedConfig.from_dict() class method for configuration loading
 
 Implementation: Dataclass with sensible defaults, validation in __post_init__, and config
-    loading from dictionary with language-specific override support. Pylint
-    too-many-instance-attributes suppressed because configuration dataclasses inherently
-    require multiple cohesive fields (8 attributes for detection thresholds, filtering,
-    cross-file settings). Splitting would reduce cohesion without benefit. This follows
-    the established pattern in DRYConfig which has the same suppression.
+    loading from dictionary with language-specific override support
+
+Suppressions:
+    - too-many-instance-attributes: Configuration dataclass with cohesive detection settings
 """
 
 from dataclasses import dataclass, field