rpytest 0.1.2__py3-none-any.whl

rpytest-0.1.2.dist-info/METADATA

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: rpytest
+Version: 0.1.2
+Summary: Rust-powered, drop-in replacement for pytest
+Author: rpytest contributors
+License: MIT
+Project-URL: Homepage, https://github.com/neul-labs/rpytest
+Project-URL: Repository, https://github.com/neul-labs/rpytest
+Project-URL: Issues, https://github.com/neul-labs/rpytest/issues
+Keywords: pytest,testing,rust,performance
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: pytest>=7.0
+Requires-Dist: msgpack>=1.0
+Provides-Extra: dev
+Requires-Dist: pytest-xdist; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+
+# rpytest
+
+> **Run your pytest suite faster. Change nothing.**
+>
+> A Rust-powered, drop-in replacement for pytest that eliminates startup overhead while keeping your tests, fixtures, and plugins untouched.
+
+[![PyPI Version](https://img.shields.io/pypi/v/rpytest.svg)](https://pypi.org/project/rpytest/)
+[![License](https://img.shields.io/pypi/l/rpytest.svg)](https://github.com/neul-labs/rpytest/blob/main/LICENSE)
+[![Python Versions](https://img.shields.io/pypi/pyversions/rpytest.svg)](https://pypi.org/project/rpytest/)
+
+## Why rpytest?
+
+```
+pytest  ->  2.91s  (480 tests)
+rpytest ->  1.55s  (same 480 tests)
+        =  1.9x faster
+```
+
+rpytest uses a persistent Rust daemon to keep Python warm between runs. No more interpreter startup costs on every invocation.
+
+## Installation
+
+```bash
+pip install rpytest
+```
+
+That's it. The correct native binary for your platform (macOS or Linux, Intel or Apple Silicon) is bundled automatically.
+
+## Usage
+
+rpytest mirrors pytest's CLI exactly. If you know pytest, you know rpytest.
+
+```bash
+# Run all tests
+rpytest
+
+# Run specific tests
+rpytest tests/test_api.py::test_login
+
+# Filter by keyword or marker
+rpytest -k "auth" -m "not slow"
+
+# Parallel execution — no pytest-xdist needed
+rpytest -n auto
+
+# Watch mode for TDD
+rpytest --watch
+```
+
+## Key Features
+
+| Feature | pytest | rpytest |
+|---------|--------|---------|
+| Startup time | ~200ms | <10ms |
+| Memory usage | 35.8 MB | 6.2 MB |
+| Parallel workers | pytest-xdist plugin | Built-in `-n` flag |
+| Watch mode | pytest-watch plugin | Built-in `--watch` |
+| Flakiness detection | flaky plugin | Built-in `--reruns` |
+| Sharding | pytest-shard plugin | Built-in `--shard` |
+
+- **Full pytest compatibility** — plugins, fixtures, conftest.py, pytest.ini all work unchanged
+- **Built-in parallelism** — `rpytest -n 4` or `rpytest -n auto`
+- **Watch mode** — file changes trigger automatic re-runs of affected tests
+- **Flakiness detection** — `rpytest --reruns 3` auto-retries failed tests
+- **Session fixture reuse** — `rpytest --reuse-fixtures` persists expensive fixtures
+- **CI sharding** — `rpytest --shard 0 --total-shards 4`
+
+## Requirements
+
+- Python 3.9+
+- pytest 7.0+
+- macOS or Linux
+
+## How It Works
+
+1. **First run**: Spawns a background daemon that collects your test suite
+2. **Subsequent runs**: Rust CLI filters tests and dispatches to warm Python workers
+3. **Results stream back** in real-time
+
+The daemon persists between runs, so TDD loops and CI retries skip all startup work.
+
+## Documentation
+
+Full docs at [docs.neullabs.com/rpytest](https://docs.neullabs.com/rpytest)
+
+## License
+
+MIT

rpytest-0.1.2.dist-info/RECORD

@@ -0,0 +1,8 @@
+rpytest_cli/__init__.py,sha256=ZsczRmh9lKetjgHObawd8ehAziZS_uSMXONd3D85lTc,2644
+rpytest_cli/download.py,sha256=Ic4arsIMVTvTzEcjQD_KnW6PmIh8Hx0kUKkGf74SK48,4706
+rpytest_cli/plugin.py,sha256=0c41ZHX-DICEfam_OM43tF-PRhE76MP5mSejgDhN_fc,1416
+rpytest-0.1.2.dist-info/METADATA,sha256=P2n9itmiczO3LeQeNIgXXZaKrT4qbx5C4Ahd1lIT88E,3861
+rpytest-0.1.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+rpytest-0.1.2.dist-info/entry_points.txt,sha256=Yj4eWrTzPzrY3grPMC1P946qjXkDu9E8sOKmGtYnS70,86
+rpytest-0.1.2.dist-info/top_level.txt,sha256=napzyGUjTnHBVNcwXz0bXwd3_CaY_-td7G6-4g2H_-A,12
+rpytest-0.1.2.dist-info/RECORD,,

rpytest-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

rpytest-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+rpytest = rpytest_cli:main
+
+[pytest11]
+rpytest = rpytest_cli.plugin

rpytest-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+rpytest_cli

rpytest_cli/__init__.py

@@ -0,0 +1,96 @@
+"""rpytest - Rust-powered, drop-in replacement for pytest.
+
+This package provides the rpytest CLI tool and pytest plugin.
+"""
+
+__version__ = "0.1.2"
+
+import os
+import platform
+import subprocess
+import sys
+from pathlib import Path
+
+
+def get_binary_path() -> Path:
+    """Get the path to the rpytest binary."""
+    # Check if we're in development mode (source checkout)
+    pkg_dir = Path(__file__).parent
+
+    # Try package-bundled binary first
+    bin_dir = pkg_dir / "bin"
+    if bin_dir.exists():
+        system = platform.system().lower()
+        machine = platform.machine().lower()
+
+        # Normalize architecture names
+        if machine in ("x86_64", "amd64"):
+            machine = "x86_64"
+        elif machine in ("arm64", "aarch64"):
+            machine = "aarch64"
+
+        if system == "darwin":
+            binary_name = f"rpytest-{machine}-apple-darwin"
+        elif system == "linux":
+            binary_name = f"rpytest-{machine}-unknown-linux-gnu"
+        else:
+            binary_name = "rpytest"
+
+        binary_path = bin_dir / binary_name
+        if binary_path.exists():
+            return binary_path
+
+    # Try system PATH
+    try:
+        result = subprocess.run(
+            ["which", "rpytest"],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return Path(result.stdout.strip())
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        pass
+
+    # Try cargo target directory (development)
+    workspace_root = pkg_dir.parent.parent
+    for build_type in ("release", "debug"):
+        target_binary = workspace_root / "target" / build_type / "rpytest"
+        if target_binary.exists():
+            return target_binary
+
+    raise RuntimeError(
+        "rpytest binary not found. Please install via:\n"
+        "  cargo install --path crates/rpytest\n"
+        "or download prebuilt binaries from releases."
+    )
+
+
+def main():
+    """Main entry point for rpytest CLI."""
+    try:
+        binary_path = get_binary_path()
+    except RuntimeError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    # Make sure the binary is executable
+    if not os.access(binary_path, os.X_OK):
+        os.chmod(binary_path, 0o755)
+
+    # Execute the Rust binary with all arguments
+    try:
+        result = subprocess.run(
+            [str(binary_path)] + sys.argv[1:],
+            check=False
+        )
+        sys.exit(result.returncode)
+    except KeyboardInterrupt:
+        sys.exit(130)
+    except Exception as e:
+        print(f"Error executing rpytest: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

rpytest_cli/download.py

@@ -0,0 +1,155 @@
+"""Download prebuilt rpytest binaries."""
+
+import hashlib
+import os
+import platform
+import sys
+import tarfile
+import tempfile
+import urllib.request
+from pathlib import Path
+
+# GitHub release URL pattern
+RELEASE_URL = "https://github.com/neul-labs/rpytest/releases/download"
+VERSION = "0.1.2"
+
+
+def get_platform_target() -> str:
+    """Get the target triple for the current platform."""
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+
+    # Normalize architecture
+    if machine in ("x86_64", "amd64"):
+        arch = "x86_64"
+    elif machine in ("arm64", "aarch64"):
+        arch = "aarch64"
+    elif machine in ("i686", "i386"):
+        arch = "i686"
+    else:
+        raise RuntimeError(f"Unsupported architecture: {machine}")
+
+    # Build target triple
+    if system == "darwin":
+        return f"{arch}-apple-darwin"
+    elif system == "linux":
+        # Check for musl vs glibc
+        try:
+            import subprocess
+            result = subprocess.run(["ldd", "--version"], capture_output=True, text=True)
+            if "musl" in result.stderr.lower() or "musl" in result.stdout.lower():
+                return f"{arch}-unknown-linux-musl"
+        except Exception:
+            pass
+        return f"{arch}-unknown-linux-gnu"
+    elif system == "windows":
+        return f"{arch}-pc-windows-msvc"
+    else:
+        raise RuntimeError(f"Unsupported platform: {system}")
+
+
+def download_binary(target: str | None = None, output_dir: Path | None = None) -> Path:
+    """Download the rpytest binary for the given target.
+
+    Args:
+        target: Target triple (e.g., "x86_64-unknown-linux-gnu").
+                If None, auto-detect the current platform.
+        output_dir: Directory to place the binary. If None, uses the package bin/ directory.
+
+    Returns:
+        Path to the downloaded binary.
+    """
+    if target is None:
+        target = get_platform_target()
+
+    if output_dir is None:
+        output_dir = Path(__file__).parent / "bin"
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Construct download URL
+    archive_name = f"rpytest-{VERSION}-{target}.tar.gz"
+    url = f"{RELEASE_URL}/v{VERSION}/{archive_name}"
+
+    print(f"Downloading rpytest {VERSION} for {target}...")
+    print(f"URL: {url}")
+
+    try:
+        # Download to temp file
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".tar.gz") as tmp:
+            tmp_path = tmp.name
+            urllib.request.urlretrieve(url, tmp_path)
+
+        # Extract binary
+        with tarfile.open(tmp_path, "r:gz") as tar:
+            # Find the binary in the archive
+            for member in tar.getmembers():
+                if member.name.endswith("rpytest") or member.name == "rpytest":
+                    # Extract to output directory
+                    member.name = f"rpytest-{target}"
+                    tar.extract(member, output_dir)
+                    binary_path = output_dir / f"rpytest-{target}"
+                    os.chmod(binary_path, 0o755)
+                    print(f"Installed: {binary_path}")
+                    return binary_path
+
+        raise RuntimeError("Binary not found in archive")
+
+    except urllib.error.HTTPError as e:
+        if e.code == 404:
+            raise RuntimeError(
+                f"No prebuilt binary available for {target}.\n"
+                f"Please build from source: cargo build --release"
+            )
+        raise
+
+    finally:
+        # Clean up temp file
+        if 'tmp_path' in locals():
+            try:
+                os.unlink(tmp_path)
+            except OSError:
+                pass
+
+
+def main():
+    """CLI entry point for downloading binaries."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Download rpytest binary")
+    parser.add_argument(
+        "--target",
+        help="Target triple (auto-detected if not specified)"
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        help="Output directory for the binary"
+    )
+    parser.add_argument(
+        "--list-targets",
+        action="store_true",
+        help="List available targets"
+    )
+
+    args = parser.parse_args()
+
+    if args.list_targets:
+        print("Available targets:")
+        print("  x86_64-unknown-linux-gnu")
+        print("  x86_64-unknown-linux-musl")
+        print("  aarch64-unknown-linux-gnu")
+        print("  x86_64-apple-darwin")
+        print("  aarch64-apple-darwin")
+        return
+
+    try:
+        binary_path = download_binary(args.target, args.output_dir)
+        print(f"\nSuccess! Binary installed at: {binary_path}")
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

rpytest_cli/plugin.py

@@ -0,0 +1,44 @@
+"""pytest plugin for rpytest integration.
+
+This plugin allows pytest to communicate with the rpytest daemon
+for enhanced performance and caching.
+"""
+
+import os
+import pytest
+
+
+def pytest_configure(config):
+    """Configure pytest to use rpytest if available."""
+    # Register custom markers
+    config.addinivalue_line(
+        "markers", "rpytest_skip: Skip this test when running under rpytest"
+    )
+    config.addinivalue_line(
+        "markers", "rpytest_only: Only run this test when running under rpytest"
+    )
+
+
+def pytest_collection_modifyitems(config, items):
+    """Modify collected items based on rpytest markers."""
+    running_under_rpytest = os.environ.get("RPYTEST") == "1"
+
+    skip_rpytest = pytest.mark.skip(reason="Skipped when running under rpytest")
+    skip_pytest = pytest.mark.skip(reason="Only runs under rpytest")
+
+    for item in items:
+        if running_under_rpytest:
+            # Skip tests marked with rpytest_skip
+            if "rpytest_skip" in item.keywords:
+                item.add_marker(skip_rpytest)
+        else:
+            # Skip tests marked with rpytest_only when not using rpytest
+            if "rpytest_only" in item.keywords:
+                item.add_marker(skip_pytest)
+
+
+def pytest_report_header(config):
+    """Add rpytest info to the pytest header."""
+    if os.environ.get("RPYTEST") == "1":
+        return ["rpytest: enabled (daemon mode)"]
+    return []