rustest 0.1.0__cp311-cp311-macosx_11_0_arm64.whl → 0.5.0__cp311-cp311-macosx_11_0_arm64.whl

rustest/__init__.py

@@ -2,23 +2,27 @@
 
 from __future__ import annotations
 
-from . import _decorators
-from ._cli import main
-from ._reporting import RunReport, TestResult
+from . import decorators
+from .approx import approx
+from .cli import main
+from .reporting import RunReport, TestResult
 from .core import run
 
-fixture = _decorators.fixture
-mark = _decorators.mark
-parametrize = _decorators.parametrize
-skip = _decorators.skip
+fixture = decorators.fixture
+mark = decorators.mark
+parametrize = decorators.parametrize
+raises = decorators.raises
+skip = decorators.skip
 
 __all__ = [
     "RunReport",
     "TestResult",
+    "approx",
     "fixture",
     "main",
     "mark",
     "parametrize",
+    "raises",
     "run",
     "skip",
 ]

rustest/__main__.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import sys
 
-from ._cli import main
+from .cli import main
 
 if __name__ == "__main__":
     sys.exit(main())

rustest/approx.py

@@ -0,0 +1,160 @@
+"""Approximate comparison for floating-point numbers.
+
+This module provides the `approx` class for comparing floating-point numbers
+with a tolerance, similar to pytest.approx.
+"""
+
+from typing import Any, Mapping, Sequence, Union
+
+# Type alias for values that can be approximated
+ApproxValue = Union[float, int, complex, Sequence[Any], Mapping[str, Any]]
+
+
+class approx:
+    """Assert that two numbers (or collections of numbers) are equal to each other
+    within some tolerance.
+
+    This is similar to pytest.approx and is useful for comparing floating-point
+    numbers that may have small rounding errors.
+
+    Usage:
+        assert 0.1 + 0.2 == approx(0.3)
+        assert 0.1 + 0.2 == approx(0.3, rel=1e-6)
+        assert 0.1 + 0.2 == approx(0.3, abs=1e-9)
+        assert [0.1 + 0.2, 0.3] == approx([0.3, 0.3])
+        assert {"a": 0.1 + 0.2} == approx({"a": 0.3})
+
+    Args:
+        expected: The expected value to compare against
+        rel: The relative tolerance (default: 1e-6)
+        abs: The absolute tolerance (default: 1e-12)
+
+    By default, numbers are considered close if the difference between them is
+    less than or equal to:
+        abs(expected * rel) + abs_tolerance
+    """
+
+    def __init__(
+        self,
+        expected: ApproxValue,
+        rel: float = 1e-6,
+        abs: float = 1e-12,
+    ) -> None:
+        """Initialize approx with expected value and tolerances.
+
+        Args:
+            expected: The expected value to compare against
+            rel: The relative tolerance (default: 1e-6)
+            abs: The absolute tolerance (default: 1e-12)
+        """
+        super().__init__()
+        self.expected = expected
+        self.rel = rel
+        self.abs = abs
+
+    def __repr__(self) -> str:
+        """Return a string representation of the approx object."""
+        return f"approx({self.expected!r}, rel={self.rel}, abs={self.abs})"
+
+    def __eq__(self, actual: Any) -> bool:
+        """Compare actual value with expected value within tolerance.
+
+        Args:
+            actual: The actual value to compare
+
+        Returns:
+            True if the values are approximately equal, False otherwise
+        """
+        return self._approx_compare(actual, self.expected)
+
+    def _approx_compare(self, actual: Any, expected: Any) -> bool:
+        """Recursively compare actual and expected values.
+
+        Args:
+            actual: The actual value
+            expected: The expected value
+
+        Returns:
+            True if values are approximately equal, False otherwise
+        """
+        # Handle None
+        if actual is None or expected is None:
+            return actual == expected
+
+        # Handle dictionaries
+        if isinstance(expected, dict):
+            if not isinstance(actual, dict):
+                return False
+            if set(actual.keys()) != set(expected.keys()):
+                return False
+            return all(self._approx_compare(actual[k], expected[k]) for k in expected.keys())
+
+        # Handle sequences (lists, tuples, etc.) but not strings
+        if isinstance(expected, (list, tuple)) and not isinstance(expected, str):
+            # Check that actual is the same type (list vs tuple matters)
+            if type(actual) is not type(expected):
+                return False
+            if len(actual) != len(expected):
+                return False
+            return all(self._approx_compare(a, e) for a, e in zip(actual, expected))
+
+        # Handle numbers (float, int, complex)
+        if isinstance(expected, (float, int, complex)) and isinstance(
+            actual, (float, int, complex)
+        ):
+            return self._is_close(actual, expected)
+
+        # For other types, use exact equality
+        return actual == expected
+
+    def _is_close(
+        self, actual: Union[float, int, complex], expected: Union[float, int, complex]
+    ) -> bool:
+        """Check if two numbers are close within tolerance.
+
+        Uses the formula: |actual - expected| <= max(rel * max(|actual|, |expected|), abs)
+
+        Args:
+            actual: The actual number
+            expected: The expected number
+
+        Returns:
+            True if numbers are close, False otherwise
+        """
+        # Handle infinities and NaN
+        if isinstance(actual, complex) or isinstance(expected, complex):
+            # For complex numbers, compare real and imaginary parts separately
+            if isinstance(actual, complex) and isinstance(expected, complex):
+                return self._is_close(actual.real, expected.real) and self._is_close(
+                    actual.imag, expected.imag
+                )
+            # One is complex, the other is not
+            if isinstance(actual, complex):
+                return self._is_close(actual.real, expected) and abs(actual.imag) <= self.abs
+            else:  # expected is complex
+                return self._is_close(actual, expected.real) and abs(expected.imag) <= self.abs
+
+        # Convert to float for comparison
+        actual_float = float(actual)
+        expected_float = float(expected)
+
+        # Handle special float values
+        if actual_float == expected_float:
+            # This handles infinities and zeros
+            return True
+
+        # Check for NaN - NaN should never be equal to anything
+        import math
+
+        if math.isnan(actual_float) or math.isnan(expected_float):
+            return False
+
+        # Check for infinities
+        if math.isinf(actual_float) or math.isinf(expected_float):
+            return actual_float == expected_float
+
+        # Calculate tolerance
+        abs_diff = abs(actual_float - expected_float)
+        tolerance = max(self.rel * max(abs(actual_float), abs(expected_float)), self.abs)
+
+        return abs_diff <= tolerance

rustest/{_cli.py → cli.py}

@@ -5,7 +5,7 @@ from __future__ import annotations
 import argparse
 from collections.abc import Sequence
 
-from ._reporting import RunReport, TestResult
+from .reporting import RunReport, TestResult
 from .core import run
 
 
@@ -52,6 +52,12 @@ def build_parser() -> argparse.ArgumentParser:
         "--pattern",
         help="Substring to filter tests by (case insensitive).",
     )
+    _ = parser.add_argument(
+        "-m",
+        "--marks",
+        dest="mark_expr",
+        help='Run tests matching the given mark expression (e.g., "slow", "not slow", "slow and integration").',
+    )
     _ = parser.add_argument(
         "-n",
         "--workers",
@@ -81,7 +87,13 @@ def build_parser() -> argparse.ArgumentParser:
         action="store_false",
         help="Disable colored output.",
     )
-    _ = parser.set_defaults(capture_output=True, color=True)
+    _ = parser.add_argument(
+        "--no-codeblocks",
+        dest="enable_codeblocks",
+        action="store_false",
+        help="Disable code block tests from markdown files.",
+    )
+    _ = parser.set_defaults(capture_output=True, color=True, enable_codeblocks=True)
     return parser
 
 
@@ -94,10 +106,12 @@ def main(argv: Sequence[str] | None = None) -> int:
         Colors.disable()
 
     report = run(
-        paths=tuple(args.paths),
+        paths=list(args.paths),
         pattern=args.pattern,
+        mark_expr=args.mark_expr,
         workers=args.workers,
         capture_output=args.capture_output,
+        enable_codeblocks=args.enable_codeblocks,
     )
     _print_report(report, verbose=args.verbose, ascii_mode=args.ascii)
     return 0 if report.failed == 0 else 1

rustest/core.py

@@ -4,18 +4,35 @@ from __future__ import annotations
 
 from collections.abc import Sequence
 
-from . import _rust
-from ._reporting import RunReport
+from . import rust
+from .reporting import RunReport
 
 
 def run(
     *,
     paths: Sequence[str],
-    pattern: str | None,
-    workers: int | None,
-    capture_output: bool,
+    pattern: str | None = None,
+    mark_expr: str | None = None,
+    workers: int | None = None,
+    capture_output: bool = True,
+    enable_codeblocks: bool = True,
 ) -> RunReport:
-    """Execute tests and return a rich report."""
+    """Execute tests and return a rich report.
 
-    raw_report = _rust.run(list(paths), pattern, workers, capture_output)
+    Args:
+        paths: Files or directories to collect tests from
+        pattern: Substring to filter tests by (case insensitive)
+        mark_expr: Mark expression to filter tests (e.g., "slow", "not slow", "slow and integration")
+        workers: Number of worker slots to use (experimental)
+        capture_output: Whether to capture stdout/stderr during test execution
+        enable_codeblocks: Whether to enable code block tests from markdown files
+    """
+    raw_report = rust.run(
+        paths=list(paths),
+        pattern=pattern,
+        mark_expr=mark_expr,
+        workers=workers,
+        capture_output=capture_output,
+        enable_codeblocks=enable_codeblocks,
+    )
     return RunReport.from_py(raw_report)