Merge branch 'master' into bvh2

Author: dpiparo

.github/workflows/cibuildwheel-impl/action.yml

@@ -12,7 +12,7 @@ runs:
   using: "composite"
   steps:
     - name: Build wheel
-      uses: pypa/cibuildwheel@v4.1.0
+      uses: pypa/cibuildwheel@v4.3.0
       env:
         CIBW_BUILD: ${{ inputs.build-tag }}
 

.github/workflows/python_wheel_build.yml

@@ -28,7 +28,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python: [cp311, cp312, cp313, cp314]
+        python: [cp311, cp312, cp313, cp314, cp315]
         config:
           # `label` is a unique artifact name for each build
           - runner: macos-15
@@ -79,7 +79,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python: ["3.11", "3.12", "3.13", "3.14"]
+        python: ["3.11", "3.12", "3.13", "3.14", "3.15"]
         test_config:
           # each runner tests the wheel built on it
           - runner: macos-15

.github/workflows/root-ci-config/buildconfig/global.txt

@@ -4,6 +4,7 @@ asan=OFF
 asimage=ON
 asserts=OFF
 builtin_bvh=ON
+builtin_cdt=ON
 builtin_cfitsio=OFF
 builtin_civetweb=OFF
 builtin_clang=ON

.github/workflows/utilities/sync_cling.py

@@ -1,8 +1,9 @@
 #!/usr/bin/env python3
 
+import subprocess
 import sys
 
-from common import printError, printWarning, printInfo, execCommand
+from common import printWarning, printInfo, execCommand
 
 # Parameters
 CLING_TAG_ROOT_HASH_PREFIX = "__internal-root-"
@@ -50,11 +51,30 @@ def getStartingRootHash(rootTag):
     prefixLen = len(CLING_TAG_ROOT_HASH_PREFIX)
     defHashLen = len(DEFAULT_STARTING_ROOT_HASH)
     hash = rootTag[prefixLen : prefixLen + defHashLen]
+    # A tag made from a local ROOT branch names a commit that is not in ROOT's history.
+    # Then start from the ROOT commit that cling's last commit came from.
+    if subprocess.run(["git", "merge-base", "--is-ancestor", hash, "HEAD"], cwd=ROOT_REPO_DIR_NAME).returncode != 0:
+        printWarning(f"The sync tag names {hash}, which is not in ROOT's history")
+        hash = findRootCommit(execCommand("git log -1 --format=%ae%x09%ad --date=raw HEAD", CLING_REPO_DIR_NAME))
     return hash
 
 
+def findRootCommit(identity):
+    """
+    Find the ROOT commit with the given author identity. git am keeps the author
+    and the author date, so they identify a ROOT commit in cling.
+    """
+    out = execCommand(f"git log --format=%h%x09%ae%x09%ad --date=raw HEAD -- {INTERP_DIR_NAME}", ROOT_REPO_DIR_NAME)
+    for line in out.split("\n"):
+        hash, commitIdentity = line.split("\t", 1)
+        if commitIdentity == identity:
+            printInfo(f"Cling's last commit comes from ROOT's {hash}")
+            return hash
+    raise ValueError(f"No ROOT commit matches cling's last commit ({identity})")
+
+
 def getHashes(repoDirName, startingHash, dirInRepoName=""):
-    out = execCommand(f"git log --oneline {startingHash}..HEAD {dirInRepoName}", thisCwd=repoDirName)
+    out = execCommand(f"git log --oneline {startingHash}..HEAD -- {dirInRepoName}", thisCwd=repoDirName)
     hashes = []
     if not out:
         return hashes
@@ -75,12 +95,19 @@ def createPatches(rootHashes, interpHashes):
     # We loop on ROOT hashes to sync, from oldest to newest
     # to return a list of triples [dirInRepo, hash, patchAsSting], where dirInRepo is the
     # directory and hash is there for debugging purposes.
+    # Commits that cling already has, e.g. because the sync tag names an older ROOT
+    # commit than the one cling was synchronized to, are skipped.
+    syncedIdentities = set(execCommand("git log -n 1000 --format=%ae%x09%ad --date=raw HEAD", CLING_REPO_DIR_NAME).split("\n"))
     for rootHashtoSync in reversed(rootHashesToSync):
+        identity = execCommand(f"git log -1 --format=%ae%x09%ad --date=raw {rootHashtoSync}", ROOT_REPO_DIR_NAME)
+        if identity in syncedIdentities:
+            printWarning(f"Skipping {rootHashtoSync}: cling already has it")
+            continue
         keys = []
         if rootHashtoSync in interpHashesSet:
             keys.append(INTERP_DIR_NAME)
         for key in keys:
-            patchAsStr = execCommand(f"git format-patch -1 {rootHashtoSync} {key} --stdout", ROOT_REPO_DIR_NAME)
+            patchAsStr = execCommand(f"git format-patch -1 {rootHashtoSync} --stdout -- {key}", ROOT_REPO_DIR_NAME)
             patches.append([key, rootHashtoSync, patchAsStr])
     return patches
 
@@ -99,27 +126,20 @@ def syncTagAndPush(oldSyncTag, rootSyncHash):
     Replace the tag mentioning the previous root commit to which the repo was synchronized.
     Push the changes and tags upstream.
     """
-    # We fetch the remote and local tags to make the following operations more resilient
-    remoteTags = execCommand("git ls-remote --tags origin", CLING_REPO_DIR_NAME)
-    localTags = execCommand("git tag", CLING_REPO_DIR_NAME)
-
-    # Clean the old tag
-    printInfo(f"Found a sync tag ({oldSyncTag}): deleting it.")
-    if oldSyncTag in localTags:
-        execCommand(f"git tag -d {oldSyncTag}", CLING_REPO_DIR_NAME)
-    if oldSyncTag in remoteTags:
-        execCommand(f"git push --delete origin  {oldSyncTag}", CLING_REPO_DIR_NAME)
-    else:
-        printWarning(f"Tag {oldSyncTag} was not found in the upstream repository.")
-
-    # Time to push the sync commits!
-    execCommand("git push", CLING_REPO_DIR_NAME)
-
-    # And finally we tag and push the tag
+    # Push the commits and the new tag together, so that cling never has the
+    # commits without a tag that names them. Only then remove the old tag.
     newTag = CLING_TAG_ROOT_HASH_PREFIX + rootSyncHash
     printInfo(f"Creating a new tag ({newTag}).")
     execCommand(f"git tag {newTag}", CLING_REPO_DIR_NAME)
-    execCommand(f"git push origin tag {newTag}", CLING_REPO_DIR_NAME)
+    execCommand(f"git push --atomic origin HEAD tag {newTag}", CLING_REPO_DIR_NAME)
+
+    printInfo(f"Deleting the previous sync tag ({oldSyncTag}).")
+    execCommand(f"git tag -d {oldSyncTag}", CLING_REPO_DIR_NAME)
+    remoteTags = execCommand("git ls-remote --tags origin", CLING_REPO_DIR_NAME)
+    if f"refs/tags/{oldSyncTag}" in remoteTags:
+        execCommand(f"git push --delete origin tag {oldSyncTag}", CLING_REPO_DIR_NAME)
+    else:
+        printWarning(f"Tag {oldSyncTag} was not found in the upstream repository.")
 
 
 def principal():
@@ -146,8 +166,7 @@ def principal():
 
     # We now apply the patches
     if not patches:
-        printError("No patch was distilled: this status should not be reachable")
-        return 1
+        printInfo("Cling already has all these commits: only moving the sync tag.")
 
     # We now need to apply patches, update the tag that mentions the ROOT commit
     # to which the cling repo was synchronised and push everything.

CMakeLists.txt

@@ -408,7 +408,6 @@ add_subdirectory (core)
 add_subdirectory (builtins/zip) # hard coded builtin for core/zip
 add_subdirectory (builtins/clib) # hard coded builtin for core
 add_subdirectory (builtins/mixmax) # hard coded builtin for math/mathcore
-add_subdirectory (builtins/CDT) # hard coded builtin for math/mathcore
 add_subdirectory (math)
 if (fortran AND CMAKE_Fortran_COMPILER)
   add_subdirectory(builtins/cernlib) # hard coded builtin for hist and main

bindings/pyroot/pythonizations/CMakeLists.txt

@@ -10,7 +10,6 @@
 
 set(cpp_sources
     src/PyROOTModule.cxx
-    src/RPyROOTApplication.cxx
     src/GenericPyz.cxx
     src/CPPInstancePyz.cxx
 )

bindings/pyroot/pythonizations/python/ROOT/_application.py

@@ -8,6 +8,8 @@
 # For the list of contributors see $ROOTSYS/README/CREDITS.                    #
 ################################################################################
 
+import ctypes
+import os
 import sys
 import time
 
@@ -16,16 +18,75 @@ class PyROOTApplication(object):
     """
     Application class for PyROOT.
     Configures the interactive usage of ROOT from Python.
+
+    It is created while the ROOT module is set up, so it reaches C++ through
+    cppyy.gbl, as attribute lookups on the ROOT module would restart the setup.
     """
 
     def __init__(self, config, is_ipython):
-        from ROOT.libROOTPythonizations import InitApplication
+        import cppyy
+
+        if not cppyy.gbl.gApplication:
+            from ROOT.libROOTPythonizations import InstallWarningHandler
 
-        # Construct a TApplication for PyROOT
-        InitApplication(config.IgnoreCommandLineOptions)
+            self._create_application(config.IgnoreCommandLineOptions)
+            self._init_root_globals()
+            InstallWarningHandler()
 
         self._is_ipython = is_ipython
 
+    @staticmethod
+    def _create_application(ignore_cmd_line_opts):
+        """
+        Create the TApplication. Unless ignore_cmd_line_opts is set, it gets
+        the command line options in sys.argv, up to a "-" or "--" that
+        separates them from the options for the Python script. For example,
+        to enable batch mode from the command line:
+
+            python script_name.py -b -- user_arg1 ... user_argn
+
+        or, if the script takes no options:
+
+            python script_name.py -b
+        """
+        import cppyy
+
+        gbl = cppyy.gbl
+
+        args = ["python"]
+        if not ignore_cmd_line_opts:
+            for arg in getattr(sys, "argv", [])[1:]:
+                if arg in ("-", "--"):
+                    break
+                args.append(arg)
+
+        # Bytes as given on the command line, and argv[argc] null like for main()
+        args = [os.fsencode(arg) for arg in args]
+        argc = ctypes.c_int(len(args))
+        argv = (ctypes.c_char_p * (len(args) + 1))(*args, None)
+        app = gbl.TApplication("PyROOT", argc, ctypes.cast(argv, ctypes.POINTER(ctypes.c_char_p)))
+        # It is gApplication from now on
+        cppyy._backend.SetOwnership(app, False)
+
+        # Prevent crashes on accessing history
+        gbl.Gl_histinit("-")
+
+        # Prevent ROOT from exiting Python
+        app.SetReturnFromRun(True)
+
+    @staticmethod
+    def _init_root_globals():
+        """Set up gBenchmark, the one ROOT global that neither TROOT nor TApplication sets"""
+        import cppyy
+
+        gbl = cppyy.gbl
+
+        if not gbl.gBenchmark:
+            # The global owns the object, so Python must not delete it
+            benchmark = gbl.TBenchmark()
+            cppyy._backend.SetOwnership(benchmark, False)
+            gbl.gBenchmark = benchmark
+
     @staticmethod
     def _ipython_config():
         # Integrate IPython >= 5 with ROOT's event loop

bindings/pyroot/pythonizations/python/ROOT/_pythonization/_rntuple.py

@@ -8,6 +8,40 @@
 # For the list of contributors see $ROOTSYS/README/CREDITS.                    #
 ################################################################################
 
+r"""
+\pythondoc RNTupleWriter
+
+RNTupleWriter is an interface to write RNTuples to storage.
+
+A simple way to write an RNTuple in python is by:
+- creating a model and adding fields to it
+- opening an RNTupleWriter 
+- creating entries and filling them with data
+- committing entries to the RNTuple via writer.Fill(entry)
+
+\code{.py}
+import ROOT
+
+# Create the model
+model = ROOT.RNTupleModel.Create()
+
+# Define the schema by adding fields to the model.
+model.MakeField['int']("foo")
+
+# Create a writer as a context manager
+with ROOT.RNTupleWriter.Recreate(model, "myNtuple", "file.root") as writer:
+    # create an entry and use it to write data to the RNTuple
+    entry = writer.CreateEntry()
+    for i in range(0,10):
+        entry['foo'] = i
+        writer.Fill(entry)
+# On destruction, the writer will flush the written data to disk
+
+\endcode
+
+\endpythondoc
+"""
+
 from . import pythonization
 from ._pyz_utils import MethodTemplateGetter, MethodTemplateWrapper
 

bindings/pyroot/pythonizations/src/PyROOTModule.cxx

@@ -11,15 +11,16 @@
 
 // Bindings
 #include "PyROOTPythonize.h"
-#include "RPyROOTApplication.h"
 
 // Cppyy
 #include "cpyrt/API.h"
 
 // ROOT
+#include "TError.h"
 #include "TInterpreter.h"
 #include "TROOT.h"
 #include "TSystem.h"
+#include "TVirtualPad.h"
 #include "RConfigure.h"
 
 // Standard
@@ -98,15 +99,68 @@ PyObject *PyObjRefCounterAsStdAny(PyObject * /*self*/, PyObject *args)
 
 } // namespace PyROOT
 
+namespace {
+
+/// Turns a ROOT warning into a Python warning, see ROOT::Internal::SetWarningHandler().
+bool WarningHandler(const char *location, const char *msg)
+{
+   PyGILState_STATE state = PyGILState_Ensure();
+   // Python code can't run while an exception is pending, e.g. a previous
+   // warning turned into an error: decline, and ROOT prints the warning.
+   bool handled = !PyErr_Occurred();
+   if (handled) {
+      // Prints or, per the warnings filters, raises: the exception stays
+      // pending until the call into C++ returns to Python.
+      PyErr_WarnExplicit(nullptr, msg, location, 0, "ROOT", nullptr);
+   }
+   PyGILState_Release(state);
+   return handled;
+}
+
+int (*gPreviousInputHook)() = nullptr;
+
+/// Processes GUI events while the Python prompt waits for input. Runs no
+/// Python code, so a Ctrl-C arriving meanwhile stays pending for the prompt.
+int GUIEventInputHook()
+{
+   PyGILState_STATE state = PyGILState_Ensure();
+   if (gPad && gPad->IsWeb())
+      gPad->UpdateAsync();
+   gSystem->ProcessEvents();
+   PyGILState_Release(state);
+
+   return gPreviousInputHook ? gPreviousInputHook() : 0;
+}
+
+/// Turn ROOT warnings into Python warnings.
+PyObject *InstallWarningHandler(PyObject * /*self*/, PyObject * /*args*/)
+{
+   ROOT::Internal::SetWarningHandler(&WarningHandler);
+   Py_RETURN_NONE;
+}
+
+/// Install the PyOS_InputHook that processes GUI events, chaining to the
+/// previous hook.
+PyObject *InstallGUIEventInputHook(PyObject * /*self*/, PyObject * /*args*/)
+{
+   if (PyOS_InputHook != &GUIEventInputHook) {
+      gPreviousInputHook = PyOS_InputHook;
+      PyOS_InputHook = &GUIEventInputHook;
+   }
+   Py_RETURN_NONE;
+}
+
+} // namespace
+
 // Methods offered by the interface
 static PyMethodDef gPyROOTMethods[] = {
    {"AddCPPInstancePickling", (PyCFunction)PyROOT::AddCPPInstancePickling, METH_NOARGS,
     "Add a custom pickling mechanism for Cppyy Python proxy objects"},
    {"AddPrettyPrintingPyz", (PyCFunction)PyROOT::AddPrettyPrintingPyz, METH_VARARGS,
     "Add pretty printing pythonization"},
-   {"InitApplication", (PyCFunction)PyROOT::RPyROOTApplication::InitApplication, METH_VARARGS,
-    "Initialize interactive ROOT use from Python"},
-   {"InstallGUIEventInputHook", (PyCFunction)PyROOT::RPyROOTApplication::InstallGUIEventInputHook, METH_NOARGS,
+   {"InstallWarningHandler", (PyCFunction)InstallWarningHandler, METH_NOARGS,
+    "Turn ROOT warnings into Python warnings"},
+   {"InstallGUIEventInputHook", (PyCFunction)InstallGUIEventInputHook, METH_NOARGS,
     "Install an input hook to process GUI events"},
    {"_CPPInstance__expand__", (PyCFunction)PyROOT::CPPInstanceExpand, METH_VARARGS,
     "Deserialize a pickled object"},