thailint 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

src/linters/method_property/python_analyzer.py

@@ -0,0 +1,472 @@
+"""
+Purpose: Python AST analysis for finding method-should-be-property candidates
+
+Scope: Python method detection and property candidacy analysis
+
+Overview: Provides PythonMethodAnalyzer class that traverses Python AST to find methods that
+    should be converted to @property decorators. Identifies simple accessor methods (returning
+    self._attribute), get_* prefixed methods (Java-style), and simple computed values. Implements
+    comprehensive exclusion rules to minimize false positives: methods with parameters, side
+    effects (assignments, loops, try/except), external function calls, decorators, complex bodies,
+    dunder methods, and async definitions. Returns structured data about each candidate including
+    method name, class name, line number, and column for violation reporting.
+
+Dependencies: ast module for AST parsing and node types, config module for exclusion defaults
+
+Exports: PythonMethodAnalyzer class, PropertyCandidate dataclass
+
+Interfaces: find_property_candidates(tree) -> list[PropertyCandidate]
+
+Implementation: AST walk pattern with comprehensive method body analysis and exclusion checks
+"""
+
+import ast
+from dataclasses import dataclass
+
+from .config import DEFAULT_EXCLUDE_NAMES, DEFAULT_EXCLUDE_PREFIXES
+
+
+@dataclass
+class PropertyCandidate:
+    """Represents a method that should be a property."""
+
+    method_name: str
+    class_name: str
+    line: int
+    column: int
+    is_get_prefix: bool
+
+
+class PythonMethodAnalyzer:  # thailint: ignore[srp]
+    """Analyzes Python AST to find methods that should be properties."""
+
+    def __init__(
+        self,
+        max_body_statements: int = 3,
+        exclude_prefixes: tuple[str, ...] | None = None,
+        exclude_names: frozenset[str] | None = None,
+    ) -> None:
+        """Initialize the analyzer.
+
+        Args:
+            max_body_statements: Maximum statements in method body
+            exclude_prefixes: Action verb prefixes to exclude (uses defaults if None)
+            exclude_names: Action verb names to exclude (uses defaults if None)
+        """
+        self.max_body_statements = max_body_statements
+        self.exclude_prefixes = exclude_prefixes or DEFAULT_EXCLUDE_PREFIXES
+        self.exclude_names = exclude_names or DEFAULT_EXCLUDE_NAMES
+        self.candidates: list[PropertyCandidate] = []
+        self._visited_classes: set[int] = set()
+
+    def find_property_candidates(self, tree: ast.AST) -> list[PropertyCandidate]:
+        """Find all methods that should be properties.
+
+        Args:
+            tree: The AST to analyze
+
+        Returns:
+            List of PropertyCandidate objects
+        """
+        self.candidates = []
+        self._visit_classes(tree)
+        return self.candidates
+
+    def _visit_classes(self, tree: ast.AST) -> None:
+        """Visit all top-level and nested classes in the AST.
+
+        Args:
+            tree: AST to traverse
+        """
+        self._visited_classes.clear()
+        self._visit_node(tree)
+
+    def _visit_node(self, node: ast.AST) -> None:
+        """Visit a node and its children for classes.
+
+        Args:
+            node: AST node to visit
+        """
+        if isinstance(node, ast.ClassDef):
+            class_id = id(node)
+            if class_id not in self._visited_classes:
+                self._visited_classes.add(class_id)
+                self._analyze_class(node)
+        else:
+            for child in ast.iter_child_nodes(node):
+                self._visit_node(child)
+
+    def _analyze_class(self, class_node: ast.ClassDef) -> None:
+        """Analyze a class for property candidates.
+
+        Args:
+            class_node: The ClassDef node
+        """
+        for item in class_node.body:
+            self._process_class_item(item, class_node.name)
+
+    def _process_class_item(self, item: ast.stmt, class_name: str) -> None:
+        """Process a single item in a class body.
+
+        Args:
+            item: Item in the class body
+            class_name: Name of the containing class
+        """
+        if isinstance(item, ast.FunctionDef):
+            self._check_method(item, class_name)
+        elif isinstance(item, ast.ClassDef):
+            self._process_nested_class(item)
+
+    def _process_nested_class(self, class_node: ast.ClassDef) -> None:
+        """Process a nested class, avoiding duplicates.
+
+        Args:
+            class_node: The nested class node
+        """
+        class_id = id(class_node)
+        if class_id in self._visited_classes:
+            return
+        self._visited_classes.add(class_id)
+        self._analyze_class(class_node)
+
+    def _check_method(self, method: ast.FunctionDef, class_name: str) -> None:
+        """Check if method should be a property.
+
+        Args:
+            method: The FunctionDef node
+            class_name: Name of the containing class
+        """
+        if not self._is_property_candidate(method):
+            return
+
+        is_get_prefix = method.name.startswith("get_") and len(method.name) > 4
+        candidate = PropertyCandidate(
+            method_name=method.name,
+            class_name=class_name,
+            line=method.lineno,
+            column=method.col_offset,
+            is_get_prefix=is_get_prefix,
+        )
+        self.candidates.append(candidate)
+
+    def _is_property_candidate(self, method: ast.FunctionDef) -> bool:
+        """Check if method should be a property.
+
+        Args:
+            method: The FunctionDef node
+
+        Returns:
+            True if method is a property candidate
+        """
+        # All conditions must be met for property candidacy
+        checks = [
+            not self._is_dunder_method(method),
+            not self._is_action_verb_method(method),
+            not self._has_decorators(method),
+            self._takes_only_self(method),
+            self._has_simple_body(method),
+            self._returns_value(method),
+            not self._has_side_effects(method),
+            not self._has_control_flow(method),
+            not self._has_external_calls(method),
+        ]
+        return all(checks)
+
+    def _is_dunder_method(self, method: ast.FunctionDef) -> bool:
+        """Check if method is a dunder method.
+
+        Args:
+            method: The method node
+
+        Returns:
+            True if dunder method
+        """
+        name = method.name
+        return name.startswith("__") and name.endswith("__")
+
+    def _is_action_verb_method(self, method: ast.FunctionDef) -> bool:
+        """Check if method is an action verb (transformation/lifecycle method).
+
+        Methods like to_dict(), to_json(), finalize() represent actions, not
+        property access. These should remain as methods following Python idioms.
+        Also handles private method variants like _to_dict(), _generate_html().
+
+        Args:
+            method: The method node
+
+        Returns:
+            True if method is an action verb
+        """
+        name = method.name
+
+        # Strip leading underscores to handle private method variants
+        # e.g., _generate_legend_section should match generate_* pattern
+        stripped_name = name.lstrip("_")
+
+        # Check for action verb prefixes like to_*, generate_*, etc.
+        for prefix in self.exclude_prefixes:
+            if stripped_name.startswith(prefix) and len(stripped_name) > len(prefix):
+                return True
+
+        # Check for specific action verb names (also check stripped version)
+        return name in self.exclude_names or stripped_name in self.exclude_names
+
+    def _has_decorators(self, method: ast.FunctionDef) -> bool:
+        """Check if method has any decorators.
+
+        Args:
+            method: The method node
+
+        Returns:
+            True if method has decorators
+        """
+        return len(method.decorator_list) > 0
+
+    def _takes_only_self(self, method: ast.FunctionDef) -> bool:
+        """Check if method takes only self parameter.
+
+        Args:
+            method: The method node
+
+        Returns:
+            True if only self parameter
+        """
+        args = method.args
+        has_only_self_arg = len(args.args) == 1
+        has_extra_args = self._has_extra_args(args)
+        return has_only_self_arg and not has_extra_args
+
+    def _has_extra_args(self, args: ast.arguments) -> bool:
+        """Check if arguments has extra parameters beyond self.
+
+        Args:
+            args: Method arguments node
+
+        Returns:
+            True if extra arguments present
+        """
+        has_positional_only = bool(args.posonlyargs)
+        has_vararg = args.vararg is not None
+        has_keyword_only = bool(args.kwonlyargs)
+        has_kwarg = args.kwarg is not None
+        has_defaults = bool(args.defaults)
+        has_kw_defaults = args.kw_defaults and any(d is not None for d in args.kw_defaults)
+
+        return any(
+            [
+                has_positional_only,
+                has_vararg,
+                has_keyword_only,
+                has_kwarg,
+                has_defaults,
+                has_kw_defaults,
+            ]
+        )
+
+    def _has_simple_body(self, method: ast.FunctionDef) -> bool:
+        """Check if method body is simple (1-3 statements).
+
+        Args:
+            method: The method node
+
+        Returns:
+            True if body is simple enough
+        """
+        # Filter out docstrings
+        body = self._get_non_docstring_body(method)
+
+        # Check statement count
+        if len(body) > self.max_body_statements:
+            return False
+
+        if len(body) == 0:
+            return False
+
+        return True
+
+    def _get_non_docstring_body(self, method: ast.FunctionDef) -> list[ast.stmt]:
+        """Get method body excluding docstrings.
+
+        Args:
+            method: The method node
+
+        Returns:
+            List of statements excluding docstrings
+        """
+        body = method.body
+        if not body:
+            return []
+
+        # Check if first statement is a docstring
+        first = body[0]
+        if isinstance(first, ast.Expr) and isinstance(first.value, ast.Constant):
+            if isinstance(first.value.value, str):
+                return body[1:]
+
+        return body
+
+    def _returns_value(self, method: ast.FunctionDef) -> bool:
+        """Check if method returns a non-None value.
+
+        Args:
+            method: The method node
+
+        Returns:
+            True if method returns a value
+        """
+        body = self._get_non_docstring_body(method)
+        if not body:
+            return False
+        last = body[-1]
+        return self._is_value_return(last)
+
+    def _is_value_return(self, node: ast.stmt) -> bool:
+        """Check if node is a return statement with a non-None value.
+
+        Args:
+            node: Statement node to check
+
+        Returns:
+            True if return statement with value
+        """
+        if not isinstance(node, ast.Return):
+            return False
+        if node.value is None:
+            return False
+        if isinstance(node.value, ast.Constant) and node.value.value is None:
+            return False
+        return True
+
+    def _has_side_effects(self, method: ast.FunctionDef) -> bool:
+        """Check if method has side effects (assignments to self.*).
+
+        Args:
+            method: The method node
+
+        Returns:
+            True if has side effects
+        """
+        return any(self._is_side_effect_node(node) for node in ast.walk(method))
+
+    def _is_side_effect_node(self, node: ast.AST) -> bool:
+        """Check if a node represents a side effect.
+
+        Args:
+            node: AST node to check
+
+        Returns:
+            True if node is a side effect
+        """
+        return (
+            self._is_self_assign(node)
+            or self._is_self_aug_assign(node)
+            or self._is_self_ann_assign(node)
+            or self._is_self_delete(node)
+        )
+
+    def _is_self_assign(self, node: ast.AST) -> bool:
+        """Check if node is assignment to self."""
+        return isinstance(node, ast.Assign) and self._assigns_to_self(node.targets)
+
+    def _is_self_aug_assign(self, node: ast.AST) -> bool:
+        """Check if node is augmented assignment to self."""
+        return isinstance(node, ast.AugAssign) and self._is_self_target(node.target)
+
+    def _is_self_ann_assign(self, node: ast.AST) -> bool:
+        """Check if node is annotated assignment to self."""
+        if not isinstance(node, ast.AnnAssign):
+            return False
+        return node.value is not None and self._is_self_target(node.target)
+
+    def _is_self_delete(self, node: ast.AST) -> bool:
+        """Check if node is delete of self attribute."""
+        return isinstance(node, ast.Delete) and self._assigns_to_self(node.targets)
+
+    def _assigns_to_self(self, targets: list[ast.expr]) -> bool:
+        """Check if any target is a self attribute.
+
+        Args:
+            targets: Assignment targets
+
+        Returns:
+            True if assigning to self.*
+        """
+        for target in targets:
+            if self._is_self_target(target):
+                return True
+        return False
+
+    def _is_self_target(self, target: ast.expr) -> bool:
+        """Check if target is a self attribute (self.* or self._*).
+
+        Args:
+            target: Assignment target
+
+        Returns:
+            True if target is self.*
+        """
+        if isinstance(target, ast.Attribute):
+            if isinstance(target.value, ast.Name) and target.value.id == "self":
+                return True
+        return False
+
+    # Node types that indicate complex control flow
+    _CONTROL_FLOW_TYPES: tuple[type, ...] = (
+        ast.For,
+        ast.While,
+        ast.Try,
+        ast.If,
+        ast.With,
+        ast.Raise,
+        ast.ListComp,
+        ast.DictComp,
+        ast.SetComp,
+        ast.GeneratorExp,
+    )
+
+    def _has_control_flow(self, method: ast.FunctionDef) -> bool:
+        """Check if method has complex control flow.
+
+        Args:
+            method: The method node
+
+        Returns:
+            True if has complex control flow
+        """
+        return any(isinstance(node, self._CONTROL_FLOW_TYPES) for node in ast.walk(method))
+
+    def _has_external_calls(self, method: ast.FunctionDef) -> bool:
+        """Check if method has external function calls.
+
+        External calls are top-level function calls like print(), format_date().
+        Method calls on objects like self._name.upper() or v.strip() are OK.
+
+        Args:
+            method: The method node
+
+        Returns:
+            True if has external calls
+        """
+        call_nodes = (node for node in ast.walk(method) if isinstance(node, ast.Call))
+        return any(self._is_external_function_call(node) for node in call_nodes)
+
+    def _is_external_function_call(self, call: ast.Call) -> bool:
+        """Check if call is an external function (not a method on an object).
+
+        Args:
+            call: The Call node
+
+        Returns:
+            True if external function call like print(), format_date()
+        """
+        func = call.func
+
+        # Simple name call like print(), format_date()
+        if isinstance(func, ast.Name):
+            return True
+
+        # Method call like obj.method() - these are OK
+        if isinstance(func, ast.Attribute):
+            return False
+
+        return False

src/linters/method_property/violation_builder.py

@@ -0,0 +1,116 @@
+"""
+Purpose: Builds Violation objects for method-should-be-property detection
+
+Scope: Violation creation for methods that should be @property decorators
+
+Overview: Provides ViolationBuilder class that creates Violation objects for method-property
+    detections. Generates descriptive messages indicating which methods should be converted to
+    @property decorators, with special handling for get_* prefix methods (Java-style) that
+    suggests removing the prefix. Constructs complete Violation instances with rule_id,
+    file_path, line number, column, message, and suggestions for Pythonic refactoring.
+
+Dependencies: pathlib.Path for file paths, src.core.types.Violation for violation structure
+
+Exports: ViolationBuilder class
+
+Interfaces: create_violation(method_name, line, column, file_path, is_get_prefix, class_name)
+
+Implementation: Builder pattern with message templates suggesting @property decorator conversion
+"""
+
+from pathlib import Path
+
+from src.core.types import Violation
+
+
+class ViolationBuilder:
+    """Builds violations for method-should-be-property detections."""
+
+    def __init__(self, rule_id: str) -> None:
+        """Initialize the violation builder.
+
+        Args:
+            rule_id: The rule ID to use in violations
+        """
+        self.rule_id = rule_id
+
+    def create_violation(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+        self,
+        method_name: str,
+        line: int,
+        column: int,
+        file_path: Path | None,
+        is_get_prefix: bool = False,
+        class_name: str | None = None,
+    ) -> Violation:
+        """Create a violation for a method that should be a property.
+
+        Args:
+            method_name: Name of the method
+            line: Line number where the violation occurs
+            column: Column number where the violation occurs
+            file_path: Path to the file
+            is_get_prefix: Whether method has get_ prefix
+            class_name: Optional class name for context
+
+        Returns:
+            Violation object with details about the method
+        """
+        message = self._build_message(method_name, is_get_prefix, class_name)
+        suggestion = self._build_suggestion(method_name, is_get_prefix)
+
+        return Violation(
+            rule_id=self.rule_id,
+            file_path=str(file_path) if file_path else "",
+            line=line,
+            column=column,
+            message=message,
+            suggestion=suggestion,
+        )
+
+    def _build_message(
+        self,
+        method_name: str,
+        is_get_prefix: bool,
+        class_name: str | None,
+    ) -> str:
+        """Build the violation message.
+
+        Args:
+            method_name: Name of the method
+            is_get_prefix: Whether method has get_ prefix
+            class_name: Optional class name
+
+        Returns:
+            Human-readable message describing the violation
+        """
+        if is_get_prefix:
+            property_name = method_name[4:]  # Remove 'get_' prefix
+            if class_name:
+                return (
+                    f"Method '{method_name}' in class '{class_name}' should be "
+                    f"a @property named '{property_name}'"
+                )
+            return f"Method '{method_name}' should be a @property named '{property_name}'"
+
+        if class_name:
+            return f"Method '{method_name}' in class '{class_name}' should be a @property"
+        return f"Method '{method_name}' should be a @property"
+
+    def _build_suggestion(self, method_name: str, is_get_prefix: bool) -> str:
+        """Build the suggestion for fixing the violation.
+
+        Args:
+            method_name: Name of the method
+            is_get_prefix: Whether method has get_ prefix
+
+        Returns:
+            Actionable suggestion for fixing
+        """
+        if is_get_prefix:
+            property_name = method_name[4:]  # Remove 'get_' prefix
+            return (
+                f"Add @property decorator and rename to '{property_name}' "
+                f"for Pythonic attribute access"
+            )
+        return "Add @property decorator for Pythonic attribute access"

{thailint-0.7.0.dist-info → thailint-0.8.0.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: thailint
-Version: 0.7.0
+Version: 0.8.0
 Summary: The AI Linter - Enterprise-grade linting and governance for AI-generated code across multiple languages
 License: MIT
 License-File: LICENSE
 Keywords: linter,ai,code-quality,static-analysis,file-placement,governance,multi-language,cli,docker,python
 Author: Steve Jackson
 Requires-Python: >=3.11,<4.0
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -37,7 +37,7 @@ 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-571%2F571%20passing-brightgreen.svg)](tests/)
+[![Tests](https://img.shields.io/badge/tests-682%2F682%20passing-brightgreen.svg)](tests/)
 [![Coverage](https://img.shields.io/badge/coverage-87%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)
@@ -98,6 +98,12 @@ thailint complements your existing linting stack by catching the patterns AI too
   - Configurable thresholds (lines, tokens, occurrences)
   - Language-specific detection (Python, TypeScript, JavaScript)
   - False positive filtering (keyword args, imports)
+- **Method Property Linting** - Detect methods that should be @property decorators
+  - Python AST-based detection
+  - get_* prefix detection (Java-style getters)
+  - Simple computed value detection
+  - Action verb exclusion (to_*, finalize, serialize)
+  - Test file detection
 - **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.7.0.dist-info → thailint-0.8.0.dist-info}/RECORD

@@ -2,7 +2,7 @@ src/__init__.py,sha256=f601zncODr2twrUHqTLS5wyOdZqZi9tMjAe2INhRKqU,2175
 src/analyzers/__init__.py,sha256=fFloZtjkBGwYbAhKTxS3Qy3yDr2_3i3WSfKTw1mAioo,972
 src/analyzers/typescript_base.py,sha256=4I7fAcMOAY9vY1AXh52QpohgFmguBECwOkvBRP4zCS4,5054
 src/api.py,sha256=pJ5l3qxccKBEY-BkANwzTgLAl1ZFq7OP6hx6LSxbhDw,4664
-src/cli.py,sha256=H8DAOCRIu4pK2fbTqryJ0arwKmJ9w3kkeRdtC-FVdAY,55579
+src/cli.py,sha256=E0PEazl-fuuNu8psnUBAQ53PihtLwgKyAOL3v193Z-o,59424
 src/config.py,sha256=2ebAjIpAhw4bHbOxViEA5nCjfBlDEIrMR59DBrzcYzM,12460
 src/core/__init__.py,sha256=5FtsDvhMt4SNRx3pbcGURrxn135XRbeRrjSUxiXwkNc,381
 src/core/base.py,sha256=Eklcagi2ktfY4Kytl_ObXov2U49N9OGDpw4cu4PUzGY,7824
@@ -17,18 +17,18 @@ src/formatters/__init__.py,sha256=yE1yIL8lplTMEjsmQm7F-kOMaYq7OjmbFuiwwK0D-gM,81
 src/formatters/sarif.py,sha256=gGOwb_v7j4mx4bpvV1NNDd-JyHH8i8XX89iQ6uRSvG4,7050
 src/linter_config/__init__.py,sha256=_I2VVlZlfKyT-tKukuUA5-aVcHLOe3m6C2cev43AiEc,298
 src/linter_config/ignore.py,sha256=S2Ub0CCOOC-wpU5Y_EodMprciw18fgWcnp4z_h1MYNk,19638
-src/linter_config/loader.py,sha256=HB09W-uVsEcgCbvUwUHS5Jm2n0bqBXA3744vMc4GAqk,2542
+src/linter_config/loader.py,sha256=BM4GJZqkEJSKxR3jIMgz0WqB_uWxXNiHsKWtwUA43AE,2545
 src/linters/__init__.py,sha256=-nnNsL8E5-2p9qlLKp_TaShHAjPH-NacOEU1sXmAR9k,77
 src/linters/dry/__init__.py,sha256=p58tN3z_VbulfTkRm1kLZJ43Bemt66T2sro1teirUY8,826
 src/linters/dry/base_token_analyzer.py,sha256=SgnsX4a4kUzOsA9hTkLkg4yB8I77ewAyiUp6cAybUrg,2684
-src/linters/dry/block_filter.py,sha256=FN1QDXQu6HYhdHo6fkzUDUrMX4TqaLV_myBOQRsmPfk,8242
+src/linters/dry/block_filter.py,sha256=8Sc4tZqHj5GpVxJTQRMCtbMLt6zscuylF2fccEwPo2w,8248
 src/linters/dry/block_grouper.py,sha256=gBvSPgy8jumChZ53px3P7hDCJfi5PDrKhwxLTgNy7ig,1810
-src/linters/dry/cache.py,sha256=QbFajUNb3v2LVuYbTJXY9ExXjjIsd73DQ5Y1hB-SH1s,5879
+src/linters/dry/cache.py,sha256=dedkGU5SolTjmTTsmj-dwPEnxyhWZ2aBiHGkQy1JwXo,5881
 src/linters/dry/cache_query.py,sha256=NTBh4ISy76LJb9tJ6G94fE0R2OiE0eQ-zVvB08WG2bA,1802
 src/linters/dry/config.py,sha256=XaHX5SnbH8cEBHiNKMSuYQJwCbKL-Q9XgZVRcc9UBgQ,5439
 src/linters/dry/config_loader.py,sha256=wikqnigOp6p1h9jaAATV_3bDXSiaIUFaf9xg1jQMDpo,1313
 src/linters/dry/deduplicator.py,sha256=a1TRvldxCszf5QByo1ihXF3W98dpGuyaRT74jPfQftM,3988
-src/linters/dry/duplicate_storage.py,sha256=3OxE2mtoWGAsNNrB8J2c-4JirLUoqZ9ptydO5beM-mg,1971
+src/linters/dry/duplicate_storage.py,sha256=9pIALnwAuz5BJUYNXrPbObbP932CE9x0vgUkICryT_s,1970
 src/linters/dry/file_analyzer.py,sha256=ufSQ85ddsGTqGnBHZNTdV_5DGfTpUmJOB58sIdJNV0I,2928
 src/linters/dry/inline_ignore.py,sha256=ASfA-fp_1aPpkakN2e0T6qdTh8S7Jqj89ovxXJLmFlc,4439
 src/linters/dry/linter.py,sha256=XMLwCgGrFX0l0dVUJs1jpsXOfgxeKKDbxOtN5h5Emhk,5835
@@ -38,7 +38,7 @@ src/linters/dry/token_hasher.py,sha256=71njBzUsWvQjIWo38AKeRHQsG8K4jrjLTKuih-i6G
 src/linters/dry/typescript_analyzer.py,sha256=ShNoB2KfPe010wKEZoFxn-ZKh0MnRUwgADDQKQtfedI,21627
 src/linters/dry/violation_builder.py,sha256=EUiEQIOZjzAoHEqZiIR8WZP8m4dgqJjcveR5mdMyClI,2803
 src/linters/dry/violation_filter.py,sha256=aTOMz8kXG2sZlSVcf3cAxgxHs7f2kBXInfr1V_04fUQ,3125
-src/linters/dry/violation_generator.py,sha256=cc6aKvTxtHSZm0F7Y-gL1bmD3JUphRmAvcbqk9aUzGg,6128
+src/linters/dry/violation_generator.py,sha256=hbMs8Fo2hS8JCXicZcZni6NEkv4fJRsyrsjzrqN6qVw,6122
 src/linters/file_header/__init__.py,sha256=S3a2xrOlxnNWD02To5K2ZwILsNEvSj1IvUAH8RjgOV4,791
 src/linters/file_header/atemporal_detector.py,sha256=bgQJPDuJj1J5gHKIIOz1TYbBwu8GHrcMafWFVqZ_zZE,3192
 src/linters/file_header/base_parser.py,sha256=HbuJpXQ4V3zTDTP_D0iFqoT7kab6gk8A1lZdlqCb6tc,3202
@@ -67,6 +67,11 @@ src/linters/magic_numbers/linter.py,sha256=maj4NgrDapv0RurKvaVgOI1BUujixZv4E7UeY
 src/linters/magic_numbers/python_analyzer.py,sha256=0u1cFaaFCqOW5yeW-YbmPoZuVIeN_KtmkFyyxup6aR0,2803
 src/linters/magic_numbers/typescript_analyzer.py,sha256=NTU1XY-Hudse5oxOtEiG6nA0Rs5Icn9HXELnyPj8OZU,7554
 src/linters/magic_numbers/violation_builder.py,sha256=SqIQv3N9lpP2GRC1TC5InrvaEdrAq24V7Ec2Xj5olb0,3308
+src/linters/method_property/__init__.py,sha256=t0C6zD5WLm-McgmvVajQJg4HQfOi7_4YzNLhKNA484w,1415
+src/linters/method_property/config.py,sha256=lcKfeCIeWBcD91j0AchccWhGvc68epiQeKbgL6DCEA8,5359
+src/linters/method_property/linter.py,sha256=zdXUqx76A8J7Ryvg333jrAUDFWx4I4n3dzayAcN2k8w,12721
+src/linters/method_property/python_analyzer.py,sha256=QQTpKrdCJzFqu7gdQfAqno9_wbzHlOQYQdCzMPriRM0,15244
+src/linters/method_property/violation_builder.py,sha256=GKZC8TS9vZq_lKK5ffOVUHUlMpZN3_-Mv3inRE-v2pE,4141
 src/linters/nesting/__init__.py,sha256=tszmyCEQMpEwB5H84WcAUfRYDQl7jpsn04es5DtAHsM,3200
 src/linters/nesting/config.py,sha256=PfPA2wJn3i6HHXeM0qu6Qx-v1KJdRwlRkFOdpf7NhS8,2405
 src/linters/nesting/linter.py,sha256=-klbXIbg145beICop81CNQ5J1OInQaeycDT8u3Ff2Ww,6236
@@ -96,8 +101,8 @@ src/orchestrator/language_detector.py,sha256=rHyVMApit80NTTNyDH1ObD1usKD8LjGmH3D
 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.7.0.dist-info/METADATA,sha256=DiyHLUK6NNz3o2MtQsJPJX-3PWdUX0vyMt2SsSI3ot0,41840
-thailint-0.7.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-thailint-0.7.0.dist-info/entry_points.txt,sha256=l7DQJgU18sVLDpSaXOXY3lLhnQHQIRrSJZTQjG1cEAk,62
-thailint-0.7.0.dist-info/licenses/LICENSE,sha256=kxh1J0Sb62XvhNJ6MZsVNe8PqNVJ7LHRn_EWa-T3djw,1070
-thailint-0.7.0.dist-info/RECORD,,
+thailint-0.8.0.dist-info/METADATA,sha256=JLoEBO87HaZBzNk9wlkn1MeCO_S2wG5dKnL6itrbDe0,42115
+thailint-0.8.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+thailint-0.8.0.dist-info/entry_points.txt,sha256=l7DQJgU18sVLDpSaXOXY3lLhnQHQIRrSJZTQjG1cEAk,62
+thailint-0.8.0.dist-info/licenses/LICENSE,sha256=kxh1J0Sb62XvhNJ6MZsVNe8PqNVJ7LHRn_EWa-T3djw,1070
+thailint-0.8.0.dist-info/RECORD,,