invar-tools 1.7.1__py3-none-any.whl → 1.10.0__py3-none-any.whl

invar/__init__.py

@@ -32,6 +32,7 @@ from invar_runtime import (
     NoNone,
     Percentage,
     Positive,
+    RelationViolation,
     ResourceWarning,
     Sorted,
     SortedNonEmpty,
@@ -42,8 +43,11 @@ from invar_runtime import (
     must_use,
     post,
     pre,
+    relates,
+    relates_multi,
     skip_property_test,
     strategy,
+    to_post_contract,
 )
 
 __all__ = [
@@ -60,6 +64,7 @@ __all__ = [
     "NonNegative",
     "Percentage",
     "Positive",
+    "RelationViolation",
     "ResourceWarning",
     "Sorted",
     "SortedNonEmpty",
@@ -70,6 +75,9 @@ __all__ = [
     "must_use",
     "post",
     "pre",
+    "relates",
+    "relates_multi",
     "skip_property_test",
     "strategy",
+    "to_post_contract",
 ]

invar/core/language.py

@@ -0,0 +1,88 @@
+"""Language detection for multi-language support.
+
+This module provides language detection based on project marker files.
+Part of LX-05 language-agnostic architecture.
+"""
+
+from deal import post, pre
+
+# Supported languages for Invar verification
+SUPPORTED_LANGUAGES: frozenset[str] = frozenset({"python", "typescript"})
+
+# Future languages (detected but not yet supported)
+FUTURE_LANGUAGES: frozenset[str] = frozenset({"rust", "go"})
+
+# All detectable languages
+ALL_DETECTABLE: frozenset[str] = SUPPORTED_LANGUAGES | FUTURE_LANGUAGES
+
+
+@pre(lambda markers: isinstance(markers, (set, frozenset)))
+@post(lambda result: result in ALL_DETECTABLE)
+def detect_language_from_markers(markers: frozenset[str]) -> str:
+    """Detect project language from marker file names (pure logic).
+
+    Args:
+        markers: Set of marker file names present in the project root.
+
+    Returns:
+        Detected language identifier string.
+
+    Examples:
+        >>> detect_language_from_markers(frozenset({"pyproject.toml"}))
+        'python'
+
+        >>> detect_language_from_markers(frozenset({"setup.py", "README.md"}))
+        'python'
+
+        >>> detect_language_from_markers(frozenset({"tsconfig.json"}))
+        'typescript'
+
+        >>> detect_language_from_markers(frozenset({"package.json"}))
+        'typescript'
+
+        >>> detect_language_from_markers(frozenset({"Cargo.toml"}))
+        'rust'
+
+        >>> detect_language_from_markers(frozenset({"go.mod"}))
+        'go'
+
+        >>> detect_language_from_markers(frozenset())  # Empty defaults to python
+        'python'
+
+        >>> detect_language_from_markers(frozenset({"README.md"}))  # Unknown defaults to python
+        'python'
+    """
+    # Detection order matters - first match wins
+    if "pyproject.toml" in markers or "setup.py" in markers:
+        return "python"
+    if "tsconfig.json" in markers or "package.json" in markers:
+        return "typescript"
+    if "Cargo.toml" in markers:
+        return "rust"
+    if "go.mod" in markers:
+        return "go"
+    return "python"  # Default
+
+
+@pre(lambda lang: isinstance(lang, str) and len(lang) > 0)
+@post(lambda result: isinstance(result, bool))
+def is_supported(lang: str) -> bool:
+    """Check if a language is currently supported for verification.
+
+    Args:
+        lang: Language identifier to check.
+
+    Returns:
+        True if the language has full Invar support.
+
+    Examples:
+        >>> is_supported("python")
+        True
+        >>> is_supported("typescript")
+        True
+        >>> is_supported("rust")
+        False
+        >>> is_supported("go")
+        False
+    """
+    return lang in SUPPORTED_LANGUAGES

invar/core/models.py

@@ -1,3 +1,4 @@
+# @invar:allow file_size: LX-10 added layer types and functions, extraction planned
 """
 Pydantic models for Invar.
 
@@ -7,6 +8,7 @@ No I/O operations allowed.
 
 from __future__ import annotations
 
+from dataclasses import dataclass
 from enum import Enum
 from typing import Literal
 
@@ -31,6 +33,47 @@ class Severity(str, Enum):
     SUGGEST = "suggest"  # DX-61: Functional pattern suggestions
 
 
+class CodeLayer(str, Enum):
+    """Code layer for differentiated size limits (LX-10)."""
+
+    CORE = "core"
+    SHELL = "shell"
+    TESTS = "tests"
+    DEFAULT = "default"
+
+
+@dataclass(frozen=True)
+class LayerLimits:
+    """Size limits for a specific code layer (LX-10).
+
+    Examples:
+        >>> limits = LayerLimits(max_file_lines=500, max_function_lines=50)
+        >>> limits.max_file_lines
+        500
+        >>> limits.max_function_lines
+        50
+    """
+
+    max_file_lines: int
+    max_function_lines: int
+
+
+# LX-10: Hardcoded layer limits (no config needed)
+PYTHON_LAYER_LIMITS: dict[CodeLayer, LayerLimits] = {
+    CodeLayer.CORE: LayerLimits(500, 50),
+    CodeLayer.SHELL: LayerLimits(700, 100),
+    CodeLayer.TESTS: LayerLimits(1000, 200),
+    CodeLayer.DEFAULT: LayerLimits(600, 80),
+}
+
+TYPESCRIPT_LAYER_LIMITS: dict[CodeLayer, LayerLimits] = {
+    CodeLayer.CORE: LayerLimits(650, 65),
+    CodeLayer.SHELL: LayerLimits(910, 130),
+    CodeLayer.TESTS: LayerLimits(1300, 260),
+    CodeLayer.DEFAULT: LayerLimits(780, 104),
+}
+
+
 class Contract(BaseModel):
     """A contract (precondition or postcondition) on a function."""
 
@@ -72,6 +115,69 @@ class FileInfo(BaseModel):
     source: str = ""  # Original source code for advanced analysis
 
 
+# LX-10: Layer detection functions
+@pre(lambda file_info: file_info is not None and hasattr(file_info, "path"))
+@post(lambda result: result in CodeLayer)
+def get_layer(file_info: FileInfo) -> CodeLayer:
+    """
+    Determine code layer from FileInfo classification.
+
+    Uses existing is_core/is_shell fields. Tests detection via path.
+
+    Examples:
+        >>> get_layer(FileInfo(path="src/core/logic.py", lines=10, is_core=True))
+        <CodeLayer.CORE: 'core'>
+        >>> get_layer(FileInfo(path="src/shell/cli.py", lines=10, is_shell=True))
+        <CodeLayer.SHELL: 'shell'>
+        >>> get_layer(FileInfo(path="tests/test_foo.py", lines=10))
+        <CodeLayer.TESTS: 'tests'>
+        >>> get_layer(FileInfo(path="src/utils.py", lines=10))
+        <CodeLayer.DEFAULT: 'default'>
+        >>> # Edge: "test_" must be at filename start, not anywhere in path
+        >>> get_layer(FileInfo(path="src/contest_utils.py", lines=10))
+        <CodeLayer.DEFAULT: 'default'>
+        >>> get_layer(FileInfo(path="src/foo_test.py", lines=10))
+        <CodeLayer.TESTS: 'tests'>
+    """
+    # Tests: path-based (no is_tests field exists)
+    path_lower = file_info.path.replace("\\", "/").lower()
+    filename = path_lower.rsplit("/", 1)[-1]  # Extract filename
+    # Match: /tests/ dir, /test/ dir, test_*.py files, *_test.py files
+    if (
+        "/tests/" in path_lower
+        or "/test/" in path_lower
+        or filename.startswith("test_")
+        or filename.endswith("_test.py")
+    ):
+        return CodeLayer.TESTS
+
+    # Core/Shell: use existing classification
+    if file_info.is_core:
+        return CodeLayer.CORE
+    if file_info.is_shell:
+        return CodeLayer.SHELL
+
+    return CodeLayer.DEFAULT
+
+
+@pre(lambda layer, language="python": isinstance(layer, CodeLayer) and language in ("python", "typescript"))
+@post(lambda result: result.max_file_lines > 0 and result.max_function_lines > 0)
+def get_limits(layer: CodeLayer, language: str = "python") -> LayerLimits:
+    """
+    Get size limits for layer and language.
+
+    Examples:
+        >>> get_limits(CodeLayer.CORE).max_function_lines
+        50
+        >>> get_limits(CodeLayer.SHELL).max_function_lines
+        100
+        >>> get_limits(CodeLayer.CORE, "typescript").max_function_lines
+        65
+    """
+    limits = TYPESCRIPT_LAYER_LIMITS if language == "typescript" else PYTHON_LAYER_LIMITS
+    return limits[layer]
+
+
 class Violation(BaseModel):
     """A rule violation found by Guard."""
 

invar/core/patterns/detector.py

@@ -27,6 +27,7 @@ class PatternDetector(Protocol):
     Detectors analyze AST nodes and return suggestions with confidence levels.
     """
 
+    # @invar:allow missing_doctest: Abstract property - no executable implementation
     @property
     @abstractmethod
     @post(lambda result: result in PatternID)
@@ -34,6 +35,7 @@ class PatternDetector(Protocol):
         """Unique identifier for this pattern."""
         ...
 
+    # @invar:allow missing_doctest: Abstract property - no executable implementation
     @property
     @abstractmethod
     @post(lambda result: result in Priority)
@@ -41,6 +43,7 @@ class PatternDetector(Protocol):
         """Priority tier (P0 or P1)."""
         ...
 
+    # @invar:allow missing_doctest: Abstract property - no executable implementation
     @property
     @abstractmethod
     @post(lambda result: len(result) > 0)
@@ -48,6 +51,7 @@ class PatternDetector(Protocol):
         """Human-readable description of the pattern."""
         ...
 
+    # @invar:allow missing_doctest: Abstract method - no executable implementation
     @abstractmethod
     @post(lambda result: all(isinstance(s, PatternSuggestion) for s in result))
     def detect(self, tree: ast.AST, file_path: str) -> list[PatternSuggestion]:
@@ -140,7 +144,8 @@ class BaseDetector:
             return f"{left} | {right}"
         else:
             # Python 3.9+ always has ast.unparse (project requires 3.11+)
-            return ast.unparse(annotation)
+            result = ast.unparse(annotation)
+            return result if result else "<unknown>"
 
     @pre(lambda self, params, type_name: len(type_name) > 0)
     @post(lambda result: result >= 0)

invar/core/patterns/p0_exhaustive.py

@@ -51,19 +51,31 @@ class ExhaustiveMatchDetector(BaseDetector):
     @property
     @post(lambda result: result == PatternID.EXHAUSTIVE)
     def pattern_id(self) -> PatternID:
-        """Unique identifier for this pattern."""
+        """Unique identifier for this pattern.
+
+        >>> ExhaustiveMatchDetector().pattern_id
+        <PatternID.EXHAUSTIVE: 'exhaustive'>
+        """
         return PatternID.EXHAUSTIVE
 
     @property
     @post(lambda result: result == Priority.P0)
     def priority(self) -> Priority:
-        """Priority tier."""
+        """Priority tier.
+
+        >>> ExhaustiveMatchDetector().priority
+        <Priority.P0: 'P0'>
+        """
         return Priority.P0
 
     @property
     @post(lambda result: len(result) > 0)
     def description(self) -> str:
-        """Human-readable description."""
+        """Human-readable description.
+
+        >>> len(ExhaustiveMatchDetector().description) > 0
+        True
+        """
         return "Use assert_never for exhaustive enum matching"
 
     @post(lambda result: all(isinstance(s, PatternSuggestion) for s in result))

invar/core/patterns/p0_literal.py

@@ -48,19 +48,31 @@ class LiteralDetector(BaseDetector):
     @property
     @post(lambda result: result == PatternID.LITERAL)
     def pattern_id(self) -> PatternID:
-        """Unique identifier for this pattern."""
+        """Unique identifier for this pattern.
+
+        >>> LiteralDetector().pattern_id
+        <PatternID.LITERAL: 'literal'>
+        """
         return PatternID.LITERAL
 
     @property
     @post(lambda result: result == Priority.P0)
     def priority(self) -> Priority:
-        """Priority tier."""
+        """Priority tier.
+
+        >>> LiteralDetector().priority
+        <Priority.P0: 'P0'>
+        """
         return Priority.P0
 
     @property
     @post(lambda result: len(result) > 0)
     def description(self) -> str:
-        """Human-readable description."""
+        """Human-readable description.
+
+        >>> len(LiteralDetector().description) > 0
+        True
+        """
         return "Use Literal type for finite value sets"
 
     @post(lambda result: all(isinstance(s, PatternSuggestion) for s in result))

invar/core/patterns/p0_newtype.py

@@ -50,19 +50,31 @@ class NewTypeDetector(BaseDetector):
     @property
     @post(lambda result: result == PatternID.NEWTYPE)
     def pattern_id(self) -> PatternID:
-        """Unique identifier for this pattern."""
+        """Unique identifier for this pattern.
+
+        >>> NewTypeDetector().pattern_id
+        <PatternID.NEWTYPE: 'newtype'>
+        """
         return PatternID.NEWTYPE
 
     @property
     @post(lambda result: result == Priority.P0)
     def priority(self) -> Priority:
-        """Priority tier."""
+        """Priority tier.
+
+        >>> NewTypeDetector().priority
+        <Priority.P0: 'P0'>
+        """
         return Priority.P0
 
     @property
     @post(lambda result: len(result) > 0)
     def description(self) -> str:
-        """Human-readable description."""
+        """Human-readable description.
+
+        >>> len(NewTypeDetector().description) > 0
+        True
+        """
         return "Use NewType for semantic clarity with multiple same-type parameters"
 
     @post(lambda result: all(isinstance(s, PatternSuggestion) for s in result))

invar/core/patterns/p0_nonempty.py

@@ -47,19 +47,31 @@ class NonEmptyDetector(BaseDetector):
     @property
     @post(lambda result: result == PatternID.NONEMPTY)
     def pattern_id(self) -> PatternID:
-        """Unique identifier for this pattern."""
+        """Unique identifier for this pattern.
+
+        >>> NonEmptyDetector().pattern_id
+        <PatternID.NONEMPTY: 'nonempty'>
+        """
         return PatternID.NONEMPTY
 
     @property
     @post(lambda result: result == Priority.P0)
     def priority(self) -> Priority:
-        """Priority tier."""
+        """Priority tier.
+
+        >>> NonEmptyDetector().priority
+        <Priority.P0: 'P0'>
+        """
         return Priority.P0
 
     @property
     @post(lambda result: len(result) > 0)
     def description(self) -> str:
-        """Human-readable description."""
+        """Human-readable description.
+
+        >>> len(NonEmptyDetector().description) > 0
+        True
+        """
         return "Use NonEmpty type for compile-time non-empty guarantees"
 
     @post(lambda result: all(isinstance(s, PatternSuggestion) for s in result))

invar/core/patterns/p0_validation.py

@@ -55,19 +55,31 @@ class ValidationDetector(BaseDetector):
     @property
     @post(lambda result: result == PatternID.VALIDATION)
     def pattern_id(self) -> PatternID:
-        """Unique identifier for this pattern."""
+        """Unique identifier for this pattern.
+
+        >>> ValidationDetector().pattern_id
+        <PatternID.VALIDATION: 'validation'>
+        """
         return PatternID.VALIDATION
 
     @property
     @post(lambda result: result == Priority.P0)
     def priority(self) -> Priority:
-        """Priority tier."""
+        """Priority tier.
+
+        >>> ValidationDetector().priority
+        <Priority.P0: 'P0'>
+        """
         return Priority.P0
 
     @property
     @post(lambda result: len(result) > 0)
     def description(self) -> str:
-        """Human-readable description."""
+        """Human-readable description.
+
+        >>> len(ValidationDetector().description) > 0
+        True
+        """
         return "Use error accumulation instead of fail-fast validation"
 
     @post(lambda result: all(isinstance(s, PatternSuggestion) for s in result))

invar/core/patterns/registry.py

@@ -53,7 +53,11 @@ class PatternRegistry:
     @property
     @post(lambda result: len(result) > 0)
     def detectors(self) -> list[PatternDetector]:
-        """Get all registered detectors."""
+        """Get all registered detectors.
+
+        >>> len(PatternRegistry().detectors) >= 5
+        True
+        """
         return self._detectors
 
     @post(lambda result: result is not None)

invar/core/patterns/types.py

@@ -149,7 +149,11 @@ class DetectionResult:
     @property
     @post(lambda result: isinstance(result, bool))
     def has_suggestions(self) -> bool:
-        """Check if any suggestions were found."""
+        """Check if any suggestions were found.
+
+        >>> DetectionResult(file="test.py", suggestions=[], patterns_checked=[]).has_suggestions
+        False
+        """
         return len(self.suggestions) > 0
 
     @pre(lambda self, min_confidence: min_confidence in Confidence)

invar/core/property_gen.py

@@ -368,6 +368,7 @@ def _skip_result(name: str, reason: str) -> PropertyTestResult:
 _SKIP_PATTERNS = (
     "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
 )
 
 
@@ -377,6 +378,9 @@ 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)")
     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)