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

invar/core/contracts.py

@@ -76,7 +76,7 @@ def is_redundant_type_contract(expression: str, annotations: dict[str, str]) ->
         return False
 
 
-@pre(lambda node: isinstance(node, ast.expr) and hasattr(node, '__class__'))
+@pre(lambda node: isinstance(node, ast.expr) and hasattr(node, "__class__"))
 @post(lambda result: result is None or isinstance(result, list))
 def _extract_isinstance_checks(node: ast.expr) -> list[tuple[str, str]] | None:
     """Extract isinstance checks. Returns None if other logic present.
@@ -84,17 +84,21 @@ def _extract_isinstance_checks(node: ast.expr) -> list[tuple[str, str]] | None:
     Conservative: returns None for complex expressions (nested BoolOp, etc.)
     to avoid false positives when detecting redundant type contracts.
     """
-    if isinstance(node, ast.Call) and hasattr(node, 'func'):
+    if isinstance(node, ast.Call) and hasattr(node, "func"):
         check = _parse_isinstance_call(node)
         return [check] if check else None
-    if isinstance(node, ast.BoolOp) and hasattr(node, 'op') and isinstance(node.op, ast.And):
-        valid_calls = [v for v in node.values if isinstance(v, ast.Call) and hasattr(v, 'func') and hasattr(v, 'args')]
+    if isinstance(node, ast.BoolOp) and hasattr(node, "op") and isinstance(node.op, ast.And):
+        valid_calls = [
+            v
+            for v in node.values
+            if isinstance(v, ast.Call) and hasattr(v, "func") and hasattr(v, "args")
+        ]
         checks = [_parse_isinstance_call(v) for v in valid_calls]
         return checks if len(checks) == len(node.values) and all(checks) else None
     return None
 
 
-@pre(lambda node: isinstance(node, ast.Call) and hasattr(node, 'func') and hasattr(node, 'args'))
+@pre(lambda node: isinstance(node, ast.Call) and hasattr(node, "func") and hasattr(node, "args"))
 @post(lambda result: result is None or (isinstance(result, tuple) and len(result) == 2))
 def _parse_isinstance_call(node: ast.Call) -> tuple[str, str] | None:
     """Parse isinstance(x, Type) call. Returns (param, type) or None."""
@@ -353,6 +357,9 @@ def check_partial_contract(file_info: FileInfo, config: RuleConfig) -> list[Viol
     - param_mismatch: lambda param COUNT != function param count (ERROR)
     - partial_contract: lambda has all params but doesn't USE all (WARN)
 
+    Note: For methods, 'self' and 'cls' are automatically excluded from unused params check,
+    since these are instance/class references that rarely need @pre constraints.
+
     Examples:
         >>> from invar.core.models import FileInfo, Symbol, SymbolKind, Contract, RuleConfig
         >>> c = Contract(kind="pre", expression="lambda x, y: x > 0", line=1)
@@ -364,6 +371,23 @@ def check_partial_contract(file_info: FileInfo, config: RuleConfig) -> list[Viol
         <Severity.WARNING: 'warning'>
         >>> "y" in vs[0].message
         True
+
+        Method's self is excluded from unused check:
+        >>> c2 = Contract(kind="pre", expression="lambda self, x, y: x > 0", line=1)
+        >>> m = Symbol(name="calc", kind=SymbolKind.METHOD, line=1, end_line=5, signature="(self, x: int, y: int) -> int", contracts=[c2])
+        >>> vs2 = check_partial_contract(FileInfo(path="c.py", lines=10, symbols=[m], is_core=True), RuleConfig())
+        >>> len(vs2)
+        1
+        >>> "self" in vs2[0].message  # self should NOT be reported
+        False
+        >>> "y" in vs2[0].message  # y should still be reported
+        True
+
+        When only self is unused, no violation:
+        >>> c3 = Contract(kind="pre", expression="lambda self, x: x > 0", line=1)
+        >>> m2 = Symbol(name="calc", kind=SymbolKind.METHOD, line=1, end_line=5, signature="(self, x: int) -> int", contracts=[c3])
+        >>> check_partial_contract(FileInfo(path="c.py", lines=10, symbols=[m2], is_core=True), RuleConfig())
+        []
     """
     violations: list[Violation] = []
     if not file_info.is_core:
@@ -376,6 +400,10 @@ def check_partial_contract(file_info: FileInfo, config: RuleConfig) -> list[Viol
             if contract.kind != "pre":
                 continue
             has_unused, unused, used = has_unused_params(contract.expression, symbol.signature)
+            # For methods, exclude self/cls from unused check (they rarely need @pre constraints)
+            if symbol.kind == SymbolKind.METHOD:
+                unused = [p for p in unused if p not in ("self", "cls")]
+                has_unused = len(unused) > 0
             if has_unused:
                 kind = "Method" if symbol.kind == SymbolKind.METHOD else "Function"
                 unused_str = ", ".join(f"'{p}'" for p in unused)
@@ -429,7 +457,11 @@ def check_skip_without_reason(file_info: FileInfo, config: RuleConfig) -> list[V
 
     for line_num, line in enumerate(source.split("\n"), 1):
         # Check for bare @skip_property_test, empty parens, or empty string reason
-        if bare_pattern.match(line) or no_reason_pattern.match(line) or empty_string_pattern.match(line):
+        if (
+            bare_pattern.match(line)
+            or no_reason_pattern.match(line)
+            or empty_string_pattern.match(line)
+        ):
             violations.append(
                 Violation(
                     rule="skip_without_reason",

invar/core/doc_edit.py

@@ -15,9 +15,14 @@ if TYPE_CHECKING:
     from invar.core.doc_parser import Section
 
 
-@pre(lambda source, section, new_content, keep_heading=True: section.line_start >= 1)
-@pre(lambda source, section, new_content, keep_heading=True: section.line_end >= section.line_start)
-@pre(lambda source, section, new_content, keep_heading=True: section.line_end <= len(source.split("\n")))
+@pre(
+    lambda source, section, new_content, keep_heading=True: len(source) > 0
+    and isinstance(new_content, str)
+    and isinstance(keep_heading, bool)
+    and section.line_start >= 1
+    and section.line_end >= section.line_start
+    and section.line_end <= len(source.split("\n"))
+)
 def replace_section(
     source: str,
     section: Section,
@@ -73,9 +78,13 @@ def replace_section(
     return "\n".join(result_lines)
 
 
-@pre(lambda source, anchor, content, position="after": anchor.line_start >= 1)
-@pre(lambda source, anchor, content, position="after": anchor.line_end <= len(source.split("\n")))
-@pre(lambda source, anchor, content, position="after": position in ("before", "after", "first_child", "last_child"))
+@pre(
+    lambda source, anchor, content, position="after": len(source) > 0
+    and isinstance(content, str)
+    and anchor.line_start >= 1
+    and anchor.line_end <= len(source.split("\n"))
+    and position in ("before", "after", "first_child", "last_child")
+)
 def insert_section(
     source: str,
     anchor: Section,
@@ -132,9 +141,13 @@ def insert_section(
     return "\n".join(result_lines)
 
 
-@pre(lambda source, section, include_children=True: section.line_start >= 1)
-@pre(lambda source, section, include_children=True: section.line_end >= section.line_start)
-@pre(lambda source, section, include_children=True: section.line_end <= len(source.split("\n")))
+@pre(
+    lambda source, section, include_children=True: len(source) > 0
+    and isinstance(include_children, bool)
+    and section.line_start >= 1
+    and section.line_end >= section.line_start
+    and section.line_end <= len(source.split("\n"))
+)
 def delete_section(source: str, section: Section, include_children: bool = True) -> str:
     """Delete a section from the document.
 

invar/core/doc_parser.py

@@ -101,9 +101,11 @@ def _slugify(title: str) -> str:
     return slug
 
 
-@skip_property_test("crosshair_incompatible: Unicode character validation conflicts with symbolic execution")  # type: ignore[untyped-decorator]
+@skip_property_test(
+    "crosshair_incompatible: Unicode character validation conflicts with symbolic execution"
+)  # type: ignore[untyped-decorator]
 @pre(lambda text: len(text) <= 1000)
-@post(lambda result: result == '' or all(c.isalnum() or c == '_' or ord(c) > 127 for c in result))
+@post(lambda result: result == "" or all(c.isalnum() or c == "_" or ord(c) > 127 for c in result))
 def _normalize_for_fuzzy(text: str) -> str:
     """
     Normalize text for Unicode-aware fuzzy matching.
@@ -128,9 +130,9 @@ def _normalize_for_fuzzy(text: str) -> str:
         'apiv20'
     """
     # Convert ASCII to lowercase, keep Unicode as-is
-    ascii_lower = ''.join(c.lower() if c.isascii() else c for c in text)
+    ascii_lower = "".join(c.lower() if c.isascii() else c for c in text)
     # Remove non-word-chars, but keep Unicode letters/digits (via re.UNICODE)
-    return re.sub(r'[^\w]', '', ascii_lower, flags=re.UNICODE)
+    return re.sub(r"[^\w]", "", ascii_lower, flags=re.UNICODE)
 
 
 @pre(lambda sections: all(1 <= s.level <= 6 for s in sections))  # Valid heading levels
@@ -313,7 +315,7 @@ def parse_toc(source: str) -> DocumentToc:
     return DocumentToc(sections=root_sections, frontmatter=frontmatter)
 
 
-@pre(lambda sections, target_line: target_line >= 1)
+@pre(lambda sections, target_line: isinstance(sections, list) and target_line >= 1)
 @post(lambda result: result is None or isinstance(result, Section))
 def _find_by_line(sections: list[Section], target_line: int) -> Section | None:
     """Find section by line number.
@@ -337,7 +339,7 @@ def _find_by_line(sections: list[Section], target_line: int) -> Section | None:
     return None
 
 
-@pre(lambda sections, path: len(path) > 0 and path.startswith("#"))
+@pre(lambda sections, path: isinstance(sections, list) and len(path) > 0 and path.startswith("#"))
 @post(lambda result: result is None or isinstance(result, Section))
 def _find_by_index(sections: list[Section], path: str) -> Section | None:
     """Find section by index path (#0/#1/#2).
@@ -378,7 +380,7 @@ def _find_by_index(sections: list[Section], path: str) -> Section | None:
 
 
 @skip_property_test("crosshair_incompatible: Calls _normalize_for_fuzzy with Unicode validation")  # type: ignore[untyped-decorator]
-@pre(lambda sections, path: len(path) > 0)
+@pre(lambda sections, path: isinstance(sections, list) and len(path) > 0)
 @post(lambda result: result is None or isinstance(result, Section))
 def _find_by_slug_or_fuzzy(sections: list[Section], path: str) -> Section | None:
     """Find section by slug path or fuzzy match.
@@ -433,7 +435,7 @@ def _find_by_slug_or_fuzzy(sections: list[Section], path: str) -> Section | None
 
 
 @skip_property_test("crosshair_incompatible: Calls _find_by_slug_or_fuzzy with Unicode validation")  # type: ignore[untyped-decorator]
-@pre(lambda sections, path: len(path) > 0)
+@pre(lambda sections, path: isinstance(sections, list) and len(path) > 0)
 @post(lambda result: result is None or isinstance(result, Section))
 def find_section(sections: list[Section], path: str) -> Section | None:
     """Find section by path (slug, fuzzy, index, or line anchor).
@@ -515,9 +517,13 @@ def _get_last_line(section: Section) -> int:
     return _get_last_line(last_child)
 
 
-@pre(lambda source, section, include_children=True: section.line_start >= 1)
-@pre(lambda source, section, include_children=True: section.line_end >= section.line_start)
-@pre(lambda source, section, include_children=True: section.line_end <= len(source.split("\n")))  # Bounds check
+@pre(
+    lambda source, section, include_children=True: len(source) > 0
+    and isinstance(include_children, bool)
+    and section.line_start >= 1
+    and section.line_end >= section.line_start
+    and section.line_end <= len(source.split("\n"))
+)
 def extract_content(source: str, section: Section, include_children: bool = True) -> str:
     """Extract section content from source.
 

invar/core/entry_points.py

@@ -22,46 +22,48 @@ if TYPE_CHECKING:
 
 # Decorator patterns that indicate framework entry points
 # These functions interface with external frameworks and cannot return Result
-ENTRY_POINT_DECORATORS: frozenset[str] = frozenset([
-    # Web frameworks - Flask
-    "app.route",
-    "app.get",
-    "app.post",
-    "app.put",
-    "app.delete",
-    "app.patch",
-    "blueprint.route",
-    "bp.route",
-    # Web frameworks - FastAPI
-    "router.get",
-    "router.post",
-    "router.put",
-    "router.delete",
-    "router.patch",
-    "api_router.get",
-    "api_router.post",
-    "api_router.put",
-    "api_router.delete",
-    # CLI frameworks - Typer
-    "app.command",
-    "app.callback",
-    "typer.command",
-    # CLI frameworks - Click
-    "click.command",
-    "click.group",
-    "cli.command",
-    # Testing - pytest
-    "pytest.fixture",
-    "fixture",
-    # Event handlers
-    "on_event",
-    "app.on_event",
-    "middleware",
-    "app.middleware",
-    # Django
-    "admin.register",
-    "receiver",
-])
+ENTRY_POINT_DECORATORS: frozenset[str] = frozenset(
+    [
+        # Web frameworks - Flask
+        "app.route",
+        "app.get",
+        "app.post",
+        "app.put",
+        "app.delete",
+        "app.patch",
+        "blueprint.route",
+        "bp.route",
+        # Web frameworks - FastAPI
+        "router.get",
+        "router.post",
+        "router.put",
+        "router.delete",
+        "router.patch",
+        "api_router.get",
+        "api_router.post",
+        "api_router.put",
+        "api_router.delete",
+        # CLI frameworks - Typer
+        "app.command",
+        "app.callback",
+        "typer.command",
+        # CLI frameworks - Click
+        "click.command",
+        "click.group",
+        "cli.command",
+        # Testing - pytest
+        "pytest.fixture",
+        "fixture",
+        # Event handlers
+        "on_event",
+        "app.on_event",
+        "middleware",
+        "app.middleware",
+        # Django
+        "admin.register",
+        "receiver",
+    ]
+)
 
 # Explicit marker comment for edge cases
 ENTRY_MARKER_PATTERN = re.compile(r"#\s*@shell:entry\b")
@@ -188,7 +190,6 @@ def is_entry_point(symbol: Symbol, source: str) -> bool:
     return _has_entry_marker(symbol, source)
 
 
-
 @post(lambda result: isinstance(result, str))
 def _decorator_to_string(decorator: ast.AST) -> str:
     """
@@ -216,6 +217,7 @@ def _decorator_to_string(decorator: ast.AST) -> str:
         return _decorator_to_string(decorator.func)
     return ""
 
+
 @pre(lambda symbol, source: symbol is not None and isinstance(source, str))
 @post(lambda result: isinstance(result, bool))
 def _has_entry_decorator(symbol: Symbol, source: str) -> bool:
@@ -320,7 +322,11 @@ def get_symbol_lines(symbol: Symbol) -> int:
     return max(1, symbol.end_line - symbol.line + 1)
 
 
-@pre(lambda symbol, source, rule: symbol is not None and isinstance(rule, str))
+@pre(
+    lambda symbol, source, rule: symbol is not None
+    and isinstance(source, str)
+    and isinstance(rule, str)
+)
 @post(lambda result: isinstance(result, bool))
 def has_allow_marker(symbol: Symbol, source: str, rule: str) -> bool:
     """

invar/core/extraction.py

@@ -32,9 +32,16 @@ def _build_call_graph(funcs: dict[str, Symbol]) -> dict[str, set[str]]:
     return graph
 
 
-@pre(lambda start, graph, visited: start and start in graph)  # Start must exist in graph
+@pre(
+    lambda start, graph, visited: start
+    and start in graph
+    and isinstance(graph, dict)
+    and isinstance(visited, set)
+)  # Start must exist in graph
 @post(lambda result: len(result) >= 1 or not result)  # At least 1 if found, else empty
-def _find_connected_component(start: str, graph: dict[str, set[str]], visited: set[str]) -> list[str]:
+def _find_connected_component(
+    start: str, graph: dict[str, set[str]], visited: set[str]
+) -> list[str]:
     """BFS to find all functions connected to start.
 
     >>> g = {"a": {"b"}, "b": {"a"}, "c": set()}
@@ -97,17 +104,24 @@ def find_extractable_groups(file_info: FileInfo) -> list[dict]:
         total_lines = sum(funcs[n].end_line - funcs[n].line + 1 for n in component)
         deps = _get_group_dependencies(component, funcs, file_info.imports)
 
-        groups.append({
-            "functions": sorted(component),
-            "lines": total_lines,
-            "dependencies": sorted(deps),
-        })
+        groups.append(
+            {
+                "functions": sorted(component),
+                "lines": total_lines,
+                "dependencies": sorted(deps),
+            }
+        )
 
     groups.sort(key=lambda g: -g["lines"])
     return groups
 
 
-@pre(lambda func_names, funcs, file_imports: all(n in funcs for n in func_names if n))
+@pre(
+    lambda func_names, funcs, file_imports: isinstance(func_names, list)
+    and isinstance(funcs, dict)
+    and isinstance(file_imports, list)
+    and all(n in funcs for n in func_names if n)
+)
 @post(lambda result: isinstance(result, set))
 def _get_group_dependencies(
     func_names: list[str],
@@ -135,7 +149,9 @@ def _get_group_dependencies(
     return deps.intersection(set(file_imports)) if file_imports else deps
 
 
-@pre(lambda file_info, max_groups=3: max_groups >= 1)  # At least 1 group
+@pre(
+    lambda file_info, max_groups=3: isinstance(file_info, FileInfo) and max_groups >= 1
+)  # At least 1 group
 def format_extraction_hint(file_info: FileInfo, max_groups: int = 3) -> str:
     """
     Format extraction suggestions for file_size_warning.

invar/core/format_specs.py

@@ -111,7 +111,10 @@ class CrossHairOutputSpec(FormatSpec):
         """
         return f"{filename}:{line}: error: {error_type} when calling {function}({args})"
 
-    @pre(lambda self, count, include_success, include_errors: count >= 0 and (not include_errors or (len(self.error_types) > 0 and bool(self.error_marker))))
+    @pre(
+        lambda self, count, include_success, include_errors: count >= 0
+        and (not include_errors or (len(self.error_types) > 0 and bool(self.error_marker)))
+    )
     @post(lambda result: isinstance(result, list))
     def generate_output(
         self,
@@ -174,7 +177,9 @@ CROSSHAIR_SPEC = CrossHairOutputSpec()
 PYTEST_SPEC = PytestOutputSpec()
 
 
-@post(lambda result: all(isinstance(line, str) and line.strip() for line in result))  # Non-empty strings
+@post(
+    lambda result: all(isinstance(line, str) and line.strip() for line in result)
+)  # Non-empty strings
 def extract_by_format(text: str, spec: CrossHairOutputSpec) -> list[str]:
     """
     Extract lines matching a format specification.

invar/core/format_strategies.py

@@ -112,7 +112,11 @@ def crosshair_output(
     )
 
 
-@pre(lambda pattern, min_occurrences, max_occurrences: len(pattern) > 0 and min_occurrences >= 0)
+@pre(
+    lambda pattern, min_occurrences, max_occurrences: len(pattern) > 0
+    and min_occurrences >= 0
+    and max_occurrences >= min_occurrences
+)
 @post(lambda result: result is not None)
 def text_with_pattern(
     pattern: str,
@@ -154,9 +158,7 @@ def text_with_pattern(
     )
 
     # Combine into full output
-    pattern_lines = st.lists(
-        pattern_line, min_size=min_occurrences, max_size=max_occurrences
-    )
+    pattern_lines = st.lists(pattern_line, min_size=min_occurrences, max_size=max_occurrences)
     noise_lines = st.lists(noise_line, min_size=0, max_size=10)
 
     # Note: Hypothesis will automatically explore different orderings of the lines,

invar/core/formatter.py

@@ -15,7 +15,7 @@ from invar.core.models import GuardReport, PerceptionMap, Symbol, SymbolRefs, Vi
 from invar.core.rule_meta import get_rule_meta
 
 
-@pre(lambda perception_map, top_n=0: top_n >= 0)
+@pre(lambda perception_map, top_n=0: isinstance(perception_map, PerceptionMap) and top_n >= 0)
 def format_map_text(perception_map: PerceptionMap, top_n: int = 0) -> str:
     """
     Format perception map as plain text.
@@ -137,7 +137,7 @@ def _symbol_refs_to_dict(sr: SymbolRefs) -> dict:
     }
 
 
-@pre(lambda symbol, file_path: len(file_path) > 0)
+@pre(lambda symbol, file_path: isinstance(symbol, Symbol) and len(file_path) > 0)
 def format_signature(symbol: Symbol, file_path: str) -> str:
     """
     Format a single symbol signature.
@@ -153,7 +153,7 @@ def format_signature(symbol: Symbol, file_path: str) -> str:
     return f"{file_path}::{symbol.name}{sig}"
 
 
-@pre(lambda symbols, file_path: len(file_path) > 0)
+@pre(lambda symbols, file_path: isinstance(symbols, list) and len(file_path) > 0)
 def format_signatures_text(symbols: list[Symbol], file_path: str) -> str:
     """
     Format multiple signatures as text.
@@ -168,7 +168,7 @@ def format_signatures_text(symbols: list[Symbol], file_path: str) -> str:
     return "\n".join(lines)
 
 
-@pre(lambda symbols, file_path: len(file_path) > 0)
+@pre(lambda symbols, file_path: isinstance(symbols, list) and len(file_path) > 0)
 def format_signatures_json(symbols: list[Symbol], file_path: str) -> dict:
     """
     Format signatures as JSON-serializable dict.
@@ -199,7 +199,10 @@ def format_signatures_json(symbols: list[Symbol], file_path: str) -> dict:
 # Phase 8.2: Agent-mode formatting
 
 
-@pre(lambda report, combined_status=None: combined_status is None or combined_status in ("passed", "failed"))
+@pre(
+    lambda report, combined_status=None: isinstance(report, GuardReport)
+    and (combined_status is None or combined_status in ("passed", "failed"))
+)
 def format_guard_agent(report: GuardReport, combined_status: str | None = None) -> dict:
     """
     Format Guard report for Agent consumption (Phase 8.2 + DX-26).
@@ -301,7 +304,7 @@ def _violation_to_fix(v: Violation) -> dict:
     return result
 
 
-@pre(lambda suggestion, rule: suggestion is None or isinstance(suggestion, str))
+@pre(lambda suggestion, rule: (suggestion is None or isinstance(suggestion, str)) and len(rule) > 0)
 def _parse_suggestion(suggestion: str | None, rule: str) -> dict | None:
     """Parse suggestion string into structured fix instruction."""
     if not suggestion:

invar/core/hypothesis_strategies.py

@@ -4,6 +4,7 @@ Hypothesis strategy generation from type annotations and @pre contracts.
 Core module: converts Python types and @pre bounds to Hypothesis strategies.
 Part of DX-12: Hypothesis as CrossHair fallback.
 """
+# @invar:allow file_size: Strategy gen inherently complex, extraction increases coupling
 
 from __future__ import annotations
 
@@ -136,7 +137,9 @@ def _strategy_for_dict(args: tuple, strategy_fn: Callable) -> StrategySpec:
 def _strategy_for_set(args: tuple, strategy_fn: Callable) -> StrategySpec:
     """Generate strategy for set type."""
     element_type = args[0] if args else int
-    return StrategySpec("frozensets", {"elements": strategy_fn(element_type).to_code()}, f"Sets of {element_type}")
+    return StrategySpec(
+        "frozensets", {"elements": strategy_fn(element_type).to_code()}, f"Sets of {element_type}"
+    )
 
 
 @post(lambda result: result is None or isinstance(result, StrategySpec))
@@ -149,7 +152,11 @@ def _strategy_for_numpy(hint: type) -> StrategySpec | None:
     if hint is np.ndarray or (hasattr(hint, "__name__") and "ndarray" in str(hint)):
         return StrategySpec(
             "arrays",
-            {"dtype": "np.float64", "shape": "st.integers(1, 100)", "elements": "st.floats(-1e6, 1e6, allow_nan=False)"},
+            {
+                "dtype": "np.float64",
+                "shape": "st.integers(1, 100)",
+                "elements": "st.floats(-1e6, 1e6, allow_nan=False)",
+            },
             "NumPy float64 array",
         )
     return None
@@ -182,7 +189,9 @@ def strategy_from_type(hint: type) -> StrategySpec:
     if hint is list:
         return StrategySpec("lists", {"elements": "st.integers()"}, "Lists of int")
     if hint is dict:
-        return StrategySpec("dictionaries", {"keys": "st.text()", "values": "st.integers()"}, "Dict")
+        return StrategySpec(
+            "dictionaries", {"keys": "st.text()", "values": "st.integers()"}, "Dict"
+        )
     if hint is tuple:
         return StrategySpec("tuples", {}, "Tuple")
     if hint is set:
@@ -310,7 +319,12 @@ def infer_strategies_for_function(func: Callable) -> dict[str, StrategySpec]:
     return result
 
 
-@pre(lambda func, type_specs, user_strategies, pre_sources: callable(func))
+@pre(
+    lambda func, type_specs, user_strategies, pre_sources: callable(func)
+    and isinstance(type_specs, dict)
+    and isinstance(user_strategies, dict)
+    and isinstance(pre_sources, list)
+)
 @post(lambda result: isinstance(result, dict))
 def _refine_all_strategies(
     func: Callable,
@@ -467,7 +481,12 @@ def _extract_pre_sources(func: Callable) -> list[str]:
     return pre_sources
 
 
-@post(lambda result: all(k in ("min_value", "max_value", "min_size", "max_size", "exclude_min", "exclude_max") for k in result))
+@post(
+    lambda result: all(
+        k in ("min_value", "max_value", "min_size", "max_size", "exclude_min", "exclude_max")
+        for k in result
+    )
+)
 def _bounds_to_strategy_kwargs(bounds: dict[str, Any], strategy_name: str) -> dict[str, Any]:
     """Convert bound constraints to Hypothesis strategy kwargs."""
     kwargs = {}

invar/core/lambda_helpers.py

@@ -8,7 +8,7 @@ import re
 from deal import post, pre
 
 
-@pre(lambda tree: isinstance(tree, ast.AST) and hasattr(tree, '__class__'))
+@pre(lambda tree: isinstance(tree, ast.AST) and hasattr(tree, "__class__"))
 @post(lambda result: result is None or isinstance(result, ast.Lambda))
 def find_lambda(tree: ast.Expression) -> ast.Lambda | None:
     """Find the lambda node in an expression tree.
@@ -114,7 +114,7 @@ def extract_func_param_names(signature: str) -> list[str] | None:
     return params
 
 
-@pre(lambda node: isinstance(node, ast.expr) and hasattr(node, '__class__'))
+@pre(lambda node: isinstance(node, ast.expr) and hasattr(node, "__class__"))
 @post(lambda result: isinstance(result, set))
 def extract_used_names(node: ast.expr) -> set[str]:
     """Extract all variable names used in an expression (Load context).