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

invar/core/strategies.py

@@ -111,7 +111,10 @@ PATTERNS: list[tuple[str, Callable[[re.Match, str], dict[str, Any] | None]]] = [
     ),
     (
         r"(-?[\d.]+(?:e[+-]?\d+)?)\s*<=\s*(\w+)\s*<=\s*(-?[\d.]+(?:e[+-]?\d+)?)",
-        lambda m, p: {"min_value": _parse_number(m.group(1)), "max_value": _parse_number(m.group(3))}
+        lambda m, p: {
+            "min_value": _parse_number(m.group(1)),
+            "max_value": _parse_number(m.group(3)),
+        }
         if m.group(2) == p
         else None,
     ),
@@ -140,7 +143,11 @@ PATTERNS: list[tuple[str, Callable[[re.Match, str], dict[str, Any] | None]]] = [
 ]
 
 
-@pre(lambda pre_source, param_name, param_type=None: len(param_name) > 0)  # Param must be named
+@pre(
+    lambda pre_source, param_name, param_type=None: isinstance(pre_source, str)
+    and len(param_name) > 0
+    and (param_type is None or isinstance(param_type, type))
+)  # Param must be named
 @post(lambda result: isinstance(result.constraints, dict))  # Returns valid hint
 def infer_from_lambda(
     pre_source: str,
@@ -193,7 +200,11 @@ def infer_from_lambda(
     )
 
 
-@pre(lambda pre_sources, param_name, param_type=None: len(param_name) > 0)  # Param must be named
+@pre(
+    lambda pre_sources, param_name, param_type=None: isinstance(pre_sources, list)
+    and len(param_name) > 0
+    and (param_type is None or isinstance(param_type, type))
+)  # Param must be named
 @post(lambda result: isinstance(result.constraints, dict))  # Returns valid hint
 def infer_from_multiple(
     pre_sources: list[str],

invar/core/suggestions.py

@@ -35,7 +35,7 @@ CONSTRAINT_PATTERNS: dict[str, list[str]] = {
 # Return-type-aware @post patterns for redundant_type_contract suggestions
 RETURN_TYPE_POST_PATTERNS: dict[str, str] = {
     "list[Violation]": '@post(lambda result: all(v.rule == "RULE_NAME" for v in result))',
-    "list": '@post(lambda result: all(<predicate> for item in result))',
+    "list": "@post(lambda result: all(<predicate> for item in result))",
     "dict": "@post(lambda result: all(isinstance(k, <type>) for k in result))",
     "set": "@post(lambda result: all(<predicate> for item in result))",
     "int": "@post(lambda result: result >= 0)",
@@ -331,11 +331,18 @@ _VIOLATION_PREFIXES = {
     "missing_contract": ("Add: ", "Add: "),
     "empty_contract": ("Replace with: ", "Replace with: "),
     "redundant_type_contract": ("Replace with business logic: ", "Replace with: "),
-    "semantic_tautology": ("Replace tautology with meaningful constraint: ", "Replace tautology with: "),
+    "semantic_tautology": (
+        "Replace tautology with meaningful constraint: ",
+        "Replace tautology with: ",
+    ),
 }
 
 
-@pre(lambda prefix, suggestion, patterns: bool(prefix) and bool(suggestion))
+@pre(
+    lambda prefix, suggestion, patterns: bool(prefix)
+    and bool(suggestion)
+    and isinstance(patterns, str)
+)
 @post(lambda result: isinstance(result, str) and len(result) > 0)
 def _format_with_patterns(prefix: str, suggestion: str, patterns: str) -> str:
     """Format suggestion with optional patterns.
@@ -350,7 +357,8 @@ def _format_with_patterns(prefix: str, suggestion: str, patterns: str) -> str:
 
 
 @pre(
-    lambda symbol, violation_type: violation_type
+    lambda symbol, violation_type: symbol is not None
+    and violation_type
     in ("missing_contract", "empty_contract", "redundant_type_contract", "semantic_tautology", "")
 )
 def format_suggestion_for_violation(symbol: Symbol, violation_type: str) -> str:

invar/core/tautology.py

@@ -61,7 +61,13 @@ def is_semantic_tautology(expression: str) -> tuple[bool, str]:
 
         # DX-38 Tier 1: Check for no-parameter lambda
         args = lambda_node.args
-        if not args.args and not args.posonlyargs and not args.kwonlyargs and not args.vararg and not args.kwarg:
+        if (
+            not args.args
+            and not args.posonlyargs
+            and not args.kwonlyargs
+            and not args.vararg
+            and not args.kwarg
+        ):
             return (True, "contract has no parameters (doesn't validate function inputs)")
 
         return _check_tautology_patterns(lambda_node.body)
@@ -92,9 +98,14 @@ def _check_comparison_patterns(node: ast.expr) -> tuple[bool, str] | None:
     # Length non-negative pattern
     if len(node.comparators) == 1:
         left, op, right = node.left, node.ops[0], node.comparators[0]
-        if (isinstance(left, ast.Call) and isinstance(left.func, ast.Name) and
-            left.func.id == "len" and isinstance(op, ast.GtE) and
-            isinstance(right, ast.Constant) and right.value == 0):
+        if (
+            isinstance(left, ast.Call)
+            and isinstance(left.func, ast.Name)
+            and left.func.id == "len"
+            and isinstance(op, ast.GtE)
+            and isinstance(right, ast.Constant)
+            and right.value == 0
+        ):
             arg = ast.unparse(left.args[0]) if left.args else "x"
             return (True, f"len({arg}) >= 0 is always True for any sequence")
     return None
@@ -103,8 +114,12 @@ def _check_comparison_patterns(node: ast.expr) -> tuple[bool, str] | None:
 @pre(lambda node: isinstance(node, ast.expr))
 def _check_isinstance_object(node: ast.expr) -> tuple[bool, str] | None:
     """Check for isinstance(x, object) pattern."""
-    if (isinstance(node, ast.Call) and isinstance(node.func, ast.Name) and
-        node.func.id == "isinstance" and len(node.args) == 2):
+    if (
+        isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Name)
+        and node.func.id == "isinstance"
+        and len(node.args) == 2
+    ):
         type_arg = node.args[1]
         if isinstance(type_arg, ast.Name) and type_arg.id == "object":
             return (True, f"isinstance({ast.unparse(node.args[0])}, object) is always True")
@@ -139,7 +154,7 @@ def _check_boolop_patterns(node: ast.expr) -> tuple[bool, str] | None:
     return None
 
 
-@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, tuple) and len(result) == 2)
 def _check_tautology_patterns(node: ast.expr) -> tuple[bool, str]:
     """Check for common tautology patterns in AST node.
@@ -157,15 +172,23 @@ def _check_tautology_patterns(node: ast.expr) -> tuple[bool, str]:
         >>> _check_tautology_patterns(ast.Constant(value=False))
         (True, 'contract always returns False (contradiction - will always fail)')
     """
-    for checker in [_check_literal_patterns, _check_comparison_patterns,
-                    _check_isinstance_object, _check_boolop_patterns]:
+    for checker in [
+        _check_literal_patterns,
+        _check_comparison_patterns,
+        _check_isinstance_object,
+        _check_boolop_patterns,
+    ]:
         result = checker(node)
         if result:
             return result
     return (False, "")
 
 
-@pre(lambda file_info, config: len(file_info.path) > 0)
+@pre(
+    lambda file_info, config: file_info is not None
+    and len(file_info.path) > 0
+    and config is not None
+)
 def check_semantic_tautology(file_info: FileInfo, config: RuleConfig) -> list[Violation]:
     """Check for semantic tautology contracts. Core files only.
 

invar/core/template_parser.py

@@ -73,9 +73,7 @@ class ParsedFile:
 # Patterns for region markers
 # <!--invar:managed version="5.0"-->
 # <!--/invar:managed-->
-REGION_START_PATTERN = re.compile(
-    r'<!--invar:(\w+)(?:\s+version=["\']([^"\']+)["\'])?-->'
-)
+REGION_START_PATTERN = re.compile(r'<!--invar:(\w+)(?:\s+version=["\']([^"\']+)["\'])?-->')
 REGION_END_PATTERN = re.compile(r"<!--/invar:(\w+)-->")
 
 
@@ -157,10 +155,15 @@ def parse_invar_regions(content: str) -> ParsedFile:
     return ParsedFile(regions=regions, before=before, after=after, raw=content)
 
 
-@pre(lambda parsed, updates: all(k == v.name for k, v in parsed.regions.items()))  # Keys must match names
-@ensure(lambda parsed, updates, result: (
-    not parsed.has_regions or all(f"<!--invar:{r}" in result for r in parsed.regions)
-))  # Checks start tag prefix (version attribute may follow)
+@pre(
+    lambda parsed, updates: isinstance(updates, dict)
+    and all(k == v.name for k, v in parsed.regions.items())
+)  # Keys must match names
+@ensure(
+    lambda parsed, updates, result: (
+        not parsed.has_regions or all(f"<!--invar:{r}" in result for r in parsed.regions)
+    )
+)  # Checks start tag prefix (version attribute may follow)
 def reconstruct_file(parsed: ParsedFile, updates: dict[str, str]) -> str:
     """Reconstruct file content with updated regions.
 
@@ -359,11 +362,16 @@ def detect_claude_md_state(content: str) -> ClaudeMdState:
     project_complete = has_project_open and has_project_close
 
     # All markers present
-    any_marker = any([
-        has_managed_open, has_managed_close,
-        has_user_open, has_user_close,
-        has_project_open, has_project_close,
-    ])
+    any_marker = any(
+        [
+            has_managed_open,
+            has_managed_close,
+            has_user_open,
+            has_user_close,
+            has_project_open,
+            has_project_close,
+        ]
+    )
 
     if not any_marker:
         return ClaudeMdState(state="missing")
@@ -424,13 +432,13 @@ def strip_invar_markers(content: str) -> str:
     """
     # Remove all <!--invar:xxx--> and <!--/invar:xxx--> markers
     # Also handle version attribute
-    cleaned = re.sub(r'<!--/?invar:\w+[^>]*-->', '', content)
+    cleaned = re.sub(r"<!--/?invar:\w+[^>]*-->", "", content)
     # Clean up excessive blank lines
-    cleaned = re.sub(r'\n{3,}', '\n\n', cleaned)
+    cleaned = re.sub(r"\n{3,}", "\n\n", cleaned)
     return cleaned.strip()
 
 
-@pre(lambda content, merge_date: len(content) > 0)
+@pre(lambda content, merge_date="": len(content) > 0 and isinstance(merge_date, str))
 @post(lambda result: "MERGED CONTENT" in result)
 def format_preserved_content(content: str, merge_date: str = "") -> str:
     """Format preserved content with review markers.

invar/core/ts_parsers.py

@@ -115,7 +115,9 @@ def parse_tsc_output(output: str) -> list[TSViolation]:
     return violations
 
 
-@pre(lambda output, base_path="": output is not None)  # Accepts any string including empty
+@pre(
+    lambda output, base_path="": output is not None and isinstance(base_path, str)
+)  # Accepts any string including empty
 @post(lambda result: all(v.source == "eslint" for v in result))
 def parse_eslint_json(output: str, base_path: str = "") -> list[TSViolation]:
     """Parse ESLint JSON output into violations list.
@@ -194,7 +196,9 @@ def parse_eslint_json(output: str, base_path: str = "") -> list[TSViolation]:
     return violations
 
 
-@pre(lambda output, base_path="": output is not None)  # Accepts any string including empty
+@pre(
+    lambda output, base_path="": output is not None and isinstance(base_path, str)
+)  # Accepts any string including empty
 @post(lambda result: all(v.source == "vitest" for v in result))
 def parse_vitest_json(output: str, base_path: str = "") -> list[TSViolation]:
     """Parse Vitest JSON output into violations list.

invar/core/ts_sig_parser.py

@@ -188,7 +188,9 @@ def extract_ts_signatures(source: str) -> list[TSSymbol]:
         # Find actual class line (skip decorators)
         match_text = match.group(0)
         class_keyword_pos = match_text.find("class ")
-        actual_start = match.start() + class_keyword_pos if class_keyword_pos >= 0 else match.start()
+        actual_start = (
+            match.start() + class_keyword_pos if class_keyword_pos >= 0 else match.start()
+        )
         line = get_line_number(actual_start)
         line_content = lines[line - 1].strip() if line <= len(lines) else ""
         signature = line_content.rstrip("{").rstrip()
@@ -241,11 +243,13 @@ def extract_ts_signatures(source: str) -> list[TSSymbol]:
     return symbols
 
 
-@pre(lambda symbols, file_path="": all(s.line > 0 for s in symbols))  # All symbols have valid line numbers
+@pre(
+    lambda symbols, file_path="": isinstance(symbols, list)
+    and isinstance(file_path, str)
+    and all(s.line > 0 for s in symbols)
+)  # All symbols have valid line numbers
 @post(lambda result: "file" in result and "symbols" in result)
-def format_ts_signatures_json(
-    symbols: list[TSSymbol], file_path: str = ""
-) -> dict:
+def format_ts_signatures_json(symbols: list[TSSymbol], file_path: str = "") -> dict:
     """Format TypeScript symbols as JSON output.
 
     Args:
@@ -277,11 +281,13 @@ def format_ts_signatures_json(
     }
 
 
-@pre(lambda symbols, file_path="": all(s.line > 0 for s in symbols))  # All symbols have valid line numbers
+@pre(
+    lambda symbols, file_path="": isinstance(symbols, list)
+    and isinstance(file_path, str)
+    and all(s.line > 0 for s in symbols)
+)  # All symbols have valid line numbers
 @post(lambda result: len(result) > 0)  # Always produces output (at least header)
-def format_ts_signatures_text(
-    symbols: list[TSSymbol], file_path: str = ""
-) -> str:
+def format_ts_signatures_text(symbols: list[TSSymbol], file_path: str = "") -> str:
     """Format TypeScript symbols as human-readable text.
 
     Args:
@@ -303,7 +309,9 @@ def format_ts_signatures_text(
         lines.append(f"  {symbol.signature}")
         if symbol.docstring:
             # Truncate long docstrings
-            doc = symbol.docstring[:100] + "..." if len(symbol.docstring) > 100 else symbol.docstring
+            doc = (
+                symbol.docstring[:100] + "..." if len(symbol.docstring) > 100 else symbol.docstring
+            )
             lines.append(f"  /** {doc} */")
         lines.append("")
 

invar/core/utils.py

@@ -15,7 +15,11 @@ from deal import post, pre
 from invar.core.models import GuardReport, RuleConfig, RuleExclusion
 
 
-@pre(lambda report, strict: report.files_checked >= 0 and report.errors >= 0)
+@pre(
+    lambda report, strict: report.files_checked >= 0
+    and report.errors >= 0
+    and isinstance(strict, bool)
+)
 @post(lambda result: result in (0, 1))
 def get_exit_code(report: GuardReport, strict: bool) -> int:
     """
@@ -37,7 +41,17 @@ def get_exit_code(report: GuardReport, strict: bool) -> int:
     return 0
 
 
-@pre(lambda report, strict, doctest_passed=True, crosshair_passed=True, property_passed=True: report.files_checked >= 0)
+@pre(
+    lambda report,
+    strict,
+    doctest_passed=True,
+    crosshair_passed=True,
+    property_passed=True: report.files_checked >= 0
+    and isinstance(strict, bool)
+    and isinstance(doctest_passed, bool)
+    and isinstance(crosshair_passed, bool)
+    and isinstance(property_passed, bool)
+)
 @post(lambda result: result in ("passed", "failed"))
 def get_combined_status(
     report: GuardReport,
@@ -83,7 +97,10 @@ def get_combined_status(
     return "passed"
 
 
-@pre(lambda data, source: source in ("pyproject", "invar", "invar_dir", "default"))
+@pre(
+    lambda data, source: isinstance(data, dict)
+    and source in ("pyproject", "invar", "invar_dir", "default")
+)
 @post(lambda result: isinstance(result, dict))
 def extract_guard_section(data: dict[str, Any], source: str) -> dict[str, Any]:
     """
@@ -115,7 +132,7 @@ def extract_guard_section(data: dict[str, Any], source: str) -> dict[str, Any]:
     return result if isinstance(result, dict) else {}
 
 
-@pre(lambda config, key: len(key) > 0)
+@pre(lambda config, key: isinstance(config, dict) and len(key) > 0)
 @post(lambda result: result is None or isinstance(result, bool))
 def _get_bool(config: dict[str, Any], key: str) -> bool | None:
     """
@@ -132,7 +149,7 @@ def _get_bool(config: dict[str, Any], key: str) -> bool | None:
     return None
 
 
-@pre(lambda config, key: len(key) > 0)
+@pre(lambda config, key: isinstance(config, dict) and len(key) > 0)
 @post(lambda result: result is None or isinstance(result, int))
 def _get_int(config: dict[str, Any], key: str) -> int | None:
     """
@@ -149,7 +166,7 @@ def _get_int(config: dict[str, Any], key: str) -> int | None:
     return None
 
 
-@pre(lambda config, key: len(key) > 0)
+@pre(lambda config, key: isinstance(config, dict) and len(key) > 0)
 @post(lambda result: result is None or isinstance(result, float))
 def _get_float(config: dict[str, Any], key: str) -> float | None:
     """
@@ -168,7 +185,7 @@ def _get_float(config: dict[str, Any], key: str) -> float | None:
     return None
 
 
-@pre(lambda config, key: len(key) > 0)
+@pre(lambda config, key: isinstance(config, dict) and len(key) > 0)
 @post(lambda result: result is None or isinstance(result, list))
 def _get_str_list(config: dict[str, Any], key: str) -> list[str] | None:
     """
@@ -204,7 +221,9 @@ def _parse_rule_exclusions(config: dict[str, Any]) -> list[RuleExclusion] | None
         if isinstance(excl, dict) and "pattern" in excl and "rules" in excl:
             pattern, rules = excl["pattern"], excl["rules"]
             if isinstance(pattern, str) and isinstance(rules, list):
-                exclusions.append(RuleExclusion(pattern=str(pattern), rules=[str(r) for r in rules]))
+                exclusions.append(
+                    RuleExclusion(pattern=str(pattern), rules=[str(r) for r in rules])
+                )
     return exclusions if exclusions else None
 
 
@@ -253,7 +272,14 @@ def parse_guard_config(guard_config: dict[str, Any]) -> RuleConfig:
     kwargs: dict[str, Any] = {}
 
     # Int fields
-    for key in ("max_file_lines", "max_function_lines"):
+    for key in (
+        "max_file_lines",
+        "max_function_lines",
+        "timeout_doctest",
+        "timeout_hypothesis",
+        "timeout_crosshair",
+        "timeout_crosshair_per_condition",
+    ):
         if (val := _get_int(guard_config, key)) is not None:
             kwargs[key] = val
 
@@ -286,7 +312,7 @@ def parse_guard_config(guard_config: dict[str, Any]) -> RuleConfig:
         return RuleConfig()
 
 
-@pre(lambda file_path, patterns: len(file_path) > 0)
+@pre(lambda file_path, patterns: len(file_path) > 0 and isinstance(patterns, list))
 def matches_pattern(file_path: str, patterns: list[str]) -> bool:
     """
     Check if a file path matches any of the glob patterns.
@@ -316,7 +342,7 @@ def matches_pattern(file_path: str, patterns: list[str]) -> bool:
     return False
 
 
-@pre(lambda file_path, prefixes: len(file_path) > 0)
+@pre(lambda file_path, prefixes: len(file_path) > 0 and isinstance(prefixes, list))
 def matches_path_prefix(file_path: str, prefixes: list[str]) -> bool:
     """
     Check if file_path starts with any of the given prefixes.
@@ -386,7 +412,7 @@ def match_glob_pattern(file_path: str, pattern: str) -> bool:
     return False
 
 
-@pre(lambda file_path, config: len(file_path) > 0)
+@pre(lambda file_path, config: len(file_path) > 0 and isinstance(config, RuleConfig))
 def get_excluded_rules(file_path: str, config: RuleConfig) -> set[str]:
     """
     Get the set of rules to exclude for a given file path.