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

src/linter_config/loader.py

@@ -16,9 +16,9 @@ Overview: Loads linter configuration from .thailint.yaml or .thailint.json files
 Dependencies: PyYAML for YAML parsing with safe_load(), json (stdlib) for JSON parsing,
     pathlib for file path handling
 
-Exports: LinterConfigLoader class
+Exports: load_config function, get_defaults function, LinterConfigLoader class (compat)
 
-Interfaces: load(config_path: Path) -> dict[str, Any] for loading config files,
+Interfaces: load_config(config_path: Path) -> dict[str, Any] for loading config files,
     get_defaults() -> dict[str, Any] for default configuration structure
 
 Implementation: Extension-based format detection (.yaml/.yml vs .json), yaml.safe_load()
@@ -31,13 +31,51 @@ from typing import Any
 from src.core.config_parser import parse_config_file
 
 
+def get_defaults() -> dict[str, Any]:
+    """Get default configuration.
+
+    Returns:
+        Default configuration with empty rules and ignore lists.
+    """
+    return {
+        "rules": {},
+        "ignore": [],
+    }
+
+
+def load_config(config_path: Path) -> dict[str, Any]:
+    """Load configuration from file.
+
+    Args:
+        config_path: Path to YAML or JSON config file.
+
+    Returns:
+        Configuration dictionary.
+
+    Raises:
+        ConfigParseError: If file format is unsupported or parsing fails.
+    """
+    if not config_path.exists():
+        return get_defaults()
+
+    return parse_config_file(config_path)
+
+
+# Legacy class wrapper for backward compatibility
 class LinterConfigLoader:
     """Load linter configuration from YAML or JSON files.
 
     Supports loading from .thailint.yaml, .thailint.json, or custom paths.
     Provides sensible defaults when config files don't exist.
+
+    Note: This class is a thin wrapper around module-level functions
+    for backward compatibility.
     """
 
+    def __init__(self) -> None:
+        """Initialize the loader."""
+        pass  # No state needed
+
     def load(self, config_path: Path) -> dict[str, Any]:
         """Load configuration from file.
 
@@ -50,18 +88,13 @@ class LinterConfigLoader:
         Raises:
             ConfigParseError: If file format is unsupported or parsing fails.
         """
-        if not config_path.exists():
-            return self.get_defaults()
-
-        return parse_config_file(config_path)
+        return load_config(config_path)
 
-    def get_defaults(self) -> dict[str, Any]:
-        """Get default configuration.
+    @property
+    def defaults(self) -> dict[str, Any]:
+        """Default configuration.
 
         Returns:
             Default configuration with empty rules and ignore lists.
         """
-        return {
-            "rules": {},
-            "ignore": [],
-        }
+        return get_defaults()

src/linters/dry/block_filter.py

@@ -53,9 +53,10 @@ class BaseBlockFilter(ABC):
         """
         pass
 
+    @property
     @abstractmethod
-    def get_name(self) -> str:
-        """Get filter name for configuration and logging."""
+    def name(self) -> str:
+        """Filter name for configuration and logging."""
         pass
 
 
@@ -152,8 +153,9 @@ class KeywordArgumentFilter(BaseBlockFilter):
             return False
         return True
 
-    def get_name(self) -> str:
-        """Get filter name."""
+    @property
+    def name(self) -> str:
+        """Filter name."""
         return "keyword_argument_filter"
 
 
@@ -163,6 +165,10 @@ class ImportGroupFilter(BaseBlockFilter):
     Import organization often creates similar patterns that aren't meaningful duplication.
     """
 
+    def __init__(self) -> None:
+        """Initialize the import group filter."""
+        pass  # Stateless filter for import blocks
+
     def should_filter(self, block: CodeBlock, file_content: str) -> bool:
         """Check if block is only import statements.
 
@@ -184,8 +190,9 @@ class ImportGroupFilter(BaseBlockFilter):
 
         return True
 
-    def get_name(self) -> str:
-        """Get filter name."""
+    @property
+    def name(self) -> str:
+        """Filter name."""
         return "import_group_filter"
 
 
@@ -204,7 +211,7 @@ class BlockFilterRegistry:
             filter_instance: Filter to register
         """
         self._filters.append(filter_instance)
-        self._enabled_filters.add(filter_instance.get_name())
+        self._enabled_filters.add(filter_instance.name)
 
     def enable_filter(self, filter_name: str) -> None:
         """Enable a specific filter by name.
@@ -233,7 +240,7 @@ class BlockFilterRegistry:
             True if block should be filtered out
         """
         for filter_instance in self._filters:
-            if filter_instance.get_name() not in self._enabled_filters:
+            if filter_instance.name not in self._enabled_filters:
                 continue
 
             if filter_instance.should_filter(block, file_content):

src/linters/dry/block_grouper.py

@@ -26,6 +26,10 @@ from .cache import CodeBlock
 class BlockGrouper:
     """Groups blocks and violations by file path."""
 
+    def __init__(self) -> None:
+        """Initialize the block grouper."""
+        pass  # Stateless grouper for code blocks
+
     def group_blocks_by_file(self, blocks: list[CodeBlock]) -> dict[Path, list[CodeBlock]]:
         """Group blocks by file path.
 

src/linters/dry/cache.py

@@ -157,8 +157,9 @@ class DRYCache:
 
         return blocks
 
-    def get_duplicate_hashes(self) -> list[int]:
-        """Get all hash values that appear 2+ times.
+    @property
+    def duplicate_hashes(self) -> list[int]:
+        """Hash values that appear 2+ times.
 
         Returns:
             List of hash values with 2 or more occurrences

src/linters/dry/cache_query.py

@@ -22,6 +22,10 @@ import sqlite3
 class CacheQueryService:
     """Handles cache database queries."""
 
+    def __init__(self) -> None:
+        """Initialize the cache query service."""
+        pass  # Stateless query service for database operations
+
     def get_duplicate_hashes(self, db: sqlite3.Connection) -> list[int]:
         """Get all hash values that appear 2+ times.
 

src/linters/dry/duplicate_storage.py

@@ -11,7 +11,7 @@ Dependencies: DRYCache, CodeBlock, Path
 
 Exports: DuplicateStorage class
 
-Interfaces: DuplicateStorage.add_blocks(file_path, blocks), get_duplicate_hashes(),
+Interfaces: DuplicateStorage.add_blocks(file_path, blocks), duplicate_hashes property,
     get_blocks_for_hash(hash_value)
 
 Implementation: Delegates to SQLite cache for all storage operations
@@ -43,13 +43,14 @@ class DuplicateStorage:
         if blocks:
             self._cache.add_blocks(file_path, blocks)
 
-    def get_duplicate_hashes(self) -> list[int]:
-        """Get all hash values with 2+ occurrences from SQLite.
+    @property
+    def duplicate_hashes(self) -> list[int]:
+        """Hash values with 2+ occurrences from SQLite.
 
         Returns:
             List of hash values that appear in multiple blocks
         """
-        return self._cache.get_duplicate_hashes()
+        return self._cache.duplicate_hashes
 
     def get_blocks_for_hash(self, hash_value: int) -> list[CodeBlock]:
         """Get all blocks with given hash value from SQLite.

src/linters/dry/token_hasher.py

@@ -20,9 +20,13 @@ Implementation: Token-based normalization with rolling window algorithm, languag
 """
 
 
-class TokenHasher:
+class TokenHasher:  # thailint: ignore[srp] - Methods support single responsibility of code tokenization
     """Tokenize code and create rolling hashes for duplicate detection."""
 
+    def __init__(self) -> None:
+        """Initialize the token hasher."""
+        pass  # Stateless hasher for code tokenization
+
     def tokenize(self, code: str) -> list[str]:
         """Tokenize code by stripping comments and normalizing whitespace.
 

src/linters/dry/violation_builder.py

@@ -27,6 +27,10 @@ from .cache import CodeBlock
 class DRYViolationBuilder:
     """Builds violation messages for duplicate code."""
 
+    def __init__(self) -> None:
+        """Initialize the DRY violation builder."""
+        pass  # Stateless builder for duplicate code violations
+
     def build_violation(
         self, block: CodeBlock, all_duplicates: list[CodeBlock], rule_id: str
     ) -> Violation:

src/linters/dry/violation_filter.py

@@ -25,6 +25,10 @@ DEFAULT_FALLBACK_LINE_COUNT = 5
 class ViolationFilter:
     """Filters overlapping violations."""
 
+    def __init__(self) -> None:
+        """Initialize the violation filter."""
+        pass  # Stateless filter for overlapping violations
+
     def filter_overlapping(self, sorted_violations: list[Violation]) -> list[Violation]:
         """Filter overlapping violations, keeping first occurrence.
 

src/linters/dry/violation_generator.py

@@ -55,7 +55,7 @@ class ViolationGenerator:
         Returns:
             List of violations filtered by ignore patterns and inline directives
         """
-        duplicate_hashes = storage.get_duplicate_hashes()
+        duplicate_hashes = storage.duplicate_hashes
         violations = []
 
         for hash_value in duplicate_hashes:

src/linters/file_header/bash_parser.py

@@ -24,6 +24,10 @@ from src.linters.file_header.base_parser import BaseHeaderParser
 class BashHeaderParser(BaseHeaderParser):
     """Extracts and parses Bash file headers from comment blocks."""
 
+    def __init__(self) -> None:
+        """Initialize the Bash header parser."""
+        pass  # BaseHeaderParser has no __init__, but we need this for stateless-class
+
     def extract_header(self, code: str) -> str | None:
         """Extract comment header from Bash script."""
         if not code or not code.strip():

src/linters/file_placement/directory_matcher.py

@@ -23,6 +23,10 @@ from typing import Any
 class DirectoryMatcher:
     """Finds matching directory rules based on path prefixes."""
 
+    def __init__(self) -> None:
+        """Initialize the directory matcher."""
+        pass  # Stateless matcher for directory rules
+
     def find_matching_rule(
         self, path_str: str, directories: dict[str, Any]
     ) -> tuple[dict[str, Any] | None, str | None]:

src/linters/file_placement/pattern_matcher.py

@@ -23,6 +23,10 @@ import re
 class PatternMatcher:
     """Handles regex pattern matching for file paths."""
 
+    def __init__(self) -> None:
+        """Initialize the pattern matcher."""
+        pass  # Stateless matcher for regex patterns
+
     def match_deny_patterns(
         self, path_str: str, deny_patterns: list[dict[str, str]]
     ) -> tuple[bool, str | None]:

src/linters/file_placement/pattern_validator.py

@@ -24,6 +24,10 @@ from typing import Any
 class PatternValidator:
     """Validates regex patterns in file placement configuration."""
 
+    def __init__(self) -> None:
+        """Initialize the pattern validator."""
+        pass  # Stateless validator for regex patterns
+
     def validate_config(self, config: dict[str, Any]) -> None:
         """Validate all regex patterns in configuration.
 

src/linters/magic_numbers/context_analyzer.py

@@ -30,6 +30,10 @@ from pathlib import Path
 class ContextAnalyzer:  # thailint: ignore[srp]
     """Analyzes contexts to determine if numeric literals are acceptable."""
 
+    def __init__(self) -> None:
+        """Initialize the context analyzer."""
+        pass  # Stateless analyzer for context checking
+
     def is_acceptable_context(
         self,
         node: ast.Constant,

src/linters/magic_numbers/typescript_analyzer.py

@@ -44,6 +44,10 @@ class TypeScriptMagicNumberAnalyzer(TypeScriptBaseAnalyzer):  # thailint: ignore
     of TypeScript magic number detection - all methods support this core purpose.
     """
 
+    def __init__(self) -> None:  # pylint: disable=useless-parent-delegation
+        """Initialize the TypeScript magic number analyzer."""
+        super().__init__()  # Sets self.tree_sitter_available from base class
+
     def find_numeric_literals(self, root_node: Node) -> list[tuple[Node, float | int, int]]:
         """Find all numeric literal nodes in TypeScript/JavaScript AST.
 

src/linters/method_property/__init__.py

@@ -0,0 +1,49 @@
+"""
+Purpose: Package exports for method-should-be-property linter
+
+Scope: Method property linter public API
+
+Overview: Exports the MethodPropertyRule class and MethodPropertyConfig dataclass for use by
+    the orchestrator and external consumers. Provides a convenience lint() function for
+    standalone usage of the linter.
+
+Dependencies: MethodPropertyRule from linter module, MethodPropertyConfig from config module
+
+Exports: MethodPropertyRule, MethodPropertyConfig, lint function
+
+Interfaces: lint(file_path, content, config) -> list[Violation] convenience function
+
+Implementation: Simple re-exports from submodules with optional convenience wrapper
+"""
+
+from .config import MethodPropertyConfig
+from .linter import MethodPropertyRule
+
+__all__ = ["MethodPropertyRule", "MethodPropertyConfig", "lint"]
+
+
+def lint(
+    file_path: str,
+    content: str,
+    config: dict | None = None,
+) -> list:
+    """Lint a file for method-should-be-property violations.
+
+    Args:
+        file_path: Path to the file being linted
+        content: Content of the file
+        config: Optional configuration dictionary
+
+    Returns:
+        List of Violation objects
+    """
+    from unittest.mock import Mock
+
+    rule = MethodPropertyRule()
+    context = Mock()
+    context.file_path = file_path
+    context.file_content = content
+    context.language = "python"
+    context.config = config
+
+    return rule.check(context)

src/linters/method_property/config.py

@@ -0,0 +1,135 @@
+"""
+Purpose: Configuration schema for method-should-be-property linter
+
+Scope: Method property linter configuration for Python files
+
+Overview: Defines configuration schema for method-should-be-property linter. Provides
+    MethodPropertyConfig dataclass with enabled flag, max_body_statements threshold (default 3)
+    for determining when a method body is too complex to be a property candidate, and ignore
+    patterns list for excluding specific files or directories. Includes configurable action verb
+    exclusions (prefixes and names) with sensible defaults that can be extended or overridden.
+    Supports per-file and per-directory config overrides through from_dict class method.
+    Integrates with orchestrator's configuration system via .thailint.yaml.
+
+Dependencies: dataclasses module for configuration structure, typing module for type hints
+
+Exports: MethodPropertyConfig dataclass, DEFAULT_EXCLUDE_PREFIXES, DEFAULT_EXCLUDE_NAMES
+
+Interfaces: from_dict(config, language) -> MethodPropertyConfig for configuration loading
+
+Implementation: Dataclass with defaults matching Pythonic conventions and common use cases
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+# Default action verb prefixes - methods starting with these are excluded
+# These represent actions/transformations, not property access
+DEFAULT_EXCLUDE_PREFIXES: tuple[str, ...] = (
+    "to_",  # Transformation: to_dict, to_json, to_string
+    "dump_",  # Serialization: dump_to_json, dump_to_apigw
+    "generate_",  # Factory: generate_report, generate_html
+    "create_",  # Factory: create_instance, create_config
+    "build_",  # Construction: build_query, build_html
+    "make_",  # Factory: make_request, make_connection
+    "render_",  # Output: render_template, render_html
+    "compute_",  # Calculation: compute_hash, compute_total
+    "calculate_",  # Calculation: calculate_sum, calculate_average
+)
+
+# Default action verb names - exact method names that are excluded
+# These are lifecycle hooks, display actions, and resource operations
+DEFAULT_EXCLUDE_NAMES: frozenset[str] = frozenset(
+    {
+        "finalize",  # Lifecycle hook
+        "serialize",  # Transformation
+        "dump",  # Serialization
+        "validate",  # Validation action
+        "show",  # Display action
+        "display",  # Display action
+        "print",  # Output action
+        "refresh",  # Update action
+        "reset",  # State action
+        "clear",  # State action
+        "close",  # Resource action
+        "open",  # Resource action
+        "save",  # Persistence action
+        "load",  # Persistence action
+        "execute",  # Action
+        "run",  # Action
+    }
+)
+
+
+def _load_list_config(
+    config: dict[str, Any], key: str, override_key: str, default: tuple[str, ...]
+) -> tuple[str, ...]:
+    """Load a list config with extend/override semantics."""
+    if override_key in config and isinstance(config[override_key], list):
+        return tuple(config[override_key])
+    if key in config and isinstance(config[key], list):
+        return default + tuple(config[key])
+    return default
+
+
+def _load_set_config(
+    config: dict[str, Any], key: str, override_key: str, default: frozenset[str]
+) -> frozenset[str]:
+    """Load a set config with extend/override semantics."""
+    if override_key in config and isinstance(config[override_key], list):
+        return frozenset(config[override_key])
+    if key in config and isinstance(config[key], list):
+        return default | frozenset(config[key])
+    return default
+
+
+@dataclass
+class MethodPropertyConfig:  # thailint: ignore[dry]
+    """Configuration for method-should-be-property linter."""
+
+    enabled: bool = True
+    max_body_statements: int = 3
+    ignore: list[str] = field(default_factory=list)
+    ignore_methods: list[str] = field(default_factory=list)
+
+    # Action verb exclusions (extend defaults or override)
+    exclude_prefixes: tuple[str, ...] = DEFAULT_EXCLUDE_PREFIXES
+    exclude_names: frozenset[str] = DEFAULT_EXCLUDE_NAMES
+
+    # dry: ignore-block
+    @classmethod
+    def from_dict(
+        cls, config: dict[str, Any] | None, language: str | None = None
+    ) -> "MethodPropertyConfig":
+        """Load configuration from dictionary.
+
+        Args:
+            config: Dictionary containing configuration values, or None
+            language: Programming language (unused, for interface compatibility)
+
+        Returns:
+            MethodPropertyConfig instance with values from dictionary
+        """
+        if config is None:
+            return cls()
+
+        ignore_patterns = config.get("ignore", [])
+        if not isinstance(ignore_patterns, list):
+            ignore_patterns = []
+
+        ignore_methods = config.get("ignore_methods", [])
+        if not isinstance(ignore_methods, list):
+            ignore_methods = []
+
+        return cls(
+            enabled=config.get("enabled", True),
+            max_body_statements=config.get("max_body_statements", 3),
+            ignore=ignore_patterns,
+            ignore_methods=ignore_methods,
+            exclude_prefixes=_load_list_config(
+                config, "exclude_prefixes", "exclude_prefixes_override", DEFAULT_EXCLUDE_PREFIXES
+            ),
+            exclude_names=_load_set_config(
+                config, "exclude_names", "exclude_names_override", DEFAULT_EXCLUDE_NAMES
+            ),
+        )