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

src/linters/magic_numbers/context_analyzer.py

@@ -3,249 +3,247 @@ Purpose: Analyzes contexts to determine if numeric literals are acceptable
 
 Scope: Context detection for magic number acceptable usage patterns
 
-Overview: Provides ContextAnalyzer class that determines whether a numeric literal is in an acceptable
+Overview: Provides module-level functions that determine whether a numeric literal is in an acceptable
     context where it should not be flagged as a magic number. Detects acceptable contexts including
     constant definitions (UPPERCASE names), small integers in range() or enumerate() calls, test files,
     and configuration contexts. Uses AST node analysis to inspect parent nodes and determine the usage
     pattern of numeric literals. Helps reduce false positives by distinguishing between legitimate
-    numeric literals and true magic numbers that should be extracted to constants. Method count (10)
-    exceeds SRP limit (8) because refactoring for A-grade complexity requires extracting helper methods.
-    Class maintains single responsibility of context analysis - all methods support this core purpose.
+    numeric literals and true magic numbers that should be extracted to constants.
 
 Dependencies: ast module for AST node types, pathlib for Path handling
 
-Exports: ContextAnalyzer class
+Exports: is_acceptable_context function and helper functions
 
-Interfaces: ContextAnalyzer.is_acceptable_context(node, parent, file_path, config) -> bool,
-    various helper methods for specific context checks
+Interfaces: is_acceptable_context(node, parent, file_path, config) -> bool
 
 Implementation: AST parent node inspection, pattern matching for acceptable contexts, configurable
     max_small_integer threshold for range detection
+
+Suppressions:
+    - B101: Assert used for internal invariant checking, not security validation
 """
 
 import ast
 from pathlib import Path
 
 
-class ContextAnalyzer:  # thailint: ignore[srp]
-    """Analyzes contexts to determine if numeric literals are acceptable."""
-
-    def __init__(self) -> None:
-        """Initialize the context analyzer."""
-        pass  # Stateless analyzer for context checking
-
-    def is_acceptable_context(
-        self,
-        node: ast.Constant,
-        parent: ast.AST | None,
-        file_path: Path | None,
-        config: dict,
-    ) -> bool:
-        """Check if a numeric literal is in an acceptable context.
-
-        Args:
-            node: The numeric constant node
-            parent: The parent node in the AST
-            file_path: Path to the file being analyzed
-            config: Configuration with allowed_numbers and max_small_integer
-
-        Returns:
-            True if the context is acceptable and should not be flagged
-        """
-        # File-level and definition checks
-        if self.is_test_file(file_path) or self.is_constant_definition(node, parent):
-            return True
-
-        # Usage pattern checks
-        return self._is_acceptable_usage_pattern(node, parent, config)
-
-    def _is_acceptable_usage_pattern(
-        self, node: ast.Constant, parent: ast.AST | None, config: dict
-    ) -> bool:
-        """Check if numeric literal is in acceptable usage pattern.
-
-        Args:
-            node: The numeric constant node
-            parent: The parent node in the AST
-            config: Configuration with max_small_integer threshold
-
-        Returns:
-            True if usage pattern is acceptable
-        """
-        if self.is_small_integer_in_range(node, parent, config):
-            return True
-
-        if self.is_small_integer_in_enumerate(node, parent, config):
-            return True
-
-        return self.is_string_repetition(node, parent)
-
-    def is_test_file(self, file_path: Path | None) -> bool:
-        """Check if the file is a test file.
-
-        Args:
-            file_path: Path to the file
-
-        Returns:
-            True if the file is a test file (matches test_*.py pattern)
-        """
-        if not file_path:
-            return False
-        return file_path.name.startswith("test_") or "_test.py" in file_path.name
-
-    def is_constant_definition(self, node: ast.Constant, parent: ast.AST | None) -> bool:
-        """Check if the number is part of an UPPERCASE constant definition.
-
-        Args:
-            node: The numeric constant node
-            parent: The parent node in the AST
-
-        Returns:
-            True if this is a constant definition
-        """
-        if not self._is_assignment_node(parent):
-            return False
-
-        # Type narrowing: parent is ast.Assign after the check above
-        assert isinstance(parent, ast.Assign)  # nosec B101
-        return self._has_constant_target(parent)
-
-    def _is_assignment_node(self, parent: ast.AST | None) -> bool:
-        """Check if parent is an assignment node."""
-        return parent is not None and isinstance(parent, ast.Assign)
-
-    def _has_constant_target(self, parent: ast.Assign) -> bool:
-        """Check if assignment has uppercase constant target."""
-        return any(
-            isinstance(target, ast.Name) and self._is_constant_name(target.id)
-            for target in parent.targets
-        )
-
-    def _is_constant_name(self, name: str) -> bool:
-        """Check if a name follows constant naming convention.
-
-        Args:
-            name: Variable name to check
-
-        Returns:
-            True if the name is UPPERCASE (constant convention)
-        """
-        return name.isupper() and len(name) > 1
-
-    def is_small_integer_in_range(
-        self, node: ast.Constant, parent: ast.AST | None, config: dict
-    ) -> bool:
-        """Check if this is a small integer used in range() call.
-
-        Args:
-            node: The numeric constant node
-            parent: The parent node in the AST
-            config: Configuration with max_small_integer threshold
-
-        Returns:
-            True if this is a small integer in range()
-        """
-        if not isinstance(node.value, int):
-            return False
-
-        max_small_int = config.get("max_small_integer", 10)
-        if not 0 <= node.value <= max_small_int:
-            return False
-
-        return self._is_in_range_call(parent)
-
-    def is_small_integer_in_enumerate(
-        self, node: ast.Constant, parent: ast.AST | None, config: dict
-    ) -> bool:
-        """Check if this is a small integer used in enumerate() call.
-
-        Args:
-            node: The numeric constant node
-            parent: The parent node in the AST
-            config: Configuration with max_small_integer threshold
-
-        Returns:
-            True if this is a small integer in enumerate()
-        """
-        if not isinstance(node.value, int):
-            return False
-
-        max_small_int = config.get("max_small_integer", 10)
-        if not 0 <= node.value <= max_small_int:
-            return False
-
-        return self._is_in_enumerate_call(parent)
-
-    def _is_in_range_call(self, parent: ast.AST | None) -> bool:
-        """Check if the parent is a range() call.
-
-        Args:
-            parent: The parent node
-
-        Returns:
-            True if parent is range() call
-        """
-        return (
-            isinstance(parent, ast.Call)
-            and isinstance(parent.func, ast.Name)
-            and parent.func.id == "range"
-        )
-
-    def _is_in_enumerate_call(self, parent: ast.AST | None) -> bool:
-        """Check if the parent is an enumerate() call.
-
-        Args:
-            parent: The parent node
-
-        Returns:
-            True if parent is enumerate() call
-        """
-        return (
-            isinstance(parent, ast.Call)
-            and isinstance(parent.func, ast.Name)
-            and parent.func.id == "enumerate"
-        )
-
-    def is_string_repetition(self, node: ast.Constant, parent: ast.AST | None) -> bool:
-        """Check if this number is used in string repetition (e.g., "-" * 40).
-
-        Args:
-            node: The numeric constant node
-            parent: The parent node in the AST
-
-        Returns:
-            True if this is a string repetition pattern
-        """
-        if not isinstance(node.value, int):
-            return False
-
-        if not isinstance(parent, ast.BinOp):
-            return False
-
-        if not isinstance(parent.op, ast.Mult):
-            return False
-
-        # Check if either operand is a string constant
-        return self._has_string_operand(parent)
-
-    def _has_string_operand(self, binop: ast.BinOp) -> bool:
-        """Check if binary operation has a string operand.
-
-        Args:
-            binop: Binary operation node
-
-        Returns:
-            True if either left or right operand is a string constant
-        """
-        return self._is_string_constant(binop.left) or self._is_string_constant(binop.right)
-
-    def _is_string_constant(self, node: ast.AST) -> bool:
-        """Check if a node is a string constant.
-
-        Args:
-            node: AST node to check
-
-        Returns:
-            True if node is a Constant with string value
-        """
-        return isinstance(node, ast.Constant) and isinstance(node.value, str)
+def is_acceptable_context(
+    node: ast.Constant,
+    parent: ast.AST | None,
+    file_path: Path | None,
+    config: dict,
+) -> bool:
+    """Check if a numeric literal is in an acceptable context.
+
+    Args:
+        node: The numeric constant node
+        parent: The parent node in the AST
+        file_path: Path to the file being analyzed
+        config: Configuration with allowed_numbers and max_small_integer
+
+    Returns:
+        True if the context is acceptable and should not be flagged
+    """
+    # File-level and definition checks
+    if is_test_file(file_path) or is_constant_definition(node, parent):
+        return True
+
+    # Usage pattern checks
+    return _is_acceptable_usage_pattern(node, parent, config)
+
+
+def _is_acceptable_usage_pattern(node: ast.Constant, parent: ast.AST | None, config: dict) -> bool:
+    """Check if numeric literal is in acceptable usage pattern.
+
+    Args:
+        node: The numeric constant node
+        parent: The parent node in the AST
+        config: Configuration with max_small_integer threshold
+
+    Returns:
+        True if usage pattern is acceptable
+    """
+    if is_small_integer_in_range(node, parent, config):
+        return True
+
+    if is_small_integer_in_enumerate(node, parent, config):
+        return True
+
+    return is_string_repetition(node, parent)
+
+
+def is_test_file(file_path: Path | None) -> bool:
+    """Check if the file is a test file.
+
+    Args:
+        file_path: Path to the file
+
+    Returns:
+        True if the file is a test file (matches test_*.py pattern)
+    """
+    if not file_path:
+        return False
+    return file_path.name.startswith("test_") or "_test.py" in file_path.name
+
+
+def is_constant_definition(node: ast.Constant, parent: ast.AST | None) -> bool:
+    """Check if the number is part of an UPPERCASE constant definition.
+
+    Args:
+        node: The numeric constant node
+        parent: The parent node in the AST
+
+    Returns:
+        True if this is a constant definition
+    """
+    if not _is_assignment_node(parent):
+        return False
+
+    # Type narrowing: parent is ast.Assign after the check above
+    assert isinstance(parent, ast.Assign)  # nosec B101
+    return _has_constant_target(parent)
+
+
+def _is_assignment_node(parent: ast.AST | None) -> bool:
+    """Check if parent is an assignment node."""
+    return parent is not None and isinstance(parent, ast.Assign)
+
+
+def _has_constant_target(parent: ast.Assign) -> bool:
+    """Check if assignment has uppercase constant target."""
+    return any(
+        isinstance(target, ast.Name) and _is_constant_name(target.id) for target in parent.targets
+    )
+
+
+def _is_constant_name(name: str) -> bool:
+    """Check if a name follows constant naming convention.
+
+    Args:
+        name: Variable name to check
+
+    Returns:
+        True if the name is UPPERCASE (constant convention)
+    """
+    return name.isupper() and len(name) > 1
+
+
+def is_small_integer_in_range(node: ast.Constant, parent: ast.AST | None, config: dict) -> bool:
+    """Check if this is a small integer used in range() call.
+
+    Args:
+        node: The numeric constant node
+        parent: The parent node in the AST
+        config: Configuration with max_small_integer threshold
+
+    Returns:
+        True if this is a small integer in range()
+    """
+    if not isinstance(node.value, int):
+        return False
+
+    max_small_int = config.get("max_small_integer", 10)
+    if not 0 <= node.value <= max_small_int:
+        return False
+
+    return _is_in_range_call(parent)
+
+
+def is_small_integer_in_enumerate(node: ast.Constant, parent: ast.AST | None, config: dict) -> bool:
+    """Check if this is a small integer used in enumerate() call.
+
+    Args:
+        node: The numeric constant node
+        parent: The parent node in the AST
+        config: Configuration with max_small_integer threshold
+
+    Returns:
+        True if this is a small integer in enumerate()
+    """
+    if not isinstance(node.value, int):
+        return False
+
+    max_small_int = config.get("max_small_integer", 10)
+    if not 0 <= node.value <= max_small_int:
+        return False
+
+    return _is_in_enumerate_call(parent)
+
+
+def _is_in_range_call(parent: ast.AST | None) -> bool:
+    """Check if the parent is a range() call.
+
+    Args:
+        parent: The parent node
+
+    Returns:
+        True if parent is range() call
+    """
+    return (
+        isinstance(parent, ast.Call)
+        and isinstance(parent.func, ast.Name)
+        and parent.func.id == "range"
+    )
+
+
+def _is_in_enumerate_call(parent: ast.AST | None) -> bool:
+    """Check if the parent is an enumerate() call.
+
+    Args:
+        parent: The parent node
+
+    Returns:
+        True if parent is enumerate() call
+    """
+    return (
+        isinstance(parent, ast.Call)
+        and isinstance(parent.func, ast.Name)
+        and parent.func.id == "enumerate"
+    )
+
+
+def is_string_repetition(node: ast.Constant, parent: ast.AST | None) -> bool:
+    """Check if this number is used in string repetition (e.g., "-" * 40).
+
+    Args:
+        node: The numeric constant node
+        parent: The parent node in the AST
+
+    Returns:
+        True if this is a string repetition pattern
+    """
+    if not isinstance(node.value, int):
+        return False
+
+    if not isinstance(parent, ast.BinOp):
+        return False
+
+    if not isinstance(parent.op, ast.Mult):
+        return False
+
+    # Check if either operand is a string constant
+    return _has_string_operand(parent)
+
+
+def _has_string_operand(binop: ast.BinOp) -> bool:
+    """Check if binary operation has a string operand.
+
+    Args:
+        binop: Binary operation node
+
+    Returns:
+        True if either left or right operand is a string constant
+    """
+    return _is_string_constant(binop.left) or _is_string_constant(binop.right)
+
+
+def _is_string_constant(node: ast.AST) -> bool:
+    """Check if a node is a string constant.
+
+    Args:
+        node: AST node to check
+
+    Returns:
+        True if node is a Constant with string value
+    """
+    return isinstance(node, ast.Constant) and isinstance(node.value, str)

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.