invar-tools 1.17.26__py3-none-any.whl → 1.17.27__py3-none-any.whl

invar/core/parser.py

@@ -21,7 +21,11 @@ from invar.core.purity import (
 )
 
 
-@pre(lambda source, path="<string>": isinstance(source, str) and len(source.strip()) > 0)
+@pre(
+    lambda source, path="<string>": isinstance(source, str)
+    and len(source.strip()) > 0
+    and isinstance(path, str)
+)
 def parse_source(source: str, path: str = "<string>") -> FileInfo | None:
     """
     Parse Python source code and extract symbols.
@@ -64,7 +68,7 @@ def parse_source(source: str, path: str = "<string>") -> FileInfo | None:
     )
 
 
-@pre(lambda tree: isinstance(tree, ast.Module) and hasattr(tree, 'body'))
+@pre(lambda tree: isinstance(tree, ast.Module) and hasattr(tree, "body"))
 def _extract_symbols(tree: ast.Module) -> list[Symbol]:
     """
     Extract function, class, and method symbols from AST.
@@ -95,10 +99,14 @@ def _extract_symbols(tree: ast.Module) -> list[Symbol]:
     return symbols
 
 
-@pre(lambda node: (
-    isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef) and
-    hasattr(node, 'name') and hasattr(node, 'args') and hasattr(node, 'lineno')
-))
+@pre(
+    lambda node: (
+        isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef)
+        and hasattr(node, "name")
+        and hasattr(node, "args")
+        and hasattr(node, "lineno")
+    )
+)
 @post(lambda result: result.kind == SymbolKind.FUNCTION)
 def _parse_function(node: ast.FunctionDef | ast.AsyncFunctionDef) -> Symbol:
     """Parse a function definition into a Symbol."""
@@ -129,10 +137,15 @@ def _parse_function(node: ast.FunctionDef | ast.AsyncFunctionDef) -> Symbol:
     )
 
 
-@pre(lambda node, class_name: (
-    isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef) and
-    hasattr(node, 'name') and hasattr(node, 'args') and hasattr(node, 'lineno')
-))
+@pre(
+    lambda node, class_name: (
+        isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef)
+        and hasattr(node, "name")
+        and hasattr(node, "args")
+        and hasattr(node, "lineno")
+        and len(class_name) > 0
+    )
+)
 @post(lambda result: result.kind == SymbolKind.METHOD)
 def _parse_method(node: ast.FunctionDef | ast.AsyncFunctionDef, class_name: str) -> Symbol:
     """
@@ -175,7 +188,11 @@ def _parse_method(node: ast.FunctionDef | ast.AsyncFunctionDef, class_name: str)
     )
 
 
-@pre(lambda node: isinstance(node, ast.ClassDef) and hasattr(node, 'name') and hasattr(node, 'lineno'))
+@pre(
+    lambda node: isinstance(node, ast.ClassDef)
+    and hasattr(node, "name")
+    and hasattr(node, "lineno")
+)
 @post(lambda result: result.kind == SymbolKind.CLASS)
 def _parse_class(node: ast.ClassDef) -> Symbol:
     """Parse a class definition into a Symbol."""
@@ -190,10 +207,11 @@ def _parse_class(node: ast.ClassDef) -> Symbol:
     )
 
 
-@pre(lambda node: (
-    isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef) and
-    hasattr(node, 'decorator_list')
-))
+@pre(
+    lambda node: (
+        isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef) and hasattr(node, "decorator_list")
+    )
+)
 @post(lambda result: all(c.kind in ("pre", "post") for c in result))
 def _extract_contracts(node: ast.FunctionDef | ast.AsyncFunctionDef) -> list[Contract]:
     """Extract @pre and @post contracts from function decorators."""
@@ -233,7 +251,7 @@ def _parse_decorator_as_contract(decorator: ast.expr) -> Contract | None:
     return None
 
 
-@pre(lambda call: isinstance(call, ast.Call) and hasattr(call, 'args'))
+@pre(lambda call: isinstance(call, ast.Call) and hasattr(call, "args"))
 def _get_contract_expression(call: ast.Call) -> str:
     """Extract the expression string from a contract decorator call."""
     if call.args:
@@ -241,10 +259,11 @@ def _get_contract_expression(call: ast.Call) -> str:
     return ""
 
 
-@pre(lambda node: (
-    isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef) and
-    hasattr(node, 'args')
-))
+@pre(
+    lambda node: (
+        isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef) and hasattr(node, "args")
+    )
+)
 @post(lambda result: result.startswith("(") and ")" in result)
 def _build_signature(node: ast.FunctionDef | ast.AsyncFunctionDef) -> str:
     """Build a signature string from function arguments."""
@@ -267,7 +286,7 @@ def _build_signature(node: ast.FunctionDef | ast.AsyncFunctionDef) -> str:
     return sig
 
 
-@pre(lambda tree: isinstance(tree, ast.Module) and hasattr(tree, 'body'))
+@pre(lambda tree: isinstance(tree, ast.Module) and hasattr(tree, "body"))
 @post(lambda result: all(isinstance(s, str) and s for s in result))
 def _extract_imports(tree: ast.Module) -> list[str]:
     """Extract imported module names from AST (top-level only)."""

invar/core/patterns/detector.py

@@ -147,11 +147,9 @@ class BaseDetector:
             result = ast.unparse(annotation)
             return result if result else "<unknown>"
 
-    @pre(lambda self, params, type_name: len(type_name) > 0)
+    @pre(lambda self, params, type_name: isinstance(params, list) and len(type_name) > 0)
     @post(lambda result: result >= 0)
-    def count_type_occurrences(
-        self, params: list[tuple[str, str | None]], type_name: str
-    ) -> int:
+    def count_type_occurrences(self, params: list[tuple[str, str | None]], type_name: str) -> int:
         """
         Count how many parameters have a specific type.
 
@@ -203,12 +201,33 @@ class BaseDetector:
         for case in match_node.cases:
             pattern = case.pattern
             if isinstance(pattern, ast.MatchValue):
-                cases.append(ast.unparse(pattern.value) if hasattr(ast, "unparse") else str(pattern.value))
+                cases.append(
+                    ast.unparse(pattern.value) if hasattr(ast, "unparse") else str(pattern.value)
+                )
             elif isinstance(pattern, ast.MatchAs) and pattern.pattern is None:
                 cases.append("_")  # Wildcard
         return cases
 
-    @pre(lambda self, pattern_id, priority, file_path, line, message, current_code, suggested_pattern, confidence, reference_pattern: line > 0)
+    @pre(
+        lambda self,
+        pattern_id,
+        priority,
+        file_path,
+        line,
+        message,
+        current_code,
+        suggested_pattern,
+        confidence,
+        reference_pattern: pattern_id in PatternID
+        and priority in Priority
+        and confidence in Confidence
+        and line > 0
+        and len(file_path) > 0
+        and len(message) > 0
+        and len(current_code) > 0
+        and len(suggested_pattern) > 0
+        and len(reference_pattern) > 0
+    )
     @post(lambda result: result.reference_file == ".invar/examples/functional.py")
     def make_suggestion(
         self,

invar/core/patterns/p0_exhaustive.py

@@ -106,10 +106,8 @@ class ExhaustiveMatchDetector(BaseDetector):
 
         return suggestions
 
-    @pre(lambda self, node, file_path: len(file_path) > 0)
-    def _check_match(
-        self, node: ast.Match, file_path: str
-    ) -> PatternSuggestion | None:
+    @pre(lambda self, node, file_path: node is not None and len(file_path) > 0)
+    def _check_match(self, node: ast.Match, file_path: str) -> PatternSuggestion | None:
         """
         Check if match statement could benefit from assert_never.
 
@@ -144,7 +142,9 @@ class ExhaustiveMatchDetector(BaseDetector):
             elif isinstance(pattern, ast.MatchValue):
                 if isinstance(pattern.value, ast.Attribute):
                     has_enum_patterns = True
-                    enum_cases.append(ast.unparse(pattern.value) if hasattr(ast, "unparse") else "...")
+                    enum_cases.append(
+                        ast.unparse(pattern.value) if hasattr(ast, "unparse") else "..."
+                    )
 
         # Suggest if: has enum patterns + has wildcard + doesn't use assert_never
         if has_enum_patterns and has_wildcard and not uses_assert_never:

invar/core/patterns/p0_literal.py

@@ -101,7 +101,7 @@ class LiteralDetector(BaseDetector):
 
         return suggestions
 
-    @pre(lambda self, node, file_path: len(file_path) > 0)
+    @pre(lambda self, node, file_path: node is not None and len(file_path) > 0)
     @post(lambda result: all(isinstance(s, PatternSuggestion) for s in result))
     def _check_function(
         self, node: ast.FunctionDef | ast.AsyncFunctionDef, file_path: str
@@ -145,7 +145,11 @@ class LiteralDetector(BaseDetector):
 
         return suggestions
 
-    @post(lambda result: all(len(name) > 0 and len(vals) > 0 and line > 0 for name, vals, line in result))
+    @post(
+        lambda result: all(
+            len(name) > 0 and len(vals) > 0 and line > 0 for name, vals, line in result
+        )
+    )
     def _find_membership_checks(
         self, node: ast.FunctionDef | ast.AsyncFunctionDef
     ) -> list[tuple[str, list[str | int], int]]:
@@ -206,9 +210,7 @@ class LiteralDetector(BaseDetector):
                 self._collect_membership_checks(stmt.orelse, checks)
 
     @post(lambda result: result is None or (len(result[0]) > 0 and len(result[1]) > 0))
-    def _extract_membership_check(
-        self, test: ast.expr
-    ) -> tuple[str, list[str | int]] | None:
+    def _extract_membership_check(self, test: ast.expr) -> tuple[str, list[str | int]] | None:
         """
         Extract variable and values from membership check.
 
@@ -259,9 +261,7 @@ class LiteralDetector(BaseDetector):
         if isinstance(node, (ast.Tuple, ast.List, ast.Set)):
             values = []
             for elt in node.elts:
-                if isinstance(elt, ast.Constant) and isinstance(
-                    elt.value, (str, int)
-                ):
+                if isinstance(elt, ast.Constant) and isinstance(elt.value, (str, int)):
                     values.append(elt.value)
                 else:
                     return None  # Non-literal value

invar/core/patterns/p0_newtype.py

@@ -107,7 +107,7 @@ class NewTypeDetector(BaseDetector):
 
         return suggestions
 
-    @pre(lambda self, node, file_path: len(file_path) > 0)
+    @pre(lambda self, node, file_path: node is not None and len(file_path) > 0)
     def _check_function(
         self, node: ast.FunctionDef | ast.AsyncFunctionDef, file_path: str
     ) -> PatternSuggestion | None:
@@ -153,7 +153,7 @@ class NewTypeDetector(BaseDetector):
 
         return None
 
-    @pre(lambda self, param_names, _node: len(param_names) > 0)
+    @pre(lambda self, param_names, _node: len(param_names) > 0 and _node is not None)
     @post(lambda result: result in Confidence)
     def _calculate_confidence(
         self, param_names: list[str], _node: ast.FunctionDef | ast.AsyncFunctionDef

invar/core/patterns/p0_nonempty.py

@@ -102,7 +102,7 @@ class NonEmptyDetector(BaseDetector):
 
         return suggestions
 
-    @pre(lambda self, node, file_path: len(file_path) > 0)
+    @pre(lambda self, node, file_path: node is not None and len(file_path) > 0)
     def _check_function(
         self, node: ast.FunctionDef | ast.AsyncFunctionDef, file_path: str
     ) -> PatternSuggestion | None:
@@ -173,9 +173,7 @@ class NonEmptyDetector(BaseDetector):
         return checks
 
     @pre(lambda self, stmts, checks: stmts is not None and checks is not None)
-    def _collect_empty_checks(
-        self, stmts: list[ast.stmt], checks: list[tuple[str, int]]
-    ) -> None:
+    def _collect_empty_checks(self, stmts: list[ast.stmt], checks: list[tuple[str, int]]) -> None:
         """
         Recursively collect empty checks, avoiding nested functions.
 
@@ -260,7 +258,7 @@ class NonEmptyDetector(BaseDetector):
         """
         return any(isinstance(stmt, (ast.Raise, ast.Return)) for stmt in body)
 
-    @pre(lambda self, node, var_name: len(var_name) > 0)
+    @pre(lambda self, node, var_name: node is not None and len(var_name) > 0)
     def _get_param_type(
         self, node: ast.FunctionDef | ast.AsyncFunctionDef, var_name: str
     ) -> str | None:
@@ -278,7 +276,11 @@ class NonEmptyDetector(BaseDetector):
                 return self._annotation_to_str(arg.annotation)
         return None
 
-    @pre(lambda self, _node, var_name, param_type: len(var_name) > 0)
+    @pre(
+        lambda self, _node, var_name, param_type=None: _node is not None
+        and len(var_name) > 0
+        and (param_type is None or isinstance(param_type, str))
+    )
     @post(lambda result: result in Confidence)
     def _calculate_confidence(
         self,
@@ -305,7 +307,10 @@ class NonEmptyDetector(BaseDetector):
 
         return Confidence.LOW
 
-    @pre(lambda self, var_name, param_type: len(var_name) > 0)
+    @pre(
+        lambda self, var_name, param_type=None: len(var_name) > 0
+        and (param_type is None or isinstance(param_type, str))
+    )
     @post(lambda result: len(result) > 0 and "if not" in result)
     def _format_check(self, var_name: str, param_type: str | None) -> str:
         """

invar/core/patterns/p0_validation.py

@@ -114,7 +114,7 @@ class ValidationDetector(BaseDetector):
 
         return suggestions
 
-    @pre(lambda self, node, file_path: len(file_path) > 0)
+    @pre(lambda self, node, file_path: node is not None and len(file_path) > 0)
     def _check_function(
         self, node: ast.FunctionDef | ast.AsyncFunctionDef, file_path: str
     ) -> PatternSuggestion | None:
@@ -156,9 +156,7 @@ class ValidationDetector(BaseDetector):
         return None
 
     @post(lambda result: result >= 0)
-    def _count_early_error_returns(
-        self, node: ast.FunctionDef | ast.AsyncFunctionDef
-    ) -> int:
+    def _count_early_error_returns(self, node: ast.FunctionDef | ast.AsyncFunctionDef) -> int:
         """
         Count early returns with error-like values inside if statements.
 
@@ -239,7 +237,7 @@ class ValidationDetector(BaseDetector):
 
         return False
 
-    @pre(lambda self, node, early_returns: early_returns >= 0)
+    @pre(lambda self, node, early_returns: node is not None and early_returns >= 0)
     @post(lambda result: result in Confidence)
     def _calculate_confidence(
         self, node: ast.FunctionDef | ast.AsyncFunctionDef, early_returns: int
@@ -269,9 +267,7 @@ class ValidationDetector(BaseDetector):
         return Confidence.LOW
 
     @post(lambda result: len(result) > 0 and "def " in result)
-    def _format_function_preview(
-        self, node: ast.FunctionDef | ast.AsyncFunctionDef
-    ) -> str:
+    def _format_function_preview(self, node: ast.FunctionDef | ast.AsyncFunctionDef) -> str:
         """
         Format function preview for display.
 

invar/core/patterns/registry.py

@@ -72,7 +72,13 @@ class PatternRegistry:
         """
         return [d for d in self._detectors if d.priority == priority]
 
-    @pre(lambda self, file_path, source, min_confidence=None, priority_filter=None: len(file_path) > 0)
+    @pre(
+        lambda self, file_path, source, min_confidence=None, priority_filter=None: len(file_path)
+        > 0
+        and isinstance(source, str)
+        and (min_confidence is None or min_confidence in Confidence)
+        and (priority_filter is None or priority_filter in Priority)
+    )
     @post(lambda result: result is not None)
     def detect_file(
         self,
@@ -220,7 +226,11 @@ def get_registry() -> PatternRegistry:
     return PatternRegistry()
 
 
-@pre(lambda file_path, source, min_confidence=None: len(file_path) > 0)
+@pre(
+    lambda file_path, source, min_confidence=None: len(file_path) > 0
+    and isinstance(source, str)
+    and (min_confidence is None or min_confidence in Confidence)
+)
 @post(lambda result: result is not None)
 def detect_patterns(
     file_path: str,

invar/core/property_gen.py

@@ -194,10 +194,12 @@ def _check_decorator_contracts(dec: ast.Call) -> tuple[bool, bool]:
     return has_pre, has_post
 
 
-@pre(lambda node: (
-    isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and
-    hasattr(node, 'decorator_list')
-))
+@pre(
+    lambda node: (
+        isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
+        and hasattr(node, "decorator_list")
+    )
+)
 @post(lambda result: isinstance(result, tuple) and len(result) == 2)
 def _get_function_contracts(node: ast.FunctionDef | ast.AsyncFunctionDef) -> tuple[bool, bool]:
     """Check function decorators for contracts, return (has_pre, has_post).
@@ -247,18 +249,22 @@ def find_contracted_functions(source: str) -> list[dict[str, Any]]:
         if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
             has_pre, has_post = _get_function_contracts(node)
             if has_pre or has_post:
-                functions.append({
-                    "name": node.name,
-                    "lineno": node.lineno,
-                    "has_pre": has_pre,
-                    "has_post": has_post,
-                    "params": _extract_params(node),
-                    "return_type": _extract_return_type(node),
-                })
+                functions.append(
+                    {
+                        "name": node.name,
+                        "lineno": node.lineno,
+                        "has_pre": has_pre,
+                        "has_post": has_post,
+                        "params": _extract_params(node),
+                        "return_type": _extract_return_type(node),
+                    }
+                )
     return functions
 
 
-@pre(lambda node: isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and hasattr(node, "args"))
+@pre(
+    lambda node: isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and hasattr(node, "args")
+)
 @post(lambda result: isinstance(result, list))
 def _extract_params(node: ast.FunctionDef | ast.AsyncFunctionDef) -> list[dict[str, str]]:
     """Extract parameter names and type annotations from function node."""
@@ -280,7 +286,11 @@ def _extract_return_type(node: ast.FunctionDef | ast.AsyncFunctionDef) -> str |
     return None
 
 
-@pre(lambda func, strategies, max_examples=100: callable(func) and isinstance(strategies, dict))
+@pre(
+    lambda func, strategies, max_examples=100: callable(func)
+    and isinstance(strategies, dict)
+    and max_examples > 0
+)
 @post(lambda result: result is None or callable(result))
 def build_test_function(
     func: Callable,
@@ -366,25 +376,37 @@ def _skip_result(name: str, reason: str) -> PropertyTestResult:
 
 # Skip patterns for untestable error detection
 _SKIP_PATTERNS = (
-    "Nothing", "NoSuchExample", "filter_too_much", "Could not resolve",
-    "validation error", "missing", "positional argument", "Unable to satisfy",
+    "Nothing",
+    "NoSuchExample",
+    "filter_too_much",
+    "Could not resolve",
+    "validation error",
+    "missing",
+    "positional argument",
+    "Unable to satisfy",
     "has no attribute 'check'",  # invar_runtime contracts, not deal contracts
 )
 
 
-@pre(lambda err_str, func_name, max_examples: len(err_str) > 0 and len(func_name) > 0 and max_examples > 0)
+@pre(
+    lambda err_str, func_name, max_examples: len(err_str) > 0
+    and len(func_name) > 0
+    and max_examples > 0
+)
 @post(lambda result: isinstance(result, PropertyTestResult))
-def _handle_test_exception(
-    err_str: str, func_name: str, max_examples: int
-) -> PropertyTestResult:
+def _handle_test_exception(err_str: str, func_name: str, max_examples: int) -> PropertyTestResult:
     """Handle exception from property test, returning skip or failure result."""
     # Check for invar_runtime contracts (deal.cases requires deal contracts)
     if "has no attribute 'check'" in err_str:
-        return _skip_result(func_name, "Skipped: uses invar_runtime (deal.cases requires deal contracts)")
+        return _skip_result(
+            func_name, "Skipped: uses invar_runtime (deal.cases requires deal contracts)"
+        )
     if any(p in err_str for p in _SKIP_PATTERNS):
         return _skip_result(func_name, "Skipped: untestable types")
     seed = _extract_hypothesis_seed(err_str)
-    return PropertyTestResult(func_name, passed=False, examples_run=max_examples, error=err_str, seed=seed)
+    return PropertyTestResult(
+        func_name, passed=False, examples_run=max_examples, error=err_str, seed=seed
+    )
 
 
 @pre(lambda func, max_examples: callable(func) and max_examples > 0)
@@ -424,7 +446,9 @@ def run_property_test(func: Callable, max_examples: int = 100) -> PropertyTestRe
     except deal.PostContractError as e:
         err_str = str(e)
         seed = _extract_hypothesis_seed(err_str)
-        return PropertyTestResult(func_name, passed=False, examples_run=max_examples, error=err_str, seed=seed)
+        return PropertyTestResult(
+            func_name, passed=False, examples_run=max_examples, error=err_str, seed=seed
+        )
     except ImportError:
         pass  # Fall through to custom strategy approach
     except Exception as e:

invar/core/shell_analysis.py

@@ -22,69 +22,71 @@ if TYPE_CHECKING:
     from invar.core.models import Symbol
 
 # I/O indicators that mark a function as legitimately in Shell
-IO_INDICATORS: frozenset[str] = frozenset([
-    # File operations
-    ".read(",
-    ".write(",
-    ".read_text(",
-    ".write_text(",
-    ".read_bytes(",
-    ".write_bytes(",
-    "open(",
-    "Path(",
-    ".exists()",
-    ".is_file()",
-    ".is_dir()",
-    ".rglob(",
-    ".glob(",
-    ".iterdir(",
-    ".mkdir(",
-    ".unlink(",
-    "shutil.",
-    "tempfile.",
-    # Process operations
-    "subprocess.",
-    "os.system(",
-    "os.popen(",
-    "os.getenv(",
-    "os.environ",
-    # Terminal/System
-    "sys.stdout",
-    "sys.stderr",
-    "sys.stdin",
-    ".isatty()",
-    # Module loading
-    "importlib.",
-    "exec_module(",
-    # Network operations
-    "requests.",
-    "aiohttp.",
-    "httpx.",
-    "urllib.",
-    # Console output
-    "print(",
-    "console.",
-    "Console(",
-    "typer.",
-    "click.",
-    "rich.",
-    # Result wrapping (Shell's primary job)
-    "Success(",
-    "Failure(",
-    "Result[",
-    # Database
-    "cursor.",
-    "connection.",
-    "session.",
-    # Logging
-    "logger.",
-    "logging.",
-    # Serialization (often to files)
-    "json.dump(",
-    "json.load(",
-    "toml.load(",
-    "yaml.load(",
-])
+IO_INDICATORS: frozenset[str] = frozenset(
+    [
+        # File operations
+        ".read(",
+        ".write(",
+        ".read_text(",
+        ".write_text(",
+        ".read_bytes(",
+        ".write_bytes(",
+        "open(",
+        "Path(",
+        ".exists()",
+        ".is_file()",
+        ".is_dir()",
+        ".rglob(",
+        ".glob(",
+        ".iterdir(",
+        ".mkdir(",
+        ".unlink(",
+        "shutil.",
+        "tempfile.",
+        # Process operations
+        "subprocess.",
+        "os.system(",
+        "os.popen(",
+        "os.getenv(",
+        "os.environ",
+        # Terminal/System
+        "sys.stdout",
+        "sys.stderr",
+        "sys.stdin",
+        ".isatty()",
+        # Module loading
+        "importlib.",
+        "exec_module(",
+        # Network operations
+        "requests.",
+        "aiohttp.",
+        "httpx.",
+        "urllib.",
+        # Console output
+        "print(",
+        "console.",
+        "Console(",
+        "typer.",
+        "click.",
+        "rich.",
+        # Result wrapping (Shell's primary job)
+        "Success(",
+        "Failure(",
+        "Result[",
+        # Database
+        "cursor.",
+        "connection.",
+        "session.",
+        # Logging
+        "logger.",
+        "logging.",
+        # Serialization (often to files)
+        "json.dump(",
+        "json.load(",
+        "toml.load(",
+        "yaml.load(",
+    ]
+)
 
 # Marker pattern to exempt functions from complexity check
 COMPLEXITY_MARKER_PATTERN = re.compile(r"#\s*@shell_complexity\s*:")
@@ -111,7 +113,7 @@ def has_io_operations(source: str) -> bool:
     return any(indicator in source for indicator in IO_INDICATORS)
 
 
-@pre(lambda symbol, source: symbol is not None)  # Symbol must exist
+@pre(lambda symbol, source: symbol is not None and isinstance(source, str))  # Symbol must exist
 def has_orchestration_marker(symbol: Symbol, source: str) -> bool:
     """
     Check if symbol has @shell_orchestration marker comment.
@@ -144,7 +146,7 @@ def has_orchestration_marker(symbol: Symbol, source: str) -> bool:
     return bool(ORCHESTRATION_MARKER_PATTERN.search(context))
 
 
-@pre(lambda symbol, source: symbol is not None)  # Symbol must exist
+@pre(lambda symbol, source: symbol is not None and isinstance(source, str))  # Symbol must exist
 def has_complexity_marker(symbol: Symbol, source: str) -> bool:
     """
     Check if symbol has @shell_complexity marker comment.
@@ -221,7 +223,9 @@ def count_branches(source: str) -> int:
     return count
 
 
-@pre(lambda symbol, file_source: symbol is not None)  # Symbol must exist
+@pre(
+    lambda symbol, file_source: symbol is not None and isinstance(file_source, str)
+)  # Symbol must exist
 def get_symbol_source(symbol: Symbol, file_source: str) -> str:
     """
     Extract the source code for a specific symbol.