coverage-flashlight 1.0.0__tar.gz

coverage_flashlight-1.0.0/.github/workflows/release.yml

@@ -0,0 +1,119 @@
+name: Release
+run-name: Release ${{ inputs.release_type }} from ${{ github.ref_name }}
+on:
+  workflow_dispatch:
+    inputs:
+      release_type:
+        description: Select release type
+        required: true
+        type: choice
+        options: [release-current, dev, release-patch, release-minor]
+        default: dev
+concurrency:
+  group: release-${{ github.ref }}
+  cancel-in-progress: false
+env:
+  UV_PYTHON: "3.13"
+  UV_VERSION: "0.10.6"
+jobs:
+  publish:
+    name: Publish PyPI package and GitHub release
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      contents: write
+      id-token: write
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+      - uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
+        with:
+          version: ${{ env.UV_VERSION }}
+          enable-cache: true
+          cache-dependency-glob: uv.lock
+      - run: uv python install "$UV_PYTHON"
+      - name: Select version
+        id: version
+        env:
+          RELEASE_TYPE: ${{ inputs.release_type }}
+        run: |
+          CURRENT=$(uv version --short)
+          case "$RELEASE_TYPE" in
+            release-current) ;;
+            dev)
+              if [[ "$CURRENT" == *".dev"* ]]; then
+                uv version --bump dev
+              else
+                uv version --bump patch --bump dev
+              fi ;;
+            release-patch)
+              if [[ "$CURRENT" == *".dev"* ]]; then
+                uv version --bump stable
+              else
+                uv version --bump patch
+              fi ;;
+            release-minor) uv version --bump minor ;;
+            *) exit 1 ;;
+          esac
+          VERSION=$(uv version --short)
+          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
+          echo "tag=v$VERSION" >> "$GITHUB_OUTPUT"
+          if [[ "$VERSION" == *".dev"* ]]; then
+            echo "prerelease=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "prerelease=false" >> "$GITHUB_OUTPUT"
+          fi
+      - run: uv sync --locked --all-extras
+      - run: uv run pytest
+      - run: uv run ruff check .
+      - run: uv run ruff format --check .
+      - run: uv build
+      - name: Verify installed wheel and packaged report assets
+        run: |
+          wheel=(dist/*.whl)
+          uv venv /tmp/flashlight-wheel
+          uv pip install --python /tmp/flashlight-wheel/bin/python "${wheel[0]}"
+          /tmp/flashlight-wheel/bin/flashlight --help
+          mkdir /tmp/flashlight-smoke
+          cd /tmp/flashlight-smoke
+          printf 'answer = 42\n' > sample.py
+          /tmp/flashlight-wheel/bin/flashlight run -- sample.py
+          /tmp/flashlight-wheel/bin/flashlight run --trace -- sample.py
+          test -s htmlcov/flashlight.html
+          test -s htmlcov/execution.html
+      - name: Commit and tag version
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          VERSION: ${{ steps.version.outputs.version }}
+          TAG: ${{ steps.version.outputs.tag }}
+          RELEASE_TYPE: ${{ inputs.release_type }}
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git add pyproject.toml uv.lock
+          git diff --cached --check
+          if [[ "$RELEASE_TYPE" == "release-current" ]]; then
+            git diff --cached --exit-code
+          else
+            git commit -m "$VERSION"
+          fi
+          git tag "$TAG"
+          gh auth setup-git
+          git push --atomic origin "HEAD:$GITHUB_REF_NAME" "refs/tags/$TAG"
+      - name: Publish to PyPI
+        run: uv publish --trusted-publishing always
+      - name: Create GitHub release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAG: ${{ steps.version.outputs.tag }}
+          PRERELEASE: ${{ steps.version.outputs.prerelease }}
+        run: |
+          args=("$TAG" dist/* --verify-tag --generate-notes --title "$TAG")
+          if [[ "$PRERELEASE" == "true" ]]; then
+            args+=(--prerelease)
+          else
+            args+=(--latest)
+          fi
+          gh release create "${args[@]}"

coverage_flashlight-1.0.0/.github/workflows/test.yml

@@ -0,0 +1,23 @@
+name: Test
+on: [push, pull_request]
+permissions:
+  contents: read
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+        python: ["3.11", "3.14"]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
+        with:
+          version: "0.10.6"
+          python-version: ${{ matrix.python }}
+      - run: uv sync --locked --all-extras
+      - run: uv run pytest
+      - run: uv run ruff check .
+      - run: uv run ruff format --check .
+      - run: uv build

coverage_flashlight-1.0.0/.gitignore

@@ -0,0 +1,11 @@
+.venv/
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.ruff_cache/
+.coverage
+.coverage.*
+htmlcov/
+dist/
+build/
+*.egg-info/

coverage_flashlight-1.0.0/LICENSE

@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+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, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

coverage_flashlight-1.0.0/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.5
+Name: coverage-flashlight
+Version: 1.0.0
+Summary: Explore Python coverage and replay execution with a code flashlight.
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: coverage>=7.10.6
+Provides-Extra: pytest
+Requires-Dist: pytest>=8; extra == 'pytest'
+Description-Content-Type: text/markdown
+
+# Coverage flashlight
+
+See which Python code ran, then replay its execution as a flashlight revealing
+source through fog. Reports are standalone HTML with source snapshots, shared
+light/dark themes, and no server or external assets.
+
+## Install and run
+
+Install in the environment containing the program and its dependencies:
+
+```sh
+uv add --dev 'coverage-flashlight[pytest]'
+# Or: python -m pip install 'coverage-flashlight[pytest]'
+```
+
+## Usage
+
+```sh
+# Static per-test line/branch coverage; pytest arguments follow --.
+flashlight pytest -- tests/ -k database
+
+# Ordered playback, including threads and newly launched Python processes.
+flashlight pytest --trace -- tests/ -k database
+
+# A script, with its arguments, executed once.
+flashlight run -- scripts/example.py --input sample.bin
+flashlight run --trace -- scripts/example.py --input sample.bin
+
+# Python modules work too, including other test runners.
+flashlight run -m my_package --help
+flashlight run --trace -m unittest discover
+
+# Render existing coverage.py branch data without another run.
+flashlight report
+```
+
+Open **htmlcov/flashlight.html** for static coverage or
+**htmlcov/execution.html** for playback. Use `--output path/to/report.html`
+before `--` to choose another destination. `python -m coverage_flashlight`
+is equivalent to `flashlight`.
+
+Coverage and tracing are separate modes: a command never silently runs a script
+twice. `--trace` selects execution recording instead of coverage.py. To create
+both reports, run the two commands explicitly. The program's exit status is
+preserved and failed runs still produce a report. Pytest mode continues recording
+other cases after a failure and returns a nonzero status.
+
+Pytest is an optional adapter. Static measurement uses coverage.py; ordered
+playback uses Python trace events. Script/module execution requires no pytest
+installation. Each pytest case runs in its own interpreter with its own context,
+which also follows newly launched Python children. This includes fixture setup
+and teardown. Isolation is slower than a normal suite run and can expose fixture
+or order dependencies; continue running ordinary tests for correctness.
+
+## Source selection
+
+Run from the target project's root. By default, the tool includes Python files
+inside that root, excluding hidden directories, virtual environments, build
+outputs, and node_modules. Narrow this with `--source src --source tests` or:
+
+```toml
+[tool.coverage-flashlight]
+source = ["src/my_package"]
+trace-source = ["src/my_package", "tests"]
+omit = ["*/generated/*"]
+```
+
+Paths are project-relative files or directories, not import names. `trace-source`
+defaults to `source`; absent both, the project root is used. `--source` overrides
+the configured selection for the current command. Keep source files inside the
+project root. Selected but unexecuted files remain visible in the reports.
+
+Coverage mode writes fresh data to `.coverage` after collection, replacing its
+previous contents. Use `--data-file path` to keep a separate database. It enables
+branch measurement and subprocess/`os._exit()` coverage itself; no coverage.py
+configuration is required. Existing report exclusion rules are respected when
+rendering. `flashlight report` can also render a combined database collected by
+coverage.py or pytest-cov, preserving its context names.
+
+Raw recordings and manifests are kept beside the report under `runs/<run-id>/`.
+The default trace cap is 100,000 events per process; increase it with
+`--max-events 500000`. Capture caps, interrupted hooks, source I/O failures, and
+missing process completion markers are explicitly reported.
+
+## Reading the reports
+
+Static coverage distinguishes executed lines, branch gaps, execution in another
+scope, and unexecuted statements. Select a line to inspect its contexts and missing
+branch destinations. Coverage is evidence of execution, not proof of assertions.
+
+Playback offers Play/Pause, stepping, timeline scrubbing, Next new line, a pytest
+Test body shortcut, Whole run, and process/thread selection. Unrevealed ranges
+collapse to grey `…` rows; Reveal source context expands them without marking
+them visited. Selecting a module pauses playback; Follow execution restores
+automatic navigation. The module map and source scroll inside the window.
+
+The timeline records observed event order, not variable history or cross-thread
+causality. Speed is events per second, not original elapsed time. Generator
+suspension produces Python return/call events. Native code, generated code with
+synthetic filenames, pre-existing processes, and threads created outside Python's
+threading module are outside capture. A forcibly killed process can lose its
+buffered tail. A skipped test can have no events. The source snapshot must remain
+consistent across cases; changed source is rejected rather than misattributed.
+
+Tracing changes timing and cannot share a trace hook with coverage.py or a
+debugger. Pytest-xdist parallel execution is rejected: per-case subprocess
+isolation already supplies attribution. Python children using `-S` or `-I`
+can bypass the opt-in bootstrap. No startup hook is installed globally.
+
+## Development and releases
+
+```sh
+uv sync --all-extras
+uv run pytest
+uv run ruff check .
+uv run ruff format --check .
+uv build
+```
+
+Tests use disposable Python projects, real threads/subprocesses, failing and
+skipped cases, arbitrary pytest layouts, and actual script/module entry points.
+They require no IDA installation. HTML, CSS and the opt-in bootstrap ship in the
+wheel and source distribution.
+
+The manual `Release` GitHub Actions workflow supports `release-current`, `dev`,
+`release-patch`, and `release-minor`. It tests, builds and checks the wheel, commits
+an optional version bump, creates a tag, publishes with `uv publish`, and creates
+a GitHub release. Versioning uses `uv version`; there is only one package version.
+
+To enable publication, create the GitHub repository and configure a PyPI trusted
+publisher for project **coverage-flashlight**, your repository owner/name,
+workflow **release.yml**, and environment **pypi**. Create that GitHub environment
+and allow the workflow to push release commits/tags. No PyPI API token is needed.
+These setup steps do not publish anything until the workflow is dispatched.
+
+References: [uv publishing](https://docs.astral.sh/uv/guides/package/),
+[coverage.py subprocess measurement](https://coverage.readthedocs.io/en/latest/subprocess.html),
+[Python tracing](https://docs.python.org/3/library/sys.html#sys.settrace).

coverage_flashlight-1.0.0/README.md

@@ -0,0 +1,138 @@
+# Coverage flashlight
+
+See which Python code ran, then replay its execution as a flashlight revealing
+source through fog. Reports are standalone HTML with source snapshots, shared
+light/dark themes, and no server or external assets.
+
+## Install and run
+
+Install in the environment containing the program and its dependencies:
+
+```sh
+uv add --dev 'coverage-flashlight[pytest]'
+# Or: python -m pip install 'coverage-flashlight[pytest]'
+```
+
+## Usage
+
+```sh
+# Static per-test line/branch coverage; pytest arguments follow --.
+flashlight pytest -- tests/ -k database
+
+# Ordered playback, including threads and newly launched Python processes.
+flashlight pytest --trace -- tests/ -k database
+
+# A script, with its arguments, executed once.
+flashlight run -- scripts/example.py --input sample.bin
+flashlight run --trace -- scripts/example.py --input sample.bin
+
+# Python modules work too, including other test runners.
+flashlight run -m my_package --help
+flashlight run --trace -m unittest discover
+
+# Render existing coverage.py branch data without another run.
+flashlight report
+```
+
+Open **htmlcov/flashlight.html** for static coverage or
+**htmlcov/execution.html** for playback. Use `--output path/to/report.html`
+before `--` to choose another destination. `python -m coverage_flashlight`
+is equivalent to `flashlight`.
+
+Coverage and tracing are separate modes: a command never silently runs a script
+twice. `--trace` selects execution recording instead of coverage.py. To create
+both reports, run the two commands explicitly. The program's exit status is
+preserved and failed runs still produce a report. Pytest mode continues recording
+other cases after a failure and returns a nonzero status.
+
+Pytest is an optional adapter. Static measurement uses coverage.py; ordered
+playback uses Python trace events. Script/module execution requires no pytest
+installation. Each pytest case runs in its own interpreter with its own context,
+which also follows newly launched Python children. This includes fixture setup
+and teardown. Isolation is slower than a normal suite run and can expose fixture
+or order dependencies; continue running ordinary tests for correctness.
+
+## Source selection
+
+Run from the target project's root. By default, the tool includes Python files
+inside that root, excluding hidden directories, virtual environments, build
+outputs, and node_modules. Narrow this with `--source src --source tests` or:
+
+```toml
+[tool.coverage-flashlight]
+source = ["src/my_package"]
+trace-source = ["src/my_package", "tests"]
+omit = ["*/generated/*"]
+```
+
+Paths are project-relative files or directories, not import names. `trace-source`
+defaults to `source`; absent both, the project root is used. `--source` overrides
+the configured selection for the current command. Keep source files inside the
+project root. Selected but unexecuted files remain visible in the reports.
+
+Coverage mode writes fresh data to `.coverage` after collection, replacing its
+previous contents. Use `--data-file path` to keep a separate database. It enables
+branch measurement and subprocess/`os._exit()` coverage itself; no coverage.py
+configuration is required. Existing report exclusion rules are respected when
+rendering. `flashlight report` can also render a combined database collected by
+coverage.py or pytest-cov, preserving its context names.
+
+Raw recordings and manifests are kept beside the report under `runs/<run-id>/`.
+The default trace cap is 100,000 events per process; increase it with
+`--max-events 500000`. Capture caps, interrupted hooks, source I/O failures, and
+missing process completion markers are explicitly reported.
+
+## Reading the reports
+
+Static coverage distinguishes executed lines, branch gaps, execution in another
+scope, and unexecuted statements. Select a line to inspect its contexts and missing
+branch destinations. Coverage is evidence of execution, not proof of assertions.
+
+Playback offers Play/Pause, stepping, timeline scrubbing, Next new line, a pytest
+Test body shortcut, Whole run, and process/thread selection. Unrevealed ranges
+collapse to grey `…` rows; Reveal source context expands them without marking
+them visited. Selecting a module pauses playback; Follow execution restores
+automatic navigation. The module map and source scroll inside the window.
+
+The timeline records observed event order, not variable history or cross-thread
+causality. Speed is events per second, not original elapsed time. Generator
+suspension produces Python return/call events. Native code, generated code with
+synthetic filenames, pre-existing processes, and threads created outside Python's
+threading module are outside capture. A forcibly killed process can lose its
+buffered tail. A skipped test can have no events. The source snapshot must remain
+consistent across cases; changed source is rejected rather than misattributed.
+
+Tracing changes timing and cannot share a trace hook with coverage.py or a
+debugger. Pytest-xdist parallel execution is rejected: per-case subprocess
+isolation already supplies attribution. Python children using `-S` or `-I`
+can bypass the opt-in bootstrap. No startup hook is installed globally.
+
+## Development and releases
+
+```sh
+uv sync --all-extras
+uv run pytest
+uv run ruff check .
+uv run ruff format --check .
+uv build
+```
+
+Tests use disposable Python projects, real threads/subprocesses, failing and
+skipped cases, arbitrary pytest layouts, and actual script/module entry points.
+They require no IDA installation. HTML, CSS and the opt-in bootstrap ship in the
+wheel and source distribution.
+
+The manual `Release` GitHub Actions workflow supports `release-current`, `dev`,
+`release-patch`, and `release-minor`. It tests, builds and checks the wheel, commits
+an optional version bump, creates a tag, publishes with `uv publish`, and creates
+a GitHub release. Versioning uses `uv version`; there is only one package version.
+
+To enable publication, create the GitHub repository and configure a PyPI trusted
+publisher for project **coverage-flashlight**, your repository owner/name,
+workflow **release.yml**, and environment **pypi**. Create that GitHub environment
+and allow the workflow to push release commits/tags. No PyPI API token is needed.
+These setup steps do not publish anything until the workflow is dispatched.
+
+References: [uv publishing](https://docs.astral.sh/uv/guides/package/),
+[coverage.py subprocess measurement](https://coverage.readthedocs.io/en/latest/subprocess.html),
+[Python tracing](https://docs.python.org/3/library/sys.html#sys.settrace).

coverage_flashlight-1.0.0/pyproject.toml

@@ -0,0 +1,32 @@
+[project]
+name = "coverage-flashlight"
+version = "1.0.0"
+description = "Explore Python coverage and replay execution with a code flashlight."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+dependencies = ["coverage>=7.10.6"]
+
+[project.optional-dependencies]
+pytest = ["pytest>=8"]
+
+[project.scripts]
+flashlight = "coverage_flashlight.cli:main"
+
+[dependency-groups]
+dev = ["pytest>=8", "ruff>=0.12.0"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/coverage_flashlight"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.coverage-flashlight]
+source = ["src/coverage_flashlight"]
+trace-source = ["src/coverage_flashlight", "tests"]

coverage_flashlight-1.0.0/src/coverage_flashlight/__init__.py

@@ -0,0 +1 @@
+"""Coverage reports and opt-in ordered Python execution recording."""

coverage_flashlight-1.0.0/src/coverage_flashlight/__main__.py

@@ -0,0 +1,3 @@
+from coverage_flashlight.cli import main
+
+raise SystemExit(main())

coverage_flashlight-1.0.0/src/coverage_flashlight/bootstrap/sitecustomize.py

@@ -0,0 +1,20 @@
+"""Opt-in child-process bootstrap; used only by the execution flashlight runner."""
+
+import importlib.machinery
+import importlib.util
+import os
+import sys
+from pathlib import Path
+
+# Preserve the environment's own startup customization.
+_here = Path(__file__).parent.resolve()
+_existing = importlib.machinery.PathFinder.find_spec(
+    "sitecustomize", [path for path in sys.path if Path(path).resolve() != _here]
+)
+if _existing is not None and _existing.loader is not None:
+    _existing.loader.exec_module(importlib.util.module_from_spec(_existing))
+
+if os.environ.get("COVERAGE_FLASHLIGHT_DIR"):
+    from coverage_flashlight.trace import install
+
+    install()

coverage_flashlight-1.0.0/src/coverage_flashlight/cli.py

@@ -0,0 +1,107 @@
+"""The flashlight command; target arguments are passed through after --."""
+
+import argparse
+import subprocess
+from importlib.metadata import version
+from pathlib import Path
+
+from coverage.exceptions import CoverageException
+
+from coverage_flashlight.config import project_sources
+from coverage_flashlight.runner import measure, render_coverage
+
+
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="flashlight",
+        description="Explore Python coverage or replay executed lines.",
+    )
+    parser.add_argument(
+        "--version", action="version", version=version("coverage-flashlight")
+    )
+    commands = parser.add_subparsers(dest="command", required=True)
+    for name, help_text in [
+        ("pytest", "Measure each selected pytest case"),
+        ("run", "Execute a Python script or module once"),
+    ]:
+        command = commands.add_parser(name, help=help_text)
+        command.add_argument(
+            "--trace",
+            action="store_true",
+            help="record ordered execution instead of line/branch coverage",
+        )
+        command.add_argument(
+            "--source",
+            action="append",
+            help="project-relative source file or directory; repeat for multiple paths",
+        )
+        command.add_argument(
+            "--output",
+            type=Path,
+            help="HTML report path (default: htmlcov/flashlight.html or execution.html)",
+        )
+        command.add_argument(
+            "--data-file",
+            type=Path,
+            default=Path(".coverage"),
+            help="coverage database to replace (coverage mode only)",
+        )
+        command.add_argument(
+            "--max-events",
+            type=int,
+            default=100_000,
+            help="maximum trace events per process",
+        )
+        if name == "run":
+            command.add_argument(
+                "-m",
+                "--module",
+                action="store_true",
+                help="run the target as a Python module",
+            )
+        command.add_argument(
+            "arguments", nargs=argparse.REMAINDER, help="target arguments, after --"
+        )
+    report = commands.add_parser(
+        "report", help="Render existing branch coverage without executing code"
+    )
+    report.add_argument("--data-file", type=Path, default=Path(".coverage"))
+    report.add_argument("--output", type=Path, default=Path("htmlcov/flashlight.html"))
+    args = parser.parse_args(argv)
+    try:
+        if args.command == "report":
+            if not args.data_file.is_file():
+                parser.error(f"Coverage database does not exist: {args.data_file}")
+            render_coverage(args.data_file, args.output, Path.cwd())
+            return 0
+        arguments = (
+            args.arguments[1:] if args.arguments[:1] == ["--"] else args.arguments
+        )
+        if args.command == "run" and not arguments:
+            parser.error("run requires a script path or module name")
+        if args.max_events <= 0:
+            parser.error("--max-events must be positive")
+        sources = project_sources(Path.cwd(), trace=args.trace, override=args.source)
+        return measure(
+            arguments,
+            args.output
+            or Path(
+                "htmlcov/execution.html" if args.trace else "htmlcov/flashlight.html"
+            ),
+            sources,
+            trace=args.trace,
+            pytest=args.command == "pytest",
+            module=getattr(args, "module", False),
+            max_events=args.max_events,
+            data_file=args.data_file,
+        )
+    except subprocess.CalledProcessError as error:
+        return error.returncode
+    except (ValueError, OSError, CoverageException) as error:
+        parser.error(str(error))
+    except KeyboardInterrupt:
+        return 130
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())