Report CEF API hash and version from CEF's cef_api_hash.h macros

GetVersion() previously reported the API hash from values that
cmake_prepare_pyx.py parsed out of CEF's generated cef_api_versions.h and
prepended to the module as __cef_api_hash_*__. Read the hash from CEF's
CEF_API_HASH_PLATFORM macro directly instead, via the new
src/extern/cef/cef_api_hash.pxd, so the compiler supplies the value for
whatever API version the module is built against. CEF_API_HASH_UNIVERSAL is
deprecated and equal to the platform hash, so both keys report the same value.

Also expose the compiled CEF_API_VERSION as cef_api_version in GetVersion().

Remove the now-unused header parsing (get_cef_api_hash / get_host_os_macro)
and the --cef-api-versions-header build plumbing from cmake_prepare_pyx.py
and CMakeLists.txt.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: linesight

CMakeLists.txt

@@ -113,11 +113,9 @@ add_custom_command(
             --out "${PYX_STAGE_DIR}"
             --pyversion "${PYVERSION}"
             --cef-version-header "${_cef_ver_header}"
-            --cef-api-versions-header "${CEF_ROOT}/include/cef_api_versions.h"
     DEPENDS
         ${_pyx_src_files}
         "${CMAKE_SOURCE_DIR}/tools/cmake_prepare_pyx.py"
-        "${CEF_ROOT}/include/cef_api_versions.h"
     COMMENT "Preparing .pyx files -> ${PYX_STAGE_DIR}"
     VERBATIM
 )

src/cefpython.pyx

@@ -227,6 +227,7 @@ IF UNAME_SYSNAME == "Linux":
     cimport x11
 
 from cef_string cimport *
+from cef_api_hash cimport *
 cdef extern from *:
     # noinspection PyUnresolvedReferences
     ctypedef CefString ConstCefString "const CefString"
@@ -1071,14 +1072,15 @@ cpdef object GetAppSetting(object key):
     return None
 
 cpdef dict GetVersion():
-    # These variable are set when building the module.
     # noinspection PyUnresolvedReferences
+    api_hash = (<bytes>CEF_API_HASH_PLATFORM).decode("utf-8")
     return dict(
         version=__version__,
         chrome_version=__chrome_version__,
         cef_version=__cef_version__,
-        cef_api_hash_platform=__cef_api_hash_platform__,
-        cef_api_hash_universal=__cef_api_hash_universal__,
+        cef_api_version=CEF_API_VERSION,
+        cef_api_hash_platform=api_hash,
+        cef_api_hash_universal=api_hash,
         cef_commit_hash=__cef_commit_hash__,
         cef_commit_number=__cef_commit_number__,
     )

src/extern/cef/cef_api_hash.pxd

@@ -0,0 +1,8 @@
+# Copyright (c) 2026 CEF Python, see the Authors file.
+# All rights reserved. Licensed under BSD 3-clause license.
+# Project website: https://github.com/cztomczak/cefpython
+
+# CEF's compiled API version and its hash, read by GetVersion().
+cdef extern from "include/cef_api_hash.h":
+    int CEF_API_VERSION
+    const char* CEF_API_HASH_PLATFORM

tools/cmake_prepare_pyx.py

@@ -20,53 +20,6 @@
 import cef_version
 
 
-# The build compiles with CEF's default API version, which cef_api_hash.h sets
-# to CEF_API_VERSION_EXPERIMENTAL (999999) when CEF_API_VERSION is not defined.
-CEF_API_VERSION_EXPERIMENTAL = 999999
-
-
-def get_host_os_macro():
-    """Return the CEF OS_* macro for the build host (builds are always native)."""
-    if sys.platform.startswith("win"):
-        return "OS_WIN"
-    if sys.platform == "darwin":
-        return "OS_MAC"
-    return "OS_LINUX"
-
-
-def get_cef_api_hash(api_versions_header, api_version, os_macro):
-    """Extract the CEF API hash for a version+platform from cef_api_versions.h.
-
-    That generated header defines the hash per platform, e.g.:
-        #if defined(OS_WIN)
-        #define CEF_API_HASH_999999 "..."
-        #elif defined(OS_MAC)
-        #define CEF_API_HASH_999999 "..."
-        #elif defined(OS_LINUX)
-        #define CEF_API_HASH_999999 "..."
-        #endif
-    Each hash define is immediately preceded by its platform guard, so pick the
-    one whose guard matches the build host.  This replaces hand-copying the hash
-    into src/version/cef_version_*.h (the hash is authoritative here).
-    """
-    define = "CEF_API_HASH_{}".format(api_version)
-    with open(api_versions_header, "r") as f:
-        lines = f.read().splitlines()
-    guard_re = re.compile(r"\s*#(?:if|elif)\s+defined\((OS_\w+)\)")
-    define_re = re.compile(
-        r'\s*#define\s+' + re.escape(define) + r'\s+"([0-9a-fA-F]+)"')
-    for i, line in enumerate(lines):
-        m = define_re.match(line)
-        if not m or i == 0:
-            continue
-        guard = guard_re.match(lines[i - 1])
-        if guard and guard.group(1) == os_macro:
-            return m.group(1)
-    raise RuntimeError(
-        "Could not find {define} for {os} in {path}".format(
-            define=define, os=os_macro, path=api_versions_header))
-
-
 def except_all_missing(content):
     """Return the line number of a cdef/cpdef returning a C type (built-in,
     pointer, template or reference) whose signature declares no exception
@@ -101,9 +54,6 @@ def main():
     parser.add_argument("--out", required=True, help="Stage output directory")
     parser.add_argument("--pyversion", required=True, help="e.g. 310")
     parser.add_argument("--cef-version-header", required=True)
-    parser.add_argument("--cef-api-versions-header", required=True,
-                        help="Path to CEF's generated cef_api_versions.h "
-                             "(in CEF_ROOT/include); source of the API hash.")
     args = parser.parse_args()
 
     src_dir = args.src
@@ -121,18 +71,10 @@ def main():
         build=ver["CHROME_VERSION_BUILD"],
         patch=ver["CHROME_VERSION_PATCH"],
     )
-    # API hash comes from CEF's generated cef_api_versions.h, not from a value
-    # hand-copied into cef_version_*.h. CEF_API_HASH_UNIVERSAL is deprecated and
-    # upstream defines it as the same value as the platform hash.
-    api_hash = get_cef_api_hash(args.cef_api_versions_header,
-                                CEF_API_VERSION_EXPERIMENTAL,
-                                get_host_os_macro())
     module_vars = (
         '__version__ = "{v}"\n'.format(v=version_str)
         + '__chrome_version__ = "{v}"\n'.format(v=chrome_ver)
         + '__cef_version__ = "{v}"\n'.format(v=ver["CEF_VERSION"])
-        + '__cef_api_hash_platform__ = "{v}"\n'.format(v=api_hash)
-        + '__cef_api_hash_universal__ = "{v}"\n'.format(v=api_hash)
         + '__cef_commit_hash__ = "{v}"\n'.format(v=ver["CEF_COMMIT_HASH"])
         + '__cef_commit_number__ = "{v}"\n'.format(v=ver["CEF_COMMIT_NUMBER"])
     )