skippy-cov 0.2.0__tar.gz

skippy_cov-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mariano Garcia Berrotaran
+
+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.

skippy_cov-0.2.0/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: skippy-cov
+Version: 0.2.0
+Summary: Selectively run tests based on the current git diff and the collected data from previous tests runs
+Keywords: python
+Author-email: Mariano Garcia Berrotaran <mariano.garciaberrotaran@shiphero.com>, Martín Gaitán <marting@shiphero.com>
+Requires-Python: >=3.8,<4.0
+Description-Content-Type: text/markdown
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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 :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+License-File: LICENSE
+Requires-Dist: unidiff >=0.7.5
+Requires-Dist: coverage>=7.6
+Requires-Dist: tomli; python_version < '3.11'
+Project-URL: Repository, https://github.com/shiphero/skippy-cov
+
+# skippy-cov
+
+## Overview
+
+`skippy-cov` is a tool that optimizes your Python testing workflow by filtering tests based on code changes. It takes a diff file from git and a `.coverage` database (generated by [`coverage.py`](https://coverage.readthedocs.io/)) to identify and run only the tests relevant to the modified code. This significantly reduces testing time and resources.
+
+
+## Usage
+
+To use this, you first need to generate the following required files:
+
+* **Run Coverage Analysis:** Generate a `.coverage` database using `coverage.py`.
+
+```bash
+    coverage run -m pytest
+```
+
+You can provide the diff to `skippy-cov` in two ways:
+
+
+* **Option 1: Use a Git Branch or Ref**
+  You can specify a branch or ref to diff against (e.g., the main branch):
+
+  ```bash
+      skippy-cov --diff main --coverage-file .coverage
+  ```
+
+* **Option 2: Use a Diff File**
+  Generate a diff file using Git:
+
+  ```bash
+      git diff > changes.diff
+  ```
+
+  Then run:
+
+  ```bash
+      skippy-cov --diff changes.diff --coverage-file .coverage
+  ```
+
+* **Option 1: Use a Git Branch or Ref**  
+  You can specify a branch or ref to diff against (e.g., the main branch):
+
+  ```bash
+      skippy-cov --diff main --coverage-file .coverage
+  ```
+
+  If you omit the `--diff` argument, it will default to the main branch as determined by your git remote (usually "main" or "master"):
+
+  ```bash
+      skippy-cov --coverage-file .coverage
+  ```
+
+But it can also be used as a `pytest` plugin:
+
+```bash
+    pytest --skippy-cov --skippy-cov-diff changes.diff --skippy-cov-coverage-file .coverage
+```
+
+which would be the equivalent of doing this:
+
+```bash
+    pytest $(skippy-cov --diff changes.diff --coverage-file .coverage)
+```
+
+## Configuration
+
+`skippy-cov` can be configured using command-line arguments. See `skippy-cov --help` for more information.
+
+### Diff Argument
+
+- `--diff`: Path to a diff file, or a git branch/ref to diff against.
+  - If the argument is a path to an existing file, its contents are used as the diff.
+  - Otherwise, it is passed to `git diff <arg>` and the output is used.
+  - If omitted, defaults to the main branch as determined by `git remote show origin`.
+
+Example usages:
+- `skippy-cov --diff changes.diff --coverage-file .coverage`
+- `skippy-cov --diff main --coverage-file .coverage`
+- `skippy-cov --coverage-file .coverage` (defaults to main branch)
+
+## Contributing
+
+See `CONTRIBUTING.md` for information on how to contribute to the project.
+
+## License
+
+See `LICENSE` for licensing information.
+

skippy_cov-0.2.0/README.md

@@ -0,0 +1,88 @@
+# skippy-cov
+
+## Overview
+
+`skippy-cov` is a tool that optimizes your Python testing workflow by filtering tests based on code changes. It takes a diff file from git and a `.coverage` database (generated by [`coverage.py`](https://coverage.readthedocs.io/)) to identify and run only the tests relevant to the modified code. This significantly reduces testing time and resources.
+
+
+## Usage
+
+To use this, you first need to generate the following required files:
+
+* **Run Coverage Analysis:** Generate a `.coverage` database using `coverage.py`.
+
+```bash
+    coverage run -m pytest
+```
+
+You can provide the diff to `skippy-cov` in two ways:
+
+
+* **Option 1: Use a Git Branch or Ref**
+  You can specify a branch or ref to diff against (e.g., the main branch):
+
+  ```bash
+      skippy-cov --diff main --coverage-file .coverage
+  ```
+
+* **Option 2: Use a Diff File**
+  Generate a diff file using Git:
+
+  ```bash
+      git diff > changes.diff
+  ```
+
+  Then run:
+
+  ```bash
+      skippy-cov --diff changes.diff --coverage-file .coverage
+  ```
+
+* **Option 1: Use a Git Branch or Ref**  
+  You can specify a branch or ref to diff against (e.g., the main branch):
+
+  ```bash
+      skippy-cov --diff main --coverage-file .coverage
+  ```
+
+  If you omit the `--diff` argument, it will default to the main branch as determined by your git remote (usually "main" or "master"):
+
+  ```bash
+      skippy-cov --coverage-file .coverage
+  ```
+
+But it can also be used as a `pytest` plugin:
+
+```bash
+    pytest --skippy-cov --skippy-cov-diff changes.diff --skippy-cov-coverage-file .coverage
+```
+
+which would be the equivalent of doing this:
+
+```bash
+    pytest $(skippy-cov --diff changes.diff --coverage-file .coverage)
+```
+
+## Configuration
+
+`skippy-cov` can be configured using command-line arguments. See `skippy-cov --help` for more information.
+
+### Diff Argument
+
+- `--diff`: Path to a diff file, or a git branch/ref to diff against.
+  - If the argument is a path to an existing file, its contents are used as the diff.
+  - Otherwise, it is passed to `git diff <arg>` and the output is used.
+  - If omitted, defaults to the main branch as determined by `git remote show origin`.
+
+Example usages:
+- `skippy-cov --diff changes.diff --coverage-file .coverage`
+- `skippy-cov --diff main --coverage-file .coverage`
+- `skippy-cov --coverage-file .coverage` (defaults to main branch)
+
+## Contributing
+
+See `CONTRIBUTING.md` for information on how to contribute to the project.
+
+## License
+
+See `LICENSE` for licensing information.

skippy_cov-0.2.0/pyproject.toml

@@ -0,0 +1,128 @@
+[project]
+name = "skippy-cov"
+description = "Selectively run tests based on the current git diff and the collected data from previous tests runs"
+authors = [
+    { name = "Mariano Garcia Berrotaran", email = "mariano.garciaberrotaran@shiphero.com" },
+    { name = "Martín Gaitán", email = "marting@shiphero.com" },
+]
+readme = "README.md"
+keywords = ['python']
+requires-python = ">=3.8,<4.0"
+classifiers = [
+    "Intended Audience :: Developers",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "unidiff >=0.7.5",
+    "coverage>=7.6",
+    "tomli; python_version < '3.11'",
+]
+scripts = { "skippy-cov" = "skippy_cov.__main__:main" }
+dynamic = ["version"]
+
+[project.urls]
+Repository = "https://github.com/shiphero/skippy-cov"
+
+[dependency-groups]
+dev = [
+    "pytest>=7.2.0",
+    "pre-commit>=2.20.0",
+    "pytest-mock>=3.14",
+    "mypy>=0.991",
+    "pytest-cov>=4.0.0",
+    "ruff>=0.9.2",
+    "types-unidiff",
+    "doc901",
+]
+
+[build-system]
+requires = ["flit_core >=3.6,<4"]
+build-backend = "flit_core.buildapi"
+
+[tool.setuptools]
+py-modules = ["skippy_cov"]
+
+[tool.mypy]
+files = ["skippy_cov"]
+disallow_untyped_defs = true
+disallow_any_unimported = true
+no_implicit_optional = true
+check_untyped_defs = true
+warn_return_any = true
+warn_unused_ignores = true
+show_error_codes = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+target-version = "py38"
+line-length = 89
+fix = true
+
+[tool.ruff.lint]
+select = [
+    # flake8-2020
+    "YTT",
+    # flake8-bandit
+    "S",
+    # flake8-bugbear
+    "B",
+    # flake8-builtins
+    "A",
+    # flake8-comprehensions
+    "C4",
+    # flake8-debugger
+    "T10",
+    # flake8-simplify
+    "SIM",
+    # isort
+    "I",
+    # mccabe
+    "C90",
+    # pycodestyle
+    "E",
+    "W",
+    # pyflakes
+    "F",
+    # pygrep-hooks
+    "PGH",
+    # pyupgrade
+    "UP",
+    # ruff
+    "RUF",
+    # tryceratops
+    "TRY",
+]
+ignore = [
+    # LineTooLong
+    "E501",
+    # DoNotAssignLambda
+    "E731",
+    "S607",
+    "S603",
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["S101"]
+
+[tool.ruff.format]
+preview = true
+
+[tool.coverage.report]
+skip_empty = true
+
+[tool.coverage.run]
+branch = true
+source = ["skippy_cov"]
+
+[project.entry-points.pytest11]
+skippy-cov = "skippy_cov.plugin"

skippy_cov-0.2.0/skippy_cov/__init__.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import ast
+import logging
+from pathlib import Path
+
+from skippy_cov.diff_handler import DiffHandler
+from skippy_cov.tests_finder import ASTTestsFinder
+from skippy_cov.utils import CoverageMap, FileTestCandidate, is_test_file
+
+logger = logging.getLogger(__name__)
+
+__version__ = "0.2.0"
+
+
+def discover_tests_in_file(file_path: Path) -> FileTestCandidate | None:
+    """
+    Discovers tests within a given Python file using AST parsing.
+    Finds top-level functions (sync/async) starting with 'test_' and
+    methods (sync/async) starting with 'test_' within classes
+    starting with 'Test'.
+
+    Args:
+        file_path: The path to the Python file.
+
+    Returns:
+        A list of test identifiers in pytest format 'file::[Class::]test_name'.
+        Returns an empty list if the file is not a test file, doesn't exist,
+        cannot be read, or contains syntax errors preventing AST parsing.
+    """
+    logger.debug(f"Discovering tests in {file_path} using AST...")
+    if not is_test_file(file_path):
+        logger.debug(
+            f"Skipping AST discovery: File path '{file_path}' "
+            "doesn't match test file pattern."
+        )
+        return None
+    if not file_path.exists() or not file_path.is_file():
+        logger.debug(
+            f"Skipping AST discovery: File path '{file_path}' "
+            "does not exist or is not a file."
+        )
+        return None
+    try:
+        tree = ast.parse(file_path.read_text(), filename=file_path.name)
+
+    except Exception as e:
+        logger.warning(
+            f"Could not discover tests via AST in '{file_path}' "
+            f"due to unexpected error: {e}"
+        )
+        return None
+
+    try:
+        finder = ASTTestsFinder(file_path)
+        finder.visit(tree)
+        found_tests = finder.tests
+
+        if found_tests:
+            logger.debug(
+                f"Found {len(found_tests)} test(s) in '{file_path}' "
+                f"via AST: {found_tests}"
+            )
+        else:
+            logger.debug(f"No tests found matching in '{file_path}' via AST.")
+
+    except Exception as e:
+        logger.warning(f"Error during AST traversal of '{file_path}': {e}")
+        return None
+
+    return FileTestCandidate(path=file_path, tests=finder.tests)
+
+
+def select_tests_to_run(
+    diff_handler: DiffHandler,
+    coverage_map: CoverageMap,
+) -> list[FileTestCandidate]:
+    """
+    Determines the set of tests to run based on changed files and coverage.
+    """
+    tests_to_run: list[FileTestCandidate] = []
+
+    logger.debug(f"Processing {len(diff_handler.changed_files)} changed file(s)...")
+    logger.debug(f"Changed files: {diff_handler.changed_files}")
+
+    for file_path in diff_handler.changed_files:
+        # 1. If the changed file is a source file with known coverage
+        if candidate := coverage_map.get_tests(file_path):
+            logger.debug(
+                f"Source file '{candidate.path}' changed. Adding {len(candidate.tests)}"
+                "related test(s) from coverage map.",
+            )
+            tests_to_run.append(candidate)
+
+        # 2. If the changed file is a test file itself
+        # Use the discovery function, which internally checks if it's a test file
+        # This handles added/modified test files.
+        # If a test file is changed, all tests in it will be run
+        tests_in_file = discover_tests_in_file(file_path)
+        if tests_in_file:
+            logger.debug(
+                f"Test file '{file_path}' changed or contains tests."
+                f" Adding all {len(tests_in_file.tests)} tests from this file.",
+            )
+            tests_to_run.append(tests_in_file)
+
+        # 3. Handle files not in coverage map and not identified as test files
+        # These might be new source files, documentation, config files etc.
+        # Current logic doesn't explicitly add tests for *new* source files
+        # unless they come with *new* test files (handled by point 2).
+        # If a new source file is added and covered by *existing* tests,
+        # the *old* coverage map won't know about it. This is a limitation.
+        if not tests_in_file and not is_test_file(file_path):
+            logger.debug(
+                f"Changed file '{file_path}' is not in the "
+                "coverage map and not identified as a test file."
+                " No direct tests added for it.",
+            )
+
+    return tests_to_run

skippy_cov-0.2.0/skippy_cov/__main__.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import argparse
+import logging
+import subprocess
+import sys
+from pathlib import Path
+
+from skippy_cov import __version__, select_tests_to_run
+from skippy_cov.diff_handler import DiffHandler
+from skippy_cov.utils import CoverageMap, filter_by_path
+
+logger = logging.getLogger(__name__)
+
+
+def run(
+    diff: str,
+    coverage_file: Path,
+    relative_to: list[Path] | None,
+    keep_prefix: bool,
+    display: bool = False,
+) -> set[str]:
+    """
+    Run the test filter. If `display` = True will also print the output to stdout
+    """
+    diff_handler = DiffHandler(diff)
+    coverage_map = CoverageMap(coverage_file)
+    selected_tests = select_tests_to_run(diff_handler, coverage_map)
+    tests = sorted(selected_tests)
+    if not tests:
+        logger.info("No specific tests selected to run based on changes and coverage.")
+    if keep_prefix and relative_to and len(relative_to) > 1:
+        logger.warning(
+            "Trying to remove prefix with more than one path as filter is not allowed. "
+            "The keep_prefix flag will be set to True"
+        )
+        keep_prefix = True
+
+    if relative_to:
+        selected_tests = filter_by_path(selected_tests, relative_to, keep_prefix)
+
+    output = set()
+    for test in selected_tests:
+        output |= test.as_set()
+
+    output_content = " ".join(output)
+    if display:
+        print(output_content)
+    return output
+
+
+def get_default_branch() -> str:
+    """
+    Determine the default branch to diff against.
+
+    This function attempts to determine the default branch by inspecting the
+    output of `git remote show origin`. If it fails to determine the branch
+    (e.g., not in a git repository, or `origin` is not configured), it falls
+    back to "main".
+
+    Returns:
+        str: The name of the default branch (e.g., "main", "develop").
+    """
+    try:
+        output = subprocess.check_output(
+            ["git", "remote", "show", "origin"], stderr=subprocess.DEVNULL, text=True
+        )
+        for line in output.splitlines():
+            if "HEAD branch" in line:
+                return line.split(":")[-1].strip()
+    except Exception:
+        logger.info("Could not determine default branch, falling back to 'main'.")
+    return "main"
+
+
+def get_diff_content(diff_arg):
+    """
+    Get the diff content based on the provided argument.
+    It can either be a file path or a git ref/branch to diff against.
+    """
+    # If it's a file path and exists, read it as a file
+    if diff_arg:  # Only try Path if diff_arg is not None/empty
+        path = Path(diff_arg)
+        if path.exists():
+            return path.read_text()
+    # Otherwise, treat as git diff argument (branch/refspec)
+    branch = diff_arg if diff_arg else get_default_branch()
+    try:
+        diff = subprocess.check_output(
+            ["git", "diff", branch], stderr=subprocess.DEVNULL, text=True
+        )
+    except Exception as e:
+        print(f"skippy-cov: failed to get git diff for '{branch}': {e}", file=sys.stderr)
+        sys.exit(1)
+    else:
+        return diff
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        description="Select pytest tests based on diff and coverage."
+    )
+    parser.add_argument(
+        "--diff",
+        required=False,
+        help="Path to a diff file or a git ref/branch to diff against (default: main branch).",
+        default=None,
+    )
+    parser.add_argument(
+        "--coverage-file",
+        required=False,
+        help="Path to the coverage file (.coverage sqlite database).",
+        type=Path,
+        default=Path(".coverage"),
+    )
+    parser.add_argument(
+        "--relative-to",
+        required=False,
+        help="Display only tests contained in a folder",
+        type=Path,
+        nargs="+",
+        default=None,
+    )
+    parser.add_argument(
+        "--keep-prefix",
+        required=False,
+        default=True,
+        action="store_true",
+        help="When using --relative-to, determine if the original path should be kept or removed",
+    )
+    parser.add_argument(
+        "--strip-prefix",
+        dest="keep_prefix",
+        action="store_false",
+        help="When using --relative-to, determine if the original path should be kept or removed",
+    )
+    parser.add_argument(
+        "--debug", action="store_true", help="Enable debug logging.", default=False
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    args = parser.parse_args(argv)
+
+    if args.debug:
+        logging.basicConfig(level=logging.DEBUG)
+
+    diff_content = (
+        get_diff_content(args.diff) if args.diff is not None else get_diff_content(None)
+    )
+
+    run(
+        diff_content,
+        args.coverage_file,
+        args.relative_to,
+        args.keep_prefix,
+        display=True,
+    )

skippy_cov-0.2.0/skippy_cov/config_handler.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import configparser
+import sys
+from enum import Enum
+from pathlib import Path
+from typing import ClassVar
+
+"""
+mypy doesn't like this
+try:
+    import tomllib
+except ImportError:
+    import tomli as tomllib
+
+see https://github.com/python/mypy/issues/13914
+"""
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+
+_config: ConfigHandler | None = None
+
+
+def get_config() -> ConfigHandler:
+    global _config
+    if not _config:
+        _config = ConfigHandler(Path.cwd())
+    return _config
+
+
+class ConfigFormat(Enum):
+    INI = "ini"
+    TOML = "toml"
+
+
+class ConfigFileHandler:
+    values: dict[str, str] | None = None
+    section_name: str
+    parser: ConfigFormat
+
+    def __init__(self, config_path: Path):
+        self.config_path = Path(config_path)
+        self._parse()
+
+    def _parse(self) -> None:
+        if self.parser == ConfigFormat.INI:
+            self._parse_ini()
+        elif self.parser == ConfigFormat.TOML:
+            self._parse_toml()
+        else:
+            raise NotImplementedError(f"Unsupported {self.parser}")
+
+    def _parse_ini(self) -> None:
+        config = configparser.ConfigParser()
+        config.read_string(self.config_path.read_text())
+
+        cfgdict = {s: dict(config.items(s)) for s in config.sections()}
+        self.values = cfgdict.get(self.section_name, None)
+
+    def _parse_toml(self) -> None:
+        config = tomllib.loads(self.config_path.read_text())
+        # TOML nests the config, so we dig deep to find it
+        for section in self.section_name.split("."):
+            if config:
+                config = config.get(section, None)
+        self.values = config
+
+
+class IniHandler(ConfigFileHandler):
+    section_name = "pytest"
+    parser = ConfigFormat.INI
+
+
+class SetupCfgHandler(IniHandler):
+    section_name = "tool:pytest"
+    parser = ConfigFormat.INI
+
+
+class PyprojectTomlHandler(ConfigFileHandler):
+    section_name = "tool.pytest.ini_options"
+    parser = ConfigFormat.TOML
+
+
+class ConfigHandler:
+    configs: ClassVar[dict[str, type[ConfigFileHandler]]] = {
+        "pytest.ini": IniHandler,
+        ".pytest.ini": IniHandler,
+        "pyproject.toml": PyprojectTomlHandler,
+        "tox.ini": IniHandler,
+        "setup.cfg": SetupCfgHandler,
+    }
+    config_priority: ClassVar[list[str]] = [
+        "pytest.ini",
+        ".pytest.ini",
+        "pyproject.toml",
+        "tox.ini",
+        "setup.cfg",
+    ]
+
+    handler: ConfigFileHandler | None
+
+    def __init__(self, base_location: Path):
+        self.handler = self._discover_config(base_location)
+
+    def __bool__(self) -> bool:
+        return bool(self.handler)
+
+    def get_value(self, key: str) -> str | int | list[str] | None:
+        if not self.handler or not self.handler.values:
+            return None
+        return self.handler.values.get(key)
+
+    def _discover_config(self, base: Path) -> ConfigFileHandler | None:
+        """
+        Find config files in current or any parent directory
+            and return a ConfigFileHandler for the corresponding format
+        looks for the following (in order of preference):
+            - pytest.ini
+            - pyproject.toml
+            - tox.ini
+            - setup.cfg
+
+            see: https://docs.pytest.org/en/stable/reference/customize.html#configuration-file-formats
+        """
+        for current in [base, *base.absolute().parents]:
+            config = {
+                path.name for path in current.iterdir() if path.name in self.configs
+            }
+            if config:
+                top_config = sorted(config, key=self.config_priority.index)[0]
+                cls = self.configs[top_config]
+                cfg_path = current / top_config
+                return cls(cfg_path)
+        return None

skippy_cov-0.2.0/skippy_cov/diff_handler.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import io
+import logging
+from collections import defaultdict
+from pathlib import Path
+
+from unidiff import PatchSet
+
+logger = logging.getLogger(__name__)
+
+
+class DiffHandlerError(Exception):
+    pass
+
+
+class DiffHandler:
+    def __init__(self, contents: str):
+        """
+        Args:
+            diff_file: The contents of the file containing the full output of a 'git diff' command.
+
+        Raises:
+            FileNotFoundError: If the specified diff file does not exist.
+        """
+        self.changes = self.parse_diff(contents)
+
+    @property
+    def changed_files(self) -> set[Path]:
+        return set(self.changes.keys())
+
+    def __getitem__(self, key: Path) -> str:
+        return self.changes[key]
+
+    def parse_diff(self, diff_text: str) -> defaultdict[Path, str]:
+        """
+        Parses the full text output of 'git diff' using the 'unidiff' library.
+
+        Args:
+            diff_text: A string containing the full output of a 'git diff' command.
+
+        Returns:
+            A set of unique file paths affected by the diff and the affected diff
+        """
+        mapped_changes: defaultdict[Path, str] = defaultdict(str)
+        try:
+            patch_set = PatchSet(io.StringIO(diff_text))
+
+            for patched_file in patch_set:
+                if patched_file.is_removed_file:
+                    path = patched_file.source_file
+                    if path.startswith("a/"):
+                        path = path[2:]
+                else:
+                    path = patched_file.target_file
+                    if path.startswith("b/"):
+                        path = path[2:]
+                mapped_changes[Path(path)] = str(patched_file).strip()
+        except Exception as e:
+            logger.exception("Failed to parse diff using unidiff")
+            raise DiffHandlerError() from e
+
+        return mapped_changes

skippy_cov-0.2.0/skippy_cov/plugin.py

@@ -0,0 +1,80 @@
+import logging
+from pathlib import Path
+
+import pytest
+
+from skippy_cov.__main__ import run
+
+logger = logging.getLogger(__name__)
+
+
+def pytest_addoption(parser):
+    group = parser.getgroup("skippy-cov", "Options for skippy coverage-based collection")
+
+    group.addoption(
+        "--skippy-cov",
+        required=False,
+        dest="skippy_cov",
+        action="store_true",
+        help="Enable skippy-cov",
+    )
+
+    group.addoption(
+        "--skippy-cov-diff",
+        required=False,
+        help="Path to a diff file or a git ref/branch to diff against (default: main branch).",
+        default=None,
+    )
+    group.addoption(
+        "--skippy-cov-coverage-file",
+        required=False,
+        help="Path to the coverage file (.coverage sqlite database).",
+        type=Path,
+        default=Path(".coverage"),
+    )
+    group.addoption(
+        "--skippy-cov-keep-prefix",
+        required=False,
+        default=True,
+        dest="skippy_cov_keep_prefix",
+        action="store_true",
+        help="When using --skippy-cov-relative-to, determine if the original path should be kept or removed",
+    )
+    group.addoption(
+        "--skippy-cov-strip-prefix",
+        dest="skippy_cov_keep_prefix",
+        action="store_false",
+        help="When using --skippy-cov-relative-to, determine if the original path should be kept or removed",
+    )
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_configure(config):
+    """
+    Attempts to filter tests using skippy-cov
+    """
+    skippy_cov = config.getoption("skippy_cov")
+    diff_arg = config.getoption("skippy_cov_diff")
+    cov_file = config.getoption("skippy_cov_coverage_file")
+    keep_prefix = config.getoption("skippy_cov_keep_prefix")
+    if not skippy_cov:
+        return
+
+    # Import get_diff_content from __main__ to match CLI logic
+    from skippy_cov.__main__ import get_diff_content
+
+    diff_content = (
+        get_diff_content(diff_arg) if diff_arg is not None else get_diff_content(None)
+    )
+
+    relative_to = [Path(x) for x in config.args if x]
+    selected_tests = run(
+        diff_content,
+        cov_file,
+        relative_to,
+        keep_prefix,
+    )
+    if selected_tests:
+        config.args = selected_tests
+    else:
+        pytest.exit("skippy-cov: couldn't find any tests to filter.", returncode=5)

skippy_cov-0.2.0/skippy_cov/tests_finder.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+class ASTTestsFinder(ast.NodeVisitor):
+    """
+    Visits an AST tree and collects test functions and methods
+    following basic pytest discovery conventions:
+    - Top-level functions `test_*`
+    - Classes `Test*` containing methods `test_*`
+        - Classes with an `__init__` method are ignored
+    See: https://docs.pytest.org/en/latest/explanation/goodpractices.html#conventions-for-python-test-discovery
+    """
+
+    def __init__(self, file_path: Path):
+        self.file_path = file_path
+        self.tests: set[str] = set()
+        self.current_class_name: str | None = None
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> None:
+        """Visit Class Definitions."""
+
+        # TODO: consider python_classes and python_functions parameters on config
+        # SEE: https://docs.pytest.org/en/stable/example/pythoncollection.html#changing-naming-conventions
+        class_has_init_method = any(
+            hasattr(method, "name") and method.name == "__init__" for method in node.body
+        )
+        if node.name.startswith("Test") and not class_has_init_method:
+            original_class_name = self.current_class_name
+            self.current_class_name = node.name
+            self.generic_visit(node)
+            self.current_class_name = original_class_name
+        else:
+            pass
+
+    def visit_FunctionDef(self, node: ast.FunctionDef | ast.AsyncFunctionDef) -> None:
+        """Visit Function (and Method) Definitions."""
+
+        # TODO: consider python_classes and python_functions parameters on config
+        # SEE: https://docs.pytest.org/en/stable/example/pythoncollection.html#changing-naming-conventions
+        if node.name.startswith("test_"):
+            if self.current_class_name:
+                test_id = f"{self.current_class_name}::{node.name}"
+                self.tests.add(test_id)
+            else:
+                test_id = node.name
+                self.tests.add(test_id)
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
+        """Visit Async Function (and Method) Definitions."""
+        return self.visit_FunctionDef(node)

skippy_cov-0.2.0/skippy_cov/utils.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from fnmatch import fnmatch
+from pathlib import Path
+
+import coverage
+
+from skippy_cov.config_handler import get_config
+
+DEFAULT_GLOB_PATTERN = "test_*.py"
+
+
+class FilterCandidatesError(ValueError):
+    def __init__(self, *args, paths: list[Path], **kwargs):
+        super().__init__(*args, **kwargs)
+        self.message = f"Attempting to relativize based in multiple paths: {paths}"
+
+
+@dataclass
+class FileTestCandidate:
+    path: Path
+    tests: set[str]
+
+    def __lt__(self, other: object) -> bool:
+        if not isinstance(other, FileTestCandidate):
+            raise NotImplementedError
+        return self.path < other.path
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, FileTestCandidate):
+            raise NotImplementedError
+        return self.path == other.path and self.tests == other.tests
+
+    def as_set(self) -> set[str]:
+        tests = set()
+        for test in self.tests:
+            tests.add(f"{self.path.as_posix()}::{test}")
+        return tests
+
+
+def is_test_file(file_path: Path) -> bool:
+    """
+    Checks if a file is a test file based on its name.
+
+    Checks if a config file is present. If so, tries to use the `python_files` key
+    from the config file.
+    Otherwise uses the default glob pattern. (test_*.py)
+    """
+
+    # TODO: consider pytest flags such as `ignore`, `addopts`, etc...
+    # config_handler.ConfigHandler should already handle it,
+    #   but I want to have something working before sinking more hours into this
+    # SEE: https://docs.pytest.org/en/stable/example/pythoncollection.html#changing-naming-conventions
+    cfg = get_config()
+    if (
+        bool(cfg)
+        and (patterns := cfg.get_value("python_files"))
+        and isinstance(patterns, str)
+    ):
+        return any(fnmatch(file_path.name, pattern) for pattern in patterns.split(" "))
+
+    return fnmatch(file_path.name, DEFAULT_GLOB_PATTERN)
+
+
+def _fix_test_name(test_name: str) -> str:
+    """
+    Removes everything after the last `|` from the test name.
+    Most likely, this is the phase name and not part of the test name or parameters.
+    """
+    return test_name.rsplit("|", 1)[0]
+
+
+def filter_by_path(
+    candidates: list[FileTestCandidate],
+    from_folders: list[Path],
+    keep_prefix: bool = True,
+) -> list[FileTestCandidate]:
+    """
+    Filters a list of FileTestCandidate objects based on a starting folder and depth.
+
+    Args:
+        candidates: A list of FileTestCandidate objects to filter.
+        from_folders: A list of Path objects representing the starting folder.
+        keep_prefix: A boolean, if true, the origial path is kept, if false it's removed
+    Returns:
+        A new list of FileTestCandidate objects that satisfy the filtering criteria.
+    Raises:
+        FilterCandidatesError: If `keep_prefix` is false and there's more than 1 path to filter,
+                    Which doesn't make sense.
+    """
+    filtered_candidates: list[FileTestCandidate] = []
+
+    if not keep_prefix and len(from_folders) > 1:
+        raise FilterCandidatesError(paths=from_folders)
+
+    for candidate in candidates:
+        for filepath in from_folders:
+            try:
+                relative_path = candidate.path.relative_to(filepath)
+            except ValueError:
+                # The candidate is not within the from_folder, so skip it
+                continue
+            if not keep_prefix:
+                candidate.path = relative_path
+            filtered_candidates.append(candidate)
+
+    return filtered_candidates
+
+
+class CoverageMap:
+    db: coverage.CoverageData
+
+    def __init__(self, filepath: Path):
+        self.db = coverage.CoverageData(filepath.name)
+        self.db.read()
+
+    def get_tests(self, filepath: Path) -> FileTestCandidate | None:
+        tests = set()
+        for line_tests in self.db.contexts_by_lineno(filepath.as_posix()).values():
+            tests |= {_fix_test_name(test) for test in line_tests}
+        if tests:
+            return FileTestCandidate(path=filepath, tests=tests)
+        return None