thailint 0.15.4__tar.gz → 0.15.6__tar.gz

{thailint-0.15.4 → thailint-0.15.6}/PKG-INFO

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

{thailint-0.15.4 → thailint-0.15.6}/pyproject.toml

@@ -17,7 +17,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "thailint"
-version = "0.15.4"
+version = "0.15.6"
 description = "The AI Linter - Enterprise-grade linting and governance for AI-generated code across multiple languages"
 authors = ["Steve Jackson"]
 license = "MIT"

{thailint-0.15.4 → thailint-0.15.6}/src/core/cli_utils.py

@@ -143,6 +143,24 @@ def _load_json_config(config_file: Path) -> dict[str, Any]:
         return dict(result) if isinstance(result, dict) else {}
 
 
+def _sanitize_string(text: str) -> str:
+    """Remove or replace surrogate characters that can't be encoded to UTF-8.
+
+    Surrogate characters (U+D800-U+DFFF) appear when Python reads filesystem paths
+    or file content with invalid UTF-8 bytes using surrogateescape error handling.
+    These characters cannot be encoded to UTF-8 and cause UnicodeEncodeError.
+
+    Args:
+        text: String that may contain surrogate characters
+
+    Returns:
+        String with surrogates replaced by the Unicode replacement character
+    """
+    # Encode with surrogateescape to handle surrogates, then decode back
+    # This effectively replaces surrogates with a replacement representation
+    return text.encode("utf-8", errors="surrogateescape").decode("utf-8", errors="replace")
+
+
 def format_violations(violations: list, output_format: str) -> None:
     """Format and print violations to console.
 
@@ -168,10 +186,10 @@ def _output_json(violations: list) -> None:
         "violations": [
             {
                 "rule_id": v.rule_id,
-                "file_path": str(v.file_path),
+                "file_path": _sanitize_string(str(v.file_path)),
                 "line": v.line,
                 "column": v.column,
-                "message": v.message,
+                "message": _sanitize_string(v.message),
                 "severity": v.severity.name,
             }
             for v in violations
@@ -215,9 +233,11 @@ def _print_violation(v: Any) -> None:
     Args:
         v: Violation object with file_path, line, column, severity, rule_id, message
     """
-    location = f"{v.file_path}:{v.line}" if v.line else str(v.file_path)
+    file_path = _sanitize_string(str(v.file_path))
+    message = _sanitize_string(v.message)
+    location = f"{file_path}:{v.line}" if v.line else file_path
     if v.column:
         location += f":{v.column}"
     click.echo(f"  {location}")
-    click.echo(f"    [{v.severity.name}] {v.rule_id}: {v.message}")
+    click.echo(f"    [{v.severity.name}] {v.rule_id}: {message}")
     click.echo()

{thailint-0.15.4 → thailint-0.15.6}/src/linters/magic_numbers/config.py

@@ -4,8 +4,9 @@ Purpose: Configuration schema for magic numbers linter
 Scope: MagicNumberConfig dataclass with allowed_numbers and max_small_integer settings
 
 Overview: Defines configuration schema for magic numbers linter. Provides MagicNumberConfig dataclass
-    with allowed_numbers set (default includes common acceptable numbers like -1, 0, 1, 2, 3, 4, 5, 10, 100, 1000)
-    and max_small_integer threshold (default 10) for range() contexts. Supports per-file and per-directory
+    with allowed_numbers set (default includes common acceptable numbers like -1, 0, 1, 2, 3, 4, 5, 10, 100, 1000
+    and standard ports like 80, 443, 22, 21, 8080, 8443, 3000, 5000) and max_small_integer threshold (default 10)
+    for range() contexts. Supports per-file and per-directory
     config overrides through from_dict class method. Validates that configuration values are appropriate
     types. Integrates with orchestrator's configuration system to allow users to customize allowed numbers
     via .thailint.yaml configuration files.
@@ -18,11 +19,41 @@ Interfaces: MagicNumberConfig(allowed_numbers: set, max_small_integer: int, enab
     from_dict class method for loading configuration from dictionary
 
 Implementation: Dataclass with validation and defaults, matches reference implementation patterns
+
+Suppressions:
+    - unnecessary-lambda: The lambda is required here because dataclass field default_factory
+        needs a callable, and DEFAULT_ALLOWED_NUMBERS.copy() is a method call, not a callable.
+        Using `default_factory=DEFAULT_ALLOWED_NUMBERS.copy` would call the method at class
+        definition time, not at instance creation time.
 """
 
 from dataclasses import dataclass, field
 from typing import Any
 
+# Default allowed numbers including common small integers and standard ports
+DEFAULT_ALLOWED_NUMBERS: set[int | float] = {
+    # Common small integers
+    -1,
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    10,
+    100,
+    1000,
+    # Standard ports
+    21,  # FTP
+    22,  # SSH
+    80,  # HTTP
+    443,  # HTTPS
+    3000,  # Common dev server (Node.js, Rails)
+    5000,  # Flask default
+    8080,  # Alternate HTTP
+    8443,  # Alternate HTTPS
+}
+
 
 @dataclass
 class MagicNumberConfig:
@@ -30,10 +61,11 @@ class MagicNumberConfig:
 
     enabled: bool = True
     allowed_numbers: set[int | float] = field(
-        default_factory=lambda: {-1, 0, 1, 2, 3, 4, 5, 10, 100, 1000}
+        default_factory=lambda: DEFAULT_ALLOWED_NUMBERS.copy()  # pylint: disable=unnecessary-lambda
     )
     max_small_integer: int = 10
     ignore: list[str] = field(default_factory=list)
+    exempt_definition_files: bool = True
 
     def __post_init__(self) -> None:
         """Validate configuration values."""
@@ -58,16 +90,14 @@ class MagicNumberConfig:
             allowed_numbers = set(
                 lang_config.get(
                     "allowed_numbers",
-                    config.get("allowed_numbers", {-1, 0, 1, 2, 3, 4, 5, 10, 100, 1000}),
+                    config.get("allowed_numbers", DEFAULT_ALLOWED_NUMBERS),
                 )
             )
             max_small_integer = lang_config.get(
                 "max_small_integer", config.get("max_small_integer", 10)
             )
         else:
-            allowed_numbers = set(
-                config.get("allowed_numbers", {-1, 0, 1, 2, 3, 4, 5, 10, 100, 1000})
-            )
+            allowed_numbers = set(config.get("allowed_numbers", DEFAULT_ALLOWED_NUMBERS))
             max_small_integer = config.get("max_small_integer", 10)
 
         ignore_patterns = config.get("ignore", [])
@@ -79,4 +109,5 @@ class MagicNumberConfig:
             allowed_numbers=allowed_numbers,
             max_small_integer=max_small_integer,
             ignore=ignore_patterns,
+            exempt_definition_files=config.get("exempt_definition_files", True),
         )

thailint-0.15.6/src/linters/magic_numbers/definition_detector.py

@@ -0,0 +1,226 @@
+"""
+Purpose: Detect constant definition files that should be exempt from magic number checking
+
+Scope: File-level detection of definition patterns (status codes, constants files)
+
+Overview: Provides functions to detect if a file is a constant definition file that should
+    be exempt from magic number violations. Definition files exist specifically to define
+    named constants and shouldn't be flagged. Detection is based on:
+    1. Filename patterns (*_codes.py, *_constants.py, constants.py)
+    2. Content patterns (dicts with 5+ int keys, 10+ UPPERCASE constant assignments)
+    Files matching these patterns contain legitimate constant definitions.
+
+Dependencies: ast module for parsing, pathlib for Path handling, re for pattern matching
+
+Exports: is_definition_file function
+
+Interfaces: is_definition_file(file_path, content) -> bool
+
+Implementation: Filename pattern matching and AST-based content analysis
+"""
+
+import ast
+import re
+from pathlib import Path
+
+# Threshold for number of UPPERCASE constants to consider a file as definition file
+MIN_UPPERCASE_CONSTANTS = 10
+
+# Threshold for number of int keys in a dict to consider it a definition pattern
+MIN_DICT_INT_KEYS = 5
+
+
+def is_definition_file(file_path: Path | str | None, content: str | None) -> bool:
+    """Check if file is a constant definition file that should be exempt.
+
+    Args:
+        file_path: Path to the file
+        content: File content
+
+    Returns:
+        True if file is a definition file that should be exempt
+    """
+    if _matches_definition_filename(file_path):
+        return True
+
+    if content and _has_definition_content_patterns(content):
+        return True
+
+    return False
+
+
+def _matches_definition_filename(file_path: Path | str | None) -> bool:
+    """Check if filename matches definition file patterns.
+
+    Patterns:
+    - *_codes.py (status_codes.py, error_codes.py, etc.)
+    - *_constants.py (app_constants.py, etc.)
+    - constants.py
+
+    Args:
+        file_path: Path to the file
+
+    Returns:
+        True if filename matches definition patterns
+    """
+    if not file_path:
+        return False
+
+    file_name = Path(file_path).name.lower()
+
+    # Check for *_codes.py pattern
+    if file_name.endswith("_codes.py"):
+        return True
+
+    # Check for constants.py or *_constants.py
+    if file_name == "constants.py" or file_name.endswith("_constants.py"):
+        return True
+
+    return False
+
+
+def _has_definition_content_patterns(content: str) -> bool:
+    """Check if content has definition file patterns.
+
+    Patterns:
+    - 10+ UPPERCASE constant assignments
+    - Dict with 5+ integer keys
+
+    Args:
+        content: File content
+
+    Returns:
+        True if content matches definition patterns
+    """
+    try:
+        tree = ast.parse(content)
+    except SyntaxError:
+        return False
+
+    # Check for many UPPERCASE constants
+    if _count_uppercase_constants(tree) >= MIN_UPPERCASE_CONSTANTS:
+        return True
+
+    # Check for dicts with many int keys
+    if _has_dict_with_int_keys(tree):
+        return True
+
+    return False
+
+
+def _count_uppercase_constants(tree: ast.Module) -> int:
+    """Count UPPERCASE constant assignments at module level.
+
+    Args:
+        tree: Parsed AST module
+
+    Returns:
+        Number of UPPERCASE constant assignments
+    """
+    count = 0
+    for node in tree.body:
+        if isinstance(node, ast.Assign):
+            count += _count_numeric_constant_targets(node)
+    return count
+
+
+def _count_numeric_constant_targets(assign_node: ast.Assign) -> int:
+    """Count UPPERCASE constant targets with numeric values in an assignment.
+
+    Args:
+        assign_node: AST Assign node
+
+    Returns:
+        Number of uppercase constant targets with numeric values
+    """
+    if not _is_numeric_constant(assign_node.value):
+        return 0
+    return sum(1 for t in assign_node.targets if _is_uppercase_name_target(t))
+
+
+def _is_numeric_constant(value: ast.expr) -> bool:
+    """Check if value is a numeric constant.
+
+    Args:
+        value: AST expression node
+
+    Returns:
+        True if value is a numeric constant
+    """
+    return isinstance(value, ast.Constant) and isinstance(value.value, (int, float))
+
+
+def _is_uppercase_name_target(target: ast.expr) -> bool:
+    """Check if target is an uppercase name.
+
+    Args:
+        target: AST expression node
+
+    Returns:
+        True if target is an uppercase Name node
+    """
+    return isinstance(target, ast.Name) and _is_constant_name(target.id)
+
+
+def _is_constant_name(name: str) -> bool:
+    """Check if name follows UPPERCASE constant convention.
+
+    Args:
+        name: Variable name
+
+    Returns:
+        True if name is UPPERCASE (with underscores allowed)
+    """
+    # Must be uppercase and contain at least 2 characters
+    if len(name) < 2:
+        return False
+    # Allow underscores but must have uppercase letters
+    return re.match(r"^[A-Z][A-Z0-9_]*$", name) is not None
+
+
+def _has_dict_with_int_keys(tree: ast.Module) -> bool:
+    """Check if module has a dict with many integer keys.
+
+    Args:
+        tree: Parsed AST module
+
+    Returns:
+        True if there's a dict with MIN_DICT_INT_KEYS+ int keys
+    """
+    return any(_has_enough_int_keys(node) for node in ast.walk(tree) if isinstance(node, ast.Dict))
+
+
+def _has_enough_int_keys(dict_node: ast.Dict) -> bool:
+    """Check if dict has enough integer keys to be a definition pattern.
+
+    Args:
+        dict_node: AST Dict node
+
+    Returns:
+        True if dict has MIN_DICT_INT_KEYS or more integer keys
+    """
+    return _count_int_keys(dict_node) >= MIN_DICT_INT_KEYS
+
+
+def _count_int_keys(dict_node: ast.Dict) -> int:
+    """Count integer keys in a dict.
+
+    Args:
+        dict_node: AST Dict node
+
+    Returns:
+        Number of integer constant keys
+    """
+    return sum(1 for key in dict_node.keys if _is_int_key(key))
+
+
+def _is_int_key(key: ast.expr | None) -> bool:
+    """Check if key is an integer constant.
+
+    Args:
+        key: AST expression node (or None for **dict unpacking)
+
+    Returns:
+        True if key is an integer constant
+    """
+    return isinstance(key, ast.Constant) and isinstance(key.value, int)

{thailint-0.15.4 → thailint-0.15.6}/src/linters/magic_numbers/linter.py

@@ -40,6 +40,7 @@ from src.linter_config.ignore import get_ignore_parser
 
 from .config import MagicNumberConfig
 from .context_analyzer import is_acceptable_context
+from .definition_detector import is_definition_file
 from .python_analyzer import PythonMagicNumberAnalyzer
 from .typescript_analyzer import TypeScriptMagicNumberAnalyzer
 from .typescript_ignore_checker import TypeScriptIgnoreChecker
@@ -174,6 +175,12 @@ class MagicNumberRule(MultiLanguageLintRule):  # thailint: ignore[srp]
         if self._is_file_ignored(context, config):
             return []
 
+        # Check if file is a definition file (status_codes.py, constants.py, etc.)
+        if config.exempt_definition_files and is_definition_file(
+            context.file_path, context.file_content
+        ):
+            return []
+
         tree = self._parse_python_code(context.file_content)
         if tree is None:
             return []

thailint-0.15.6/src/linters/nesting/python_analyzer.py

@@ -0,0 +1,156 @@
+"""
+Purpose: Python AST-based nesting depth calculator
+
+Scope: Python code nesting depth analysis using ast module
+
+Overview: Analyzes Python code to calculate maximum nesting depth using AST traversal. Implements
+    visitor pattern to walk AST, tracking current depth and maximum depth found. Increments depth
+    for If, For, While, With, AsyncWith, Try, ExceptHandler, Match, and match_case nodes. Correctly
+    handles elif chains by detecting when an If node is in elif position (sole child in parent's
+    orelse list) and not incrementing depth. Starts depth counting at 1 for function body, matching
+    reference implementation behavior. Returns maximum depth found and location information for
+    violation reporting. Provides helper method to find all function definitions in an AST tree
+    for batch processing.
+
+Dependencies: ast module for Python parsing
+
+Exports: PythonNestingAnalyzer class with calculate_max_depth method
+
+Interfaces: calculate_max_depth(func_node: ast.FunctionDef) -> tuple[int, int], find_all_functions
+
+Implementation: AST visitor pattern with depth tracking, elif detection via parent orelse inspection
+"""
+
+import ast
+
+# Control structure types that increase nesting depth
+_CONTROL_STRUCTURES = (
+    ast.For,
+    ast.While,
+    ast.With,
+    ast.AsyncWith,
+    ast.Try,
+    ast.Match,
+    ast.match_case,
+)
+
+
+class _DepthTracker:
+    """Tracks maximum nesting depth during AST traversal."""
+
+    def __init__(self, default_line: int) -> None:
+        """Initialize tracker with default line number."""
+        self.max_depth = 0
+        self.max_depth_line = default_line
+
+    def record(self, node: ast.AST, depth: int, default_line: int) -> None:
+        """Record depth if it's the new maximum."""
+        if depth > self.max_depth:
+            self.max_depth = depth
+            self.max_depth_line = getattr(node, "lineno", default_line)
+
+
+class PythonNestingAnalyzer:
+    """Calculates maximum nesting depth in Python functions."""
+
+    def __init__(self) -> None:
+        """Initialize the Python nesting analyzer."""
+        pass  # Stateless analyzer for nesting depth calculation
+
+    def calculate_max_depth(
+        self, func_node: ast.FunctionDef | ast.AsyncFunctionDef
+    ) -> tuple[int, int]:
+        """Calculate maximum nesting depth in a function.
+
+        Args:
+            func_node: AST node for function definition
+
+        Returns:
+            Tuple of (max_depth, line_number_of_max_depth)
+        """
+        tracker = _DepthTracker(func_node.lineno)
+
+        for stmt in func_node.body:
+            _visit_node(stmt, 0, tracker, func_node.lineno)
+
+        return tracker.max_depth, tracker.max_depth_line
+
+    def find_all_functions(self, tree: ast.AST) -> list[ast.FunctionDef | ast.AsyncFunctionDef]:
+        """Find all function definitions in AST.
+
+        Args:
+            tree: Python AST to search
+
+        Returns:
+            List of all FunctionDef and AsyncFunctionDef nodes found
+        """
+        functions = []
+        for node in ast.walk(tree):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                functions.append(node)
+        return functions
+
+
+def _visit_node(
+    node: ast.AST,
+    current_depth: int,
+    tracker: _DepthTracker,
+    default_line: int,
+    is_elif: bool = False,
+) -> None:
+    """Visit AST node, tracking nesting depth for control structures only."""
+    if isinstance(node, ast.If):
+        _visit_if_node(node, current_depth, tracker, default_line, is_elif)
+    elif isinstance(node, _CONTROL_STRUCTURES):
+        _visit_control_structure(node, current_depth, tracker, default_line)
+    else:
+        _visit_children(node, current_depth, tracker, default_line)
+
+
+def _visit_if_node(
+    node: ast.If, current_depth: int, tracker: _DepthTracker, default_line: int, is_elif: bool
+) -> None:
+    """Visit If node with special elif handling."""
+    if not is_elif:
+        current_depth += 1
+        tracker.record(node, current_depth, default_line)
+
+    # Visit body
+    for child in node.body:
+        _visit_node(child, current_depth, tracker, default_line)
+
+    # Handle orelse - check for elif chain
+    if _is_elif_chain(node.orelse):
+        _visit_node(node.orelse[0], current_depth, tracker, default_line, is_elif=True)
+    else:
+        for child in node.orelse:
+            _visit_node(child, current_depth, tracker, default_line)
+
+
+def _visit_control_structure(
+    node: ast.AST, current_depth: int, tracker: _DepthTracker, default_line: int
+) -> None:
+    """Visit a control structure node that increases depth."""
+    current_depth += 1
+    tracker.record(node, current_depth, default_line)
+    _visit_children(node, current_depth, tracker, default_line)
+
+
+def _visit_children(
+    node: ast.AST, current_depth: int, tracker: _DepthTracker, default_line: int
+) -> None:
+    """Visit all children of a node without incrementing depth."""
+    for child in ast.iter_child_nodes(node):
+        _visit_node(child, current_depth, tracker, default_line)
+
+
+def _is_elif_chain(orelse: list[ast.stmt]) -> bool:
+    """Check if orelse list represents an elif (single If node).
+
+    Args:
+        orelse: The orelse list from an If node
+
+    Returns:
+        True if this is an elif (single If in orelse), False otherwise
+    """
+    return len(orelse) == 1 and isinstance(orelse[0], ast.If)

{thailint-0.15.4 → thailint-0.15.6}/src/linters/stateless_class/config.py

@@ -30,6 +30,8 @@ class StatelessClassConfig:
     enabled: bool = True
     min_methods: int = 2
     ignore: list[str] = field(default_factory=list)
+    exempt_test_classes: bool = True
+    exempt_mixins: bool = True
 
     @classmethod
     def from_dict(
@@ -55,4 +57,6 @@ class StatelessClassConfig:
             enabled=config.get("enabled", True),
             min_methods=config.get("min_methods", 2),
             ignore=ignore_patterns,
+            exempt_test_classes=config.get("exempt_test_classes", True),
+            exempt_mixins=config.get("exempt_mixins", True),
         )