pytest-codspeed 4.4.0__tar.gz → 5.0.0__tar.gz

{pytest_codspeed-4.4.0/src/pytest_codspeed.egg-info → pytest_codspeed-5.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-codspeed
-Version: 4.4.0
+Version: 5.0.0
 Summary: Pytest plugin to create CodSpeed benchmarks
 Author-email: Arthur Pastel <arthur@codspeed.io>
 License: The MIT License (MIT)
@@ -47,7 +47,6 @@ Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: cffi>=1.17.1
 Requires-Dist: pytest>=3.8
 Requires-Dist: rich>=13.8.1
 Requires-Dist: importlib-metadata>=8.5.0; python_version < "3.10"

{pytest_codspeed-4.4.0 → pytest_codspeed-5.0.0}/pyproject.toml

@@ -31,7 +31,6 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
-    "cffi >= 1.17.1",
     "pytest>=3.8",
     "rich>=13.8.1",
     "importlib-metadata>=8.5.0; python_version < '3.10'",
@@ -47,7 +46,7 @@ compat = [
 [tool.uv]
 # Python builds change with uv versions, and we are quite susceptible to that.
 # We pin uv to to make sure reproducibility is maintained for any contributor.
-required-version = "0.9.5"
+required-version = "0.11.14"
 
 [tool.uv.sources]
 pytest-codspeed = { workspace = true }
@@ -66,18 +65,23 @@ dev = [
 pytest11 = { codspeed = "pytest_codspeed.plugin" }
 
 [build-system]
-requires = ["setuptools >= 61", "cffi >= 1.17.1"]
+requires = ["setuptools >= 61"]
 build-backend = "setuptools.build_meta"
 
 [tool.setuptools]
 license-files = [] # Workaround of https://github.com/astral-sh/uv/issues/9513
 
+[tool.setuptools.package-data]
+pytest_codspeed = [
+    "instruments/hooks/instrument-hooks/includes/*.h",
+]
+
 [tool.setuptools.dynamic]
 version = { attr = "pytest_codspeed.__version__" }
 
 
 [tool.bumpver]
-current_version = "4.4.0"
+current_version = "5.0.0"
 version_pattern = "MAJOR.MINOR.PATCH[-TAG[NUM]]"
 commit_message = "Release v{new_version} 🚀"
 tag_message = "Release v{new_version} 🚀"
@@ -98,7 +102,7 @@ push = false
 ]
 
 [tool.cibuildwheel]
-build = "cp*manylinux*"
+build = "cp*{manylinux,macosx}*"
 test-extras = ["build", "test", "compat"]
 test-command = "pytest -v --ignore={project}/tests/benchmarks {project}/tests"
 
@@ -108,6 +112,9 @@ manylinux-x86_64-image = "manylinux_2_28"
 manylinux-aarch64-image = "manylinux_2_28"
 before-all = "yum -y install valgrind-devel"
 
+[tool.cibuildwheel.macos]
+environment = { PYTEST_CODSPEED_FORCE_EXTENSION_BUILD = "1" }
+
 [tool.mypy]
 python_version = "3.12"
 

pytest_codspeed-5.0.0/setup.py

@@ -0,0 +1,65 @@
+import os
+import platform
+
+from setuptools import Extension, setup
+
+system = platform.system()
+current_arch = platform.machine()
+
+print(f"System: {system} ({current_arch})")
+
+IS_EXTENSION_BUILDABLE = (
+    system == "Linux" and current_arch in ["x86_64", "aarch64"]
+) or (system == "Darwin" and current_arch == "arm64")
+
+IS_EXTENSION_REQUIRED = (
+    os.environ.get("PYTEST_CODSPEED_FORCE_EXTENSION_BUILD") is not None
+)
+
+SKIP_EXTENSION_BUILD = (
+    os.environ.get("PYTEST_CODSPEED_SKIP_EXTENSION_BUILD") is not None
+)
+
+if SKIP_EXTENSION_BUILD and IS_EXTENSION_REQUIRED:
+    raise ValueError("Extension build required but the build requires to skip it")
+
+if IS_EXTENSION_REQUIRED and not IS_EXTENSION_BUILDABLE:
+    raise ValueError(
+        "The extension is required but the current platform is not supported"
+    )
+
+# Build native C extension
+native_extension = Extension(
+    "pytest_codspeed.instruments.hooks.dist_instrument_hooks",
+    sources=[
+        "src/pytest_codspeed/instruments/hooks/instrument_hooks_module.c",
+        "src/pytest_codspeed/instruments/hooks/instrument-hooks/dist/core.c",
+    ],
+    include_dirs=["src/pytest_codspeed/instruments/hooks/instrument-hooks/includes"],
+    # IMPORTANT: Keep in sync with instrument-hooks/.github/workflows/ci.yml
+    # (COMMON_CFLAGS). The Zig-generated core.c emits many warnings that
+    # upstream silences; in particular distros like Nix/Debian/Fedora inject
+    # -Werror=format-security, which would otherwise fail the build.
+    extra_compile_args=[
+        "-Wno-format",
+        "-Wno-format-security",
+        "-Wno-unused-but-set-variable",
+        "-Wno-unused-const-variable",
+        "-Wno-type-limits",
+        "-Wno-uninitialized",
+    ],
+    optional=not IS_EXTENSION_REQUIRED,
+)
+
+print(
+    "CodSpeed native extension is "
+    + ("required" if IS_EXTENSION_REQUIRED else "optional")
+)
+
+setup(
+    ext_modules=(
+        [native_extension]
+        if IS_EXTENSION_BUILDABLE and not SKIP_EXTENSION_BUILD
+        else []
+    ),
+)

{pytest_codspeed-4.4.0 → pytest_codspeed-5.0.0}/src/pytest_codspeed/__init__.py

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

{pytest_codspeed-4.4.0 → pytest_codspeed-5.0.0}/src/pytest_codspeed/instruments/analysis.py

@@ -6,10 +6,7 @@ from typing import TYPE_CHECKING
 
 from pytest_codspeed import __semver_version__
 from pytest_codspeed.instruments import Instrument
-from pytest_codspeed.instruments.hooks import (
-    FEATURE_DISABLE_CALLGRIND_MARKERS,
-    InstrumentHooks,
-)
+from pytest_codspeed.instruments.hooks import InstrumentHooks
 from pytest_codspeed.utils import SUPPORTS_PERF_TRAMPOLINE
 
 if TYPE_CHECKING:
@@ -79,17 +76,17 @@ class AnalysisInstrument(Instrument):
             # Warmup CPython performance map cache
             __codspeed_root_frame__()
 
-        self.instrument_hooks.set_feature(FEATURE_DISABLE_CALLGRIND_MARKERS, True)
+        self.instrument_hooks.disable_callgrind_markers()
         self.instrument_hooks.start_benchmark()
 
         # Manually call the library function to avoid an extra stack frame. Also
         # call the callgrind markers directly to avoid extra overhead.
-        self.instrument_hooks.lib.callgrind_start_instrumentation()
+        self.instrument_hooks.callgrind_start_instrumentation()
         try:
             return __codspeed_root_frame__()
         finally:
             # Ensure instrumentation is stopped even if the test failed
-            self.instrument_hooks.lib.callgrind_stop_instrumentation()
+            self.instrument_hooks.callgrind_stop_instrumentation()
             self.instrument_hooks.stop_benchmark()
             self.instrument_hooks.set_executed_benchmark(uri)
 
@@ -128,16 +125,16 @@ class AnalysisInstrument(Instrument):
         # Compute the actual result of the function
         args, kwargs = pedantic_options.setup_and_get_args_kwargs()
 
-        self.instrument_hooks.set_feature(FEATURE_DISABLE_CALLGRIND_MARKERS, True)
+        self.instrument_hooks.disable_callgrind_markers()
         self.instrument_hooks.start_benchmark()
 
         # Manually call the library function to avoid an extra stack frame. Also
         # call the callgrind markers directly to avoid extra overhead.
-        self.instrument_hooks.lib.callgrind_start_instrumentation()
+        self.instrument_hooks.callgrind_start_instrumentation()
         try:
             out = __codspeed_root_frame__(*args, **kwargs)
         finally:
-            self.instrument_hooks.lib.callgrind_stop_instrumentation()
+            self.instrument_hooks.callgrind_stop_instrumentation()
             self.instrument_hooks.stop_benchmark()
             self.instrument_hooks.set_executed_benchmark(uri)
             if pedantic_options.teardown is not None:

{pytest_codspeed-4.4.0 → pytest_codspeed-5.0.0}/src/pytest_codspeed/instruments/hooks/__init__.py

@@ -11,20 +11,18 @@ from typing import TYPE_CHECKING
 from pytest_codspeed.utils import SUPPORTS_PERF_TRAMPOLINE
 
 if TYPE_CHECKING:
-    from cffi import FFI
-
-    from .dist_instrument_hooks import InstrumentHooksPointer, LibType
-
-# Feature flags for instrument hooks
-FEATURE_DISABLE_CALLGRIND_MARKERS = 0
+    from typing import Any, Callable
 
 
 class InstrumentHooks:
-    """Zig library wrapper class providing benchmark measurement functionality."""
+    """Native library wrapper class providing benchmark measurement functionality."""
 
-    lib: LibType
-    ffi: FFI
-    instance: InstrumentHooksPointer
+    _module: Any
+    _instance: Any
+    # Bound directly to the C functions in __init__ to avoid an extra Python
+    # stack frame when starting/stopping callgrind instrumentation.
+    callgrind_start_instrumentation: Callable[[], None]
+    callgrind_stop_instrumentation: Callable[[], None]
 
     def __init__(self) -> None:
         if os.environ.get("CODSPEED_ENV") is None:
@@ -34,32 +32,37 @@ class InstrumentHooks:
             )
 
         try:
-            from .dist_instrument_hooks import ffi, lib  # type: ignore
+            from . import dist_instrument_hooks  # type: ignore
         except ImportError as e:
             raise RuntimeError(f"Failed to load instrument hooks library: {e}") from e
-        self.lib = lib
-        self.ffi = ffi
+        self._module = dist_instrument_hooks
+        self.callgrind_start_instrumentation = (
+            dist_instrument_hooks.callgrind_start_instrumentation
+        )
+        self.callgrind_stop_instrumentation = (
+            dist_instrument_hooks.callgrind_stop_instrumentation
+        )
 
-        self.instance = self.lib.instrument_hooks_init()
-        if self.instance == 0:
+        self._instance = self._module.instrument_hooks_init()
+        if self._instance is None:
             raise RuntimeError("Failed to initialize CodSpeed instrumentation library.")
 
         if SUPPORTS_PERF_TRAMPOLINE and not sys.is_stack_trampoline_active():
             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)
+        # Don't manually deinit - let the capsule destructor handle it
+        pass
 
     def start_benchmark(self) -> None:
         """Start a new benchmark measurement."""
-        ret = self.lib.instrument_hooks_start_benchmark(self.instance)
+        ret = self._module.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)
+        ret = self._module.instrument_hooks_stop_benchmark(self._instance)
         if ret != 0:
             warnings.warn("Failed to stop benchmark measurement", RuntimeWarning)
 
@@ -73,32 +76,60 @@ class InstrumentHooks:
         if pid is None:
             pid = os.getpid()
 
-        ret = self.lib.instrument_hooks_set_executed_benchmark(
-            self.instance, pid, uri.encode("ascii")
+        ret = self._module.instrument_hooks_set_executed_benchmark(
+            self._instance, pid, uri.encode("ascii")
         )
         if ret != 0:
             warnings.warn("Failed to set executed benchmark", RuntimeWarning)
 
+    @staticmethod
+    def current_timestamp() -> int:
+        """Return a monotonic timestamp in nanoseconds from the native library."""
+        from . import dist_instrument_hooks  # type: ignore
+
+        return dist_instrument_hooks.instrument_hooks_current_timestamp()
+
+    def add_marker(
+        self, marker_type: int, timestamp: int, pid: int | None = None
+    ) -> None:
+        """Emit a single marker at the given timestamp."""
+        if pid is None:
+            pid = os.getpid()
+        ret = self._module.instrument_hooks_add_marker(
+            self._instance, pid, marker_type, timestamp
+        )
+        if ret != 0:
+            warnings.warn("Failed to add marker", RuntimeWarning)
+
+    def add_benchmark_timestamps(self, start: int, end: int) -> None:
+        """Emit a BenchmarkStart/BenchmarkEnd marker pair around a captured window."""
+        self.add_marker(self._module.MARKER_TYPE_BENCHMARK_START, start)
+        self.add_marker(self._module.MARKER_TYPE_BENCHMARK_END, end)
+
     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")
+        ret = self._module.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 simulation is active."""
-        return self.lib.instrument_hooks_is_instrumented(self.instance)
+        return self._module.instrument_hooks_is_instrumented(self._instance)
 
-    def set_feature(self, feature: int, enabled: bool) -> None:
+    def _set_feature(self, feature: int, enabled: bool) -> None:
         """Set a feature flag in the instrument hooks library.
 
         Args:
             feature: The feature flag to set
             enabled: Whether to enable or disable the feature
         """
-        self.lib.instrument_hooks_set_feature(feature, enabled)
+        self._module.instrument_hooks_set_feature(feature, enabled)
+
+    def disable_callgrind_markers(self, disabled: bool = True) -> None:
+        """Disable automatic callgrind markers around benchmark start/stop."""
+        self._set_feature(self._module.FEATURE_DISABLE_CALLGRIND_MARKERS, disabled)
 
     def set_environment(self, section_name: str, key: str, value: str) -> None:
         """Register a key-value pair under a named section for environment collection.
@@ -108,8 +139,8 @@ class InstrumentHooks:
             key: The key (e.g. "version")
             value: The value (e.g. "3.13.12")
         """
-        ret = self.lib.instrument_hooks_set_environment(
-            self.instance,
+        ret = self._module.instrument_hooks_set_environment(
+            self._instance,
             section_name.encode("utf-8"),
             key.encode("utf-8"),
             value.encode("utf-8"),
@@ -127,14 +158,11 @@ class InstrumentHooks:
             key: The key (e.g. "build_args")
             values: The list of string values
         """
-        encoded = [self.ffi.new("char[]", v.encode("utf-8")) for v in values]
-        c_values = self.ffi.new("char*[]", encoded)
-        ret = self.lib.instrument_hooks_set_environment_list(
-            self.instance,
+        ret = self._module.instrument_hooks_set_environment_list(
+            self._instance,
             section_name.encode("utf-8"),
             key.encode("utf-8"),
-            c_values,
-            len(encoded),
+            [v.encode("utf-8") for v in values],
         )
         if ret != 0:
             warnings.warn("Failed to set environment list data", RuntimeWarning)
@@ -149,7 +177,7 @@ class InstrumentHooks:
         """
         if pid is None:
             pid = os.getpid()
-        ret = self.lib.instrument_hooks_write_environment(self.instance, pid)
+        ret = self._module.instrument_hooks_write_environment(self._instance, pid)
         if ret != 0:
             warnings.warn("Failed to write environment data", RuntimeWarning)