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

src/linters/dry/config.py

@@ -15,11 +15,16 @@ Exports: DRYConfig dataclass
 Interfaces: DRYConfig.__init__, DRYConfig.from_dict(config: dict) -> DRYConfig
 
 Implementation: Dataclass with field defaults, __post_init__ validation, and dict-based construction
+
+Suppressions:
+    - too-many-instance-attributes: Configuration dataclass with related settings
 """
 
 from dataclasses import dataclass, field
 from typing import Any
 
+from src.core.constants import StorageMode
+
 # Default configuration constants
 DEFAULT_MIN_DUPLICATE_LINES = 3
 DEFAULT_MIN_DUPLICATE_TOKENS = 30
@@ -72,7 +77,8 @@ class DRYConfig:  # pylint: disable=too-many-instance-attributes
     def __post_init__(self) -> None:
         """Validate configuration values."""
         self._validate_positive_fields()
-        if self.storage_mode not in ("memory", "tempfile"):
+        valid_modes = (StorageMode.MEMORY, StorageMode.TEMPFILE)
+        if self.storage_mode not in valid_modes:
             raise ValueError(
                 f"storage_mode must be 'memory' or 'tempfile', got '{self.storage_mode}'"
             )

src/linters/dry/constant_matcher.py

@@ -12,11 +12,14 @@ Overview: Implements fuzzy matching strategies to identify related constants acr
 
 Dependencies: ConstantInfo, ConstantLocation, ConstantGroup from constant module
 
-Exports: ConstantMatcher class
+Exports: find_constant_groups function
 
-Interfaces: ConstantMatcher.find_groups(constants) -> list[ConstantGroup]
+Interfaces: find_constant_groups(constants) -> list[ConstantGroup]
 
 Implementation: Union-Find algorithm for grouping, word-set hashing, Levenshtein distance calculation
+
+Suppressions:
+    - arguments-out-of-order: Named arguments used for clarity in ConstantLocation
 """
 
 from collections.abc import Callable
@@ -80,29 +83,35 @@ class UnionFind:
             self._parent[px] = py
 
 
-class ConstantMatcher:
-    """Fuzzy matching for constant names."""
-
-    def find_groups(self, constants: list[tuple[Path, ConstantInfo]]) -> list[ConstantGroup]:
-        """Find groups of related constants."""
-        if not constants:
-            return []
-        locations = _build_locations(constants)
-        exact_groups = _group_by_exact_name(locations)
-        return self._merge_fuzzy_groups(exact_groups)
-
-    def _merge_fuzzy_groups(self, groups: dict[str, ConstantGroup]) -> list[ConstantGroup]:
-        """Merge groups that match via fuzzy matching."""
-        names = list(groups.keys())
-        uf = UnionFind(names)
-        _union_matching_pairs(names, uf, self._is_fuzzy_match)
-        return _build_merged_groups(names, groups, uf)
-
-    def _is_fuzzy_match(self, name1: str, name2: str) -> bool:
-        """Check if two constant names should be considered a match."""
-        if name1 == name2:
-            return True
-        return _is_fuzzy_similar(name1, name2)
+def find_constant_groups(constants: list[tuple[Path, ConstantInfo]]) -> list[ConstantGroup]:
+    """Find groups of related constants.
+
+    Args:
+        constants: List of (file_path, ConstantInfo) tuples
+
+    Returns:
+        List of ConstantGroup instances representing related constants
+    """
+    if not constants:
+        return []
+    locations = _build_locations(constants)
+    exact_groups = _group_by_exact_name(locations)
+    return _merge_fuzzy_groups(exact_groups)
+
+
+def _merge_fuzzy_groups(groups: dict[str, ConstantGroup]) -> list[ConstantGroup]:
+    """Merge groups that match via fuzzy matching."""
+    names = list(groups.keys())
+    uf = UnionFind(names)
+    _union_matching_pairs(names, uf, _is_fuzzy_match)
+    return _build_merged_groups(names, groups, uf)
+
+
+def _is_fuzzy_match(name1: str, name2: str) -> bool:
+    """Check if two constant names should be considered a match."""
+    if name1 == name2:
+        return True
+    return _is_fuzzy_similar(name1, name2)
 
 
 def _build_locations(constants: list[tuple[Path, ConstantInfo]]) -> list[ConstantLocation]:

src/linters/dry/file_analyzer.py

@@ -18,6 +18,8 @@ Implementation: Delegates to language-specific analyzers, always performs fresh
 
 from pathlib import Path
 
+from src.core.constants import Language
+
 from .block_filter import BlockFilterRegistry, create_default_registry
 from .cache import CodeBlock
 from .config import DRYConfig
@@ -83,8 +85,8 @@ class FileAnalyzer:
             List of CodeBlock instances
         """
         # Analyze file based on language
-        if language == "python":
+        if language == Language.PYTHON:
             return self._python_analyzer.analyze(file_path, content, config)
-        if language in ("typescript", "javascript"):
+        if language in (Language.TYPESCRIPT, Language.JAVASCRIPT):
             return self._typescript_analyzer.analyze(file_path, content, config)
         return []

src/linters/dry/inline_ignore.py

@@ -50,14 +50,11 @@ class InlineIgnoreParser:
         Returns:
             List of (start, end) tuples for ignore ranges
         """
-        ranges = []
-
-        for i, line in enumerate(lines, start=1):
-            ignore_range = self._parse_ignore_directive(line, i, len(lines))
-            if ignore_range:
-                ranges.append(ignore_range)
-
-        return ranges
+        return [
+            ignore_range
+            for i, line in enumerate(lines, start=1)
+            if (ignore_range := self._parse_ignore_directive(line, i, len(lines)))
+        ]
 
     def _parse_ignore_directive(
         self, line: str, line_num: int, total_lines: int
@@ -115,10 +112,7 @@ class InlineIgnoreParser:
         Returns:
             True if ranges overlap
         """
-        for ign_start, ign_end in ranges:
-            if line <= ign_end and end_line >= ign_start:
-                return True
-        return False
+        return any(line <= ign_end and end_line >= ign_start for ign_start, ign_end in ranges)
 
     def _check_single_line(self, line: int, ranges: list[tuple[int, int]]) -> bool:
         """Check if single line is in any ignore range.
@@ -130,10 +124,7 @@ class InlineIgnoreParser:
         Returns:
             True if line is in any range
         """
-        for start, end in ranges:
-            if start <= line <= end:
-                return True
-        return False
+        return any(start <= line <= end for start, end in ranges)
 
     def clear(self) -> None:
         """Clear all stored ignore ranges."""

src/linters/dry/linter.py

@@ -11,18 +11,23 @@ Overview: Implements DRY linter rule following BaseLintRule interface with state
     with SRP.
 
 Dependencies: BaseLintRule, BaseLintContext, ConfigLoader, StorageInitializer, FileAnalyzer,
-    DuplicateStorage, ViolationGenerator, PythonConstantExtractor, TypeScriptConstantExtractor,
-    ConstantMatcher, ConstantViolationBuilder
+    DuplicateStorage, ViolationGenerator, extract_python_constants, TypeScriptConstantExtractor,
+    find_constant_groups, ConstantViolationBuilder
 
 Exports: DRYRule class
 
 Interfaces: DRYRule.check(context) -> list[Violation], finalize() -> list[Violation]
 
 Implementation: Delegates all logic to helper classes, maintains only orchestration and state
+
+Suppressions:
+    - too-many-instance-attributes: DRYComponents groups related helper dependencies
+    - B101: Type narrowing assertions after guards (storage initialized, file_path/content set)
 """
 
 from __future__ import annotations
 
+from collections.abc import Callable
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -33,12 +38,12 @@ from src.core.types import Violation
 from .config import DRYConfig
 from .config_loader import ConfigLoader
 from .constant import ConstantInfo
-from .constant_matcher import ConstantMatcher
+from .constant_matcher import find_constant_groups
 from .constant_violation_builder import ConstantViolationBuilder
 from .duplicate_storage import DuplicateStorage
 from .file_analyzer import FileAnalyzer
 from .inline_ignore import InlineIgnoreParser
-from .python_constant_extractor import PythonConstantExtractor
+from .python_constant_extractor import extract_python_constants
 from .storage_initializer import StorageInitializer
 from .typescript_constant_extractor import TypeScriptConstantExtractor
 from .violation_generator import ViolationGenerator
@@ -53,9 +58,7 @@ class DRYComponents:  # pylint: disable=too-many-instance-attributes
     file_analyzer: FileAnalyzer
     violation_generator: ViolationGenerator
     inline_ignore: InlineIgnoreParser
-    python_extractor: PythonConstantExtractor
     typescript_extractor: TypeScriptConstantExtractor
-    constant_matcher: ConstantMatcher
     constant_violation_builder: ConstantViolationBuilder
 
 
@@ -79,12 +82,22 @@ class DRYRule(BaseLintRule):
             file_analyzer=FileAnalyzer(),  # Placeholder, will be replaced with configured one
             violation_generator=ViolationGenerator(),
             inline_ignore=InlineIgnoreParser(),
-            python_extractor=PythonConstantExtractor(),
             typescript_extractor=TypeScriptConstantExtractor(),
-            constant_matcher=ConstantMatcher(),
             constant_violation_builder=ConstantViolationBuilder(),
         )
 
+    @property
+    def _active_storage(self) -> DuplicateStorage:
+        """Get storage, asserting it has been initialized."""
+        assert self._storage is not None, "Storage not initialized"  # nosec B101
+        return self._storage
+
+    @property
+    def _active_file_analyzer(self) -> FileAnalyzer:
+        """Get file analyzer, asserting it has been initialized."""
+        assert self._file_analyzer is not None, "File analyzer not initialized"  # nosec B101
+        return self._file_analyzer
+
     @property
     def rule_id(self) -> str:
         """Unique identifier for this rule."""
@@ -115,8 +128,12 @@ class DRYRule(BaseLintRule):
 
     def _process_file(self, context: BaseLintContext, config: DRYConfig) -> None:
         """Process a single file for duplicates and constants."""
-        file_path = Path(context.file_path)  # type: ignore[arg-type]
-        self._helpers.inline_ignore.parse_file(file_path, context.file_content or "")
+        # should_process_file ensures file_path and file_content are set
+        assert context.file_path is not None  # nosec B101
+        assert context.file_content is not None  # nosec B101
+
+        file_path = context.file_path
+        self._helpers.inline_ignore.parse_file(file_path, context.file_content)
         self._ensure_storage_initialized(context, config)
         self._analyze_and_store(context, config)
         if config.detect_duplicate_constants:
@@ -134,15 +151,18 @@ class DRYRule(BaseLintRule):
         """Analyze file and store blocks."""
         if not self._can_analyze(context):
             return
-        file_path = Path(context.file_path)  # type: ignore[arg-type]
-        blocks = self._file_analyzer.analyze(  # type: ignore[union-attr]
-            file_path,
-            context.file_content,  # type: ignore[arg-type]
+        # _can_analyze ensures file_path and file_content are set
+        assert context.file_path is not None  # nosec B101
+        assert context.file_content is not None  # nosec B101
+
+        blocks = self._active_file_analyzer.analyze(
+            context.file_path,
+            context.file_content,
             context.language,
             config,
         )
         if blocks:
-            self._storage.add_blocks(file_path, blocks)  # type: ignore[union-attr]
+            self._active_storage.add_blocks(context.file_path, blocks)
 
     def _can_analyze(self, context: BaseLintContext) -> bool:
         """Check if context is ready for analysis."""
@@ -158,9 +178,9 @@ class DRYRule(BaseLintRule):
         if context.file_path is None or context.file_content is None:
             return
         file_path = Path(context.file_path)
-        extractor = _get_extractor_for_language(context.language, self._helpers)
-        if extractor:
-            self._constants.extend((file_path, c) for c in extractor.extract(context.file_content))
+        extract_fn = _get_extractor_for_language(context.language, self._helpers)
+        if extract_fn:
+            self._constants.extend((file_path, c) for c in extract_fn(context.file_content))
 
     def finalize(self) -> list[Violation]:
         """Generate violations after all files processed."""
@@ -180,14 +200,17 @@ class DRYRule(BaseLintRule):
         return violations
 
 
+ConstantExtractorFn = Callable[[str], list[ConstantInfo]]
+
+
 def _get_extractor_for_language(
     language: str | None, helpers: DRYComponents
-) -> PythonConstantExtractor | TypeScriptConstantExtractor | None:
-    """Get the appropriate constant extractor for a language."""
-    extractors: dict[str, PythonConstantExtractor | TypeScriptConstantExtractor] = {
-        "python": helpers.python_extractor,
-        "typescript": helpers.typescript_extractor,
-        "javascript": helpers.typescript_extractor,
+) -> ConstantExtractorFn | None:
+    """Get the appropriate constant extractor function for a language."""
+    extractors: dict[str, ConstantExtractorFn] = {
+        "python": extract_python_constants,
+        "typescript": helpers.typescript_extractor.extract,
+        "javascript": helpers.typescript_extractor.extract,
     }
     return extractors.get(language or "")
 
@@ -199,6 +222,6 @@ def _generate_constant_violations(
     rule_id: str,
 ) -> list[Violation]:
     """Generate violations for duplicate constants."""
-    groups = helpers.constant_matcher.find_groups(constants)
+    groups = find_constant_groups(constants)
     helpers.constant_violation_builder.min_occurrences = config.min_constant_occurrences
     return helpers.constant_violation_builder.build_violations(groups, rule_id)

src/linters/dry/python_analyzer.py

@@ -8,7 +8,7 @@ Overview: Analyzes Python source files to extract code blocks for duplicate dete
     Filters out docstrings at the tokenization level to prevent false positive duplication
     detection on documentation strings.
 
-Dependencies: BaseTokenAnalyzer, CodeBlock, DRYConfig, pathlib.Path, ast, TokenHasher
+Dependencies: BaseTokenAnalyzer, CodeBlock, DRYConfig, pathlib.Path, ast, token_hasher module
 
 Exports: PythonDuplicateAnalyzer class
 
@@ -17,6 +17,12 @@ Interfaces: PythonDuplicateAnalyzer.analyze(file_path: Path, content: str, confi
 
 Implementation: Uses custom tokenizer that filters docstrings before hashing
 
+Suppressions:
+    - too-many-arguments,too-many-positional-arguments: Line processing with related params
+    - type:ignore[arg-type]: ast.get_docstring returns str|None, typing limitation
+    - srp.violation: Complex AST analysis algorithm for duplicate detection. See SRP Exception below.
+    - nesting.excessive-depth: analyze method uses nested loops for docstring extraction.
+
 SRP Exception: PythonDuplicateAnalyzer has 32 methods and 358 lines (exceeds max 8 methods/200 lines)
     Justification: Complex AST analysis algorithm for duplicate code detection with sophisticated
     false positive filtering. Methods form tightly coupled algorithm pipeline: docstring extraction,
@@ -31,6 +37,7 @@ SRP Exception: PythonDuplicateAnalyzer has 32 methods and 358 lines (exceeds max
 import ast
 from pathlib import Path
 
+from . import token_hasher
 from .base_token_analyzer import BaseTokenAnalyzer
 from .block_filter import BlockFilterRegistry, create_default_registry
 from .cache import CodeBlock
@@ -98,14 +105,15 @@ class PythonDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.violat
         content: str,
     ) -> list[CodeBlock]:
         """Filter hash windows and create valid CodeBlock instances."""
-        blocks = []
-        for hash_val, start_line, end_line, snippet in windows:
-            block = self._create_block_if_valid(
-                file_path, content, hash_val, start_line, end_line, snippet
+        return [
+            block
+            for hash_val, start_line, end_line, snippet in windows
+            if (
+                block := self._create_block_if_valid(
+                    file_path, content, hash_val, start_line, end_line, snippet
+                )
             )
-            if block:
-                blocks.append(block)
-        return blocks
+        ]
 
     def _create_block_if_valid(  # pylint: disable=too-many-arguments,too-many-positional-arguments
         self,
@@ -229,11 +237,11 @@ class PythonDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.violat
         Returns:
             Tuple of (new_import_state, normalized_line or None if should skip)
         """
-        normalized = self._hasher._normalize_line(line)  # pylint: disable=protected-access
+        normalized = token_hasher.normalize_line(line)
         if not normalized:
             return in_multiline_import, None
 
-        new_state, should_skip = self._hasher._should_skip_import_line(  # pylint: disable=protected-access
+        new_state, should_skip = token_hasher.should_skip_import_line(
             normalized, in_multiline_import
         )
         if should_skip:

src/linters/dry/python_constant_extractor.py

@@ -11,9 +11,9 @@ Overview: Extracts module-level constant definitions from Python source code usi
 
 Dependencies: Python ast module, re for pattern matching, ConstantInfo from constant module
 
-Exports: PythonConstantExtractor class
+Exports: extract_python_constants function
 
-Interfaces: PythonConstantExtractor.extract(content: str) -> list[ConstantInfo]
+Interfaces: extract_python_constants(content: str) -> list[ConstantInfo]
 
 Implementation: AST-based parsing with module-level filtering and ALL_CAPS regex matching
 """
@@ -26,49 +26,55 @@ from .constant import CONSTANT_NAME_PATTERN, ConstantInfo
 CONTAINER_REPRESENTATIONS = {ast.List: "[...]", ast.Dict: "{...}", ast.Tuple: "(...)"}
 
 
-class PythonConstantExtractor:
-    """Extracts module-level constants from Python source code."""
-
-    def extract(self, content: str) -> list[ConstantInfo]:
-        """Extract constants from Python source code."""
-        try:
-            tree = ast.parse(content)
-        except SyntaxError:
-            return []
-        constants: list[ConstantInfo] = []
-        for node in tree.body:
-            constants.extend(self._extract_from_node(node))
-        return constants
-
-    def _extract_from_node(self, node: ast.stmt) -> list[ConstantInfo]:
-        """Extract constants from a single AST node."""
-        if isinstance(node, ast.Assign):
-            return self._extract_from_assign(node)
-        if isinstance(node, ast.AnnAssign):
-            return self._extract_from_ann_assign(node)
+def extract_python_constants(content: str) -> list[ConstantInfo]:
+    """Extract constants from Python source code.
+
+    Args:
+        content: Python source code as string
+
+    Returns:
+        List of ConstantInfo for module-level constants
+    """
+    try:
+        tree = ast.parse(content)
+    except SyntaxError:
+        return []
+    constants: list[ConstantInfo] = []
+    for node in tree.body:
+        constants.extend(_extract_from_node(node))
+    return constants
+
+
+def _extract_from_node(node: ast.stmt) -> list[ConstantInfo]:
+    """Extract constants from a single AST node."""
+    if isinstance(node, ast.Assign):
+        return _extract_from_assign(node)
+    if isinstance(node, ast.AnnAssign):
+        return _extract_from_ann_assign(node)
+    return []
+
+
+def _extract_from_assign(node: ast.Assign) -> list[ConstantInfo]:
+    """Extract constants from a simple assignment."""
+    return [info for t in node.targets if (info := _to_const_info(t, node.value, node.lineno))]
+
+
+def _extract_from_ann_assign(node: ast.AnnAssign) -> list[ConstantInfo]:
+    """Extract constants from an annotated assignment."""
+    if node.value is None:
         return []
+    info = _to_const_info(node.target, node.value, node.lineno)
+    return [info] if info else []
 
-    def _extract_from_assign(self, node: ast.Assign) -> list[ConstantInfo]:
-        """Extract constants from a simple assignment."""
-        return [
-            info for t in node.targets if (info := self._to_const_info(t, node.value, node.lineno))
-        ]
-
-    def _extract_from_ann_assign(self, node: ast.AnnAssign) -> list[ConstantInfo]:
-        """Extract constants from an annotated assignment."""
-        if node.value is None:
-            return []
-        info = self._to_const_info(node.target, node.value, node.lineno)
-        return [info] if info else []
-
-    def _to_const_info(self, target: ast.expr, value: ast.expr, lineno: int) -> ConstantInfo | None:
-        """Extract constant info from target and value."""
-        if not isinstance(target, ast.Name):
-            return None
-        name = target.id
-        if not _is_constant_name(name):
-            return None
-        return ConstantInfo(name=name, line_number=lineno, value=_get_value_string(value))
+
+def _to_const_info(target: ast.expr, value: ast.expr, lineno: int) -> ConstantInfo | None:
+    """Extract constant info from target and value."""
+    if not isinstance(target, ast.Name):
+        return None
+    name = target.id
+    if not _is_constant_name(name):
+        return None
+    return ConstantInfo(name=name, line_number=lineno, value=_get_value_string(value))
 
 
 def _is_constant_name(name: str) -> bool:
@@ -78,8 +84,8 @@ def _is_constant_name(name: str) -> bool:
 
 def _get_value_string(value: ast.expr) -> str | None:
     """Get string representation of a value expression."""
-    if isinstance(value, (ast.Constant, ast.Num, ast.Str)):
-        return _literal_repr(value)
+    if isinstance(value, ast.Constant):
+        return repr(value.value)
     if isinstance(value, ast.Name):
         return value.id
     if isinstance(value, ast.Call):
@@ -87,13 +93,6 @@ def _get_value_string(value: ast.expr) -> str | None:
     return CONTAINER_REPRESENTATIONS.get(type(value))
 
 
-def _literal_repr(node: ast.expr) -> str:
-    """Get repr of a literal node."""
-    if isinstance(node, ast.Constant):
-        return repr(node.value)
-    return repr(getattr(node, "n", None) or getattr(node, "s", None))
-
-
 def _call_to_string(node: ast.Call) -> str:
     """Convert call expression to string."""
     if isinstance(node.func, ast.Name):

src/linters/dry/single_statement_detector.py

@@ -18,6 +18,12 @@ Interfaces: SingleStatementDetector.is_single_statement(content, start_line, end
 
 Implementation: AST walking with line-to-node index optimization for performance
 
+Suppressions:
+    - type:ignore[attr-defined]: Tree-sitter Node.text attribute access (optional dependency)
+    - type:ignore[operator]: Tree-sitter Node comparison operations (optional dependency)
+    - too-many-arguments,too-many-positional-arguments: Builder pattern with related params
+    - srp.violation: Complex AST analysis algorithm for single-statement detection. See SRP Exception below.
+
 SRP Exception: SingleStatementDetector has 33 methods and 308 lines (exceeds max 8 methods/200 lines)
     Justification: Complex AST analysis algorithm for single-statement pattern detection with sophisticated
     false positive filtering. Methods form tightly coupled algorithm pipeline: class field detection,
@@ -157,17 +163,13 @@ class SingleStatementDetector:  # thailint: ignore[srp.violation]
         self, nodes: set[ast.AST], start_line: int, end_line: int
     ) -> bool:
         """Check if any node matches single-statement pattern."""
-        for node in nodes:
-            if self._is_single_statement_pattern(node, start_line, end_line):
-                return True
-        return False
+        return any(self._is_single_statement_pattern(node, start_line, end_line) for node in nodes)
 
     def _check_nodes_via_walk(self, tree: ast.Module, start_line: int, end_line: int) -> bool:
         """Check nodes using ast.walk() fallback."""
-        for node in ast.walk(tree):
-            if self._node_matches_via_walk(node, start_line, end_line):
-                return True
-        return False
+        return any(
+            self._node_matches_via_walk(node, start_line, end_line) for node in ast.walk(tree)
+        )
 
     def _node_matches_via_walk(self, node: ast.AST, start_line: int, end_line: int) -> bool:
         """Check if a single node overlaps and matches pattern."""
@@ -368,10 +370,10 @@ class SingleStatementDetector:  # thailint: ignore[srp.violation]
 
         def has_decorators(tree: ast.Module, _lookback_start: int) -> bool:
             """Check if any function or class in the tree has decorators."""
-            for stmt in tree.body:
-                if isinstance(stmt, (ast.FunctionDef, ast.ClassDef)) and stmt.decorator_list:
-                    return True
-            return False
+            return any(
+                isinstance(stmt, (ast.FunctionDef, ast.ClassDef)) and stmt.decorator_list
+                for stmt in tree.body
+            )
 
         return self.check_ast_context(lines, start_line, end_line, 10, 10, has_decorators)