pytest-codspeed 3.2.0__tar.gz → 4.0.0__tar.gz

{pytest_codspeed-3.2.0/src/pytest_codspeed.egg-info → pytest_codspeed-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: pytest-codspeed
-Version: 3.2.0
+Version: 4.0.0
 Summary: Pytest plugin to create CodSpeed benchmarks
 Author-email: Arthur Pastel <arthur@codspeed.io>
 License: The MIT License (MIT)
@@ -26,7 +26,7 @@ License: The MIT License (MIT)
         THE SOFTWARE.
         
 Project-URL: Homepage, https://codspeed.io/
-Project-URL: Documentation, https://docs.codspeed.io/
+Project-URL: Documentation, https://codspeed.io/docs/reference/pytest-codspeed
 Project-URL: Source, https://github.com/CodSpeedHQ/pytest-codspeed
 Keywords: codspeed,benchmark,performance,pytest
 Classifier: Development Status :: 5 - Production/Stable
@@ -52,7 +52,7 @@ Requires-Dist: rich>=13.8.1
 Requires-Dist: importlib-metadata>=8.5.0; python_version < "3.10"
 Provides-Extra: lint
 Requires-Dist: mypy~=1.11.2; extra == "lint"
-Requires-Dist: ruff~=0.6.5; extra == "lint"
+Requires-Dist: ruff~=0.11.12; extra == "lint"
 Provides-Extra: compat
 Requires-Dist: pytest-benchmark~=5.0.0; extra == "compat"
 Requires-Dist: pytest-xdist~=3.6.1; extra == "compat"
@@ -73,11 +73,11 @@ Pytest plugin to create CodSpeed benchmarks
 
 </div>
 
-## Requirements
+---
 
-**Python**: 3.9 and later
+**Documentation**: https://codspeed.io/docs/reference/pytest-codspeed
 
-**pytest**: any recent version
+---
 
 ## Installation
 
@@ -89,9 +89,9 @@ pip install pytest-codspeed
 
 ### Creating benchmarks
 
-Creating benchmarks with `pytest-codspeed` is compatible with the standard `pytest-benchmark` API. So if you already have benchmarks written with it, you can start using `pytest-codspeed` right away.
+In a nutshell, `pytest-codspeed` offers two approaches to create performance benchmarks that integrate seamlessly with your existing test suite.
 
-#### Marking a whole test function as a benchmark with `pytest.mark.benchmark`
+Use `@pytest.mark.benchmark` to measure entire test functions automatically:
 
 ```python
 import pytest
@@ -99,55 +99,53 @@ from statistics import median
 
 @pytest.mark.benchmark
 def test_median_performance():
-    return median([1, 2, 3, 4, 5])
+    input = [1, 2, 3, 4, 5]
+    output = sum(i**2 for i in input)
+    assert output == 55
 ```
 
-#### Benchmarking selected lines of a test function with the `benchmark` fixture
+Since this measure the entire function, you might want to use the `benchmark` fixture for precise control over what code gets measured:
 
 ```python
-import pytest
-from statistics import mean
-
 def test_mean_performance(benchmark):
-    # Precompute some data useful for the benchmark but that should not be
-    # included in the benchmark time
     data = [1, 2, 3, 4, 5]
+    # Only the function call is measured
+    result = benchmark(lambda: sum(i**2 for i in data))
+    assert result == 55
+```
 
-    # Benchmark the execution of the function
-    benchmark(lambda: mean(data))
-
+Check out the [full documentation](https://codspeed.io/docs/reference/pytest-codspeed) for more details.
 
-def test_mean_and_median_performance(benchmark):
-    # Precompute some data useful for the benchmark but that should not be
-    # included in the benchmark time
-    data = [1, 2, 3, 4, 5]
+### Testing the benchmarks locally
 
-    # Benchmark the execution of the function:
-    # The `@benchmark` decorator will automatically call the function and
-    # measure its execution
-    @benchmark
-    def bench():
-        mean(data)
-        median(data)
-```
+If you want to run the benchmarks tests locally, you can use the `--codspeed` pytest flag:
 
-### Running benchmarks
+```sh
+$ pytest tests/ --codspeed
+============================= test session starts ====================
+platform darwin -- Python 3.13.0, pytest-7.4.4, pluggy-1.5.0
+codspeed: 3.0.0 (enabled, mode: walltime, timer_resolution: 41.7ns)
+rootdir: /home/user/codspeed-test, configfile: pytest.ini
+plugins: codspeed-3.0.0
+collected 1 items
 
-#### Testing the benchmarks locally
+tests/test_sum_squares.py .                                    [ 100%]
 
-If you want to run only the benchmarks tests locally, you can use the `--codspeed` pytest flag:
-
-```shell
-pytest tests/ --codspeed
+                         Benchmark Results
+┏━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━┓
+┃     Benchmark  ┃ Time (best) ┃ Rel. StdDev ┃ Run time ┃ Iters  ┃
+┣━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━╋━━━━━━━━━━━━━╋━━━━━━━━━━╋━━━━━━━━┫
+┃test_sum_squares┃     1,873ns ┃        4.8% ┃    3.00s ┃ 66,930 ┃
+┗━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━┻━━━━━━━━━━━━━┻━━━━━━━━━━┻━━━━━━━━┛
+=============================== 1 benchmarked ========================
+=============================== 1 passed in 4.12s ====================
 ```
 
-> **Note:** Running `pytest-codspeed` locally will not produce any performance reporting. It's only useful for making sure that your benchmarks are working as expected. If you want to get performance reporting, you should run the benchmarks in your CI.
-
-#### In your CI
+### Running the benchmarks in your CI
 
 You can use the [CodSpeedHQ/action](https://github.com/CodSpeedHQ/action) to run the benchmarks in Github Actions and upload the results to CodSpeed.
 
-Example workflow:
+Here is an example of a GitHub Actions workflow that runs the benchmarks and reports the results to CodSpeed on every push to the `main` branch and every pull request:
 
 ```yaml
 name: CodSpeed
@@ -157,6 +155,9 @@ on:
     branches:
       - "main" # or "master"
   pull_request:
+  # `workflow_dispatch` allows CodSpeed to trigger backtest
+  # performance analysis in order to generate initial data.
+  workflow_dispatch:
 
 jobs:
   benchmarks:
@@ -166,9 +167,11 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v5
         with:
-          python-version: "3.12"
+          python-version: "3.13"
+
       - name: Install dependencies
         run: pip install -r requirements.txt
+
       - name: Run benchmarks
         uses: CodSpeedHQ/action@v3
         with:

pytest_codspeed-4.0.0/README.md

@@ -0,0 +1,118 @@
+<div align="center">
+<h1>pytest-codspeed</h1>
+
+[![CI](https://github.com/CodSpeedHQ/pytest-codspeed/actions/workflows/ci.yml/badge.svg)](https://github.com/CodSpeedHQ/pytest-codspeed/actions/workflows/ci.yml)
+[![PyPi Version](https://img.shields.io/pypi/v/pytest-codspeed?color=%2334D058&label=pypi)](https://pypi.org/project/pytest-codspeed)
+![Python Version](https://img.shields.io/badge/python-3.9%20|%203.10%20|%203.11%20|%203.12%20|%203.13-informational.svg)
+[![Discord](https://img.shields.io/badge/chat%20on-discord-7289da.svg)](https://discord.com/invite/MxpaCfKSqF)
+[![CodSpeed Badge](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://codspeed.io/CodSpeedHQ/pytest-codspeed)
+
+Pytest plugin to create CodSpeed benchmarks
+
+</div>
+
+---
+
+**Documentation**: https://codspeed.io/docs/reference/pytest-codspeed
+
+---
+
+## Installation
+
+```shell
+pip install pytest-codspeed
+```
+
+## Usage
+
+### Creating benchmarks
+
+In a nutshell, `pytest-codspeed` offers two approaches to create performance benchmarks that integrate seamlessly with your existing test suite.
+
+Use `@pytest.mark.benchmark` to measure entire test functions automatically:
+
+```python
+import pytest
+from statistics import median
+
+@pytest.mark.benchmark
+def test_median_performance():
+    input = [1, 2, 3, 4, 5]
+    output = sum(i**2 for i in input)
+    assert output == 55
+```
+
+Since this measure the entire function, you might want to use the `benchmark` fixture for precise control over what code gets measured:
+
+```python
+def test_mean_performance(benchmark):
+    data = [1, 2, 3, 4, 5]
+    # Only the function call is measured
+    result = benchmark(lambda: sum(i**2 for i in data))
+    assert result == 55
+```
+
+Check out the [full documentation](https://codspeed.io/docs/reference/pytest-codspeed) for more details.
+
+### Testing the benchmarks locally
+
+If you want to run the benchmarks tests locally, you can use the `--codspeed` pytest flag:
+
+```sh
+$ pytest tests/ --codspeed
+============================= test session starts ====================
+platform darwin -- Python 3.13.0, pytest-7.4.4, pluggy-1.5.0
+codspeed: 3.0.0 (enabled, mode: walltime, timer_resolution: 41.7ns)
+rootdir: /home/user/codspeed-test, configfile: pytest.ini
+plugins: codspeed-3.0.0
+collected 1 items
+
+tests/test_sum_squares.py .                                    [ 100%]
+
+                         Benchmark Results
+┏━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━┓
+┃     Benchmark  ┃ Time (best) ┃ Rel. StdDev ┃ Run time ┃ Iters  ┃
+┣━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━╋━━━━━━━━━━━━━╋━━━━━━━━━━╋━━━━━━━━┫
+┃test_sum_squares┃     1,873ns ┃        4.8% ┃    3.00s ┃ 66,930 ┃
+┗━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━┻━━━━━━━━━━━━━┻━━━━━━━━━━┻━━━━━━━━┛
+=============================== 1 benchmarked ========================
+=============================== 1 passed in 4.12s ====================
+```
+
+### Running the benchmarks in your CI
+
+You can use the [CodSpeedHQ/action](https://github.com/CodSpeedHQ/action) to run the benchmarks in Github Actions and upload the results to CodSpeed.
+
+Here is an example of a GitHub Actions workflow that runs the benchmarks and reports the results to CodSpeed on every push to the `main` branch and every pull request:
+
+```yaml
+name: CodSpeed
+
+on:
+  push:
+    branches:
+      - "main" # or "master"
+  pull_request:
+  # `workflow_dispatch` allows CodSpeed to trigger backtest
+  # performance analysis in order to generate initial data.
+  workflow_dispatch:
+
+jobs:
+  benchmarks:
+    name: Run benchmarks
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+
+      - name: Install dependencies
+        run: pip install -r requirements.txt
+
+      - name: Run benchmarks
+        uses: CodSpeedHQ/action@v3
+        with:
+          token: ${{ secrets.CODSPEED_TOKEN }}
+          run: pytest tests/ --codspeed
+```

{pytest_codspeed-3.2.0 → pytest_codspeed-4.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project.urls]
 Homepage = "https://codspeed.io/"
-Documentation = "https://docs.codspeed.io/"
+Documentation = "https://codspeed.io/docs/reference/pytest-codspeed"
 Source = "https://github.com/CodSpeedHQ/pytest-codspeed"
 
 [project]
@@ -37,7 +37,7 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
-lint = ["mypy ~= 1.11.2", "ruff ~= 0.6.5"]
+lint = ["mypy ~= 1.11.2", "ruff ~= 0.11.12"]
 compat = [
     "pytest-benchmark ~= 5.0.0",
     "pytest-xdist ~= 3.6.1",
@@ -66,7 +66,7 @@ version = { attr = "pytest_codspeed.__version__" }
 
 
 [tool.bumpver]
-current_version = "3.2.0"
+current_version = "4.0.0"
 version_pattern = "MAJOR.MINOR.PATCH[-TAG[NUM]]"
 commit_message = "Release v{new_version} 🚀"
 tag_message = "Release v{new_version} 🚀"

{pytest_codspeed-3.2.0 → pytest_codspeed-4.0.0}/setup.py

@@ -5,9 +5,7 @@ from pathlib import Path
 
 from setuptools import setup
 
-build_path = (
-    Path(__file__).parent / "src/pytest_codspeed/instruments/valgrind/_wrapper/build.py"
-)
+build_path = Path(__file__).parent / "src/pytest_codspeed/instruments/hooks/build.py"
 
 spec = importlib.util.spec_from_file_location("build", build_path)
 assert spec is not None, "The spec should be initialized"
@@ -52,8 +50,8 @@ print(
 setup(
     package_data={
         "pytest_codspeed": [
-            "instruments/valgrind/_wrapper/*.h",
-            "instruments/valgrind/_wrapper/*.c",
+            "instruments/hooks/instrument-hooks/includes/*.h",
+            "instruments/hooks/instrument-hooks/dist/*.c",
         ]
     },
     ext_modules=(

{pytest_codspeed-3.2.0 → pytest_codspeed-4.0.0}/src/pytest_codspeed/__init__.py

@@ -1,6 +1,6 @@
-__version__ = "3.2.0"
+__version__ = "4.0.0"
 # We also have the semver version since __version__ is not semver compliant
-__semver_version__ = "3.2.0"
+__semver_version__ = "4.0.0"
 
 from .plugin import BenchmarkFixture
 

pytest_codspeed-4.0.0/src/pytest_codspeed/config.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import dataclasses
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Generic, TypeVar
+
+T = TypeVar("T")
+
+if TYPE_CHECKING:
+    from typing import Any, Callable
+
+    import pytest
+
+
+@dataclass(frozen=True)
+class CodSpeedConfig:
+    """
+    The configuration for the codspeed plugin.
+    Usually created from the command line arguments.
+    """
+
+    warmup_time_ns: int | None = None
+    max_time_ns: int | None = None
+    max_rounds: int | None = None
+
+    @classmethod
+    def from_pytest_config(cls, config: pytest.Config) -> CodSpeedConfig:
+        warmup_time = config.getoption("--codspeed-warmup-time", None)
+        warmup_time_ns = (
+            int(warmup_time * 1_000_000_000) if warmup_time is not None else None
+        )
+        max_time = config.getoption("--codspeed-max-time", None)
+        max_time_ns = int(max_time * 1_000_000_000) if max_time is not None else None
+        return cls(
+            warmup_time_ns=warmup_time_ns,
+            max_rounds=config.getoption("--codspeed-max-rounds", None),
+            max_time_ns=max_time_ns,
+        )
+
+
+@dataclass(frozen=True)
+class BenchmarkMarkerOptions:
+    group: str | None = None
+    """The group name to use for the benchmark."""
+    min_time: int | None = None
+    """
+    The minimum time of a round (in seconds).
+    Only available in walltime mode.
+    """
+    max_time: int | None = None
+    """
+    The maximum time to run the benchmark for (in seconds).
+    Only available in walltime mode.
+    """
+    max_rounds: int | None = None
+    """
+    The maximum number of rounds to run the benchmark for.
+    Takes precedence over max_time. Only available in walltime mode.
+    """
+
+    @classmethod
+    def from_pytest_item(cls, item: pytest.Item) -> BenchmarkMarkerOptions:
+        marker = item.get_closest_marker(
+            "codspeed_benchmark"
+        ) or item.get_closest_marker("benchmark")
+        if marker is None:
+            return cls()
+        if len(marker.args) > 0:
+            raise ValueError(
+                "Positional arguments are not allowed in the benchmark marker"
+            )
+        kwargs = marker.kwargs
+
+        unknown_kwargs = set(kwargs.keys()) - {
+            field.name for field in dataclasses.fields(cls)
+        }
+        if unknown_kwargs:
+            raise ValueError(
+                "Unknown kwargs passed to benchmark marker: "
+                + ", ".join(sorted(unknown_kwargs))
+            )
+
+        return cls(**kwargs)
+
+
+@dataclass(frozen=True)
+class PedanticOptions(Generic[T]):
+    """Parameters for running a benchmark using the pedantic fixture API."""
+
+    target: Callable[..., T]
+    setup: Callable[[], Any | None] | None
+    teardown: Callable[..., Any | None] | None
+    rounds: int
+    warmup_rounds: int
+    iterations: int
+    args: tuple[Any, ...] = field(default_factory=tuple)
+    kwargs: dict[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if self.rounds < 0:
+            raise ValueError("rounds must be positive")
+        if self.warmup_rounds < 0:
+            raise ValueError("warmup_rounds must be non-negative")
+        if self.iterations <= 0:
+            raise ValueError("iterations must be positive")
+        if self.iterations > 1 and self.setup is not None:
+            raise ValueError(
+                "setup cannot be used with multiple iterations, use multiple rounds"
+            )
+
+    def setup_and_get_args_kwargs(self) -> tuple[tuple[Any, ...], dict[str, Any]]:
+        if self.setup is None:
+            return self.args, self.kwargs
+        maybe_result = self.setup(*self.args, **self.kwargs)
+        if maybe_result is not None:
+            if len(self.args) > 0 or len(self.kwargs) > 0:
+                raise ValueError("setup cannot return a value when args are provided")
+            return maybe_result
+        return self.args, self.kwargs

{pytest_codspeed-3.2.0 → pytest_codspeed-4.0.0}/src/pytest_codspeed/instruments/__init__.py

@@ -5,14 +5,14 @@ from enum import Enum
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, ClassVar, ParamSpec, TypeVar
+    from typing import Any, Callable, ClassVar, TypeVar
 
     import pytest
 
+    from pytest_codspeed.config import BenchmarkMarkerOptions, PedanticOptions
     from pytest_codspeed.plugin import CodSpeedConfig
 
     T = TypeVar("T")
-    P = ParamSpec("P")
 
 
 class Instrument(metaclass=ABCMeta):
@@ -27,11 +27,21 @@ class Instrument(metaclass=ABCMeta):
     @abstractmethod
     def measure(
         self,
+        marker_options: BenchmarkMarkerOptions,
+        name: str,
+        uri: str,
+        fn: Callable[..., T],
+        *args: tuple,
+        **kwargs: dict[str, Any],
+    ) -> T: ...
+
+    @abstractmethod
+    def measure_pedantic(
+        self,
+        marker_options: BenchmarkMarkerOptions,
+        pedantic_options: PedanticOptions[T],
         name: str,
         uri: str,
-        fn: Callable[P, T],
-        *args: P.args,
-        **kwargs: P.kwargs,
     ) -> T: ...
 
     @abstractmethod

pytest_codspeed-4.0.0/src/pytest_codspeed/instruments/hooks/__init__.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import os
+import sys
+import warnings
+from typing import TYPE_CHECKING
+
+from pytest_codspeed.utils import SUPPORTS_PERF_TRAMPOLINE
+
+if TYPE_CHECKING:
+    from .dist_instrument_hooks import InstrumentHooksPointer, LibType
+
+
+class InstrumentHooks:
+    """Zig library wrapper class providing benchmark measurement functionality."""
+
+    lib: LibType
+    instance: InstrumentHooksPointer
+
+    def __init__(self) -> None:
+        if os.environ.get("CODSPEED_ENV") is None:
+            raise RuntimeError(
+                "Can't run benchmarks outside of CodSpeed environment."
+                "Please set the CODSPEED_ENV environment variable."
+            )
+
+        try:
+            from .dist_instrument_hooks import lib  # type: ignore
+        except ImportError as e:
+            raise RuntimeError(f"Failed to load instrument hooks library: {e}") from e
+        self.lib = lib
+
+        self.instance = self.lib.instrument_hooks_init()
+        if self.instance == 0:
+            raise RuntimeError("Failed to initialize CodSpeed instrumentation library.")
+
+        if SUPPORTS_PERF_TRAMPOLINE:
+            sys.activate_stack_trampoline("perf")  # type: ignore
+
+    def __del__(self):
+        if hasattr(self, "lib") and hasattr(self, "instance"):
+            self.lib.instrument_hooks_deinit(self.instance)
+
+    def start_benchmark(self) -> None:
+        """Start a new benchmark measurement."""
+        ret = self.lib.instrument_hooks_start_benchmark(self.instance)
+        if ret != 0:
+            warnings.warn("Failed to start benchmark measurement", RuntimeWarning)
+
+    def stop_benchmark(self) -> None:
+        """Stop the current benchmark measurement."""
+        ret = self.lib.instrument_hooks_stop_benchmark(self.instance)
+        if ret != 0:
+            warnings.warn("Failed to stop benchmark measurement", RuntimeWarning)
+
+    def set_executed_benchmark(self, uri: str, pid: int | None = None) -> None:
+        """Set the executed benchmark URI and process ID.
+
+        Args:
+            uri: The benchmark URI string identifier
+            pid: Optional process ID (defaults to current process)
+        """
+        if pid is None:
+            pid = os.getpid()
+
+        ret = self.lib.instrument_hooks_executed_benchmark(
+            self.instance, pid, uri.encode("ascii")
+        )
+        if ret != 0:
+            warnings.warn("Failed to set executed benchmark", RuntimeWarning)
+
+    def set_integration(self, name: str, version: str) -> None:
+        """Set the integration name and version."""
+        ret = self.lib.instrument_hooks_set_integration(
+            self.instance, name.encode("ascii"), version.encode("ascii")
+        )
+        if ret != 0:
+            warnings.warn("Failed to set integration name and version", RuntimeWarning)
+
+    def is_instrumented(self) -> bool:
+        """Check if instrumentation is active."""
+        return self.lib.instrument_hooks_is_instrumented(self.instance)

pytest_codspeed-4.0.0/src/pytest_codspeed/instruments/hooks/build.py

@@ -0,0 +1,26 @@
+from pathlib import Path
+
+from cffi import FFI  # type: ignore
+
+ffibuilder = FFI()
+
+includes_dir = Path(__file__).parent.joinpath("instrument-hooks/includes")
+header_text = (includes_dir / "core.h").read_text()
+filtered_header = "\n".join(
+    line for line in header_text.splitlines() if not line.strip().startswith("#")
+)
+ffibuilder.cdef(filtered_header)
+
+ffibuilder.set_source(
+    "pytest_codspeed.instruments.hooks.dist_instrument_hooks",
+    """
+    #include "core.h"
+    """,
+    sources=[
+        "src/pytest_codspeed/instruments/hooks/instrument-hooks/dist/core.c",
+    ],
+    include_dirs=[str(includes_dir)],
+)
+
+if __name__ == "__main__":
+    ffibuilder.compile(verbose=True)

pytest_codspeed-4.0.0/src/pytest_codspeed/instruments/hooks/dist_instrument_hooks.pyi

@@ -0,0 +1,27 @@
+InstrumentHooksPointer = object
+
+class lib:
+    @staticmethod
+    def instrument_hooks_init() -> InstrumentHooksPointer: ...
+    @staticmethod
+    def instrument_hooks_deinit(hooks: InstrumentHooksPointer) -> None: ...
+    @staticmethod
+    def instrument_hooks_is_instrumented(hooks: InstrumentHooksPointer) -> bool: ...
+    @staticmethod
+    def instrument_hooks_start_benchmark(hooks: InstrumentHooksPointer) -> int: ...
+    @staticmethod
+    def instrument_hooks_stop_benchmark(hooks: InstrumentHooksPointer) -> int: ...
+    @staticmethod
+    def instrument_hooks_executed_benchmark(
+        hooks: InstrumentHooksPointer, pid: int, uri: bytes
+    ) -> int: ...
+    @staticmethod
+    def instrument_hooks_set_integration(
+        hooks: InstrumentHooksPointer, name: bytes, version: bytes
+    ) -> int: ...
+    @staticmethod
+    def callgrind_start_instrumentation() -> int: ...
+    @staticmethod
+    def callgrind_stop_instrumentation() -> int: ...
+
+LibType = type[lib]