Do not expose the "Running" C-API (for now).

ericsnowcurrently · Oct 2, 2023 · Sep 25, 2023 · Sep 26, 2023 · Sep 26, 2023 · Sep 26, 2023
commit 399859f5906ac4af410984c8d090850a0dd13644
diff --git a/Doc/c-api/init.rst b/Doc/c-api/init.rst
@@ -1115,80 +1115,6 @@ All of the following functions must be called after :c:func:`Py_Initialize`.
    .. versionadded:: 3.7
 
 
-.. c:function:: int PyInterpreterState_SetRunningMain(PyInterpreterState *interp)
-
-   Indicate that the current thread will be running the "main" Python
-   program (e.g. script) for the given interpreter.  This typically
-   means executing Python code against the ``__main__`` module of
-   the interpreter, e.g. using :c:func:`PyRun_SimpleString`.
-
-   Only one thread may be "main" at a time for each interpreter.
-   Thus, this should not be called in subthreads created by the program.
-   If the interpreter is already marked as running then this function
-   will raise :exc:`RuntimeError` (even if in the same thread where
-   it was called earlier).
-
-   Every call to this function must have a corresponding call to
-   :c:func:`PyInterpreterState_UnsetRunningMain`.  The pairs of calls
-   may happen any number of times.
-
-   Subthreads from a previous "main" execution may still be running
-   when this is called.  Likewise, the interpreter is not required
-   to be in a pristine condition and may still hold state and objects
-   from an earlier "main".
-
-   Before running a Python program, there are often a number of
-   interactions with the runtime, sometimes even including running
-   non-"main" Python code.  Calling this function first before doing
-   them is not necessary, as long as it is called before running the
-   program itself.
-
-   The caller must hold the GIL.
-
-   This function is intended for use in embedded applications or by
-   extension modules that manage subinterpreters.
-
-   .. versionadded:: 3.13
-
-
-.. c:function:: void PyInterpreterState_UnsetRunningMain(PyInterpreterState *interp)
-
-   Indicate that the current thread is done running the "main" Python
-   program for the given interpreter.  This is the companion to
-   :c:func:`PyInterpreterState_SetRunningMain`.
-
-   Subthreads created by the program may still be running when this
-   is called.  Likewise, the interpreter's state is neither reset nor
-   required to be reset.
-
-   The caller must hold the GIL.
-
-   This function is intended for use in embedded applications
-   or by extension modules that manage subinterpreters.
-
-   .. versionadded:: 3.13
-
-
-.. c:function:: int PyInterpreterState_IsRunningMain(PyInterpreterState *interp)
-
-   Return true (nonzero) if the interpreter is currently running
-   a "main" Python program in one of its threads, false (zero) if not.
-   See :c:func:`PyInterpreterState_SetRunningMain`.
-
-   This relates only to the thread where the program started,
-   not subthreads.  An interpreter may still have subthreads running
-   even if this returns false.
-
-   The caller must hold the GIL.
-
-   This function will typically only be useful for embedded applications
-   or extension modules that manage subinterpreters.  For other cases
-   expect that this would always return true, since the application
-   or subinterpreters extension should have already set it.
-
-   .. versionadded:: 3.13
-
-
 .. c:function:: PyObject* PyInterpreterState_GetDict(PyInterpreterState *interp)
 
    Return a dictionary in which interpreter-specific data may be stored.

@@ -211,10 +211,6 @@ struct _ts {
  * if it is NULL. */
 PyAPI_FUNC(PyThreadState *) _PyThreadState_UncheckedGet(void);
 
-PyAPI_FUNC(int) PyInterpreterState_SetRunningMain(PyInterpreterState *);
-PyAPI_FUNC(void) PyInterpreterState_SetNotRunningMain(PyInterpreterState *);
-PyAPI_FUNC(int) PyInterpreterState_IsRunningMain(PyInterpreterState *);
-
 
 // Disable tracing and profiling.
 PyAPI_FUNC(void) PyThreadState_EnterTracing(PyThreadState *tstate);

@@ -44,6 +44,11 @@ _Py_IsMainInterpreterFinalizing(PyInterpreterState *interp)
             interp == &_PyRuntime._main_interpreter);
 }
 
+// Export for _xxsubinterpreters module.
+PyAPI_FUNC(int) _PyInterpreterState_SetRunningMain(PyInterpreterState *);
+PyAPI_FUNC(void) _PyInterpreterState_SetNotRunningMain(PyInterpreterState *);
+PyAPI_FUNC(int) _PyInterpreterState_IsRunningMain(PyInterpreterState *);
+
 
 static inline const PyConfig *
 _Py_GetMainConfig(void)

diff --git a/Modules/_xxsubinterpretersmodule.c b/Modules/_xxsubinterpretersmodule.c
@@ -8,6 +8,7 @@
 #include "Python.h"
 #include "pycore_initconfig.h"    // _PyErr_SetFromPyStatus()
 #include "pycore_pyerrors.h"      // _PyErr_ChainExceptions1()
+#include "pycore_pystate.h"       // _PyInterpreterState_SetRunningMain()
 #include "interpreteridobject.h"
 
 
@@ -361,7 +362,7 @@ static int
 _run_script(PyInterpreterState *interp, const char *codestr,
             _sharedns *shared, _sharedexception *sharedexc)
 {
-    if (PyInterpreterState_SetRunningMain(interp) < 0) {
+    if (_PyInterpreterState_SetRunningMain(interp) < 0) {
         // We skip going through the shared exception.
         return -1;
     }
@@ -395,7 +396,7 @@ _run_script(PyInterpreterState *interp, const char *codestr,
     else {
         Py_DECREF(result);  // We throw away the result.
     }
-    PyInterpreterState_SetNotRunningMain(interp);
+    _PyInterpreterState_SetNotRunningMain(interp);
 
     *sharedexc = no_exception;
     return 0;
@@ -411,7 +412,7 @@ _run_script(PyInterpreterState *interp, const char *codestr,
     }
     Py_XDECREF(excval);
     assert(!PyErr_Occurred());
-    PyInterpreterState_SetNotRunningMain(interp);
+    _PyInterpreterState_SetNotRunningMain(interp);
     return -1;
 }
 
@@ -441,7 +442,7 @@ _run_script_in_interpreter(PyObject *mod, PyInterpreterState *interp,
         // exception gets raised in the right one.
         // XXX gh-109860: Drop this redundant check once we stop
         // re-using tstates that might already be in use.
-        if (PyInterpreterState_IsRunningMain(interp)) {
+        if (_PyInterpreterState_IsRunningMain(interp)) {
             PyErr_SetString(PyExc_RuntimeError,
                             "interpreter already running");
             if (shared != NULL) {
@@ -566,7 +567,7 @@ interp_destroy(PyObject *self, PyObject *args, PyObject *kwds)
     // Ensure the interpreter isn't running.
     /* XXX We *could* support destroying a running interpreter but
        aren't going to worry about it for now. */
-    if (PyInterpreterState_IsRunningMain(interp)) {
+    if (_PyInterpreterState_IsRunningMain(interp)) {
         PyErr_Format(PyExc_RuntimeError, "interpreter running");
         return NULL;
     }
@@ -748,7 +749,7 @@ interp_is_running(PyObject *self, PyObject *args, PyObject *kwds)
     if (interp == NULL) {
         return NULL;
     }
-    if (PyInterpreterState_IsRunningMain(interp)) {
+    if (_PyInterpreterState_IsRunningMain(interp)) {
         Py_RETURN_TRUE;
     }
     Py_RETURN_FALSE;

@@ -594,7 +594,7 @@ pymain_run_python(int *exitcode)
 
     pymain_header(config);
 
-    PyInterpreterState_SetRunningMain(interp);
+    _PyInterpreterState_SetRunningMain(interp);
     assert(!PyErr_Occurred());
 
     if (config->run_command) {
@@ -620,7 +620,7 @@ pymain_run_python(int *exitcode)
     *exitcode = pymain_exit_err_print();
 
 done:
-    PyInterpreterState_SetNotRunningMain(interp);
+    _PyInterpreterState_SetNotRunningMain(interp);
     Py_XDECREF(main_importer_path);
 }
 

@@ -1092,7 +1092,7 @@ _PyInterpreterState_DeleteExceptMain(_PyRuntimeState *runtime)
 
 
 int
-PyInterpreterState_SetRunningMain(PyInterpreterState *interp)
+_PyInterpreterState_SetRunningMain(PyInterpreterState *interp)
 {
     if (interp->threads.main != NULL) {
         PyErr_SetString(PyExc_RuntimeError,
@@ -1111,14 +1111,14 @@ PyInterpreterState_SetRunningMain(PyInterpreterState *interp)
 }
 
 void
-PyInterpreterState_SetNotRunningMain(PyInterpreterState *interp)
+_PyInterpreterState_SetNotRunningMain(PyInterpreterState *interp)
 {
     assert(interp->threads.main == current_fast_get(&_PyRuntime));
     interp->threads.main = NULL;
 }
 
 int
-PyInterpreterState_IsRunningMain(PyInterpreterState *interp)
+_PyInterpreterState_IsRunningMain(PyInterpreterState *interp)
 {
     return (interp->threads.main != NULL);
 }