pytest-delta 0.1.0__tar.gz

pytest_delta-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 CemAlpturk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pytest_delta-0.1.0/PKG-INFO

@@ -0,0 +1,241 @@
+Metadata-Version: 2.3
+Name: pytest-delta
+Version: 0.1.0
+Summary: Run only tests impacted by your code changes (delta-based selection) for pytest.
+License: MIT
+Keywords: pytest,plugin,selective,impact,test,ci,graph
+Author: Cem Alptürk
+Author-email: cem.alpturk@gmail.com
+Requires-Python: >=3.12
+Classifier: Framework :: Pytest
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: gitpython (>=3.1.0)
+Requires-Dist: pytest (>=7.0)
+Project-URL: Homepage, https://github.com/CemAlpturk/pytest-delta
+Project-URL: Repository, https://github.com/CemAlpturk/pytest-delta
+Description-Content-Type: text/markdown
+
+# pytest-delta
+
+Run only tests impacted by your code changes (delta-based selection) for pytest.
+
+## Overview
+
+pytest-delta is a pytest plugin that reduces test execution time by running only the tests that are potentially affected by your code changes. It creates a directional dependency graph based on Python imports and selects tests intelligently based on what files have changed since the last successful test run.
+
+## Features
+
+- **Smart Test Selection**: Only runs tests affected by changed files
+- **Dependency Tracking**: Creates a dependency graph based on Python imports
+- **Git Integration**: Compares against the last successful test run commit
+- **Uncommitted Changes Support**: Includes both staged and unstaged changes
+- **Force Regeneration**: Option to force running all tests and regenerate metadata
+- **File-based Mapping**: Assumes test files follow standard naming conventions
+
+## Installation
+
+```bash
+pip install pytest-delta
+```
+
+Or for development:
+
+```bash
+git clone https://github.com/CemAlpturk/pytest-delta
+cd pytest-delta
+pip install -e .
+```
+
+## Usage
+
+### Basic Usage
+
+Run tests with delta selection:
+
+```bash
+pytest --delta
+```
+
+On first run, it will execute all tests and create a `.delta.json` file with metadata.
+
+### Command Line Options
+
+- `--delta`: Enable delta-based test selection
+- `--delta-filename NAME`: Specify filename for delta metadata file (default: `.delta`, `.json` extension added automatically)
+- `--delta-dir PATH`: Specify directory for delta metadata file (default: current directory)
+- `--delta-force`: Force regeneration of delta file and run all tests
+- `--delta-ignore PATTERN`: Ignore file patterns during dependency analysis (can be used multiple times)
+
+### Examples
+
+```bash
+# Run only affected tests
+pytest --delta
+
+# Force run all tests and regenerate metadata
+pytest --delta --delta-force
+
+# Use custom delta filename (will become custom-delta.json)
+pytest --delta --delta-filename custom-delta
+
+# Use custom directory for delta file
+pytest --delta --delta-dir .metadata
+
+# Combine custom filename and directory
+pytest --delta --delta-filename my-tests --delta-dir /tmp/deltas
+
+# Combine with other pytest options
+pytest --delta -v --tb=short
+
+# Ignore generated files during analysis
+pytest --delta --delta-ignore "*generated*"
+
+# Ignore multiple patterns
+pytest --delta --delta-ignore "*generated*" --delta-ignore "vendor/*"
+
+# Ignore test files from dependency analysis (useful for complex test hierarchies)
+pytest --delta --delta-ignore "tests/integration/*"
+```
+
+### Migration from Previous Versions
+
+If you were using the old `--delta-file` option, you can migrate as follows:
+
+```bash
+# Old way (no longer supported):
+# pytest --delta --delta-file /path/to/custom.json
+
+# New way:
+pytest --delta --delta-filename custom --delta-dir /path/to
+# This creates: /path/to/custom.json
+```
+
+## How It Works
+
+1. **First Run**: On the first run (or when the delta file doesn't exist), all tests are executed and a delta metadata file is created containing the current Git commit hash.
+
+2. **Change Detection**: On subsequent runs, the plugin:
+   - Compares current Git state with the last successful run
+   - Identifies changed Python files (both committed and uncommitted)
+   - Builds a dependency graph based on Python imports
+   - Finds all files transitively affected by the changes
+
+3. **Test Selection**: The plugin selects tests based on:
+   - Direct test files that were modified
+   - Test files that test the modified source files
+   - Test files that test files affected by the changes (transitive dependencies)
+
+4. **File Mapping**: Test files are mapped to source files using naming conventions:
+   - `tests/test_module.py` ↔ `src/module.py`
+   - `tests/subdir/test_module.py` ↔ `src/subdir/module.py`
+
+## Project Structure Assumptions
+
+The plugin works best with projects that follow these conventions:
+
+```
+project/
+├── src/                    # Source code
+│   ├── module1.py
+│   └── package/
+│       └── module2.py
+├── tests/                  # Test files
+│   ├── test_module1.py
+│   └── package/
+│       └── test_module2.py
+└── .delta.json            # Delta metadata (auto-generated, default location)
+```
+
+## Configuration
+
+### Ignoring Files
+
+The `--delta-ignore` option allows you to exclude certain files from dependency analysis. This is useful for:
+
+- **Generated files**: Auto-generated code that shouldn't trigger test runs
+- **Vendor/third-party code**: External dependencies that don't need analysis
+- **Temporary files**: Files that are frequently modified but don't affect tests
+- **Documentation**: Markdown, text files that might be mixed with Python code
+
+The ignore patterns support:
+- **Glob patterns**: `*generated*`, `*.tmp`, `vendor/*`
+- **Path matching**: Both relative and absolute paths are checked
+- **Multiple patterns**: Use the option multiple times for different patterns
+
+Examples:
+```bash
+# Ignore all generated files
+pytest --delta --delta-ignore "*generated*"
+
+# Ignore vendor directory and any temp files
+pytest --delta --delta-ignore "vendor/*" --delta-ignore "*.tmp"
+
+# Ignore specific test subdirectories from analysis
+pytest --delta --delta-ignore "tests/integration/*" --delta-ignore "tests/e2e/*"
+```
+
+### Default Configuration
+
+The plugin requires no configuration for basic usage. It automatically:
+
+- Finds Python files in `src/` and `tests/` directories
+- Excludes virtual environments, `__pycache__`, and other irrelevant directories
+- Creates dependency graphs based on import statements
+- Maps test files to source files using naming conventions
+
+## Error Handling
+
+The plugin includes robust error handling:
+
+- **No Git Repository**: Falls back to running all tests
+- **Invalid Delta File**: Regenerates metadata and runs all tests
+- **Git Errors**: Falls back to running all tests with warnings
+- **Import Analysis Errors**: Continues with partial dependency graph
+
+## Example Output
+
+```bash
+$ pytest --delta -v
+================ test session starts ================
+plugins: delta-0.1.0
+[pytest-delta] Selected 3/10 tests based on code changes
+[pytest-delta] Affected files: src/calculator.py, tests/test_calculator.py
+
+tests/test_calculator.py::test_add PASSED
+tests/test_calculator.py::test_multiply PASSED
+tests/test_math_utils.py::test_area PASSED
+
+[pytest-delta] Delta metadata updated successfully
+================ 3 passed in 0.02s ================
+```
+
+## Development
+
+To set up for development:
+
+```bash
+git clone https://github.com/CemAlpturk/pytest-delta
+cd pytest-delta
+python -m venv .venv
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+pip install -e .
+pip install pytest gitpython
+
+# Run tests
+pytest tests/
+
+# Test the plugin
+pytest --delta
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+

pytest_delta-0.1.0/README.md

@@ -0,0 +1,220 @@
+# pytest-delta
+
+Run only tests impacted by your code changes (delta-based selection) for pytest.
+
+## Overview
+
+pytest-delta is a pytest plugin that reduces test execution time by running only the tests that are potentially affected by your code changes. It creates a directional dependency graph based on Python imports and selects tests intelligently based on what files have changed since the last successful test run.
+
+## Features
+
+- **Smart Test Selection**: Only runs tests affected by changed files
+- **Dependency Tracking**: Creates a dependency graph based on Python imports
+- **Git Integration**: Compares against the last successful test run commit
+- **Uncommitted Changes Support**: Includes both staged and unstaged changes
+- **Force Regeneration**: Option to force running all tests and regenerate metadata
+- **File-based Mapping**: Assumes test files follow standard naming conventions
+
+## Installation
+
+```bash
+pip install pytest-delta
+```
+
+Or for development:
+
+```bash
+git clone https://github.com/CemAlpturk/pytest-delta
+cd pytest-delta
+pip install -e .
+```
+
+## Usage
+
+### Basic Usage
+
+Run tests with delta selection:
+
+```bash
+pytest --delta
+```
+
+On first run, it will execute all tests and create a `.delta.json` file with metadata.
+
+### Command Line Options
+
+- `--delta`: Enable delta-based test selection
+- `--delta-filename NAME`: Specify filename for delta metadata file (default: `.delta`, `.json` extension added automatically)
+- `--delta-dir PATH`: Specify directory for delta metadata file (default: current directory)
+- `--delta-force`: Force regeneration of delta file and run all tests
+- `--delta-ignore PATTERN`: Ignore file patterns during dependency analysis (can be used multiple times)
+
+### Examples
+
+```bash
+# Run only affected tests
+pytest --delta
+
+# Force run all tests and regenerate metadata
+pytest --delta --delta-force
+
+# Use custom delta filename (will become custom-delta.json)
+pytest --delta --delta-filename custom-delta
+
+# Use custom directory for delta file
+pytest --delta --delta-dir .metadata
+
+# Combine custom filename and directory
+pytest --delta --delta-filename my-tests --delta-dir /tmp/deltas
+
+# Combine with other pytest options
+pytest --delta -v --tb=short
+
+# Ignore generated files during analysis
+pytest --delta --delta-ignore "*generated*"
+
+# Ignore multiple patterns
+pytest --delta --delta-ignore "*generated*" --delta-ignore "vendor/*"
+
+# Ignore test files from dependency analysis (useful for complex test hierarchies)
+pytest --delta --delta-ignore "tests/integration/*"
+```
+
+### Migration from Previous Versions
+
+If you were using the old `--delta-file` option, you can migrate as follows:
+
+```bash
+# Old way (no longer supported):
+# pytest --delta --delta-file /path/to/custom.json
+
+# New way:
+pytest --delta --delta-filename custom --delta-dir /path/to
+# This creates: /path/to/custom.json
+```
+
+## How It Works
+
+1. **First Run**: On the first run (or when the delta file doesn't exist), all tests are executed and a delta metadata file is created containing the current Git commit hash.
+
+2. **Change Detection**: On subsequent runs, the plugin:
+   - Compares current Git state with the last successful run
+   - Identifies changed Python files (both committed and uncommitted)
+   - Builds a dependency graph based on Python imports
+   - Finds all files transitively affected by the changes
+
+3. **Test Selection**: The plugin selects tests based on:
+   - Direct test files that were modified
+   - Test files that test the modified source files
+   - Test files that test files affected by the changes (transitive dependencies)
+
+4. **File Mapping**: Test files are mapped to source files using naming conventions:
+   - `tests/test_module.py` ↔ `src/module.py`
+   - `tests/subdir/test_module.py` ↔ `src/subdir/module.py`
+
+## Project Structure Assumptions
+
+The plugin works best with projects that follow these conventions:
+
+```
+project/
+├── src/                    # Source code
+│   ├── module1.py
+│   └── package/
+│       └── module2.py
+├── tests/                  # Test files
+│   ├── test_module1.py
+│   └── package/
+│       └── test_module2.py
+└── .delta.json            # Delta metadata (auto-generated, default location)
+```
+
+## Configuration
+
+### Ignoring Files
+
+The `--delta-ignore` option allows you to exclude certain files from dependency analysis. This is useful for:
+
+- **Generated files**: Auto-generated code that shouldn't trigger test runs
+- **Vendor/third-party code**: External dependencies that don't need analysis
+- **Temporary files**: Files that are frequently modified but don't affect tests
+- **Documentation**: Markdown, text files that might be mixed with Python code
+
+The ignore patterns support:
+- **Glob patterns**: `*generated*`, `*.tmp`, `vendor/*`
+- **Path matching**: Both relative and absolute paths are checked
+- **Multiple patterns**: Use the option multiple times for different patterns
+
+Examples:
+```bash
+# Ignore all generated files
+pytest --delta --delta-ignore "*generated*"
+
+# Ignore vendor directory and any temp files
+pytest --delta --delta-ignore "vendor/*" --delta-ignore "*.tmp"
+
+# Ignore specific test subdirectories from analysis
+pytest --delta --delta-ignore "tests/integration/*" --delta-ignore "tests/e2e/*"
+```
+
+### Default Configuration
+
+The plugin requires no configuration for basic usage. It automatically:
+
+- Finds Python files in `src/` and `tests/` directories
+- Excludes virtual environments, `__pycache__`, and other irrelevant directories
+- Creates dependency graphs based on import statements
+- Maps test files to source files using naming conventions
+
+## Error Handling
+
+The plugin includes robust error handling:
+
+- **No Git Repository**: Falls back to running all tests
+- **Invalid Delta File**: Regenerates metadata and runs all tests
+- **Git Errors**: Falls back to running all tests with warnings
+- **Import Analysis Errors**: Continues with partial dependency graph
+
+## Example Output
+
+```bash
+$ pytest --delta -v
+================ test session starts ================
+plugins: delta-0.1.0
+[pytest-delta] Selected 3/10 tests based on code changes
+[pytest-delta] Affected files: src/calculator.py, tests/test_calculator.py
+
+tests/test_calculator.py::test_add PASSED
+tests/test_calculator.py::test_multiply PASSED
+tests/test_math_utils.py::test_area PASSED
+
+[pytest-delta] Delta metadata updated successfully
+================ 3 passed in 0.02s ================
+```
+
+## Development
+
+To set up for development:
+
+```bash
+git clone https://github.com/CemAlpturk/pytest-delta
+cd pytest-delta
+python -m venv .venv
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+pip install -e .
+pip install pytest gitpython
+
+# Run tests
+pytest tests/
+
+# Test the plugin
+pytest --delta
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

pytest_delta-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[tool.poetry]
+name = "pytest-delta"
+version = "0.1.0"
+description = "Run only tests impacted by your code changes (delta-based selection) for pytest."
+authors = ["Cem Alptürk <cem.alpturk@gmail.com>"]
+license = "MIT"
+readme = "README.md"
+packages = [{ include = "pytest_delta", from = "src" }]
+keywords = ["pytest", "plugin", "selective", "impact", "test", "ci", "graph"]
+homepage = "https://github.com/CemAlpturk/pytest-delta"
+repository = "https://github.com/CemAlpturk/pytest-delta"
+classifiers = [
+  "Framework :: Pytest",
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+]
+
+[tool.poetry.dependencies]
+python = ">=3.12"
+pytest = ">=7.0"
+gitpython = ">=3.1.0"
+
+[tool.poetry.plugins."pytest11"]
+pytest-delta = "pytest_delta.plugin"
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+
+[tool.mypy]
+python_version = "3.12"
+strict = true
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

pytest_delta-0.1.0/src/pytest_delta/__init__.py

@@ -0,0 +1,4 @@
+"""pytest-delta: Run only tests impacted by your code changes."""
+
+__all__ = ["__version__"]
+__version__ = "0.1.0"

pytest_delta-0.1.0/src/pytest_delta/delta_manager.py

@@ -0,0 +1,65 @@
+"""
+Delta metadata manager for pytest-delta plugin.
+
+Handles saving and loading metadata about the last test run,
+including the git commit hash and other relevant information.
+"""
+
+import json
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from git import Repo
+from git.exc import GitCommandError, InvalidGitRepositoryError
+
+
+class DeltaManager:
+    """Manages delta metadata file operations."""
+
+    def __init__(self, delta_file: Path):
+        self.delta_file = delta_file
+
+    def load_metadata(self) -> Optional[Dict[str, Any]]:
+        """Load metadata from the delta file."""
+        if not self.delta_file.exists():
+            return None
+
+        try:
+            with open(self.delta_file, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, OSError) as e:
+            raise ValueError(f"Failed to load delta metadata: {e}") from e
+
+    def save_metadata(self, metadata: Dict[str, Any]) -> None:
+        """Save metadata to the delta file."""
+        try:
+            # Ensure parent directory exists
+            self.delta_file.parent.mkdir(parents=True, exist_ok=True)
+
+            with open(self.delta_file, "w", encoding="utf-8") as f:
+                json.dump(metadata, f, indent=2, sort_keys=True)
+        except OSError as e:
+            raise ValueError(f"Failed to save delta metadata: {e}") from e
+
+    def update_metadata(self, root_dir: Path) -> None:
+        """Update metadata with current git state."""
+        try:
+            repo = Repo(root_dir)
+        except InvalidGitRepositoryError as e:
+            raise ValueError("Not a Git repository") from e
+
+        try:
+            # Get current commit hash
+            current_commit = repo.head.commit.hexsha
+
+            # Create metadata
+            metadata = {
+                "last_commit": current_commit,
+                "last_successful_run": True,
+                "version": "0.1.0",
+            }
+
+            self.save_metadata(metadata)
+
+        except GitCommandError as e:
+            raise ValueError(f"Failed to get Git information: {e}") from e

pytest_delta-0.1.0/src/pytest_delta/dependency_analyzer.py

@@ -0,0 +1,272 @@
+"""
+Dependency analyzer for pytest-delta plugin.
+
+Creates a directional dependency graph based on Python imports
+and determines which files are affected by changes.
+"""
+
+import ast
+import fnmatch
+from pathlib import Path
+from typing import Dict, List, Set
+
+
+class DependencyAnalyzer:
+    """Analyzes Python file dependencies based on imports."""
+
+    def __init__(self, root_dir: Path, ignore_patterns: List[str] | None = None):
+        self.root_dir = root_dir
+        self.ignore_patterns = ignore_patterns or []
+
+    def build_dependency_graph(self) -> Dict[Path, Set[Path]]:
+        """
+        Build a dependency graph where keys are files and values are sets of files they depend on.
+
+        Returns:
+            A dictionary mapping file paths to their dependencies.
+        """
+        dependency_graph = {}
+        python_files = self._find_python_files()
+
+        for file_path in python_files:
+            dependencies = self._extract_dependencies(file_path, python_files)
+            dependency_graph[file_path] = dependencies
+
+        return dependency_graph
+
+    def find_affected_files(
+        self, changed_files: Set[Path], dependency_graph: Dict[Path, Set[Path]]
+    ) -> Set[Path]:
+        """
+        Find all files affected by the given changed files.
+
+        This includes:
+        1. The changed files themselves
+        2. Files that directly depend on changed files
+        3. Files that transitively depend on changed files
+
+        Args:
+            changed_files: Set of files that have been modified
+            dependency_graph: Dependency graph from build_dependency_graph()
+
+        Returns:
+            Set of all files that are potentially affected by the changes
+        """
+        affected = set(changed_files)
+
+        # Build reverse dependency graph (who depends on whom)
+        reverse_deps = self._build_reverse_dependency_graph(dependency_graph)
+
+        # Use BFS to find all files affected transitively
+        to_process = list(changed_files)
+        processed = set()
+
+        while to_process:
+            current_file = to_process.pop(0)
+            if current_file in processed:
+                continue
+            processed.add(current_file)
+
+            # Find files that depend on the current file
+            dependents = reverse_deps.get(current_file, set())
+            for dependent in dependents:
+                if dependent not in processed and dependent not in to_process:
+                    affected.add(dependent)
+                    to_process.append(dependent)
+
+        return affected
+
+    def _find_python_files(self) -> Set[Path]:
+        """Find all Python files in the project."""
+        python_files = set()
+
+        # Search in common Python directories
+        search_dirs = [
+            self.root_dir / "src",
+            self.root_dir / "tests",
+        ]
+
+        # Also check for Python files in the root directory (but not recursively)
+        for file_path in self.root_dir.glob("*.py"):
+            if file_path.is_file():
+                python_files.add(file_path.resolve())
+
+        for search_dir in search_dirs:
+            if search_dir.is_dir():
+                python_files.update(search_dir.rglob("*.py"))
+
+        # Filter out __pycache__, .venv, and other irrelevant files
+        filtered_files = set()
+        exclude_patterns = [
+            "__pycache__",
+            ".venv",
+            "venv",
+            ".git",
+            "node_modules",
+            ".pytest_cache",
+        ]
+
+        for file_path in python_files:
+            path_str = str(file_path)
+            relative_path_str = str(file_path.relative_to(self.root_dir))
+
+            # Skip if any exclude pattern is in the path
+            if any(pattern in path_str for pattern in exclude_patterns):
+                continue
+
+            # Skip if matches any user-provided ignore patterns
+            if self._should_ignore_file(file_path, relative_path_str):
+                continue
+
+            if file_path.is_file():
+                filtered_files.add(file_path.resolve())
+
+        return filtered_files
+
+    def _extract_dependencies(self, file_path: Path, all_files: Set[Path]) -> Set[Path]:
+        """Extract dependencies (imports) from a Python file."""
+        dependencies = set()
+
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                content = f.read()
+        except (OSError, UnicodeDecodeError):
+            # Skip files that can't be read
+            return dependencies
+
+        try:
+            tree = ast.parse(content)
+        except SyntaxError:
+            # Skip files with syntax errors
+            return dependencies
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    dep_path = self._resolve_import_to_file(alias.name, all_files)
+                    if dep_path:
+                        dependencies.add(dep_path)
+
+            elif isinstance(node, ast.ImportFrom):
+                if node.module:
+                    # Handle relative imports
+                    if node.level > 0:  # Relative import
+                        module_name = self._resolve_relative_import(
+                            file_path, node.module, node.level
+                        )
+                    else:
+                        module_name = node.module
+
+                    if module_name:
+                        dep_path = self._resolve_import_to_file(module_name, all_files)
+                        if dep_path:
+                            dependencies.add(dep_path)
+
+                # Also handle individual imports from modules
+                for alias in node.names:
+                    if node.module:
+                        full_name = f"{node.module}.{alias.name}"
+                    else:
+                        full_name = alias.name
+
+                    dep_path = self._resolve_import_to_file(full_name, all_files)
+                    if dep_path:
+                        dependencies.add(dep_path)
+
+        return dependencies
+
+    def _resolve_import_to_file(
+        self, import_name: str, all_files: Set[Path]
+    ) -> Path | None:
+        """Resolve an import name to an actual file path."""
+        # Convert module name to potential file paths
+        parts = import_name.split(".")
+
+        # Try different combinations to find the file
+        potential_paths = []
+
+        # Try as a direct module file
+        potential_paths.append(Path(*parts).with_suffix(".py"))
+
+        # Try as a package with __init__.py
+        potential_paths.append(Path(*parts) / "__init__.py")
+
+        # Try in src/ directory
+        potential_paths.append(Path("src") / Path(*parts) / "__init__.py")
+        potential_paths.append((Path("src") / Path(*parts)).with_suffix(".py"))
+
+        # Search for matches in all known files
+        for potential_path in potential_paths:
+            for file_path in all_files:
+                try:
+                    # Check if the file path ends with our potential path
+                    if file_path.relative_to(self.root_dir) == potential_path:
+                        return file_path
+                except ValueError:
+                    continue
+
+                # Also check suffix matching for nested structures
+                if str(file_path).endswith(str(potential_path)):
+                    return file_path
+
+        return None
+
+    def _resolve_relative_import(
+        self, file_path: Path, module_name: str | None, level: int
+    ) -> str | None:
+        """Resolve relative imports to absolute module names."""
+        try:
+            file_rel_path = file_path.relative_to(self.root_dir)
+        except ValueError:
+            return None
+
+        # Remove the file name to get the directory
+        current_dir_parts = list(file_rel_path.parent.parts)
+
+        # Remove 'level' number of directories
+        if level > len(current_dir_parts):
+            return None
+
+        base_parts = current_dir_parts[:-level] if level > 0 else current_dir_parts
+
+        if module_name:
+            module_parts = module_name.split(".")
+            full_parts = base_parts + module_parts
+        else:
+            full_parts = base_parts
+
+        return ".".join(full_parts) if full_parts else None
+
+    def _build_reverse_dependency_graph(
+        self, dependency_graph: Dict[Path, Set[Path]]
+    ) -> Dict[Path, Set[Path]]:
+        """Build reverse dependency graph (who depends on whom)."""
+        reverse_deps = {}
+
+        for file_path, dependencies in dependency_graph.items():
+            for dependency in dependencies:
+                if dependency not in reverse_deps:
+                    reverse_deps[dependency] = set()
+                reverse_deps[dependency].add(file_path)
+
+        return reverse_deps
+
+    def _should_ignore_file(self, file_path: Path, relative_path_str: str) -> bool:
+        """Check if a file should be ignored based on user-provided patterns."""
+        if not self.ignore_patterns:
+            return False
+
+        # Check against both absolute path and relative path
+        absolute_path_str = str(file_path)
+
+        for pattern in self.ignore_patterns:
+            # Use fnmatch for glob-style pattern matching
+            if fnmatch.fnmatch(relative_path_str, pattern):
+                return True
+            if fnmatch.fnmatch(absolute_path_str, pattern):
+                return True
+            # Also check if pattern is simply contained in the path
+            if pattern in relative_path_str or pattern in absolute_path_str:
+                return True
+
+        return False

pytest_delta-0.1.0/src/pytest_delta/plugin.py

@@ -0,0 +1,313 @@
+"""
+pytest-delta plugin for running only tests impacted by code changes.
+
+This plugin creates a directional dependency graph based on imports and selects
+only the tests that are potentially affected by the changed files.
+"""
+
+from pathlib import Path
+from typing import List, Set
+
+import pytest
+from git import Repo
+from git.exc import GitCommandError, InvalidGitRepositoryError
+
+from .dependency_analyzer import DependencyAnalyzer
+from .delta_manager import DeltaManager
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    """Add command line options for pytest-delta."""
+    group = parser.getgroup("delta", "pytest-delta options")
+    group.addoption(
+        "--delta",
+        action="store_true",
+        default=False,
+        help="Run only tests impacted by code changes since last successful run",
+    )
+    group.addoption(
+        "--delta-filename",
+        action="store",
+        default=".delta",
+        help="Filename for the delta metadata file (default: .delta, .json extension added automatically)",
+    )
+    group.addoption(
+        "--delta-dir",
+        action="store",
+        default=".",
+        help="Directory to store the delta metadata file (default: current directory)",
+    )
+    group.addoption(
+        "--delta-force",
+        action="store_true",
+        default=False,
+        help="Force regeneration of the delta file and run all tests",
+    )
+    group.addoption(
+        "--delta-ignore",
+        action="append",
+        default=[],
+        help="Ignore file patterns during dependency analysis (can be used multiple times)",
+    )
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    """Configure the plugin if --delta flag is used."""
+    if config.getoption("--delta"):
+        config.pluginmanager.register(DeltaPlugin(config), "delta-plugin")
+
+
+class DeltaPlugin:
+    """Main plugin class for pytest-delta functionality."""
+
+    def __init__(self, config: pytest.Config):
+        self.config = config
+        # Construct delta file path from filename and directory
+        delta_filename = config.getoption("--delta-filename")
+        delta_dir = config.getoption("--delta-dir")
+
+        # Ensure filename has .json extension
+        if not delta_filename.endswith(".json"):
+            delta_filename += ".json"
+
+        self.delta_file = Path(delta_dir) / delta_filename
+        self.force_regenerate = config.getoption("--delta-force")
+        self.ignore_patterns = config.getoption("--delta-ignore")
+        self.root_dir = Path.cwd()
+        self.delta_manager = DeltaManager(self.delta_file)
+        self.dependency_analyzer = DependencyAnalyzer(
+            self.root_dir, ignore_patterns=self.ignore_patterns
+        )
+        self.affected_files: Set[Path] = set()
+        self.should_run_all = False
+
+    def pytest_collection_modifyitems(
+        self, config: pytest.Config, items: List[pytest.Item]
+    ) -> None:
+        """Modify the collected test items to only include affected tests."""
+        try:
+            # Try to determine which files are affected
+            self._analyze_changes()
+
+            if self.should_run_all:
+                # Run all tests and regenerate delta file
+                self._print_info("Running all tests (regenerating delta file)")
+                return
+
+            if not self.affected_files:
+                # No changes detected, skip all tests
+                self._print_info("No changes detected, skipping all tests")
+                items.clear()
+                return
+
+            # Filter tests based on affected files
+            original_count = len(items)
+            items[:] = self._filter_affected_tests(items)
+            filtered_count = len(items)
+
+            self._print_info(
+                f"Selected {filtered_count}/{original_count} tests based on code changes"
+            )
+
+            if filtered_count > 0:
+                affected_files_str = ", ".join(
+                    str(f.relative_to(self.root_dir))
+                    for f in sorted(self.affected_files)
+                )
+                self._print_info(f"Affected files: {affected_files_str}")
+
+        except Exception as e:
+            self._print_warning(f"Error in delta analysis: {e}")
+            self._print_warning("Running all tests as fallback")
+            self.should_run_all = True
+
+    def pytest_sessionfinish(self, session: pytest.Session, exitstatus: int) -> None:
+        """Update delta metadata after test session completion."""
+        if exitstatus == 0:  # Tests passed successfully
+            try:
+                self.delta_manager.update_metadata(self.root_dir)
+                self._print_info("Delta metadata updated successfully")
+            except Exception as e:
+                self._print_warning(f"Failed to update delta metadata: {e}")
+
+    def _analyze_changes(self) -> None:
+        """Analyze what files have changed and determine affected files."""
+        try:
+            repo = Repo(self.root_dir)
+        except InvalidGitRepositoryError:
+            self._print_warning("Not a Git repository, running all tests")
+            self.should_run_all = True
+            return
+
+        if self.force_regenerate or not self.delta_file.exists():
+            self._print_info("Delta file not found or force regeneration requested")
+            self.should_run_all = True
+            return
+
+        try:
+            # Load previous metadata
+            metadata = self.delta_manager.load_metadata()
+            if not metadata or "last_commit" not in metadata:
+                self._print_warning("Invalid delta metadata, running all tests")
+                self.should_run_all = True
+                return
+
+            last_commit = metadata["last_commit"]
+
+            # Get changed files since last commit
+            try:
+                changed_files = self._get_changed_files(repo, last_commit)
+            except GitCommandError as e:
+                self._print_warning(f"Git error: {e}")
+                self._print_warning("Running all tests")
+                self.should_run_all = True
+                return
+
+            if not changed_files:
+                # No changes detected
+                return
+
+            # Build dependency graph and find affected files
+            dependency_graph = self.dependency_analyzer.build_dependency_graph()
+            self.affected_files = self.dependency_analyzer.find_affected_files(
+                changed_files, dependency_graph
+            )
+
+        except Exception as e:
+            self._print_warning(f"Error analyzing changes: {e}")
+            self.should_run_all = True
+
+    def _get_changed_files(self, repo: Repo, last_commit: str) -> Set[Path]:
+        """Get list of files changed since the last commit."""
+        changed_files = set()
+
+        try:
+            # Get committed changes
+            diff = repo.commit(last_commit).diff("HEAD")
+            for item in diff:
+                if item.a_path:
+                    file_path = self.root_dir / item.a_path
+                    if file_path.suffix == ".py":
+                        changed_files.add(file_path)
+                if item.b_path:
+                    file_path = self.root_dir / item.b_path
+                    if file_path.suffix == ".py":
+                        changed_files.add(file_path)
+        except GitCommandError:
+            # Last commit might not exist, compare with HEAD
+            pass
+
+        # Get uncommitted changes (staged and unstaged)
+        try:
+            # Staged changes
+            diff_staged = repo.index.diff("HEAD")
+            for item in diff_staged:
+                if item.a_path:
+                    file_path = self.root_dir / item.a_path
+                    if file_path.suffix == ".py":
+                        changed_files.add(file_path)
+                if item.b_path:
+                    file_path = self.root_dir / item.b_path
+                    if file_path.suffix == ".py":
+                        changed_files.add(file_path)
+
+            # Unstaged changes
+            diff_unstaged = repo.index.diff(None)
+            for item in diff_unstaged:
+                if item.a_path:
+                    file_path = self.root_dir / item.a_path
+                    if file_path.suffix == ".py":
+                        changed_files.add(file_path)
+                if item.b_path:
+                    file_path = self.root_dir / item.b_path
+                    if file_path.suffix == ".py":
+                        changed_files.add(file_path)
+        except GitCommandError:
+            pass
+
+        return changed_files
+
+    def _filter_affected_tests(self, items: List[pytest.Item]) -> List[pytest.Item]:
+        """Filter test items to only include those affected by changes."""
+        affected_tests = []
+
+        for item in items:
+            test_file = Path(item.fspath)
+
+            # Check if the test file itself is affected
+            if test_file in self.affected_files:
+                affected_tests.append(item)
+                continue
+
+            # Check if the test file tests any affected source files
+            if self._test_covers_affected_files(test_file):
+                affected_tests.append(item)
+
+        return affected_tests
+
+    def _test_covers_affected_files(self, test_file: Path) -> bool:
+        """Check if a test file covers any of the affected source files."""
+        # Simple heuristic: match test file path with source file path
+        # test_something.py -> something.py
+        # tests/test_module.py -> src/module.py or module.py
+
+        test_name = test_file.name
+        if test_name.startswith("test_"):
+            source_name = test_name[5:]  # Remove 'test_' prefix
+        else:
+            return False
+
+        # Look for corresponding source files in affected files
+        for affected_file in self.affected_files:
+            if affected_file.name == source_name:
+                return True
+            # Also check if the test directory structure matches source structure
+            if self._paths_match(test_file, affected_file):
+                return True
+
+        return False
+
+    def _paths_match(self, test_file: Path, source_file: Path) -> bool:
+        """Check if test file path corresponds to source file path."""
+        # Convert paths to relative and normalize
+        try:
+            test_rel = test_file.relative_to(self.root_dir)
+            source_rel = source_file.relative_to(self.root_dir)
+        except ValueError:
+            return False
+
+        # Simple matching logic:
+        # tests/test_module.py matches src/module.py
+        # tests/subdir/test_module.py matches src/subdir/module.py
+        test_parts = list(test_rel.parts)
+        source_parts = list(source_rel.parts)
+
+        if len(test_parts) != len(source_parts):
+            return False
+
+        for i, (test_part, source_part) in enumerate(zip(test_parts, source_parts)):
+            if i == 0:  # First part: tests vs src
+                if test_part == "tests" and source_part == "src":
+                    continue
+                elif test_part == source_part:
+                    continue
+                else:
+                    return False
+            elif i == len(test_parts) - 1:  # Last part: filename
+                if test_part.startswith("test_") and test_part[5:] == source_part:
+                    return True
+                else:
+                    return False
+            else:  # Middle parts: should match exactly
+                if test_part != source_part:
+                    return False
+
+        return False
+
+    def _print_info(self, message: str) -> None:
+        """Print informational message."""
+        print(f"[pytest-delta] {message}")
+
+    def _print_warning(self, message: str) -> None:
+        """Print warning message."""
+        print(f"[pytest-delta] WARNING: {message}")