pintest-cli 0.2.3__tar.gz → 0.2.6__tar.gz

{pintest_cli-0.2.3 → pintest_cli-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pintest-cli
-Version: 0.2.3
+Version: 0.2.6
 Summary: Run only the tests affected by your code changes.
 Author: Pintest Contributors
 Classifier: Development Status :: 3 - Alpha

{pintest_cli-0.2.3 → pintest_cli-0.2.6}/pintest/__init__.py

@@ -1,6 +1,6 @@
 """Pintest - Run only tests affected by code changes."""
 
-__version__ = "0.2.0"
+__version__ = "0.2.5"
 __author__ = "Pintest Contributors"
 __description__ = "Intelligently select and run only tests affected by code changes"
 

{pintest_cli-0.2.3 → pintest_cli-0.2.6}/pintest/build_mapping_iterative.py

@@ -28,8 +28,6 @@ from pintest.test_mapping_db_v2 import TestMappingDBV2
 from pintest.pre_commit_hook import (
     collect_all_tests,
     find_unmapped_tests,
-    ensure_docker_containers,
-    run_preflight_scripts
 )
 
 
@@ -54,7 +52,7 @@ def run_test_chunk_with_mapping(
     # Run chunk of tests with coverage
     cmd = [
         sys.executable, "-m", "pytest",
-        "--cov=src",
+        "--cov",
         "--cov-context=test",
         "--cov-append",
         "--cov-report=",
@@ -85,7 +83,9 @@ def run_test_chunk_with_mapping(
     
     # Find and use coverage data files
     coverage_file = repo_root / ".coverage"
-    coverage_chunks = list(repo_root.glob(".coverage.*"))
+    if not coverage_file.exists() and (repo_root / "coverage" / ".coverage").exists():
+        coverage_file = repo_root / "coverage" / ".coverage"
+    coverage_chunks = list(repo_root.glob(".coverage.*")) + list((repo_root / "coverage").glob(".coverage.*"))
     
     # Filter out empty files
     valid_chunks = []
@@ -171,16 +171,6 @@ def build_mapping_iteratively(
     print(f"Repository: {repo_root}")
     print(f"Mapping DB: {mapping_db}")
     
-    # Ensure Docker and preflight checks
-    print("\n🔧 Pre-checks...")
-    if not ensure_docker_containers(repo_root, verbose):
-        print("❌ Docker container check failed.")
-        return 1
-    
-    if not run_preflight_scripts(repo_root, verbose):
-        print("❌ Preflight checks failed.")
-        return 1
-    
     # Initialize mapping database
     with TestMappingDBV2(mapping_db) as db:
         db.initialize_schema()

{pintest_cli-0.2.3 → pintest_cli-0.2.6}/pintest/cli.py

@@ -70,7 +70,7 @@ class PintestRunner:
                 # CloudMappingDB or optimized interface
                 # Format changes for the API: [{"file": "path", "lines": [1, 2]}, ...]
                 formatted_changes = [
-                    {"file": path, "lines": change.get_all_changed_lines()}
+                    {"file": path, "lines": list(change.get_all_changed_lines())}
                     for path, change in python_changes.items()
                     if not change.is_new and change.get_all_changed_lines()
                 ]
@@ -138,7 +138,10 @@ class PintestRunner:
             return 0
         
         # Build pytest command
-        cmd = ["pytest"]
+        cmd = [sys.executable, "-m", "pytest"]
+        
+        # Automatically generate coverage for local updates (suppress terminal report)
+        cmd.extend(["--cov", "--cov-context=test", "--cov-append", "--cov-report="])
         
         if verbose:
             cmd.append("-v")
@@ -187,11 +190,28 @@ def cmd_run(args):
         if not mapping_db:
             mapping_db = repo_root / ".test_mapping.db"
             
-        if mapping_db.exists():
-            if args.verbose:
-                print(f"🖥️  Local mode: {mapping_db}", file=sys.stderr)
-            mapping_db_obj = TestMappingDBV2(mapping_db)
-            mapping_db_obj.connect()
+        if not mapping_db.exists():
+            print("🏗️  No local mapping DB found. Initializing build...", file=sys.stderr)
+            from .build_mapping_iterative import build_mapping_iteratively
+            
+            # Use test_dir from config or default "tests"
+            cfg_local = Config.load()
+            default_test_dir = "tests"
+            if getattr(cfg_local.cloud, "test_dir", None):
+                default_test_dir = cfg_local.cloud.test_dir
+                
+            exit_code = build_mapping_iteratively(
+                repo_root,
+                mapping_db,
+                test_dir=default_test_dir,
+                verbose=args.verbose
+            )
+            sys.exit(exit_code)
+            
+        if args.verbose:
+            print(f"🖥️  Local mode: {mapping_db}", file=sys.stderr)
+        mapping_db_obj = TestMappingDBV2(mapping_db)
+        mapping_db_obj.connect()
 
     # Initialize runner
     runner = PintestRunner(
@@ -201,9 +221,13 @@ def cmd_run(args):
     )
     
     try:
+        base_branch = args.base_branch
+        if base_branch == "master" and cfg.is_cloud_enabled and getattr(cfg.cloud, "branch", None):
+            base_branch = cfg.cloud.branch
+
         # Find affected tests
         affected_tests = runner.find_affected_tests(
-            args.base_branch
+            base_branch
         )
         
         # Unmapped tests discovery (Cloud mode only)
@@ -240,6 +264,13 @@ def cmd_run(args):
             verbose=args.verbose,
             pytest_args=pytest_extra_args
         )
+        
+        # Auto-update the local database with the new coverage
+        if not use_cloud and not args.dry_run:
+            print("\n🔄 Updating mapping database with new coverage...")
+            from .update_mapping import update_mapping
+            update_mapping(repo_root, mapping_db=mapping_db, verbose=args.verbose)
+            
         sys.exit(exit_code)
         
     except KeyboardInterrupt:
@@ -483,6 +514,8 @@ def cmd_push(args):
         sys.exit(1)
 
     coverage_file = repo_root / ".coverage"
+    if not coverage_file.exists() and (repo_root / "coverage" / ".coverage").exists():
+        coverage_file = repo_root / "coverage" / ".coverage"
     if not coverage_file.exists():
         print(f"❌ Coverage file not found at {coverage_file}")
         print("Run your tests first (e.g. 'pytest --cov --cov-context=test')")

{pintest_cli-0.2.3 → pintest_cli-0.2.6}/pintest/cloud_mapping_db.py

@@ -108,14 +108,14 @@ class CloudMappingDB:
             True on success, False on failure
         """
         from .coverage_mapper import CoverageMapper   # existing module
+        from .push_cache import PushCache
 
         if not coverage_file.exists():
             if verbose:
                 print(f"⚠️  No coverage file at {coverage_file} — skipping cloud push")
             return False
 
-        if verbose:
-            print("☁️  Parsing coverage data for cloud upload...", flush=True)
+        print("☁️  Parsing coverage data for cloud upload...", flush=True)
 
         mapper = CoverageMapper(coverage_file)
         try:
@@ -138,47 +138,93 @@ class CloudMappingDB:
                         test_file_ranges[key] = RangeSet()
                     test_file_ranges[key].add_range(line_num, line_num)
 
+        cache_db_path = coverage_file.parent / ".pintest_push_cache.db"
+        push_cache = PushCache(cache_db_path)
+        cached_state = push_cache.get_cached_state(self._branch)
+
         mappings = []
         for (test_name, file_path), rs in test_file_ranges.items():
-            mappings.append({
-                "test_name": test_name,
-                "file_path": file_path,
-                "ranges": rs.to_compact_string(),
-            })
+            compact_ranges = rs.to_compact_string()
+            key = (test_name, file_path)
+            if key not in cached_state or cached_state[key] != compact_ranges:
+                mappings.append({
+                    "test_name": test_name,
+                    "file_path": file_path,
+                    "ranges": compact_ranges,
+                })
 
         if not mappings:
-            if verbose:
-                print("ℹ️  No coverage mappings to push")
+            print("ℹ️  All coverage mappings are up-to-date with Pintest Cloud (0 deltas)")
             return True
 
-        if verbose:
-            print(f"☁️  Pushing {len(mappings)} mappings to Pintest...", flush=True)
+        print(f"☁️  Pushing {len(mappings)} delta mappings to Pintest...", flush=True)
 
-        payload = {
+        payload_base = {
             "branch": self._branch,
-            "mappings": mappings,
         }
         if run_stats:
-            payload["run_stats"] = run_stats
+            payload_base["run_stats"] = run_stats
 
-        try:
+        from concurrent.futures import ThreadPoolExecutor, as_completed
+
+        # Send in chunks of 1,000 parallelized in 10 threads
+        CHUNK_SIZE = 1000
+        success = True
+        total_inserted = 0
+        total_updated = 0
+        total_tests_cloud = 0
+
+        chunks = [mappings[i:i + CHUNK_SIZE] for i in range(0, len(mappings), CHUNK_SIZE)]
+        total_chunks = len(chunks)
+
+        def push_chunk(chunk_num, chunk_data):
+            print(f"☁️  Pushing chunk {chunk_num}/{total_chunks} ({len(chunk_data)} mappings)...", flush=True)
+            payload = payload_base.copy()
+            payload["mappings"] = chunk_data
             resp = self.session.post(
                 f"{self._api}/api/v1/repos/{self._repo_id}/coverage",
                 json=payload,
                 timeout=60,
             )
             resp.raise_for_status()
+            push_cache.batch_upsert(self._branch, chunk_data)
             data = resp.json()
-            if verbose:
-                print(
-                    f"☁️  Cloud sync: {data['inserted']} new, "
-                    f"{data['updated']} updated, "
-                    f"{data['total_tests']} total tests"
-                )
-            return True
-        except requests.RequestException as e:
-            print(f"⚠️  Cloud push failed: {e}", file=sys.stderr)
-            return False
+            inserted = data.get('inserted', 0)
+            updated = data.get('updated', 0)
+            t_tests = data.get('total_tests', 0)
+            print(f"   ✓ Chunk {chunk_num}/{total_chunks} complete ({inserted} new, {updated} updated)", flush=True)
+            return inserted, updated, t_tests
+
+        with ThreadPoolExecutor(max_workers=10) as executor:
+            futures = {executor.submit(push_chunk, idx + 1, chunk): idx + 1 for idx, chunk in enumerate(chunks)}
+            for future in as_completed(futures):
+                chunk_num = futures[future]
+                try:
+                    inserted, updated, t_tests = future.result()
+                    total_inserted += inserted
+                    total_updated += updated
+                    if t_tests > total_tests_cloud:
+                        total_tests_cloud = t_tests
+                except requests.RequestException as e:
+                    print(f"⚠️  Cloud push failed on chunk {chunk_num}: {e}", file=sys.stderr)
+                    success = False
+                    for f in futures:
+                        f.cancel()
+                except Exception as e:
+                    if success:
+                        print(f"⚠️  Cloud push failed on chunk {chunk_num}: {e}", file=sys.stderr)
+                        success = False
+                        for f in futures:
+                            f.cancel()
+                
+        if success:
+            print(
+                f"☁️  Cloud sync complete: {total_inserted} new, "
+                f"{total_updated} updated, "
+                f"{total_tests_cloud} total tests",
+                flush=True
+            )
+        return success
 
     def get_all_test_names(self) -> Set[str]:
         """Fetch all unique test names from the cloud."""

{pintest_cli-0.2.3 → pintest_cli-0.2.6}/pintest/git_diff_parser.py

@@ -62,7 +62,13 @@ class GitDiffParser:
                 # For pre-commit hooks, we usually want staged changes
                 cmd = ["git", "diff", "--cached", "--unified=0", "HEAD"]
             else:
-                cmd = ["git", "diff", "--unified=0", f"{base_branch}...HEAD"]
+                # Find merge base to handle branches properly
+                mb_cmd = ["git", "merge-base", base_branch, "HEAD"]
+                mb_result = subprocess.run(mb_cmd, cwd=self.repo_root, capture_output=True, text=True, check=True)
+                merge_base = mb_result.stdout.strip()
+                
+                # Diff from merge base to working tree (includes uncommitted changes)
+                cmd = ["git", "diff", "--unified=0", merge_base]
                 
             result = subprocess.run(
                 cmd,

{pintest_cli-0.2.3 → pintest_cli-0.2.6}/pintest/pre_commit_hook.py

@@ -115,140 +115,6 @@ def ensure_git_lfs(repo_root: Path, verbose: bool = False) -> bool:
         return True  # Not critical - continue anyway
 
 
-def ensure_docker_containers(repo_root: Path, verbose: bool = False) -> bool:
-    """
-    Ensure Docker containers are running from a docker-compose-ut.yml or docker-compose.yml file.
-    
-    Searches for a compose file in common locations under the repo root.
-    
-    Args:
-        repo_root: Repository root directory
-        verbose: Print verbose output
-        
-    Returns:
-        True if containers are running (or no compose file found), False on failure
-    """
-    # Search for a docker-compose file in common locations
-    candidates = [
-        repo_root / "docker-compose-ut.yml",
-        repo_root / "docker-compose.yml",
-    ] + list(repo_root.rglob("docker-compose-ut.yml"))
-    
-    docker_compose_path = next((p for p in candidates if p.exists()), None)
-    
-    if docker_compose_path is None:
-        if verbose:
-            print("ℹ️  No docker-compose file found, skipping Docker check")
-        return True  # No compose file in this repo, skip Docker check
-    
-    if verbose:
-        print("🐳 Checking Docker containers...", flush=True)
-    
-    try:
-        # Check if containers are running
-        # Note: In Docker Compose v5.x, ps -q may return exit code 1 when no containers exist
-        result = subprocess.run(
-            ["docker-compose", "-f", str(docker_compose_path), "ps", "-q"],
-            capture_output=True,
-            text=True,
-            check=False  # Don't raise on non-zero exit (containers may not exist yet)
-        )
-        
-        # If ps command failed or no containers running, start them
-        if result.returncode != 0 or not result.stdout.strip():
-            # No containers running or project doesn't exist yet, start them
-            if verbose:
-                print("   Starting Docker containers...")
-            start_result = subprocess.run(
-                ["docker-compose", "-f", str(docker_compose_path), "up", "-d"],
-                capture_output=not verbose,
-                text=True,
-                check=False
-            )
-            
-            if start_result.returncode != 0:
-                print(f"❌ Failed to start Docker containers (exit code {start_result.returncode})", file=sys.stderr)
-                if start_result.stderr:
-                    print(start_result.stderr, file=sys.stderr)
-                return False
-                
-            if verbose:
-                print("   ✓ Docker containers started")
-        else:
-            if verbose:
-                print("   ✓ Docker containers already running")
-        
-        return True
-        
-    except FileNotFoundError:
-        print("❌ docker-compose not found. Install it: https://docs.docker.com/compose/install/", file=sys.stderr)
-        return False
-
-
-def run_preflight_scripts(repo_root: Path, verbose: bool = False) -> bool:
-    """
-    Run preflight scripts for Neo4j and Postgres.
-    
-    Args:
-        repo_root: Repository root directory
-        verbose: Print verbose output
-        
-    Returns:
-        True if all preflight scripts passed, False otherwise
-    """
-    script_names = [
-        "preflight-postgres.sh",
-        "preflight-neo4j.sh"
-    ]
-    
-    if verbose:
-        print("🔧 Running preflight checks...", flush=True)
-    
-    for script_name in script_names:
-        # Try multiple possible locations for the script
-        possible_locations = [
-            repo_root / "scripts" / script_name,      # Workspace root scripts
-            Path.cwd() / "scripts" / script_name,     # Current directory scripts
-        ]
-        
-        script = None
-        for location in possible_locations:
-            if location.exists():
-                script = location
-                break
-        
-        if script is None:
-            if verbose:
-                print(f"   ⚠️  Preflight script not found: {script_name} (tried {len(possible_locations)} locations)")
-            continue
-        
-        try:
-            if verbose:
-                print(f"   Running {script.name}...", flush=True)
-            
-            result = subprocess.run(
-                [str(script)],
-                cwd=repo_root,
-                capture_output=not verbose,
-                text=True,
-                check=True
-            )
-            
-            if verbose:
-                print(f"   ✓ {script.name} passed")
-                
-        except subprocess.CalledProcessError as e:
-            print(f"❌ Preflight check failed: {script.name}", file=sys.stderr)
-            if not verbose and e.stderr:
-                print(e.stderr, file=sys.stderr)
-            return False
-    
-    if verbose:
-        print("   ✓ All preflight checks passed")
-    
-    return True
-
-
 def should_exclude_test(test_name: str) -> bool:
     """
     Check if a test should be excluded from runs and mapping.
@@ -560,7 +426,7 @@ def run_test_chunk_with_mapping_update(
     # Run tests with coverage - output flows directly to terminal
     cmd = [
         sys.executable, "-m", "pytest",
-        "--cov=src",
+        "--cov",
         "--cov-context=test",
         "--cov-append",
         "--cov-report=",
@@ -591,6 +457,8 @@ def run_test_chunk_with_mapping_update(
     
     try:
         coverage_file = repo_root / ".coverage"
+        if not coverage_file.exists() and (repo_root / "coverage" / ".coverage").exists():
+            coverage_file = repo_root / "coverage" / ".coverage"
         if not coverage_file.exists():
             print(f"    ⚠️  No coverage file found at {coverage_file}", flush=True)
             print(f"    Tests may have crashed before generating coverage data.", flush=True)
@@ -690,7 +558,7 @@ def run_single_test_with_mapping_update(
     # Run single test with coverage
     cmd = [
         "python", "-m", "pytest",
-        "--cov=src",
+        "--cov",
         "--cov-context=test",
         "--cov-append",
         "--cov-report=",
@@ -713,6 +581,8 @@ def run_single_test_with_mapping_update(
     # Update mapping database with new coverage
     try:
         coverage_file = repo_root / ".coverage"
+        if not coverage_file.exists() and (repo_root / "coverage" / ".coverage").exists():
+            coverage_file = repo_root / "coverage" / ".coverage"
         if coverage_file.exists():
             with TestMappingDBV2(mapping_db_path) as db:
                 db.import_from_coverage(coverage_file, incremental=True)
@@ -925,6 +795,8 @@ def combine_coverage_files(repo_root: Path, new_coverage: Path):
         new_coverage: Path to new coverage file from test run
     """
     existing_coverage = repo_root / ".coverage"
+    if not existing_coverage.exists() and (repo_root / "coverage" / ".coverage").exists():
+        existing_coverage = repo_root / "coverage" / ".coverage"
     
     if not new_coverage.exists():
         print(f"Warning: New coverage file not found: {new_coverage}", file=sys.stderr)

pintest_cli-0.2.6/pintest/push_cache.py

@@ -0,0 +1,61 @@
+import sqlite3
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+
+class PushCache:
+    """
+    Manages the local SQLite cache for Pintest Cloud delta pushes.
+    Tracks previously synchronized test coverage mappings to filter out unmodified entries.
+    """
+
+    def __init__(self, db_path: Path):
+        self.db_path = db_path
+        self._init_db()
+
+    def _init_db(self):
+        """Initialize the local push cache database schema."""
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute("PRAGMA journal_mode=WAL")
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS push_cache (
+                    branch TEXT,
+                    test_name TEXT,
+                    file_path TEXT,
+                    ranges TEXT,
+                    last_pushed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    PRIMARY KEY (branch, test_name, file_path)
+                )
+            """)
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_push_cache_lookup ON push_cache(branch)")
+
+    def get_cached_state(self, branch: str) -> Dict[Tuple[str, str], str]:
+        """
+        Fetch the last successfully pushed state for the active branch.
+
+        Returns:
+            {(test_name, file_path): ranges_string}
+        """
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute(
+                "SELECT test_name, file_path, ranges FROM push_cache WHERE branch = ?",
+                (branch,)
+            )
+            return {(row[0], row[1]): row[2] for row in cursor}
+
+    def batch_upsert(self, branch: str, mappings: List[Dict[str, str]]):
+        """
+        Atomically update the cache with successfully pushed mappings.
+
+        Args:
+            branch: Active git branch
+            mappings: List of dicts [{"test_name": ..., "file_path": ..., "ranges": ...}]
+        """
+        with sqlite3.connect(self.db_path) as conn:
+            conn.executemany("""
+                INSERT INTO push_cache (branch, test_name, file_path, ranges, last_pushed_at)
+                VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP)
+                ON CONFLICT(branch, test_name, file_path) DO UPDATE SET
+                    ranges = EXCLUDED.ranges,
+                    last_pushed_at = CURRENT_TIMESTAMP
+            """, [(branch, m["test_name"], m["file_path"], m["ranges"]) for m in mappings])

{pintest_cli-0.2.3 → pintest_cli-0.2.6}/pintest/update_mapping.py

@@ -15,7 +15,7 @@ SCRIPT_DIR = Path(__file__).parent
 sys.path.insert(0, str(SCRIPT_DIR))
 
 from pintest.test_mapping_db_v2 import TestMappingDBV2
-from pintest.pre_commit_hook import ensure_docker_containers, run_preflight_scripts
+# from pintest.pre_commit_hook import ensure_docker_containers, run_preflight_scripts
 
 
 def update_mapping(
@@ -38,21 +38,14 @@ def update_mapping(
     # Default paths
     if coverage_file is None:
         coverage_file = repo_root / ".coverage"
+        if not coverage_file.exists() and (repo_root / "coverage" / ".coverage").exists():
+            coverage_file = repo_root / "coverage" / ".coverage"
     
     if mapping_db is None:
         mapping_db = repo_root / ".test_mapping.db"
     
-    # Ensure Docker containers are running (if a compose file is present)
     if verbose:
-        print("\n🔧 Pre-checks...")
-    
-    if not ensure_docker_containers(repo_root, verbose):
-        print("❌ Docker container check failed.", file=sys.stderr)
-        return 1
-    
-    if not run_preflight_scripts(repo_root, verbose):
-        print("❌ Preflight checks failed.", file=sys.stderr)
-        return 1
+        pass
     
     if not coverage_file.exists():
         print(f"❌ Error: Coverage file not found: {coverage_file}", file=sys.stderr)

{pintest_cli-0.2.3 → pintest_cli-0.2.6}/pintest_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pintest-cli
-Version: 0.2.3
+Version: 0.2.6
 Summary: Run only the tests affected by your code changes.
 Author: Pintest Contributors
 Classifier: Development Status :: 3 - Alpha

{pintest_cli-0.2.3 → pintest_cli-0.2.6}/pintest_cli.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ pintest/coverage_mapper.py
 pintest/git_diff_parser.py
 pintest/post_commit_hook.py
 pintest/pre_commit_hook.py
+pintest/push_cache.py
 pintest/range_set.py
 pintest/test_mapping_db_v2.py
 pintest/update_mapping.py

{pintest_cli-0.2.3 → pintest_cli-0.2.6}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="pintest-cli",
-    version="0.2.3",
+    version="0.2.6",
     description="Run only the tests affected by your code changes.",
     long_description=long_description,
     long_description_content_type="text/markdown",