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

src/linters/srp/linter.py

@@ -16,12 +16,16 @@ 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 IgnoreDirectiveParser
+from src.linter_config.ignore import get_ignore_parser
 
 from .class_analyzer import ClassAnalyzer
 from .config import SRPConfig
@@ -34,7 +38,7 @@ class SRPRule(MultiLanguageLintRule):
 
     def __init__(self) -> None:
         """Initialize the SRP rule."""
-        self._ignore_parser = IgnoreDirectiveParser()
+        self._ignore_parser = get_ignore_parser()
         self._class_analyzer = ClassAnalyzer()
         self._violation_builder = ViolationBuilder()
 
@@ -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,14 +171,12 @@ class SRPRule(MultiLanguageLintRule):
         Returns:
             List of violations
         """
-        violations = []
-        for metrics in metrics_list:
-            if not isinstance(metrics, dict):
-                continue
-            violation = self._create_violation_if_needed(metrics, config, context)
-            if violation:
-                violations.append(violation)
-        return violations
+        valid_metrics = (m for m in metrics_list if isinstance(m, dict))
+        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/python_analyzer.py

@@ -1,7 +1,7 @@
 """
 Purpose: Python AST analyzer for detecting SRP violations in Python classes
 
-Scope: PythonSRPAnalyzer class for analyzing Python classes using AST
+Scope: Functions for analyzing Python classes using AST
 
 Overview: Implements Python-specific SRP analysis using the ast module to parse and analyze
     class definitions. Walks the AST to find all class definitions, then analyzes each class
@@ -13,7 +13,7 @@ Overview: Implements Python-specific SRP analysis using the ast module to parse
 
 Dependencies: ast module for Python AST parsing, typing for type hints, heuristics module
 
-Exports: PythonSRPAnalyzer class
+Exports: find_all_classes function, analyze_class function, PythonSRPAnalyzer class (compat)
 
 Interfaces: find_all_classes(tree), analyze_class(class_node, source, config)
 
@@ -27,8 +27,58 @@ from .config import SRPConfig
 from .heuristics import count_loc, count_methods, has_responsibility_keyword
 
 
+def find_all_classes(tree: ast.AST) -> list[ast.ClassDef]:
+    """Find all class definitions in AST.
+
+    Args:
+        tree: Root AST node to search
+
+    Returns:
+        List of all class definition nodes
+    """
+    classes = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef):
+            classes.append(node)
+    return classes
+
+
+def analyze_class(class_node: ast.ClassDef, source: str, config: SRPConfig) -> dict[str, Any]:
+    """Analyze a class for SRP metrics.
+
+    Args:
+        class_node: AST node representing a class definition
+        source: Full source code of the file
+        config: SRP configuration with thresholds and keywords
+
+    Returns:
+        Dictionary with class metrics (name, method_count, loc, etc.)
+    """
+    method_count = count_methods(class_node)
+    loc = count_loc(class_node, source)
+    has_keyword = has_responsibility_keyword(class_node.name, config.keywords)
+
+    return {
+        "class_name": class_node.name,
+        "method_count": method_count,
+        "loc": loc,
+        "has_keyword": has_keyword,
+        "line": class_node.lineno,
+        "column": class_node.col_offset,
+    }
+
+
+# Legacy class wrapper for backward compatibility
 class PythonSRPAnalyzer:
-    """Analyzes Python classes for SRP violations."""
+    """Analyzes Python classes for SRP violations.
+
+    Note: This class is a thin wrapper around module-level functions
+    for backward compatibility.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the analyzer."""
+        pass  # No state needed
 
     def find_all_classes(self, tree: ast.AST) -> list[ast.ClassDef]:
         """Find all class definitions in AST.
@@ -39,11 +89,7 @@ class PythonSRPAnalyzer:
         Returns:
             List of all class definition nodes
         """
-        classes = []
-        for node in ast.walk(tree):
-            if isinstance(node, ast.ClassDef):
-                classes.append(node)
-        return classes
+        return find_all_classes(tree)
 
     def analyze_class(
         self, class_node: ast.ClassDef, source: str, config: SRPConfig
@@ -58,15 +104,4 @@ class PythonSRPAnalyzer:
         Returns:
             Dictionary with class metrics (name, method_count, loc, etc.)
         """
-        method_count = count_methods(class_node)
-        loc = count_loc(class_node, source)
-        has_keyword = has_responsibility_keyword(class_node.name, config.keywords)
-
-        return {
-            "class_name": class_node.name,
-            "method_count": method_count,
-            "loc": loc,
-            "has_keyword": has_keyword,
-            "line": class_node.lineno,
-            "column": class_node.col_offset,
-        }
+        return analyze_class(class_node, source, config)

src/linters/srp/typescript_metrics_calculator.py

@@ -4,13 +4,14 @@ Purpose: TypeScript class metrics calculation for SRP analysis
 Scope: Calculates method count and lines of code for TypeScript classes
 
 Overview: Provides metrics calculation functionality for TypeScript classes in SRP analysis. Counts
-    public methods in class bodies (excludes constructors), calculates lines of code from AST node
-    positions, and identifies class body nodes. Uses tree-sitter AST node types. Isolates metrics
-    calculation from class analysis and tree traversal logic.
+    public methods in class bodies (excludes constructors and private methods starting with _),
+    calculates lines of code from AST node positions, and identifies class body nodes. Uses
+    tree-sitter AST node types. Isolates metrics calculation from class analysis and tree
+    traversal logic.
 
 Dependencies: typing
 
-Exports: TypeScriptMetricsCalculator
+Exports: count_methods function, count_loc function, TypeScriptMetricsCalculator class (compat)
 
 Interfaces: count_methods(class_node), count_loc(class_node, source)
 
@@ -20,8 +21,110 @@ Implementation: Tree-sitter node type matching, AST position arithmetic
 from typing import Any
 
 
+def count_methods(class_node: Any) -> int:
+    """Count number of methods in a TypeScript class.
+
+    Args:
+        class_node: Class declaration tree-sitter node
+
+    Returns:
+        Number of public methods (excludes constructor)
+    """
+    class_body = _get_class_body(class_node)
+    if not class_body:
+        return 0
+
+    method_count = 0
+    for child in class_body.children:
+        if _is_countable_method(child):
+            method_count += 1
+
+    return method_count
+
+
+def count_loc(class_node: Any, source: str) -> int:
+    """Count lines of code in a TypeScript class.
+
+    Args:
+        class_node: Class declaration tree-sitter node
+        source: Full source code string
+
+    Returns:
+        Number of lines in class definition
+    """
+    start_line = class_node.start_point[0]
+    end_line = class_node.end_point[0]
+    return end_line - start_line + 1
+
+
+def _get_class_body(class_node: Any) -> Any:
+    """Get the class_body node from a class declaration.
+
+    Args:
+        class_node: Class declaration node
+
+    Returns:
+        Class body node or None
+    """
+    for child in class_node.children:
+        if child.type == "class_body":
+            return child
+    return None
+
+
+def _is_countable_method(node: Any) -> bool:
+    """Check if node is a public method that should be counted.
+
+    Excludes constructors and private methods (names starting with _).
+
+    Args:
+        node: Tree-sitter node to check
+
+    Returns:
+        True if node is a countable public method
+    """
+    if node.type != "method_definition":
+        return False
+
+    method_name = _get_method_name(node)
+
+    # Don't count constructors
+    if method_name == "constructor":
+        return False
+
+    # Don't count private methods (underscore prefix convention)
+    if method_name and method_name.startswith("_"):
+        return False
+
+    return True
+
+
+def _get_method_name(node: Any) -> str | None:
+    """Extract method name from method_definition node.
+
+    Args:
+        node: Method definition tree-sitter node
+
+    Returns:
+        Method name or None if not found
+    """
+    for child in node.children:
+        if child.type == "property_identifier":
+            return child.text.decode()
+    return None
+
+
+# Legacy class wrapper for backward compatibility
 class TypeScriptMetricsCalculator:
-    """Calculates metrics for TypeScript classes."""
+    """Calculates metrics for TypeScript classes.
+
+    Note: This class is a thin wrapper around module-level functions
+    for backward compatibility.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the metrics calculator."""
+        pass  # No state needed
 
     def count_methods(self, class_node: Any) -> int:
         """Count number of methods in a TypeScript class.
@@ -32,16 +135,7 @@ class TypeScriptMetricsCalculator:
         Returns:
             Number of public methods (excludes constructor)
         """
-        class_body = self._get_class_body(class_node)
-        if not class_body:
-            return 0
-
-        method_count = 0
-        for child in class_body.children:
-            if self._is_countable_method(child):
-                method_count += 1
-
-        return method_count
+        return count_methods(class_node)
 
     def count_loc(self, class_node: Any, source: str) -> int:
         """Count lines of code in a TypeScript class.
@@ -53,38 +147,4 @@ class TypeScriptMetricsCalculator:
         Returns:
             Number of lines in class definition
         """
-        start_line = class_node.start_point[0]
-        end_line = class_node.end_point[0]
-        return end_line - start_line + 1
-
-    def _get_class_body(self, class_node: Any) -> Any:
-        """Get the class_body node from a class declaration.
-
-        Args:
-            class_node: Class declaration node
-
-        Returns:
-            Class body node or None
-        """
-        for child in class_node.children:
-            if child.type == "class_body":
-                return child
-        return None
-
-    def _is_countable_method(self, node: Any) -> bool:
-        """Check if node is a method that should be counted.
-
-        Args:
-            node: Tree-sitter node to check
-
-        Returns:
-            True if node is a countable method
-        """
-        if node.type != "method_definition":
-            return False
-
-        # Check if it's a constructor
-        return all(
-            not (child.type == "property_identifier" and child.text.decode() == "constructor")
-            for child in node.children
-        )
+        return count_loc(class_node, source)

src/linters/stateless_class/__init__.py

@@ -0,0 +1,25 @@
+"""
+Purpose: Stateless class linter package for detecting classes without state
+
+Scope: Python classes that should be refactored to module-level functions
+
+Overview: Package for detecting Python classes that have no constructor (__init__
+    or __new__) and no instance state (self.attr assignments), indicating they should
+    be refactored to module-level functions. Identifies a common anti-pattern in
+    AI-generated code where classes are used as namespaces rather than for object-
+    oriented encapsulation.
+
+Dependencies: Python AST module, base linter framework
+
+Exports: StatelessClassRule - main rule for detecting stateless classes
+
+Interfaces: StatelessClassRule.check(context) -> list[Violation]
+
+Implementation: AST-based analysis checking for constructor methods and instance
+    attribute assignments while excluding legitimate patterns (ABC, Protocol, decorators)
+"""
+
+from .linter import StatelessClassRule
+from .python_analyzer import ClassInfo, StatelessClassAnalyzer
+
+__all__ = ["StatelessClassRule", "StatelessClassAnalyzer", "ClassInfo"]

src/linters/stateless_class/config.py

@@ -0,0 +1,58 @@
+"""
+Purpose: Configuration schema for stateless-class linter
+
+Scope: Stateless class linter configuration for Python files
+
+Overview: Defines configuration schema for stateless-class linter. Provides
+    StatelessClassConfig dataclass with enabled flag, min_methods threshold (default 2)
+    for determining minimum methods required to flag a class as stateless, and ignore
+    patterns list for excluding specific files or directories. Supports per-file and
+    per-directory config overrides through from_dict class method. Integrates with
+    orchestrator's configuration system via .thailint.yaml.
+
+Dependencies: dataclasses module for configuration structure, typing module for type hints
+
+Exports: StatelessClassConfig dataclass
+
+Interfaces: from_dict(config, language) -> StatelessClassConfig for configuration loading
+
+Implementation: Dataclass with defaults matching stateless class detection conventions
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class StatelessClassConfig:
+    """Configuration for stateless-class linter."""
+
+    enabled: bool = True
+    min_methods: int = 2
+    ignore: list[str] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(
+        cls, config: dict[str, Any] | None, language: str | None = None
+    ) -> "StatelessClassConfig":
+        """Load configuration from dictionary.
+
+        Args:
+            config: Dictionary containing configuration values, or None
+            language: Programming language (unused, for interface compatibility)
+
+        Returns:
+            StatelessClassConfig instance with values from dictionary
+        """
+        if config is None:
+            return cls()
+
+        ignore_patterns = config.get("ignore", [])
+        if not isinstance(ignore_patterns, list):
+            ignore_patterns = []
+
+        return cls(
+            enabled=config.get("enabled", True),
+            min_methods=config.get("min_methods", 2),
+            ignore=ignore_patterns,
+        )