thailint 0.15.2__py3-none-any.whl → 0.15.4__py3-none-any.whl

src/linters/dry/linter.py

@@ -21,7 +21,9 @@ Interfaces: DRYRule.check(context) -> list[Violation], finalize() -> list[Violat
 Implementation: Delegates all logic to helper classes, maintains only orchestration and state
 
 Suppressions:
-    - too-many-instance-attributes: DRYComponents groups related helper dependencies
+    - too-many-instance-attributes: DRYComponents groups helper dependencies; DRYRule has 8
+        attributes due to stateful caching requirements (storage, config, constants, file contents
+        for ignore directive processing)
     - B101: Type narrowing assertions after guards (storage initialized, file_path/content set)
 """
 
@@ -34,6 +36,7 @@ from pathlib import Path
 from src.core.base import BaseLintContext, BaseLintRule
 from src.core.linter_utils import should_process_file
 from src.core.types import Violation
+from src.linter_config.ignore import IgnoreDirectiveParser
 
 from .config import DRYConfig
 from .config_loader import ConfigLoader
@@ -46,7 +49,7 @@ from .inline_ignore import InlineIgnoreParser
 from .python_constant_extractor import extract_python_constants
 from .storage_initializer import StorageInitializer
 from .typescript_constant_extractor import TypeScriptConstantExtractor
-from .violation_generator import ViolationGenerator
+from .violation_generator import IgnoreContext, ViolationGenerator
 
 
 @dataclass
@@ -62,7 +65,7 @@ class DRYComponents:  # pylint: disable=too-many-instance-attributes
     constant_violation_builder: ConstantViolationBuilder
 
 
-class DRYRule(BaseLintRule):
+class DRYRule(BaseLintRule):  # pylint: disable=too-many-instance-attributes
     """Detects duplicate code across project files."""
 
     def __init__(self) -> None:
@@ -71,10 +74,14 @@ class DRYRule(BaseLintRule):
         self._initialized = False
         self._config: DRYConfig | None = None
         self._file_analyzer: FileAnalyzer | None = None
+        self._project_root: Path | None = None
 
         # Collected constants for cross-file detection: list of (file_path, ConstantInfo)
         self._constants: list[tuple[Path, ConstantInfo]] = []
 
+        # Cache file contents for ignore directive checking during finalize
+        self._file_contents: dict[str, str] = {}
+
         # Helper components grouped to reduce instance attributes
         self._helpers = DRYComponents(
             config_loader=ConfigLoader(),
@@ -133,6 +140,12 @@ class DRYRule(BaseLintRule):
         assert context.file_content is not None  # nosec B101
 
         file_path = context.file_path
+        # Cache file content for ignore directive checking in finalize
+        self._file_contents[str(file_path)] = context.file_content
+        # Get project root from context metadata if available
+        if self._project_root is None:
+            self._project_root = self._get_project_root(context)
+
         self._helpers.inline_ignore.parse_file(file_path, context.file_content)
         self._ensure_storage_initialized(context, config)
         self._analyze_and_store(context, config)
@@ -182,21 +195,56 @@ class DRYRule(BaseLintRule):
         if extract_fn:
             self._constants.extend((file_path, c) for c in extract_fn(context.file_content))
 
+    def _get_project_root(self, context: BaseLintContext) -> Path | None:
+        """Get project root from context if available.
+
+        Args:
+            context: Lint context
+
+        Returns:
+            Project root path or None if not available
+        """
+        # Try to get from metadata (orchestrator sets this)
+        if hasattr(context, "metadata") and isinstance(context.metadata, dict):
+            project_root = context.metadata.get("project_root")
+            if project_root:
+                return Path(project_root)
+
+        # Fallback: derive from file path
+        if context.file_path:
+            return Path(context.file_path).parent
+
+        return None
+
     def finalize(self) -> list[Violation]:
         """Generate violations after all files processed."""
         if not self._storage or not self._config:
             return []
+
+        # Create ignore context for violation filtering
+        ignore_parser = IgnoreDirectiveParser(self._project_root)
+        ignore_ctx = IgnoreContext(
+            inline_ignore=self._helpers.inline_ignore,
+            shared_parser=ignore_parser,
+            file_contents=self._file_contents,
+        )
+
         violations = self._helpers.violation_generator.generate_violations(
-            self._storage, self.rule_id, self._config, self._helpers.inline_ignore
+            self._storage, self.rule_id, self._config, ignore_ctx
         )
         if self._config.detect_duplicate_constants and self._constants:
-            violations.extend(
-                _generate_constant_violations(
-                    self._constants, self._config, self._helpers, self.rule_id
-                )
+            constant_violations = _generate_constant_violations(
+                self._constants, self._config, self._helpers, self.rule_id
             )
+            # Filter constant violations through shared ignore parser
+            constant_violations = _filter_ignored_violations(
+                constant_violations, ignore_parser, self._file_contents
+            )
+            violations.extend(constant_violations)
+
         self._helpers.inline_ignore.clear()
         self._constants = []
+        self._file_contents = {}
         return violations
 
 
@@ -225,3 +273,26 @@ def _generate_constant_violations(
     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)
+
+
+def _filter_ignored_violations(
+    violations: list[Violation],
+    ignore_parser: IgnoreDirectiveParser,
+    file_contents: dict[str, str],
+) -> list[Violation]:
+    """Filter violations through the shared ignore directive parser.
+
+    Args:
+        violations: List of violations to filter
+        ignore_parser: Shared ignore directive parser
+        file_contents: Cached file contents for checking ignore directives
+
+    Returns:
+        Filtered list of violations not matching ignore directives
+    """
+    filtered = []
+    for violation in violations:
+        file_content = file_contents.get(violation.file_path, "")
+        if not ignore_parser.should_ignore_violation(violation, file_content):
+            filtered.append(violation)
+    return filtered

src/linters/dry/violation_generator.py

@@ -10,14 +10,16 @@ Overview: Handles violation generation for duplicate code blocks. Queries storag
 
 Dependencies: DuplicateStorage, ViolationDeduplicator, DRYViolationBuilder, Violation, DRYConfig
 
-Exports: ViolationGenerator class
+Exports: ViolationGenerator class, IgnoreContext dataclass
 
 Interfaces: ViolationGenerator.generate_violations(storage, rule_id, config) -> list[Violation]
 
 Implementation: Queries storage, deduplicates blocks, builds violations, filters by ignore patterns
 """
 
+from dataclasses import dataclass
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from src.core.types import Violation
 from src.orchestrator.language_detector import detect_language
@@ -28,6 +30,18 @@ from .duplicate_storage import DuplicateStorage
 from .inline_ignore import InlineIgnoreParser
 from .violation_builder import DRYViolationBuilder
 
+if TYPE_CHECKING:
+    from src.linter_config.ignore import IgnoreDirectiveParser
+
+
+@dataclass
+class IgnoreContext:
+    """Context for ignore directive filtering."""
+
+    inline_ignore: InlineIgnoreParser
+    shared_parser: "IgnoreDirectiveParser | None" = None
+    file_contents: dict[str, str] | None = None
+
 
 class ViolationGenerator:
     """Generates violations from duplicate code blocks."""
@@ -42,7 +56,7 @@ class ViolationGenerator:
         storage: DuplicateStorage,
         rule_id: str,
         config: DRYConfig,
-        inline_ignore: InlineIgnoreParser,
+        ignore_ctx: IgnoreContext,
     ) -> list[Violation]:
         """Generate violations from storage.
 
@@ -50,19 +64,42 @@ class ViolationGenerator:
             storage: Duplicate storage instance
             rule_id: Rule identifier for violations
             config: DRY configuration with ignore patterns
-            inline_ignore: Parser with inline ignore directives
+            ignore_ctx: Context containing ignore parsers and file contents
 
         Returns:
             List of violations filtered by ignore patterns and inline directives
         """
-        duplicate_hashes = storage.duplicate_hashes
-        violations = []
+        raw_violations = self._collect_violations(storage, rule_id, config)
+        deduplicated = self._deduplicator.deduplicate_violations(raw_violations)
+        pattern_filtered = self._filter_ignored(deduplicated, config.ignore_patterns)
+        inline_filtered = self._filter_inline_ignored(pattern_filtered, ignore_ctx.inline_ignore)
+
+        # Apply shared ignore directive filtering for block and line directives
+        if ignore_ctx.shared_parser and ignore_ctx.file_contents:
+            return self._filter_shared_ignored(
+                inline_filtered, ignore_ctx.shared_parser, ignore_ctx.file_contents
+            )
+
+        return inline_filtered
 
-        for hash_value in duplicate_hashes:
+    def _collect_violations(
+        self, storage: DuplicateStorage, rule_id: str, config: DRYConfig
+    ) -> list[Violation]:
+        """Collect raw violations from storage duplicate hashes.
+
+        Args:
+            storage: Duplicate storage instance
+            rule_id: Rule identifier for violations
+            config: DRY configuration
+
+        Returns:
+            List of raw violations before filtering
+        """
+        violations = []
+        for hash_value in storage.duplicate_hashes:
             blocks = storage.get_blocks_for_hash(hash_value)
             dedup_blocks = self._deduplicator.deduplicate_blocks(blocks)
 
-            # Check min_occurrences threshold (language-aware)
             if not self._meets_min_occurrences(dedup_blocks, config):
                 continue
 
@@ -70,9 +107,7 @@ class ViolationGenerator:
                 violation = self._violation_builder.build_violation(block, dedup_blocks, rule_id)
                 violations.append(violation)
 
-        deduplicated = self._deduplicator.deduplicate_violations(violations)
-        pattern_filtered = self._filter_ignored(deduplicated, config.ignore_patterns)
-        return self._filter_inline_ignored(pattern_filtered, inline_ignore)
+        return violations
 
     def _meets_min_occurrences(self, blocks: list, config: DRYConfig) -> bool:
         """Check if blocks meet minimum occurrence threshold for the language.
@@ -169,3 +204,28 @@ class ViolationGenerator:
             return int(message[start:end])
         except (ValueError, IndexError):
             return 1
+
+    def _filter_shared_ignored(
+        self,
+        violations: list[Violation],
+        ignore_parser: "IgnoreDirectiveParser",
+        file_contents: dict[str, str],
+    ) -> list[Violation]:
+        """Filter violations using the shared ignore directive parser.
+
+        This enables standard # thailint: ignore-start/end directives for DRY linter.
+
+        Args:
+            violations: List of violations to filter
+            ignore_parser: Shared ignore directive parser
+            file_contents: Cached file contents for ignore checking
+
+        Returns:
+            Filtered list of violations
+        """
+        filtered = []
+        for violation in violations:
+            file_content = file_contents.get(violation.file_path, "")
+            if not ignore_parser.should_ignore_violation(violation, file_content):
+                filtered.append(violation)
+        return filtered

src/linters/lazy_ignores/config.py

@@ -42,6 +42,10 @@ class LazyIgnoresConfig:  # pylint: disable=too-many-instance-attributes
     # Orphaned detection
     check_orphaned: bool = True  # Header entries without matching ignores
 
+    # Inline justification options
+    allow_inline_justifications: bool = True  # Allow " - reason" syntax
+    min_justification_length: int = 10  # Minimum chars for valid justification
+
     # File patterns to ignore
     ignore_patterns: list[str] = field(
         default_factory=lambda: [
@@ -64,5 +68,7 @@ class LazyIgnoresConfig:  # pylint: disable=too-many-instance-attributes
             check_thailint_ignore=config_dict.get("check_thailint_ignore", True),
             check_test_skips=config_dict.get("check_test_skips", True),
             check_orphaned=config_dict.get("check_orphaned", True),
+            allow_inline_justifications=config_dict.get("allow_inline_justifications", True),
+            min_justification_length=config_dict.get("min_justification_length", 10),
             ignore_patterns=config_dict.get("ignore_patterns", []),
         )

src/linters/lazy_ignores/directive_utils.py

@@ -5,15 +5,21 @@ Scope: Common directive creation and path normalization for ignore detectors
 
 Overview: Provides shared utility functions used across Python, TypeScript, and test skip
     detectors. Centralizes logic for normalizing file paths, extracting rule IDs from
-    regex matches, and creating IgnoreDirective objects to avoid code duplication.
+    regex matches, extracting inline justifications, and creating IgnoreDirective objects
+    to avoid code duplication.
 
 Dependencies: re for match handling, pathlib for file paths, types module for dataclasses
 
-Exports: normalize_path, extract_rule_ids, create_directive, create_directive_no_rules
+Exports: normalize_path, extract_rule_ids, create_directive, create_directive_no_rules,
+    extract_inline_justification
 
 Interfaces: Pure utility functions with no state
 
 Implementation: Simple helper functions for directive creation
+
+Suppressions:
+    too-many-arguments: create_directive needs all params for proper IgnoreDirective construction
+    too-many-positional-arguments: Factory function mirrors IgnoreDirective fields
 """
 
 import re
@@ -21,6 +27,9 @@ from pathlib import Path
 
 from src.linters.lazy_ignores.types import IgnoreDirective, IgnoreType
 
+# Pattern for inline justification: space-dash-space followed by text
+INLINE_JUSTIFICATION_PATTERN = re.compile(r"\s+-\s+(.+)$")
+
 
 def normalize_path(file_path: Path | str | None) -> Path:
     """Normalize file path to Path object.
@@ -38,6 +47,29 @@ def normalize_path(file_path: Path | str | None) -> Path:
     return file_path
 
 
+def extract_inline_justification(raw_text: str) -> str | None:
+    """Extract inline justification from raw directive text.
+
+    Looks for the pattern " - " (space-dash-space) followed by justification text.
+    This allows inline justifications like:
+        # noqa: PLR0912 - state machine inherently complex
+        # type: ignore[arg-type] - library has typing bug
+
+    Args:
+        raw_text: The raw comment text containing the ignore directive
+
+    Returns:
+        The justification text if found, None otherwise.
+        Returns None for empty/whitespace-only justifications.
+    """
+    match = INLINE_JUSTIFICATION_PATTERN.search(raw_text)
+    if not match:
+        return None
+
+    justification = match.group(1).strip()
+    return justification if justification else None
+
+
 def _get_captured_group(match: re.Match[str]) -> str | None:
     """Get the first captured group from a regex match if it exists.
 
@@ -69,12 +101,13 @@ def extract_rule_ids(match: re.Match[str]) -> list[str]:
     return [rule_id for rule_id in ids if rule_id]
 
 
-def create_directive(
+def create_directive(  # pylint: disable=too-many-arguments,too-many-positional-arguments
     match: re.Match[str],
     ignore_type: IgnoreType,
     line_num: int,
     file_path: Path,
     rule_ids: tuple[str, ...] | None = None,
+    full_line: str | None = None,
 ) -> IgnoreDirective:
     """Create an IgnoreDirective from a regex match.
 
@@ -84,6 +117,7 @@ def create_directive(
         line_num: 1-indexed line number
         file_path: Path to source file
         rule_ids: Optional tuple of rule IDs; if None, extracts from match group 1
+        full_line: Optional full line text for extracting inline justification
 
     Returns:
         IgnoreDirective for this match
@@ -91,13 +125,22 @@ def create_directive(
     if rule_ids is None:
         rule_ids = tuple(extract_rule_ids(match))
 
+    # Use full line from match position to capture inline justification
+    if full_line is not None:
+        raw_text = full_line[match.start() :].strip()
+    else:
+        raw_text = match.group(0).strip()
+
+    inline_justification = extract_inline_justification(raw_text)
+
     return IgnoreDirective(
         ignore_type=ignore_type,
         rule_ids=rule_ids,
         line=line_num,
         column=match.start() + 1,
-        raw_text=match.group(0).strip(),
+        raw_text=raw_text,
         file_path=file_path,
+        inline_justification=inline_justification,
     )
 
 

src/linters/lazy_ignores/matcher.py

@@ -32,13 +32,15 @@ from .types import IgnoreDirective, IgnoreType
 class IgnoreSuppressionMatcher:
     """Matches ignore directives with header suppressions."""
 
-    def __init__(self, parser: SuppressionsParser) -> None:
+    def __init__(self, parser: SuppressionsParser, min_justification_length: int = 10) -> None:
         """Initialize the matcher.
 
         Args:
             parser: SuppressionsParser for rule ID normalization.
+            min_justification_length: Minimum length for valid inline justification.
         """
         self._parser = parser
+        self._min_justification_length = min_justification_length
 
     def collect_used_rule_ids(self, ignores: list[IgnoreDirective]) -> set[str]:
         """Collect all normalized rule IDs used in ignore directives.
@@ -72,6 +74,9 @@ class IgnoreSuppressionMatcher:
     ) -> list[str]:
         """Find which rule IDs in an ignore are not justified.
 
+        Checks inline justification first (higher precedence), then falls back
+        to header-based suppressions.
+
         Args:
             ignore: The ignore directive to check.
             suppressions: Dict of normalized rule IDs to justifications.
@@ -79,17 +84,45 @@ class IgnoreSuppressionMatcher:
         Returns:
             List of unjustified rule IDs (original case preserved).
         """
+        if self._has_valid_inline_justification(ignore):
+            return []
+
         if not ignore.rule_ids:
-            type_key = self._normalize(ignore.ignore_type.value)
-            if type_key not in suppressions:
-                return [ignore.ignore_type.value]
+            return self._check_bare_ignore(ignore, suppressions)
+
+        return self._check_rule_specific_ignore(ignore, suppressions)
+
+    def _check_bare_ignore(
+        self, ignore: IgnoreDirective, suppressions: dict[str, str]
+    ) -> list[str]:
+        """Check if a bare ignore (no specific rules) is justified."""
+        type_key = self._normalize(ignore.ignore_type.value)
+        if type_key in suppressions:
             return []
+        return [ignore.ignore_type.value]
 
-        unjustified: list[str] = []
-        for rule_id in ignore.rule_ids:
-            if not self._is_rule_justified(ignore, rule_id, suppressions):
-                unjustified.append(rule_id)
-        return unjustified
+    def _check_rule_specific_ignore(
+        self, ignore: IgnoreDirective, suppressions: dict[str, str]
+    ) -> list[str]:
+        """Check which specific rule IDs are not justified."""
+        return [
+            rule_id
+            for rule_id in ignore.rule_ids
+            if not self._is_rule_justified(ignore, rule_id, suppressions)
+        ]
+
+    def _has_valid_inline_justification(self, ignore: IgnoreDirective) -> bool:
+        """Check if the ignore has a valid inline justification.
+
+        Args:
+            ignore: The ignore directive to check.
+
+        Returns:
+            True if the ignore has an inline justification meeting minimum length.
+        """
+        if not ignore.inline_justification:
+            return False
+        return len(ignore.inline_justification) >= self._min_justification_length
 
     def _is_rule_justified(
         self, ignore: IgnoreDirective, rule_id: str, suppressions: dict[str, str]

src/linters/lazy_ignores/python_analyzer.py

@@ -205,5 +205,5 @@ class PythonIgnoreDetector:
                 continue
             if _is_pattern_in_string_literal(line, match.start()):
                 continue
-            found.append(create_directive(match, ignore_type, line_num, file_path))
+            found.append(create_directive(match, ignore_type, line_num, file_path, full_line=line))
         return found

src/linters/lazy_ignores/types.py

@@ -59,6 +59,7 @@ class IgnoreDirective:
     column: int
     raw_text: str  # Original comment text
     file_path: Path
+    inline_justification: str | None = None  # Justification after " - " delimiter
 
 
 @dataclass(frozen=True)

src/linters/lazy_ignores/violation_builder.py

@@ -72,8 +72,12 @@ def _build_unjustified_suggestion(rule_id: str) -> str:
 
     suppression_entries = "\n".join(f"    {rid}: [Your justification here]" for rid in rule_ids)
 
-    return f"""To fix, add an entry to the file header Suppressions section:
+    return f"""To fix, either:
 
+1. Add an inline justification (10+ chars) after the ignore directive:
+   # noqa: {rule_ids[0]} - [Your justification here]
+
+2. Or add an entry to the file header Suppressions section:
     Suppressions:
 {suppression_entries}
 

src/linters/stringly_typed/storage.py

@@ -461,7 +461,7 @@ class StringlyTypedStorage:  # thailint: ignore[srp]
             List of (function_name, param_index, unique_values) tuples
         """
         cursor = self._db.execute(
-            """SELECT function_name, param_index, GROUP_CONCAT(DISTINCT string_value)
+            """SELECT function_name, param_index, json_group_array(DISTINCT string_value)
                FROM function_calls
                GROUP BY function_name, param_index
                HAVING COUNT(DISTINCT string_value) >= ?
@@ -470,12 +470,7 @@ class StringlyTypedStorage:  # thailint: ignore[srp]
             (min_values, max_values, min_files),
         )
 
-        results: list[tuple[str, int, set[str]]] = []
-        for row in cursor.fetchall():
-            values = set(row[2].split(",")) if row[2] else set()
-            results.append((row[0], row[1], values))
-
-        return results
+        return [(row[0], row[1], set(json.loads(row[2]))) for row in cursor.fetchall()]
 
     def get_calls_by_function(
         self, function_name: str, param_index: int
@@ -566,7 +561,7 @@ class StringlyTypedStorage:  # thailint: ignore[srp]
             List of (variable_name, unique_values) tuples
         """
         cursor = self._db.execute(
-            """SELECT variable_name, GROUP_CONCAT(DISTINCT compared_value)
+            """SELECT variable_name, json_group_array(DISTINCT compared_value)
                FROM string_comparisons
                GROUP BY variable_name
                HAVING COUNT(DISTINCT compared_value) >= ?
@@ -574,12 +569,7 @@ class StringlyTypedStorage:  # thailint: ignore[srp]
             (min_values, min_files),
         )
 
-        results: list[tuple[str, set[str]]] = []
-        for row in cursor.fetchall():
-            values = set(row[1].split(",")) if row[1] else set()
-            results.append((row[0], values))
-
-        return results
+        return [(row[0], set(json.loads(row[1]))) for row in cursor.fetchall()]
 
     def get_comparisons_by_variable(self, variable_name: str) -> list[StoredComparison]:
         """Get all comparisons for a specific variable.

src/linters/stringly_typed/violation_generator.py

@@ -54,6 +54,11 @@ def _is_allowed_value_set(values: set[str], config: StringlyTypedConfig) -> bool
     return any(values == set(allowed) for allowed in config.allowed_string_sets)
 
 
+def _has_spaces(values: set[str]) -> bool:
+    """Check if any value contains spaces (indicates SQL/templates, not enums)."""
+    return any(" " in v for v in values)
+
+
 def _is_enum_candidate(pattern: StoredPattern, config: StringlyTypedConfig) -> bool:
     """Check if pattern's value count is within enum range."""
     value_count = len(pattern.string_values)
@@ -65,6 +70,15 @@ def _is_pattern_allowed(pattern: StoredPattern, config: StringlyTypedConfig) ->
     return _is_allowed_value_set(set(pattern.string_values), config)
 
 
+def _should_skip_pattern_values(values: set[str], config: StringlyTypedConfig) -> bool:
+    """Check if pattern values should be skipped."""
+    return (
+        _is_allowed_value_set(values, config)
+        or context_filter.are_all_values_excluded(values)
+        or _has_spaces(values)
+    )
+
+
 def _should_skip_patterns(patterns: list[StoredPattern], config: StringlyTypedConfig) -> bool:
     """Check if pattern group should be skipped based on config."""
     if not patterns:
@@ -72,12 +86,7 @@ def _should_skip_patterns(patterns: list[StoredPattern], config: StringlyTypedCo
     first = patterns[0]
     if not _is_enum_candidate(first, config):
         return True
-    if _is_pattern_allowed(first, config):
-        return True
-    # Skip if all values match excluded patterns (numeric strings, etc.)
-    if context_filter.are_all_values_excluded(set(first.string_values)):
-        return True
-    return False
+    return _should_skip_pattern_values(set(first.string_values), config)
 
 
 def _should_skip_comparison(unique_values: set[str], config: StringlyTypedConfig) -> bool:
@@ -88,6 +97,8 @@ def _should_skip_comparison(unique_values: set[str], config: StringlyTypedConfig
         return True
     if context_filter.are_all_values_excluded(unique_values):
         return True
+    if _has_spaces(unique_values):
+        return True
     return False
 
 
@@ -250,6 +261,15 @@ def _process_pattern_group(
 # --- Helper functions for function call processing ---
 
 
+def _is_valid_function(name: str, idx: int, vals: set[str], config: StringlyTypedConfig) -> bool:
+    """Check if a function passes all validity filters."""
+    if _is_allowed_value_set(vals, config):
+        return False
+    if _has_spaces(vals):
+        return False
+    return context_filter.should_include(name, idx, vals)
+
+
 def _get_valid_functions(
     storage: StringlyTypedStorage,
     config: StringlyTypedConfig,
@@ -261,13 +281,7 @@ def _get_valid_functions(
         max_values=config.max_values_for_enum,
         min_files=min_files,
     )
-
-    return [
-        (name, idx, vals)
-        for name, idx, vals in limited_funcs
-        if not _is_allowed_value_set(vals, config)
-        and context_filter.should_include(name, idx, vals)
-    ]
+    return [(n, i, v) for n, i, v in limited_funcs if _is_valid_function(n, i, v, config)]
 
 
 def _build_call_violations(

{thailint-0.15.2.dist-info → thailint-0.15.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thailint
-Version: 0.15.2
+Version: 0.15.4
 Summary: The AI Linter - Enterprise-grade linting and governance for AI-generated code across multiple languages
 License: MIT
 License-File: LICENSE

{thailint-0.15.2.dist-info → thailint-0.15.4.dist-info}/RECORD

@@ -79,7 +79,7 @@ src/linters/dry/deduplicator.py,sha256=a1TRvldxCszf5QByo1ihXF3W98dpGuyaRT74jPfQf
 src/linters/dry/duplicate_storage.py,sha256=9pIALnwAuz5BJUYNXrPbObbP932CE9x0vgUkICryT_s,1970
 src/linters/dry/file_analyzer.py,sha256=3uO2fy8HvxFiRCtYaBs9LztkzvDynqmy7INYRaJjK-g,2990
 src/linters/dry/inline_ignore.py,sha256=3fgPsn_kXeF7kVy_9FL8xYwSUA9cSmgUR3F0tOwzjuY,4275
-src/linters/dry/linter.py,sha256=-8MiprIs2MsAj2fAmg-hCbasDVBkLLgMP9BR2_ZcDv0,9304
+src/linters/dry/linter.py,sha256=oXhFAFYrukiVQq8KmfwGBXvbPLutwW_OuzZAElRTYbc,12066
 src/linters/dry/python_analyzer.py,sha256=b7n7u3NbOW3DFZHeC-bG3N_6VgW2NU2easG8pIHYaZc,10962
 src/linters/dry/python_constant_extractor.py,sha256=v9-3NDCq9CKT6uvti_PRIC3DMEESHW2g3i2IfFy0hw8,3469
 src/linters/dry/single_statement_detector.py,sha256=ZmMo_tsvVxugFmnNzWtGc-4e5sGOw18HHxHre3lRUUA,18220
@@ -91,7 +91,7 @@ src/linters/dry/typescript_statement_detector.py,sha256=8WiwcjLs8j8_wp0UTsoXN0vV
 src/linters/dry/typescript_value_extractor.py,sha256=TbHIvcEnmjSV1WNnkRbXeUi_JA9-rGX0_BrD4bczO9Y,2519
 src/linters/dry/violation_builder.py,sha256=WkCibSNytoqMHGC-3GrVff4PD7-SOnVzzZgkMeqmzco,2952
 src/linters/dry/violation_filter.py,sha256=2e6NHN7GYadt27Pz5kiXhttKPJu1loiXhOi0G3J3Epk,3211
-src/linters/dry/violation_generator.py,sha256=7jkRfauwAEdipFuDhoy82eIeXS1ECN4W_3jspMlnFaU,6068
+src/linters/dry/violation_generator.py,sha256=aXKVB-ERpigzwFD4iY5GoN2BWTESBhZaO6Qr7Vm7mzU,8146
 src/linters/file_header/__init__.py,sha256=S3a2xrOlxnNWD02To5K2ZwILsNEvSj1IvUAH8RjgOV4,791
 src/linters/file_header/atemporal_detector.py,sha256=lerkiMwiUhYv3X3vxpm_88otZhSMG3DBgryhFyxe3As,3934
 src/linters/file_header/base_parser.py,sha256=k6ymg1ocuesA6PH7NMDQOy0LTgSglu0wXed68fPaHxM,3382
@@ -114,17 +114,17 @@ src/linters/file_placement/pattern_validator.py,sha256=P6qbgnVxxFlBrsPzxjXjVlVPp
 src/linters/file_placement/rule_checker.py,sha256=HInWmyxxZfqmrBH-5RealvYIV5ChzGd4EwxB6RNZE9w,7930
 src/linters/file_placement/violation_factory.py,sha256=NkQmBcgpa3g3W2ZdFZNQ5djLVP4x9OKs65d7F1rCKvM,6040
 src/linters/lazy_ignores/__init__.py,sha256=qPwCC1Y-TPn6tNLTO4X6QsACaAiPMBpsIKlKh_dSz5k,1656
-src/linters/lazy_ignores/config.py,sha256=IBW9hO5QgVyIhuSJw6KrupCjbVilDiNUUHL-TcQMOXU,2591
-src/linters/lazy_ignores/directive_utils.py,sha256=6Mc56hrcFe21LG7PMmIVEPDGKUF6F9dffhHkwixj1R8,3432
+src/linters/lazy_ignores/config.py,sha256=Bg7A01BLt4zhXOSb_AQsNP7vNtyyL30HTcACdsdBStY,2960
+src/linters/lazy_ignores/directive_utils.py,sha256=x0Xaj92R1Z7kAmCpH0rUWRBd32rRwd8z9NBZNgG_LeI,5111
 src/linters/lazy_ignores/header_parser.py,sha256=ADtVJUoJfoVx_zehoPpo6YLws0N-7c2PLK1PhNqn5Uk,6030
 src/linters/lazy_ignores/linter.py,sha256=1bl3b2NliVurlb9bUcZUzd8sBZG6KJhRODD-Mb46HnE,6052
-src/linters/lazy_ignores/matcher.py,sha256=jLE12aPPEz6tBejFrmXGXdCb7kzeFh8IYH5b_UjHqpQ,5201
-src/linters/lazy_ignores/python_analyzer.py,sha256=ia60Y0mw0FxngXWw55JqZggWL8HJD6M3mN93PoqyOGA,7367
+src/linters/lazy_ignores/matcher.py,sha256=3djc1iRiwBeigmRl5OIeIIZqRYRiku7E65WyzELg2LY,6496
+src/linters/lazy_ignores/python_analyzer.py,sha256=MuP-mXuLrZ3Qe3OHl63iVVvlja5YbziUUEcOKkKVNG8,7383
 src/linters/lazy_ignores/rule_id_utils.py,sha256=sE7kAQFO6zGAR5JQN2OLLVjAdiVNPZONTb0sY01ri9w,5809
 src/linters/lazy_ignores/skip_detector.py,sha256=9RK5uD4b2pAfdJsK1dHRTAWG4kKfAf1yfjc1OBsI14M,10461
-src/linters/lazy_ignores/types.py,sha256=ygcRYjiuCAx4qDZoBG6xSWNbd1Fh7_FPwoyH8PvLFvc,2251
+src/linters/lazy_ignores/types.py,sha256=2lnFazlxbJ7SEThEVcWaV5PWLztYyGcPzYQVzHE9iO0,2334
 src/linters/lazy_ignores/typescript_analyzer.py,sha256=k8R60Mcw9OxvHFFUPhUErrb-tbek7Q7PXXZDq_H0ioM,5322
-src/linters/lazy_ignores/violation_builder.py,sha256=Z5RlCRJKkTfetkRVqsu1rfJRgBeiE9RTEu1djr-nmto,4203
+src/linters/lazy_ignores/violation_builder.py,sha256=FIlybBPgXTQfot745eQwM4gm7-Pst50SBpBhriG53-w,4342
 src/linters/lbyl/__init__.py,sha256=5_an3Zy9iQvbajvuQT_DTMtlIMfOWxwewZGFe-cSDg8,1124
 src/linters/lbyl/config.py,sha256=kWCjBRs1HEVf9oK4dHKHfjQX8KU-o5i-Jc_94ULDD4Y,2434
 src/linters/lbyl/linter.py,sha256=sp6PETOKuk13wzfWYPYmWVqcdCwcFRr6CGvFmNPunaU,2288
@@ -206,21 +206,21 @@ src/linters/stringly_typed/python/constants.py,sha256=IF3Y2W96hihHlr5HMenq5Q93uO
 src/linters/stringly_typed/python/match_analyzer.py,sha256=mgarAtnL79iOrK6xuiRE2Hw-9tR8ocrIRza6g0SorY8,2719
 src/linters/stringly_typed/python/validation_detector.py,sha256=jzcowBcA7R_aKeXFf2sxI2yGGUoT1lGj1y7DTnmO88M,6288
 src/linters/stringly_typed/python/variable_extractor.py,sha256=yYJQ5jTSMz94SD_0IMfCHMWcw1F57GmRuh9h51oiAEs,2769
-src/linters/stringly_typed/storage.py,sha256=UoaY3Ejpb4k-7it15d_wzZFcEJNjWTClMJhkY6wkc9A,22021
+src/linters/stringly_typed/storage.py,sha256=4ymgg1JiBPLUazKShOb6djPGAVSma3SOIUDmOmeqH5A,21742
 src/linters/stringly_typed/storage_initializer.py,sha256=3-4St1ieN8325Xkb0HTS27dVyjjluM_X-bkwOfJW1JM,1548
 src/linters/stringly_typed/typescript/__init__.py,sha256=lOgclS9wxLNyszfwVGbVxKfCkbTLX1pvskHzcADi5Xg,1121
 src/linters/stringly_typed/typescript/analyzer.py,sha256=iNEk6wQJJfmJoRTXx29GEeqTpKzQ5TcNIimSuQPb6UU,6376
 src/linters/stringly_typed/typescript/call_tracker.py,sha256=NPRpjqTe-Owi3_qJk_baojAazqaL6EsH4E2SIOsUAjU,11299
 src/linters/stringly_typed/typescript/comparison_tracker.py,sha256=TiEldIqppu6i2XYd9a040HK0U4cy7IFf6Qjjlb93wAA,12573
-src/linters/stringly_typed/violation_generator.py,sha256=aye60bShNnt8f6BPQwduTOLX97jAuy7Z7DLq9wzrFB4,14769
+src/linters/stringly_typed/violation_generator.py,sha256=g1dTc6EvjvTYmW3zdfTydmLaTCnqWDq4Q5UIntYxF1A,15336
 src/orchestrator/__init__.py,sha256=XXLDJq2oaB-TpP2Y97GRnde9EkITGuFCmuLrDfxI9nY,245
 src/orchestrator/core.py,sha256=rt3h-YFgF1aAFeKvTa0PP7k_8zfwpeGIqrIxKuyckxY,17683
 src/orchestrator/language_detector.py,sha256=ALt2BEZKXQM2dWr1ChF9lZVj83YF4Bl9xwrB9ezfmMc,2799
 src/templates/thailint_config_template.yaml,sha256=57ZtLxnIoOHtR5Ejq3clb4nhY9J4n6h36XFb79ZZPlc,12020
 src/utils/__init__.py,sha256=NiBtKeQ09Y3kuUzeN4O1JNfUIYPQDS2AP1l5ODq-Dec,125
 src/utils/project_root.py,sha256=aaxUM-LQ1okrPClmZWPFd_D09W3V1ArgJiidEEp_eU8,6262
-thailint-0.15.2.dist-info/METADATA,sha256=isRRo7g6PLejqPDJ0k8Fd2ni6QP8_jVE6Q638kdS2Jg,7202
-thailint-0.15.2.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-thailint-0.15.2.dist-info/entry_points.txt,sha256=DNoGUlxpaMFqxQDgHp1yeGqohOjdFR-kH19uHYi3OUY,72
-thailint-0.15.2.dist-info/licenses/LICENSE,sha256=kxh1J0Sb62XvhNJ6MZsVNe8PqNVJ7LHRn_EWa-T3djw,1070
-thailint-0.15.2.dist-info/RECORD,,
+thailint-0.15.4.dist-info/METADATA,sha256=NNgbYCX8kCsjk1YvX9govMKHkNKPltrzwATaBA5fx9E,7202
+thailint-0.15.4.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+thailint-0.15.4.dist-info/entry_points.txt,sha256=DNoGUlxpaMFqxQDgHp1yeGqohOjdFR-kH19uHYi3OUY,72
+thailint-0.15.4.dist-info/licenses/LICENSE,sha256=kxh1J0Sb62XvhNJ6MZsVNe8PqNVJ7LHRn_EWa-T3djw,1070
+thailint-0.15.4.dist-info/RECORD,,