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

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