invar-tools 1.0.0__py3-none-any.whl

invar/core/parser.py

@@ -0,0 +1,276 @@
+"""
+AST parser for extracting symbols and contracts.
+
+This module receives string content (not file paths) and returns
+structured data. No I/O operations.
+"""
+
+from __future__ import annotations
+
+import ast
+
+from deal import post, pre
+
+from invar.core.models import Contract, FileInfo, Symbol, SymbolKind
+from invar.core.purity import (
+    count_code_lines,
+    count_doctest_lines,
+    extract_function_calls,
+    extract_impure_calls,
+    extract_internal_imports,
+)
+
+
+@pre(lambda source, path="<string>": isinstance(source, str) and len(source) > 0)
+def parse_source(source: str, path: str = "<string>") -> FileInfo | None:
+    """
+    Parse Python source code and extract symbols.
+
+    Args:
+        source: Python source code as string
+        path: Path for reporting (not used for I/O)
+
+    Returns:
+        FileInfo with extracted symbols, or None if syntax error
+
+    Examples:
+        >>> info = parse_source("def foo(): pass")
+        >>> info is not None
+        True
+        >>> len(info.symbols)
+        1
+        >>> info.symbols[0].name
+        'foo'
+    """
+    try:
+        tree = ast.parse(source)
+    except (SyntaxError, TypeError, ValueError):
+        return None
+
+    lines = source.count("\n") + 1
+    symbols = _extract_symbols(tree)
+    imports = _extract_imports(tree)
+
+    return FileInfo(
+        path=path,
+        lines=lines,
+        symbols=symbols,
+        imports=imports,
+        source=source,
+    )
+
+
+@pre(lambda tree: isinstance(tree, ast.Module))
+def _extract_symbols(tree: ast.Module) -> list[Symbol]:
+    """
+    Extract function, class, and method symbols from AST.
+
+    Examples:
+        >>> import ast
+        >>> tree = ast.parse("class Foo:\\n    def bar(self): pass")
+        >>> symbols = _extract_symbols(tree)
+        >>> len(symbols)
+        2
+        >>> symbols[0].kind.value
+        'class'
+        >>> symbols[1].kind.value
+        'method'
+    """
+    symbols: list[Symbol] = []
+
+    for node in tree.body:
+        if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef):
+            symbols.append(_parse_function(node))
+        elif isinstance(node, ast.ClassDef):
+            symbols.append(_parse_class(node))
+            # Extract methods from class body
+            for item in node.body:
+                if isinstance(item, ast.FunctionDef | ast.AsyncFunctionDef):
+                    symbols.append(_parse_method(item, node.name))
+
+    return symbols
+
+
+@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."""
+    contracts = _extract_contracts(node)
+    docstring = ast.get_docstring(node)
+    has_doctest = docstring is not None and ">>>" in docstring
+    signature = _build_signature(node)
+    internal_imports = extract_internal_imports(node)
+    impure_calls = extract_impure_calls(node)
+    code_lines = count_code_lines(node)
+    doctest_lines = count_doctest_lines(node)
+    function_calls = extract_function_calls(node)  # P25
+
+    return Symbol(
+        name=node.name,
+        kind=SymbolKind.FUNCTION,
+        line=node.lineno,
+        end_line=node.end_lineno or node.lineno,
+        signature=signature,
+        docstring=docstring,
+        contracts=contracts,
+        has_doctest=has_doctest,
+        internal_imports=internal_imports,
+        impure_calls=impure_calls,
+        code_lines=code_lines,
+        doctest_lines=doctest_lines,
+        function_calls=function_calls,
+    )
+
+
+@pre(lambda node, class_name: (
+    isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef) and
+    hasattr(node, 'name') and hasattr(node, 'args') and hasattr(node, 'lineno')
+))
+@post(lambda result: result.kind == SymbolKind.METHOD)
+def _parse_method(node: ast.FunctionDef | ast.AsyncFunctionDef, class_name: str) -> Symbol:
+    """
+    Parse a method definition into a Symbol.
+
+    Examples:
+        >>> import ast
+        >>> tree = ast.parse("class Foo:\\n    def bar(self): pass")
+        >>> method_node = tree.body[0].body[0]
+        >>> sym = _parse_method(method_node, "Foo")
+        >>> sym.name
+        'Foo.bar'
+        >>> sym.kind.value
+        'method'
+    """
+    contracts = _extract_contracts(node)
+    docstring = ast.get_docstring(node)
+    has_doctest = docstring is not None and ">>>" in docstring
+    signature = _build_signature(node)
+    internal_imports = extract_internal_imports(node)
+    impure_calls = extract_impure_calls(node)
+    code_lines = count_code_lines(node)
+    doctest_lines = count_doctest_lines(node)
+    function_calls = extract_function_calls(node)  # P25
+
+    return Symbol(
+        name=f"{class_name}.{node.name}",
+        kind=SymbolKind.METHOD,
+        line=node.lineno,
+        end_line=node.end_lineno or node.lineno,
+        signature=signature,
+        docstring=docstring,
+        contracts=contracts,
+        has_doctest=has_doctest,
+        internal_imports=internal_imports,
+        impure_calls=impure_calls,
+        code_lines=code_lines,
+        doctest_lines=doctest_lines,
+        function_calls=function_calls,
+    )
+
+
+@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."""
+    docstring = ast.get_docstring(node)
+
+    return Symbol(
+        name=node.name,
+        kind=SymbolKind.CLASS,
+        line=node.lineno,
+        end_line=node.end_lineno or node.lineno,
+        docstring=docstring,
+    )
+
+
+@pre(lambda node: isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef))
+@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."""
+    contracts: list[Contract] = []
+
+    for decorator in node.decorator_list:
+        contract = _parse_decorator_as_contract(decorator)
+        if contract:
+            contracts.append(contract)
+
+    return contracts
+
+
+@pre(lambda decorator: not isinstance(decorator, ast.Call) or hasattr(decorator, "func"))
+@post(lambda result: result is None or result.kind in ("pre", "post"))
+def _parse_decorator_as_contract(decorator: ast.expr) -> Contract | None:
+    """Try to parse a decorator as a contract (@pre or @post)."""
+    # Handle @pre(...) or @post(...)
+    if isinstance(decorator, ast.Call):
+        func = decorator.func
+        if isinstance(func, ast.Name) and func.id in ("pre", "post"):
+            expr = _get_contract_expression(decorator)
+            return Contract(
+                kind="pre" if func.id == "pre" else "post",
+                expression=expr,
+                line=decorator.lineno,
+            )
+        # Handle deal.pre(...) or deal.post(...)
+        if isinstance(func, ast.Attribute) and func.attr in ("pre", "post"):
+            expr = _get_contract_expression(decorator)
+            return Contract(
+                kind="pre" if func.attr == "pre" else "post",
+                expression=expr,
+                line=decorator.lineno,
+            )
+
+    return None
+
+
+@pre(lambda call: isinstance(call, ast.Call))
+def _get_contract_expression(call: ast.Call) -> str:
+    """Extract the expression string from a contract decorator call."""
+    if call.args:
+        return ast.unparse(call.args[0])
+    return ""
+
+
+@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."""
+    args = node.args
+    parts: list[str] = []
+
+    # Regular args
+    for arg in args.args:
+        part = arg.arg
+        if arg.annotation:
+            part += f": {ast.unparse(arg.annotation)}"
+        parts.append(part)
+
+    sig = f"({', '.join(parts)})"
+
+    # Return type
+    if node.returns:
+        sig += f" -> {ast.unparse(node.returns)}"
+
+    return sig
+
+
+@pre(lambda tree: isinstance(tree, ast.Module))
+@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)."""
+    imports: list[str] = []
+
+    for node in tree.body:
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                imports.append(alias.name.split(".")[0])
+        elif isinstance(node, ast.ImportFrom) and node.module:
+            imports.append(node.module.split(".")[0])
+
+    return list(set(imports))  # Deduplicate

invar/core/property_gen.py

@@ -0,0 +1,383 @@
+"""
+Property test generation from contracts.
+
+DX-08: Automatically generates Hypothesis property tests from @pre/@post contracts.
+Core module: pure logic, no I/O.
+"""
+
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+from deal import post, pre
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+@dataclass
+class PropertyTestResult:
+    """Result of running a property test."""
+
+    function_name: str
+    passed: bool
+    examples_run: int = 0
+    counterexample: dict[str, Any] | None = None
+    error: str | None = None
+
+
+@dataclass
+class GeneratedTest:
+    """A generated property test."""
+
+    function_name: str
+    module_name: str
+    strategies: dict[str, str]  # param_name -> strategy code
+    test_code: str
+    description: str = ""
+
+
+@dataclass
+class PropertyTestReport:
+    """Report from running property tests on multiple functions."""
+
+    functions_tested: int = 0
+    functions_passed: int = 0
+    functions_failed: int = 0
+    functions_skipped: int = 0
+    total_examples: int = 0
+    results: list[PropertyTestResult] = field(default_factory=list)
+    errors: list[str] = field(default_factory=list)
+
+    @post(lambda result: isinstance(result, bool))
+    def all_passed(self) -> bool:
+        """Check if all tests passed.
+
+        >>> report = PropertyTestReport(functions_failed=0)
+        >>> report.all_passed()
+        True
+        >>> report2 = PropertyTestReport(functions_failed=1)
+        >>> report2.all_passed()
+        False
+        """
+        return self.functions_failed == 0 and len(self.errors) == 0
+
+
+@pre(lambda func: callable(func))
+@post(lambda result: result is None or isinstance(result, dict))
+def _infer_strategy_strings(func: Callable) -> dict[str, str] | None:
+    """Infer strategy code strings from function.
+
+    >>> def example(x: int) -> int: return x
+    >>> result = _infer_strategy_strings(example)
+    >>> result is None or isinstance(result, dict)
+    True
+    """
+    # Lazy import to avoid circular dependency
+    from invar.core.hypothesis_strategies import infer_strategies_for_function
+
+    try:
+        strategy_specs = infer_strategies_for_function(func)
+    except Exception:
+        return None
+
+    if not strategy_specs:
+        return None
+
+    strategies: dict[str, str] = {}
+    for param_name, spec in strategy_specs.items():
+        try:
+            strategies[param_name] = spec.to_code()
+        except (AttributeError, TypeError):
+            continue
+
+    return strategies if strategies else None
+
+
+@pre(lambda func: callable(func))
+@post(lambda result: result is None or isinstance(result, GeneratedTest))
+def generate_property_test(func: Callable) -> GeneratedTest | None:
+    """
+    Generate a Hypothesis property test from a function's contracts.
+
+    Returns None if:
+    - Function has no @pre contracts
+    - @pre is too complex to parse
+    - Types are not inferrable
+
+    DX-08: Uses strategies.py for constraint inference and
+    hypothesis_strategies.py for type-based strategy generation.
+
+    >>> def example(x: int) -> int:
+    ...     return x * 2
+    >>> result = generate_property_test(example)
+    >>> result is None or isinstance(result, GeneratedTest)
+    True
+    """
+    # Get function metadata
+    try:
+        func_name = func.__name__
+        module_name = func.__module__ or "__main__"
+    except AttributeError:
+        return None
+
+    # Infer strategies
+    strategies = _infer_strategy_strings(func)
+    if not strategies:
+        return None
+
+    # Generate test code
+    test_code = _generate_test_code(func_name, strategies)
+
+    return GeneratedTest(
+        function_name=func_name,
+        module_name=module_name,
+        strategies=strategies,
+        test_code=test_code,
+        description=f"Property test for {func_name}",
+    )
+
+
+@pre(lambda func_name, strategies: isinstance(func_name, str) and isinstance(strategies, dict))
+@post(lambda result: isinstance(result, str) and "@given" in result)
+def _generate_test_code(func_name: str, strategies: dict[str, str]) -> str:
+    """
+    Generate the actual test code string.
+
+    >>> code = _generate_test_code("sqrt", {"x": "st.floats(min_value=0)"})
+    >>> "@given" in code
+    True
+    >>> "def test_sqrt_property" in code
+    True
+    """
+    # Build @given decorator arguments
+    given_args = ", ".join(f"{name}={strat}" for name, strat in strategies.items())
+
+    # Build test function
+    param_list = ", ".join(strategies.keys())
+
+    return f'''@given({given_args})
+def test_{func_name}_property({param_list}):
+    """Auto-generated property test for {func_name}."""
+    {func_name}({param_list})  # @post verified by deal at runtime
+'''
+
+
+@pre(lambda dec: isinstance(dec, ast.Call) and hasattr(dec, "func"))
+@post(lambda result: isinstance(result, tuple) and len(result) == 2)
+def _check_decorator_contracts(dec: ast.Call) -> tuple[bool, bool]:
+    """Check if decorator is @pre or @post, return (has_pre, has_post).
+
+    >>> import ast
+    >>> code = "pre(lambda x: x > 0)"
+    >>> tree = ast.parse(code, mode='eval')
+    >>> isinstance(tree.body, ast.Call)
+    True
+    """
+    func = dec.func
+    has_pre, has_post = False, False
+    # @pre(...) or @post(...)
+    if isinstance(func, ast.Name):
+        has_pre = func.id == "pre"
+        has_post = func.id == "post"
+    # @deal.pre(...) or @deal.post(...)
+    elif isinstance(func, ast.Attribute):
+        has_pre = func.attr == "pre"
+        has_post = func.attr == "post"
+    return has_pre, has_post
+
+
+@pre(lambda node: isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)))
+@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).
+
+    >>> import ast
+    >>> code = '''
+    ... @pre(lambda x: x > 0)
+    ... def foo(x): pass
+    ... '''
+    >>> tree = ast.parse(code)
+    >>> func_node = tree.body[0]
+    >>> isinstance(func_node, ast.FunctionDef)
+    True
+    """
+    has_pre, has_post = False, False
+    for dec in node.decorator_list:
+        if isinstance(dec, ast.Call):
+            dec_pre, dec_post = _check_decorator_contracts(dec)
+            has_pre = has_pre or dec_pre
+            has_post = has_post or dec_post
+    return has_pre, has_post
+
+
+@pre(lambda source: isinstance(source, str) and len(source) > 0)
+@post(lambda result: isinstance(result, list))
+def find_contracted_functions(source: str) -> list[dict[str, Any]]:
+    """
+    Find all functions with @pre/@post contracts in source code.
+
+    >>> source = '''
+    ... from deal import pre, post
+    ... @pre(lambda x: x > 0)
+    ... def sqrt(x: float) -> float:
+    ...     return x ** 0.5
+    ... '''
+    >>> funcs = find_contracted_functions(source)
+    >>> len(funcs) >= 0
+    True
+    """
+    try:
+        tree = ast.parse(source)
+    except (SyntaxError, ValueError, TypeError):
+        return []
+
+    functions: list[dict[str, Any]] = []
+    for node in ast.walk(tree):
+        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),
+                })
+    return functions
+
+
+@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."""
+    params = []
+    for arg in node.args.args:
+        param_info = {"name": arg.arg, "type": None}
+        if arg.annotation:
+            param_info["type"] = ast.unparse(arg.annotation)
+        params.append(param_info)
+    return params
+
+
+@pre(lambda node: isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)))
+@post(lambda result: result is None or isinstance(result, str))
+def _extract_return_type(node: ast.FunctionDef | ast.AsyncFunctionDef) -> str | None:
+    """Extract return type annotation from function node."""
+    if node.returns:
+        return ast.unparse(node.returns)
+    return None
+
+
+@pre(lambda func, strategies, max_examples=100: callable(func) and isinstance(strategies, dict))
+@post(lambda result: result is None or callable(result))
+def build_test_function(
+    func: Callable,
+    strategies: dict[str, str],
+    max_examples: int = 100,
+) -> Callable | None:
+    """
+    Build an executable test function using Hypothesis.
+
+    Returns None if hypothesis is not available.
+
+    >>> def example(x: int) -> int:
+    ...     return x * 2
+    >>> test_fn = build_test_function(example, {"x": "st.integers()"})
+    >>> test_fn is None or callable(test_fn)
+    True
+    """
+    # Lazy import: hypothesis is optional dependency
+    try:
+        from hypothesis import given, settings
+        from hypothesis import strategies as st
+    except ImportError:
+        return None
+
+    # Build strategy dict
+    strategy_dict = {}
+    for param_name, strat_code in strategies.items():
+        # Evaluate the strategy code
+        try:
+            # strat_code is like "st.integers(min_value=0)"
+            strategy = eval(strat_code, {"st": st})
+            strategy_dict[param_name] = strategy
+        except Exception:
+            # If evaluation fails, use a fallback
+            return None
+
+    if not strategy_dict:
+        return None
+
+    # Create the test function
+    @settings(max_examples=max_examples)
+    @given(**strategy_dict)
+    def property_test(**kwargs):
+        func(**kwargs)
+
+    property_test.__name__ = f"test_{func.__name__}_property"
+    return property_test
+
+
+@pre(lambda func, max_examples: callable(func) and max_examples > 0)
+@post(lambda result: isinstance(result, PropertyTestResult))
+def run_property_test(
+    func: Callable,
+    max_examples: int = 100,
+) -> PropertyTestResult:
+    """
+    Run a property test on a single function.
+
+    Generates strategies from contracts and runs Hypothesis.
+
+    >>> from deal import pre, post
+    >>> @pre(lambda x: x >= 0)
+    ... @post(lambda result: result >= 0)
+    ... def square(x: int) -> int:
+    ...     return x * x
+    >>> result = run_property_test(square, max_examples=10)
+    >>> isinstance(result, PropertyTestResult)
+    True
+    """
+    func_name = getattr(func, "__name__", "unknown")
+
+    # Generate test
+    generated = generate_property_test(func)
+    if generated is None:
+        return PropertyTestResult(
+            function_name=func_name,
+            passed=True,  # No test generated = skip, not fail
+            examples_run=0,
+            error="Could not generate test (no contracts or unparseable)",
+        )
+
+    # Build executable test
+    test_fn = build_test_function(func, generated.strategies, max_examples)
+    if test_fn is None:
+        return PropertyTestResult(
+            function_name=func_name,
+            passed=True,
+            examples_run=0,
+            error="Could not build test (hypothesis not available or strategy error)",
+        )
+
+    # Run the test
+    try:
+        test_fn()
+        return PropertyTestResult(
+            function_name=func_name,
+            passed=True,
+            examples_run=max_examples,
+        )
+    except Exception as e:
+        # Extract counterexample if available
+        error_str = str(e)
+        return PropertyTestResult(
+            function_name=func_name,
+            passed=False,
+            examples_run=max_examples,
+            error=error_str,
+        )