pytest-fastcollect 0.5.1__cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

pytest_fastcollect/__init__.py

@@ -0,0 +1,12 @@
+"""pytest-fastcollect: High-performance test collection using Rust."""
+
+__version__ = "0.5.0"
+
+try:
+    from .pytest_fastcollect import FastCollector, get_version
+except ImportError:
+    # Fallback when the Rust extension is not built
+    FastCollector = None
+    get_version = lambda: __version__
+
+__all__ = ["FastCollector", "get_version", "__version__"]

pytest_fastcollect/cache.py

@@ -0,0 +1,171 @@
+"""Caching layer for pytest-fastcollect to enable incremental collection."""
+
+import json
+import os
+from pathlib import Path
+from typing import Dict, Any, Optional, Tuple, List
+from dataclasses import dataclass, asdict
+
+from .constants import CACHE_VERSION, MTIME_TOLERANCE_SECONDS
+
+
+@dataclass
+class CacheStats:
+    """Statistics about cache usage."""
+    cache_hits: int = 0
+    cache_misses: int = 0
+    files_parsed: int = 0
+    files_from_cache: int = 0
+
+    @property
+    def hit_rate(self) -> float:
+        """Calculate cache hit rate."""
+        total = self.cache_hits + self.cache_misses
+        return self.cache_hits / total if total > 0 else 0.0
+
+    def __str__(self) -> str:
+        return (f"FastCollect Cache: {self.files_from_cache} files from cache, "
+                f"{self.files_parsed} parsed ({self.hit_rate:.1%} hit rate)")
+
+
+class CollectionCache:
+    """Manages persistent cache of parsed test data with file modification times."""
+
+    def __init__(self, cache_dir: Path):
+        """
+        Initialize cache manager.
+
+        Args:
+            cache_dir: Directory to store cache (typically .pytest_cache/v/fastcollect)
+        """
+        self.cache_dir = cache_dir
+        self.cache_file = cache_dir / "cache.json"
+        self.cache_data: Dict[str, Dict[str, Any]] = {}
+        self.stats = CacheStats()
+        self._load_cache()
+
+    def _load_cache(self) -> None:
+        """Load cache from disk if it exists."""
+        if self.cache_file.exists():
+            try:
+                with open(self.cache_file, 'r') as f:
+                    data = json.load(f)
+
+                    # Check cache version
+                    if data.get('version') == CACHE_VERSION:
+                        self.cache_data = data.get('entries', {})
+                    else:
+                        # Cache version mismatch, start fresh
+                        self.cache_data = {}
+            except (json.JSONDecodeError, IOError):
+                # Corrupted cache, start fresh
+                self.cache_data = {}
+
+    def save_cache(self) -> None:
+        """Save cache to disk."""
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+        cache_structure = {
+            'version': CACHE_VERSION,
+            'entries': self.cache_data
+        }
+
+        try:
+            with open(self.cache_file, 'w') as f:
+                json.dump(cache_structure, f, indent=2)
+        except IOError:
+            # Silently fail if we can't write cache
+            pass
+
+    def get_cached_data(self, file_path: str, current_mtime: float) -> Optional[Dict[str, Any]]:
+        """
+        Get cached data for a file if it's still valid.
+
+        Args:
+            file_path: Absolute path to the file
+            current_mtime: Current modification time of the file
+
+        Returns:
+            Cached test data if valid, None otherwise
+        """
+        if file_path not in self.cache_data:
+            self.stats.cache_misses += 1
+            return None
+
+        cached_entry = self.cache_data[file_path]
+        cached_mtime = cached_entry.get('mtime', 0)
+
+        # Check if file has been modified
+        if abs(cached_mtime - current_mtime) < MTIME_TOLERANCE_SECONDS:  # Allow small floating point difference
+            self.stats.cache_hits += 1
+            self.stats.files_from_cache += 1
+            return cached_entry.get('items', [])
+        else:
+            self.stats.cache_misses += 1
+            return None
+
+    def update_cache(self, file_path: str, mtime: float, items: List[Any]) -> None:
+        """
+        Update cache with newly parsed data.
+
+        Args:
+            file_path: Absolute path to the file
+            mtime: Modification time of the file
+            items: List of test items found in the file
+        """
+        self.cache_data[file_path] = {
+            'mtime': mtime,
+            'items': items
+        }
+        self.stats.files_parsed += 1
+
+    def merge_with_rust_data(self, rust_metadata: Dict[str, Dict[str, Any]]) -> Tuple[Dict[str, List[Any]], bool]:
+        """
+        Merge Rust-collected metadata with cache.
+
+        Args:
+            rust_metadata: Dictionary from Rust collector with {file_path: {mtime: float, items: list}}
+
+        Returns:
+            Tuple of (merged data dict, cache_updated flag)
+        """
+        merged_data = {}
+        cache_updated = False
+
+        for file_path, metadata in rust_metadata.items():
+            current_mtime = metadata['mtime']
+            rust_items = metadata['items']
+
+            # Try to use cached data
+            cached_items = self.get_cached_data(file_path, current_mtime)
+
+            if cached_items is not None:
+                # Use cached data
+                merged_data[file_path] = cached_items
+            else:
+                # Use newly parsed data and update cache
+                merged_data[file_path] = rust_items
+                self.update_cache(file_path, current_mtime, rust_items)
+                cache_updated = True
+
+        # Remove deleted files from cache
+        current_files = set(rust_metadata.keys())
+        cached_files = set(self.cache_data.keys())
+        deleted_files = cached_files - current_files
+
+        if deleted_files:
+            for file_path in deleted_files:
+                del self.cache_data[file_path]
+            cache_updated = True
+
+        return merged_data, cache_updated
+
+    def clear(self) -> None:
+        """Clear the entire cache."""
+        self.cache_data = {}
+        self.stats = CacheStats()
+        if self.cache_file.exists():
+            try:
+                self.cache_file.unlink()
+            except IOError:
+                pass

pytest_fastcollect/constants.py

@@ -0,0 +1,89 @@
+"""Constants for pytest-fastcollect.
+
+This module centralizes magic numbers and configuration values to improve
+code maintainability and make it easier to tune performance.
+"""
+
+# === Daemon Configuration ===
+
+# Maximum size for incoming requests (10MB)
+MAX_REQUEST_SIZE_BYTES = 10 * 1024 * 1024
+
+# Maximum number of concurrent client connections
+MAX_CONCURRENT_CONNECTIONS = 10
+
+# Socket accept timeout in seconds
+SOCKET_ACCEPT_TIMEOUT_SECONDS = 1.0
+
+# Maximum time to process a single request
+REQUEST_TIMEOUT_SECONDS = 30.0
+
+# Interval for daemon health checks
+HEALTH_CHECK_INTERVAL_SECONDS = 60.0
+
+# Log file rotation settings
+LOG_FILE_MAX_BYTES = 10 * 1024 * 1024  # 10MB
+LOG_FILE_BACKUP_COUNT = 5
+
+# Brief pause to prevent tight loops in daemon
+DAEMON_LOOP_PAUSE_SECONDS = 0.1
+
+
+# === Client Configuration ===
+
+# Default number of retry attempts for failed requests
+DEFAULT_MAX_RETRIES = 3
+
+# Default timeout for client requests
+DEFAULT_REQUEST_TIMEOUT_SECONDS = 5.0
+
+# Timeout for health check requests
+HEALTH_CHECK_TIMEOUT_SECONDS = 1.0
+
+# Number of retries for health checks
+HEALTH_CHECK_RETRIES = 1
+
+# Timeout for stop command
+STOP_COMMAND_TIMEOUT_SECONDS = 2.0
+
+# Base sleep time for exponential backoff (in seconds)
+RETRY_BACKOFF_BASE_SECONDS = 0.1
+
+
+# === Process Management ===
+
+# Sleep time after sending stop command
+STOP_COMMAND_SLEEP_SECONDS = 0.5
+
+# Sleep time after SIGTERM before checking if process stopped
+SIGTERM_WAIT_SECONDS = 0.5
+
+# Sleep time after SIGKILL
+SIGKILL_WAIT_SECONDS = 0.2
+
+# Timeout for Windows tasklist command
+TASKLIST_TIMEOUT_SECONDS = 5
+
+
+# === Performance ===
+
+# Fallback CPU count if os.cpu_count() returns None
+DEFAULT_CPU_COUNT = 4
+
+# Benchmark timeout for standard pytest collection
+BENCHMARK_TIMEOUT_SECONDS = 120
+
+
+# === Cache Configuration ===
+
+# Cache version string
+CACHE_VERSION = "1.0"
+
+# Tolerance for file modification time comparison (in seconds)
+MTIME_TOLERANCE_SECONDS = 0.01
+
+
+# === Socket Path ===
+
+# MD5 hash length for socket path generation
+SOCKET_PATH_HASH_LENGTH = 8