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

src/linters/magic_numbers/linter.py

@@ -12,7 +12,7 @@ Overview: Implements magic numbers linter rule following BaseLintRule interface.
     because refactoring for A-grade complexity requires extracting helper methods. Class maintains
     single responsibility of magic number detection - all methods support this core purpose.
 
-Dependencies: BaseLintRule, BaseLintContext, PythonMagicNumberAnalyzer, ContextAnalyzer,
+Dependencies: BaseLintRule, BaseLintContext, PythonMagicNumberAnalyzer, is_acceptable_context,
     ViolationBuilder, MagicNumberConfig, IgnoreDirectiveParser
 
 Exports: MagicNumberRule class
@@ -21,10 +21,16 @@ Interfaces: MagicNumberRule.check(context) -> list[Violation], properties for ru
 
 Implementation: Composition pattern with helper classes, AST-based analysis with configurable
     allowed numbers and context detection
+
+Suppressions:
+    - too-many-arguments,too-many-positional-arguments: TypeScript violation creation with related params
+    - srp: Rule class coordinates analyzers and violation builders. Method count exceeds limit
+        due to complexity refactoring. All methods support magic number detection.
 """
 
 import ast
 from pathlib import Path
+from typing import Any
 
 from src.core.base import BaseLintContext, MultiLanguageLintRule
 from src.core.linter_utils import load_linter_config
@@ -33,7 +39,7 @@ from src.core.violation_utils import get_violation_line, has_python_noqa
 from src.linter_config.ignore import get_ignore_parser
 
 from .config import MagicNumberConfig
-from .context_analyzer import ContextAnalyzer
+from .context_analyzer import is_acceptable_context
 from .python_analyzer import PythonMagicNumberAnalyzer
 from .typescript_analyzer import TypeScriptMagicNumberAnalyzer
 from .typescript_ignore_checker import TypeScriptIgnoreChecker
@@ -47,7 +53,6 @@ class MagicNumberRule(MultiLanguageLintRule):  # thailint: ignore[srp]
         """Initialize the magic numbers rule."""
         self._ignore_parser = get_ignore_parser()
         self._violation_builder = ViolationBuilder(self.rule_id)
-        self._context_analyzer = ContextAnalyzer()
         self._typescript_ignore_checker = TypeScriptIgnoreChecker()
 
     @property
@@ -134,10 +139,7 @@ class MagicNumberRule(MultiLanguageLintRule):  # thailint: ignore[srp]
             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.
@@ -251,9 +253,7 @@ class MagicNumberRule(MultiLanguageLintRule):  # thailint: ignore[srp]
             "allowed_numbers": config.allowed_numbers,
         }
 
-        if self._context_analyzer.is_acceptable_context(
-            node, parent, context.file_path, config_dict
-        ):
+        if is_acceptable_context(node, parent, context.file_path, config_dict):
             return False
 
         return True
@@ -421,12 +421,17 @@ class MagicNumberRule(MultiLanguageLintRule):  # thailint: ignore[srp]
         return value in config.allowed_numbers or self._is_test_file(context.file_path)
 
     def _is_typescript_special_context(
-        self, node: object, analyzer: TypeScriptMagicNumberAnalyzer, context: BaseLintContext
+        self, node: Any, analyzer: TypeScriptMagicNumberAnalyzer, context: BaseLintContext
     ) -> bool:
-        """Check if in TypeScript-specific special context."""
-        # Calls require type: ignore because node is typed as object but analyzer expects Node
-        in_enum = analyzer.is_enum_context(node)  # type: ignore[arg-type]
-        in_const_def = analyzer.is_constant_definition(node, context.file_content or "")  # type: ignore[arg-type]
+        """Check if in TypeScript-specific special context.
+
+        Args:
+            node: Tree-sitter Node (typed as Any due to optional dependency)
+            analyzer: TypeScript analyzer
+            context: Lint context
+        """
+        in_enum = analyzer.is_enum_context(node)
+        in_const_def = analyzer.is_constant_definition(node, context.file_content or "")
         return in_enum or in_const_def
 
     def _is_test_file(self, file_path: object) -> bool:

src/linters/magic_numbers/python_analyzer.py

@@ -10,7 +10,7 @@ Overview: Provides PythonMagicNumberAnalyzer class that traverses Python AST to
     value, and source location. This analyzer handles Python-specific AST structure and provides
     the foundation for magic number detection by identifying all candidates before context filtering.
 
-Dependencies: ast module for AST parsing and node types
+Dependencies: ast module for AST parsing and node types, analyzers.ast_utils
 
 Exports: PythonMagicNumberAnalyzer class
 
@@ -23,6 +23,8 @@ Implementation: AST NodeVisitor pattern with parent tracking, filters for numeri
 import ast
 from typing import Any
 
+from src.analyzers.ast_utils import build_parent_map
+
 
 class PythonMagicNumberAnalyzer(ast.NodeVisitor):
     """Analyzes Python AST to find numeric literals."""
@@ -44,24 +46,10 @@ class PythonMagicNumberAnalyzer(ast.NodeVisitor):
             List of tuples (node, parent, value, line_number)
         """
         self.numeric_literals = []
-        self.parent_map = {}
-        self._build_parent_map(tree)
+        self.parent_map = build_parent_map(tree)
         self.visit(tree)
         return self.numeric_literals
 
-    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 visit_Constant(self, node: ast.Constant) -> None:
         """Visit a Constant node and check if it's a numeric literal.
 

src/linters/magic_numbers/typescript_analyzer.py

@@ -20,20 +20,17 @@ Interfaces: find_numeric_literals(root_node) -> list[tuple], is_enum_context(nod
 
 Implementation: Tree-sitter node traversal with visitor pattern, context-aware filtering
     for acceptable numeric literal locations
-"""
-
-from typing import Any
-
-from src.analyzers.typescript_base import TypeScriptBaseAnalyzer
 
-# dry: ignore-block - tree-sitter import pattern (common across TypeScript analyzers)
-try:
-    from tree_sitter import Node
+Suppressions:
+    - srp: Analyzer implements tree-sitter traversal with context detection methods.
+        Methods support single responsibility of magic number detection in TypeScript.
+"""
 
-    TREE_SITTER_AVAILABLE = True
-except ImportError:
-    TREE_SITTER_AVAILABLE = False
-    Node = Any  # type: ignore
+from src.analyzers.typescript_base import (
+    TREE_SITTER_AVAILABLE,
+    Node,
+    TypeScriptBaseAnalyzer,
+)
 
 
 class TypeScriptMagicNumberAnalyzer(TypeScriptBaseAnalyzer):  # thailint: ignore[srp]
@@ -44,10 +41,6 @@ class TypeScriptMagicNumberAnalyzer(TypeScriptBaseAnalyzer):  # thailint: ignore
     of TypeScript magic number detection - all methods support this core purpose.
     """
 
-    def __init__(self) -> None:  # pylint: disable=useless-parent-delegation
-        """Initialize the TypeScript magic number analyzer."""
-        super().__init__()  # Sets self.tree_sitter_available from base class
-
     def find_numeric_literals(self, root_node: Node) -> list[tuple[Node, float | int, int]]:
         """Find all numeric literal nodes in TypeScript/JavaScript AST.
 

src/linters/method_property/config.py

@@ -18,6 +18,10 @@ Exports: MethodPropertyConfig dataclass, DEFAULT_EXCLUDE_PREFIXES, DEFAULT_EXCLU
 Interfaces: from_dict(config, language) -> MethodPropertyConfig for configuration loading
 
 Implementation: Dataclass with defaults matching Pythonic conventions and common use cases
+
+Suppressions:
+    - dry: MethodPropertyConfig includes extensive exclusion lists that share patterns with
+        other config classes. Lists are maintained separately for clear documentation.
 """
 
 from dataclasses import dataclass, field

src/linters/method_property/linter.py

@@ -21,6 +21,10 @@ Interfaces: check(context) -> list[Violation] for rule validation, standard rule
 
 Implementation: Composition pattern with helper classes (analyzer, violation builder),
     AST-based analysis for Python with comprehensive exclusion rules
+
+Suppressions:
+    - srp,dry: Rule class coordinates analyzer, config, and violation building. Method count
+        exceeds limit due to comprehensive ignore directive support.
 """
 
 import ast
@@ -109,10 +113,7 @@ class MethodPropertyRule(MultiLanguageLintRule):  # 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)
 
     # dry: ignore-block
     def _matches_pattern(self, file_path: Path, pattern: str) -> bool:

src/linters/method_property/python_analyzer.py

@@ -18,6 +18,10 @@ Exports: PythonMethodAnalyzer class, PropertyCandidate dataclass
 Interfaces: find_property_candidates(tree) -> list[PropertyCandidate]
 
 Implementation: AST walk pattern with comprehensive method body analysis and exclusion checks
+
+Suppressions:
+    - srp: Analyzer class implements comprehensive exclusion rules requiring many helper methods.
+        All methods support single responsibility of property candidate detection.
 """
 
 import ast
@@ -391,10 +395,7 @@ class PythonMethodAnalyzer:  # thailint: ignore[srp]
         Returns:
             True if assigning to self.*
         """
-        for target in targets:
-            if self._is_self_target(target):
-                return True
-        return False
+        return any(self._is_self_target(target) for target in targets)
 
     def _is_self_target(self, target: ast.expr) -> bool:
         """Check if target is a self attribute (self.* or self._*).

src/linters/method_property/violation_builder.py

@@ -16,6 +16,9 @@ Exports: ViolationBuilder class
 Interfaces: create_violation(method_name, line, column, file_path, is_get_prefix, class_name)
 
 Implementation: Builder pattern with message templates suggesting @property decorator conversion
+
+Suppressions:
+    - too-many-arguments,too-many-positional-arguments: Violation creation with related params
 """
 
 from pathlib import Path

src/linters/nesting/typescript_analyzer.py

@@ -16,20 +16,14 @@ Exports: TypeScriptNestingAnalyzer class with calculate_max_depth methods
 Interfaces: calculate_max_depth(func_node) -> tuple[int, int], find_all_functions(root_node)
 
 Implementation: Inherits tree-sitter parsing from base, visitor pattern with depth tracking
-"""
-
-from typing import Any
 
-from src.analyzers.typescript_base import TypeScriptBaseAnalyzer
-
-# 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
+from src.analyzers.typescript_base import (
+    TREE_SITTER_AVAILABLE,
+    Node,
+    TypeScriptBaseAnalyzer,
+)
 
 from .typescript_function_extractor import TypeScriptFunctionExtractor
 

src/linters/nesting/typescript_function_extractor.py

@@ -27,10 +27,6 @@ from src.analyzers.typescript_base import TypeScriptBaseAnalyzer
 class TypeScriptFunctionExtractor(TypeScriptBaseAnalyzer):
     """Extracts function information from TypeScript AST nodes."""
 
-    def __init__(self) -> None:  # pylint: disable=useless-parent-delegation
-        """Initialize the TypeScript function extractor."""
-        super().__init__()  # Sets self.tree_sitter_available from base class
-
     def collect_all_functions(self, root_node: Any) -> list[tuple[Any, str]]:
         """Collect all function nodes from TypeScript AST.
 

src/linters/print_statements/linter.py

@@ -21,6 +21,11 @@ Interfaces: check(context) -> list[Violation] for rule validation, standard rule
 
 Implementation: Composition pattern with helper classes (analyzers, violation builder),
     AST-based analysis for Python, tree-sitter for TypeScript/JavaScript
+
+Suppressions:
+    - too-many-arguments,too-many-positional-arguments: Violation creation with related fields
+    - srp: Rule class coordinates multiple language analyzers and violation building.
+        Method count exceeds limit due to dual-language support (Python + TypeScript).
 """
 
 import ast
@@ -121,10 +126,7 @@ class PrintStatementRule(MultiLanguageLintRule):  # thailint: ignore[srp]
             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.

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],