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

src/linters/stringly_typed/violation_generator.py

@@ -0,0 +1,376 @@
+"""
+Purpose: Violation generation from cross-file stringly-typed patterns
+
+Scope: Generates violations from duplicate pattern hashes, function call patterns, and
+    scattered string comparisons
+
+Overview: Handles violation generation for stringly-typed patterns that appear across multiple
+    files. Queries storage for duplicate hashes, retrieves patterns for each hash, builds
+    violations with cross-references to other files, and filters patterns based on enum value
+    thresholds. Delegates function call violation generation to FunctionCallViolationBuilder.
+    Generates violations for scattered string comparisons (e.g., `if env == "production"`)
+    where a variable is compared to multiple unique string values across files.
+    Applies inline ignore directives via IgnoreChecker to filter suppressed violations.
+    Separates violation generation logic from main linter rule to maintain SRP compliance.
+
+Dependencies: StringlyTypedStorage, StoredPattern, StoredComparison, StringlyTypedConfig,
+    Violation, Severity, FunctionCallViolationBuilder, IgnoreChecker
+
+Exports: ViolationGenerator class
+
+Interfaces: ViolationGenerator.generate_violations(storage, rule_id, config) -> list[Violation]
+
+Implementation: Queries storage, validates pattern thresholds, builds violations with
+    cross-file references, delegates function call violations to builder, generates
+    comparison violations from scattered string comparisons, filters by ignore directives
+"""
+
+from src.core.types import Severity, Violation
+
+from .config import StringlyTypedConfig
+from .context_filter import FunctionCallFilter
+from .function_call_violation_builder import FunctionCallViolationBuilder
+from .ignore_checker import IgnoreChecker
+from .ignore_utils import is_ignored
+from .storage import StoredComparison, StoredPattern, StringlyTypedStorage
+
+
+def _filter_by_ignore(violations: list[Violation], ignore: list[str]) -> list[Violation]:
+    """Filter violations by ignore patterns."""
+    if not ignore:
+        return violations
+    return [v for v in violations if not is_ignored(v.file_path, ignore)]
+
+
+def _is_allowed_value_set(values: set[str], config: StringlyTypedConfig) -> bool:
+    """Check if a set of values is in the allowed list."""
+    return any(values == set(allowed) for allowed in config.allowed_string_sets)
+
+
+class ViolationGenerator:  # thailint: ignore srp
+    """Generates violations from cross-file stringly-typed patterns."""
+
+    def __init__(self) -> None:
+        """Initialize with helper builders and filters."""
+        self._call_builder = FunctionCallViolationBuilder()
+        self._call_filter = FunctionCallFilter()
+        self._ignore_checker = IgnoreChecker()
+
+    def generate_violations(
+        self,
+        storage: StringlyTypedStorage,
+        rule_id: str,
+        config: StringlyTypedConfig,
+    ) -> list[Violation]:
+        """Generate violations from storage.
+
+        Args:
+            storage: Pattern storage instance
+            rule_id: Rule identifier for violations
+            config: Stringly-typed configuration with thresholds
+
+        Returns:
+            List of violations for patterns appearing in multiple files
+        """
+        violations: list[Violation] = []
+        pattern_violations, covered_vars = self._generate_pattern_violations(
+            storage, rule_id, config
+        )
+        violations.extend(pattern_violations)
+        violations.extend(self._generate_function_call_violations(storage, config))
+        violations.extend(self._generate_comparison_violations(storage, config, covered_vars))
+
+        # Apply path-based ignore patterns from config
+        violations = _filter_by_ignore(violations, config.ignore)
+
+        # Apply inline ignore directives (# thailint: ignore[stringly-typed])
+        violations = self._ignore_checker.filter_violations(violations)
+
+        return violations
+
+    def _generate_pattern_violations(
+        self,
+        storage: StringlyTypedStorage,
+        rule_id: str,
+        config: StringlyTypedConfig,
+    ) -> tuple[list[Violation], set[str]]:
+        """Generate violations for duplicate validation patterns.
+
+        Returns:
+            Tuple of (violations list, set of variable names covered by these violations)
+        """
+        duplicate_hashes = storage.get_duplicate_hashes(min_files=config.min_occurrences)
+        violations: list[Violation] = []
+        covered_variables: set[str] = set()
+
+        for hash_value in duplicate_hashes:
+            patterns = storage.get_patterns_by_hash(hash_value)
+            self._process_pattern_group(patterns, config, rule_id, violations, covered_variables)
+
+        return violations, covered_variables
+
+    def _process_pattern_group(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+        self,
+        patterns: list[StoredPattern],
+        config: StringlyTypedConfig,
+        rule_id: str,
+        violations: list[Violation],
+        covered_variables: set[str],
+    ) -> None:
+        """Process a group of patterns with the same hash."""
+        if self._should_skip_patterns(patterns, config):
+            return
+        violations.extend(self._build_violation(p, patterns, rule_id) for p in patterns)
+        # Track variable names to avoid duplicate comparison violations
+        for pattern in patterns:
+            if pattern.variable_name:
+                covered_variables.add(pattern.variable_name)
+
+    def _generate_function_call_violations(
+        self,
+        storage: StringlyTypedStorage,
+        config: StringlyTypedConfig,
+    ) -> list[Violation]:
+        """Generate violations for function call patterns."""
+        min_files = config.min_occurrences if config.require_cross_file else 1
+        limited_funcs = storage.get_limited_value_functions(
+            min_values=config.min_values_for_enum,
+            max_values=config.max_values_for_enum,
+            min_files=min_files,
+        )
+
+        violations: list[Violation] = []
+        for function_name, param_index, unique_values in limited_funcs:
+            if _is_allowed_value_set(unique_values, config):
+                continue
+            # Apply context-aware filtering to reduce false positives
+            if not self._call_filter.should_include(function_name, param_index, unique_values):
+                continue
+            calls = storage.get_calls_by_function(function_name, param_index)
+            violations.extend(self._call_builder.build_violations(calls, unique_values))
+
+        return violations
+
+    def _should_skip_patterns(
+        self, patterns: list[StoredPattern], config: StringlyTypedConfig
+    ) -> bool:
+        """Check if pattern group should be skipped based on config."""
+        if not patterns:
+            return True
+        first = patterns[0]
+        if not self._is_enum_candidate(first, config):
+            return True
+        if self._is_pattern_allowed(first, config):
+            return True
+        # Skip if all values match excluded patterns (numeric strings, etc.)
+        if self._call_filter.are_all_values_excluded(set(first.string_values)):
+            return True
+        return False
+
+    def _is_enum_candidate(self, pattern: StoredPattern, config: StringlyTypedConfig) -> bool:
+        """Check if pattern's value count is within enum range."""
+        value_count = len(pattern.string_values)
+        return config.min_values_for_enum <= value_count <= config.max_values_for_enum
+
+    def _is_pattern_allowed(self, pattern: StoredPattern, config: StringlyTypedConfig) -> bool:
+        """Check if pattern's string set is in allowed list."""
+        return _is_allowed_value_set(set(pattern.string_values), config)
+
+    def _build_violation(
+        self, pattern: StoredPattern, all_patterns: list[StoredPattern], rule_id: str
+    ) -> Violation:
+        """Build a violation for a pattern with cross-references."""
+        message = self._build_message(pattern, all_patterns)
+        suggestion = self._build_suggestion(pattern)
+
+        return Violation(
+            rule_id=rule_id,
+            file_path=str(pattern.file_path),
+            line=pattern.line_number,
+            column=pattern.column,
+            message=message,
+            severity=Severity.ERROR,
+            suggestion=suggestion,
+        )
+
+    def _build_message(self, pattern: StoredPattern, all_patterns: list[StoredPattern]) -> str:
+        """Build violation message with cross-file references."""
+        file_count = len({p.file_path for p in all_patterns})
+        values_str = ", ".join(f"'{v}'" for v in sorted(pattern.string_values))
+        other_refs = self._build_cross_references(pattern, all_patterns)
+
+        message = (
+            f"Stringly-typed pattern with values [{values_str}] appears in {file_count} files."
+        )
+        if other_refs:
+            message += f" Also found in: {other_refs}."
+
+        return message
+
+    def _build_cross_references(
+        self, pattern: StoredPattern, all_patterns: list[StoredPattern]
+    ) -> str:
+        """Build cross-reference string for other files."""
+        refs = [
+            f"{other.file_path.name}:{other.line_number}"
+            for other in all_patterns
+            if other.file_path != pattern.file_path
+        ]
+        return ", ".join(refs)
+
+    def _build_suggestion(self, pattern: StoredPattern) -> str:
+        """Build fix suggestion for the pattern."""
+        values_count = len(pattern.string_values)
+        var_info = f" for '{pattern.variable_name}'" if pattern.variable_name else ""
+
+        return (
+            f"Consider defining an enum or type union{var_info} with the "
+            f"{values_count} possible values instead of using string literals."
+        )
+
+    def _generate_comparison_violations(
+        self,
+        storage: StringlyTypedStorage,
+        config: StringlyTypedConfig,
+        covered_variables: set[str] | None = None,
+    ) -> list[Violation]:
+        """Generate violations for scattered string comparisons.
+
+        Finds variables that are compared to multiple unique string values across
+        files (e.g., `if env == "production"` in one file and `if env == "staging"`
+        in another), suggesting they should use enums instead.
+
+        Args:
+            storage: Pattern storage instance
+            config: Stringly-typed configuration
+            covered_variables: Variable names already flagged by pattern violations (to deduplicate)
+        """
+        covered_variables = covered_variables or set()
+        min_files = config.min_occurrences if config.require_cross_file else 1
+        variables = storage.get_variables_with_multiple_values(
+            min_values=config.min_values_for_enum,
+            min_files=min_files,
+        )
+
+        violations: list[Violation] = []
+        for variable_name, unique_values in variables:
+            self._process_variable_comparisons(
+                variable_name, unique_values, storage, config, covered_variables, violations
+            )
+
+        return violations
+
+    def _process_variable_comparisons(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+        self,
+        variable_name: str,
+        unique_values: set[str],
+        storage: StringlyTypedStorage,
+        config: StringlyTypedConfig,
+        covered_variables: set[str],
+        violations: list[Violation],
+    ) -> None:
+        """Process comparisons for a single variable."""
+        # Skip if already covered by equality chain or validation pattern
+        if variable_name in covered_variables:
+            return
+        # Skip false positive variable patterns (.value, .method, etc.)
+        if self._should_skip_variable(variable_name):
+            return
+        if self._should_skip_comparison(unique_values, config):
+            return
+        comparisons = storage.get_comparisons_by_variable(variable_name)
+        violations.extend(
+            self._build_comparison_violation(c, comparisons, unique_values) for c in comparisons
+        )
+
+    def _should_skip_comparison(self, unique_values: set[str], config: StringlyTypedConfig) -> bool:
+        """Check if a comparison pattern should be skipped based on config."""
+        if len(unique_values) > config.max_values_for_enum:
+            return True
+        if _is_allowed_value_set(unique_values, config):
+            return True
+        if self._call_filter.are_all_values_excluded(unique_values):
+            return True
+        return False
+
+    def _should_skip_variable(self, variable_name: str) -> bool:
+        """Check if a variable name indicates a false positive comparison.
+
+        Excludes:
+        - Variables ending with .value (enum value access)
+        - HTTP method variables (request.method, etc.)
+        - Variables that are likely test fixtures (underscore prefix patterns)
+        """
+        # Enum value access - already using an enum
+        if variable_name.endswith(".value"):
+            return True
+        # HTTP method - standard protocol strings
+        if variable_name.endswith(".method"):
+            return True
+        # Test assertion patterns (underscore prefix is common in comprehensions/lambdas)
+        if variable_name.startswith("_."):
+            return True
+        return False
+
+    def _build_comparison_violation(
+        self,
+        comparison: StoredComparison,
+        all_comparisons: list[StoredComparison],
+        unique_values: set[str],
+    ) -> Violation:
+        """Build a violation for a scattered string comparison."""
+        message = self._build_comparison_message(comparison, all_comparisons, unique_values)
+        suggestion = self._build_comparison_suggestion(comparison, unique_values)
+
+        return Violation(
+            rule_id="stringly-typed.scattered-comparison",
+            file_path=str(comparison.file_path),
+            line=comparison.line_number,
+            column=comparison.column,
+            message=message,
+            severity=Severity.ERROR,
+            suggestion=suggestion,
+        )
+
+    def _build_comparison_message(
+        self,
+        comparison: StoredComparison,
+        all_comparisons: list[StoredComparison],
+        unique_values: set[str],
+    ) -> str:
+        """Build violation message for scattered comparison."""
+        file_count = len({c.file_path for c in all_comparisons})
+        values_str = ", ".join(f"'{v}'" for v in sorted(unique_values))
+        other_refs = self._build_comparison_cross_references(comparison, all_comparisons)
+
+        message = (
+            f"Variable '{comparison.variable_name}' is compared to {len(unique_values)} "
+            f"different string values [{values_str}] across {file_count} file(s)."
+        )
+        if other_refs:
+            message += f" Also compared in: {other_refs}."
+
+        return message
+
+    def _build_comparison_cross_references(
+        self,
+        comparison: StoredComparison,
+        all_comparisons: list[StoredComparison],
+    ) -> str:
+        """Build cross-reference string for other comparison locations."""
+        refs = [
+            f"{other.file_path.name}:{other.line_number}"
+            for other in all_comparisons
+            if other.file_path != comparison.file_path
+        ]
+        return ", ".join(refs)
+
+    def _build_comparison_suggestion(
+        self, comparison: StoredComparison, unique_values: set[str]
+    ) -> str:
+        """Build fix suggestion for scattered comparison."""
+        return (
+            f"Consider defining an enum for '{comparison.variable_name}' with the "
+            f"{len(unique_values)} possible values instead of using string literals "
+            f"in scattered comparisons."
+        )

{thailint-0.11.0.dist-info → thailint-0.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thailint
-Version: 0.11.0
+Version: 0.12.0
 Summary: The AI Linter - Enterprise-grade linting and governance for AI-generated code across multiple languages
 License: MIT
 License-File: LICENSE
@@ -37,8 +37,8 @@ Description-Content-Type: text/markdown
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
-[![Tests](https://img.shields.io/badge/tests-884%2F884%20passing-brightgreen.svg)](tests/)
-[![Coverage](https://img.shields.io/badge/coverage-88%25-brightgreen.svg)](htmlcov/)
+[![Tests](https://img.shields.io/badge/tests-1076%2F1076%20passing-brightgreen.svg)](tests/)
+[![Coverage](https://img.shields.io/badge/coverage-89%25-brightgreen.svg)](htmlcov/)
 [![Documentation Status](https://readthedocs.org/projects/thai-lint/badge/?version=latest)](https://thai-lint.readthedocs.io/en/latest/?badge=latest)
 [![SARIF 2.1.0](https://img.shields.io/badge/SARIF-2.1.0-orange.svg)](docs/sarif-output.md)
 
@@ -116,6 +116,12 @@ thailint complements your existing linting stack by catching the patterns AI too
   - No instance state (self.attr) detection
   - Excludes ABC, Protocol, and decorated classes
   - Helpful refactoring suggestions
+- **Stringly-Typed Linting** - Detect string patterns that should use enums
+  - Python and TypeScript support
+  - Cross-file detection with SQLite storage
+  - Detects membership validation, equality chains, function call patterns
+  - False positive filtering (200+ exclusion patterns)
+  - Inline ignore directive support
 - **Pluggable Architecture** - Easy to extend with custom linters
 - **Multi-Language Support** - Python, TypeScript, JavaScript, and more
 - **Flexible Configuration** - YAML/JSON configs with pattern matching

{thailint-0.11.0.dist-info → thailint-0.12.0.dist-info}/RECORD

@@ -7,13 +7,13 @@ src/cli/__main__.py,sha256=xIKI57yqB1NOw9eXnGXfU8rC2UwcAJYjDxlZbt9eP0w,671
 src/cli/config.py,sha256=a_kMr3DRQ8t_HzVXmgemKnKMSS0tPAxTA33tQswpRkc,14328
 src/cli/linters/__init__.py,sha256=zpPCtFyKIkq0t3wqfUsd5_VJepPyT3LvAg4JZ_ToEeA,2056
 src/cli/linters/code_patterns.py,sha256=Cyu26_Y-dTBudSgLDcwH3-djjXCN83xqzgMkZV9oZ-U,12434
-src/cli/linters/code_smells.py,sha256=6L8jcXFJeVunno0mZuF1H3npsfAX4xTSU9HHT1Vgfk4,11189
+src/cli/linters/code_smells.py,sha256=xf9fSS5qwRGOMw4FvhJo0QsU5Et0gFcObriZk-BUIg8,14858
 src/cli/linters/documentation.py,sha256=UaD2MMltgfSVlQAo8MCXepmQWGLiz-5Llg6uowrwvIA,5170
 src/cli/linters/shared.py,sha256=tHOsLF_L-xwf1KE4kVR7oES4IMOj-1ADWRnDhW36QzM,3010
 src/cli/linters/structure.py,sha256=xPhb-SqtPM9QMhB5un8pi74l9SYKN1LHQL9Eb0ZLVqI,10538
 src/cli/linters/structure_quality.py,sha256=qjZn1zKAp_rnmg1vVwUJ-Ob057AoYV3uZtZqiW2qFsU,10585
 src/cli/main.py,sha256=mRyRN_IQI2WyqDCxI8vuzdhbkCkVrK6INfJPjU8ayIU,3844
-src/cli/utils.py,sha256=kaUopX9OYs6y3wqU4B9Xe7r8PYkSocLZZu6ois_CJyg,11828
+src/cli/utils.py,sha256=L1q2i6NBkWoQZLYnkeNNdfzHYRhaUobbzqSr2w8JUFY,12595
 src/cli_main.py,sha256=-3XVwLztHt9clehSxr0nrXh9mhAiZOt0gP73TgijPEI,1499
 src/config.py,sha256=gQ2DoBSZra4Dw3zUVd-t0lyD_pOY4iufx7sL_sXGBGU,12482
 src/core/__init__.py,sha256=5FtsDvhMt4SNRx3pbcGURrxn135XRbeRrjSUxiXwkNc,381
@@ -127,24 +127,38 @@ src/linters/stateless_class/__init__.py,sha256=8ePpinmCD27PCz7ukwUWcNwo-ZgyvhOqu
 src/linters/stateless_class/config.py,sha256=u8Jt_xygIkuxZx2o0Uw_XFatOh11QhC9aN8lB_vfnLk,1993
 src/linters/stateless_class/linter.py,sha256=mYGF7Qn-7RG8qCwbLMTFXcfbU5jDbi8qEZpx6TEk-Bs,11121
 src/linters/stateless_class/python_analyzer.py,sha256=Nv8mTM7HKjqDA8Kyu-bw3GOo9eq9XA4zD3GYsjQmV9E,7789
-src/linters/stringly_typed/__init__.py,sha256=S8-kArX2R1xhU8KwdI4rosXtXWvv3Tvpuw79NRQKYec,841
-src/linters/stringly_typed/config.py,sha256=HfiO4RLPQ2p2ZchPFvtm6NKVxnltUHjTWZGUv4Sk15w,6946
-src/linters/stringly_typed/python/__init__.py,sha256=0IQIIH5P2_TSULZWfedxueHczAySHGkm5x2swoqPS0w,1186
-src/linters/stringly_typed/python/analyzer.py,sha256=Nihb2Qeer34zJyMHzs-CQki1yoDK_pwfk-Zdvvw3yQg,6974
+src/linters/stringly_typed/__init__.py,sha256=6r4IIykZ6mm551KQpRTSDp418EFqJQbuzjSfLHcwyBc,1511
+src/linters/stringly_typed/config.py,sha256=-ckS5SG5DEo-G7ty9gB3BB09Xf24Pr4VHz3WylL4bAU,7738
+src/linters/stringly_typed/context_filter.py,sha256=lpDQBC1Sh0nC_dnPBhHPXJ0oUH012_xs8loo8eYiXDU,13511
+src/linters/stringly_typed/function_call_violation_builder.py,sha256=JpiPRvlarZcyX-v4jQeawLI2xN6r4OdEHTOCU8HEL8w,4694
+src/linters/stringly_typed/ignore_checker.py,sha256=sFV9NzsIhUWZe59h2X9JJv8yE3PWQLWAbhOG7Sl1Cs8,3438
+src/linters/stringly_typed/ignore_utils.py,sha256=hw0wfnGFJQkysr1qi_vmykZPr02SNBElwVHFu55tB6M,1531
+src/linters/stringly_typed/linter.py,sha256=cqgQ_8SElEOzCtdi7I6sct281zheuQyo6gm1ZPyBHvU,12224
+src/linters/stringly_typed/python/__init__.py,sha256=y1ELj3We0_VeA0ygXd1DxudSWrZE5OhLGtZNkKwuomA,1359
+src/linters/stringly_typed/python/analyzer.py,sha256=j6ObrKexB6oQILZ_HhaULbBDiQg6MWjkpYUVMdWrIe4,12073
+src/linters/stringly_typed/python/call_tracker.py,sha256=xSel_LVB6shZJsSCyK--pwH_5KQnw-S4hvAYWRdJHCk,5898
+src/linters/stringly_typed/python/comparison_tracker.py,sha256=EGJRyC2e7Zj3_EvC2sHdTq2cgnvB1l7Im2ugBAOE69Y,8075
 src/linters/stringly_typed/python/condition_extractor.py,sha256=R1-7TXu2_pBMSGf8RD8ygWh-BmKkXUlLA6ZbCZysbsA,4114
 src/linters/stringly_typed/python/conditional_detector.py,sha256=umXVh-gWAybnnrqS2AHlcDy-Fdd3ty5KhJpbWTU_P_Q,5927
 src/linters/stringly_typed/python/constants.py,sha256=IF3Y2W96hihHlr5HMenq5Q93uOo7KHzNazVVvhq3E58,671
 src/linters/stringly_typed/python/match_analyzer.py,sha256=o7_XCIEggsS9NBPQ3aNBvu37cpQAEvWyXjfqNMMj2k8,2536
 src/linters/stringly_typed/python/validation_detector.py,sha256=VKm3V5t2JhkyVJHF8C8iX7fcsk_5o5zGeZpSEnMJU8I,6190
 src/linters/stringly_typed/python/variable_extractor.py,sha256=yYJQ5jTSMz94SD_0IMfCHMWcw1F57GmRuh9h51oiAEs,2769
+src/linters/stringly_typed/storage.py,sha256=gbQwkmy7gXnE2ePqFJP0l4-tvZ8RRYOxb1-CXNLVSzc,22069
+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=W88M5FrTYlLTjavkY3Auqw4ynKweJRSd68MoV2H9lbI,10909
+src/linters/stringly_typed/typescript/comparison_tracker.py,sha256=GTfAQAhDsHrUoiSy-L5AIOFLJCR_7PpVPi3yn19hVmw,12186
+src/linters/stringly_typed/violation_generator.py,sha256=vBNT2ei9mOSbW-DuLNlgXLYHM-Vk5-7AevUwWyZ8w4Y,15637
 src/orchestrator/__init__.py,sha256=XXLDJq2oaB-TpP2Y97GRnde9EkITGuFCmuLrDfxI9nY,245
 src/orchestrator/core.py,sha256=exdSuPm9ly7xy3QUB9vjAlk2LlSMhkTHNifLZ-fgsS8,17369
 src/orchestrator/language_detector.py,sha256=rHyVMApit80NTTNyDH1ObD1usKD8LjGmH3DwqNAWYGc,2736
 src/templates/thailint_config_template.yaml,sha256=vxyhRRi25_xOnHDRx0jzz69dgPqKU2IU5-YFGUoX5lM,4953
 src/utils/__init__.py,sha256=NiBtKeQ09Y3kuUzeN4O1JNfUIYPQDS2AP1l5ODq-Dec,125
 src/utils/project_root.py,sha256=b3YTEGTa9RPcOeHn1IByMMWyRiUabfVlpnlektL0A0o,6156
-thailint-0.11.0.dist-info/METADATA,sha256=k3OywNMPxV8CW6UgLdPf6YLUUtxHd6vVeQM_ve51cZQ,48517
-thailint-0.11.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-thailint-0.11.0.dist-info/entry_points.txt,sha256=DNoGUlxpaMFqxQDgHp1yeGqohOjdFR-kH19uHYi3OUY,72
-thailint-0.11.0.dist-info/licenses/LICENSE,sha256=kxh1J0Sb62XvhNJ6MZsVNe8PqNVJ7LHRn_EWa-T3djw,1070
-thailint-0.11.0.dist-info/RECORD,,
+thailint-0.12.0.dist-info/METADATA,sha256=bqVguJOc21dxwRlIOmu73KSW3ELtCB5uJGW7OXT4tvo,48840
+thailint-0.12.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+thailint-0.12.0.dist-info/entry_points.txt,sha256=DNoGUlxpaMFqxQDgHp1yeGqohOjdFR-kH19uHYi3OUY,72
+thailint-0.12.0.dist-info/licenses/LICENSE,sha256=kxh1J0Sb62XvhNJ6MZsVNe8PqNVJ7LHRn_EWa-T3djw,1070
+thailint-0.12.0.dist-info/RECORD,,