ENH: Make f2py use multiphase init (numpy#31578)

Adapt f2py to use multiphase init (and on Python 3.15+, to use PEP 793 and 820 init). This is mainly useful for future Limited API support (although mutliphase init is generally "preferred" and so arguably better anyway).

The main complication was the usercode that gets injected into the module init function. This wasn't tested (so I added a test) but user code with error handling requires return NULL to be valid, so I moved it to a separate function that keeps that interface.

One potential issue to flag is if people are doing embedding type things and manually calling the PyInit_ function. This isn't recommended and isn't an insurmountable problem, but will break that case.

Author: da-woods

numpy/f2py/common_rules.py

@@ -120,8 +120,8 @@ def dadd(line, s=doc):
              f'(f2py_setup_{name});')
         cadd('}\n')
         iadd(f'\ttmp = PyFortranObject_New(f2py_{name}_def,f2py_init_{name});')
-        iadd('\tif (tmp == NULL) return NULL;')
-        iadd(f'\tif (F2PyDict_SetItemString(d, "{name}", tmp) == -1) return NULL;')
+        iadd('\tif (tmp == NULL) return -1;')
+        iadd(f'\tif (F2PyDict_SetItemString(d, "{name}", tmp) == -1) return -1;')
         iadd('\tPy_DECREF(tmp);')
         tname = name.replace('_', '\\_')
         dadd(f'\\subsection{{Common block \\texttt{{{tname}}}}}\n')

numpy/f2py/rules.py

@@ -239,26 +239,18 @@
     {NULL,NULL}
 };
 
-static struct PyModuleDef moduledef = {
-    PyModuleDef_HEAD_INIT,
-    "#modulename#",
-    NULL,
-    -1,
-    f2py_module_methods,
-    NULL,
-    NULL,
-    NULL,
-    NULL
-};
+static PyObject *f2py_module_interface_usercode(PyObject *m, PyObject *d) {
+    /* Returns a PyObject* because existing user code will return NULL on exit */
+    #interface_usercode#
+    return m;
+}
 
-PyMODINIT_FUNC PyInit_#modulename#(void) {
+static int f2py_module_exec(PyObject *m) {
     int i;
-    PyObject *m,*d, *s, *tmp;
-    m = #modulename#_module = PyModule_Create(&moduledef);
-    Py_SET_TYPE(&PyFortran_Type, &PyType_Type);
-    import_array();
-    if (PyErr_Occurred())
-        {PyErr_SetString(PyExc_ImportError, \"can't initialize module #modulename# (failed to import numpy)\"); return m;}
+    PyObject *d, *s, *tmp;
+    #modulename#_module = m;
+    Py_SET_TYPE((PyObject*)&PyFortran_Type, &PyType_Type);
+    import_array2(\"can't initialize module #modulename# (failed to import numpy)\", -1);
     d = PyModule_GetDict(m);
     s = PyUnicode_FromString(\"#f2py_version#\");
     PyDict_SetItemString(d, \"__version__\", s);
@@ -282,27 +274,74 @@
         PyDict_SetItemString(d, f2py_routine_defs[i].name, tmp);
         Py_DECREF(tmp);
     }
+
 #initf2pywraphooks#
 #initf90modhooks#
 #initcommonhooks#
-#interface_usercode#
-
-#ifdef Py_GIL_DISABLED
-    // signal whether this module supports running with the GIL disabled
-    PyUnstable_Module_SetGIL(m , #gil_used#);
-#endif
+    if (!f2py_module_interface_usercode(m, d)) return -1;
 
 #ifdef F2PY_REPORT_ATEXIT
     if (! PyErr_Occurred())
         on_exit(f2py_report_on_exit,(void*)\"#modulename#\");
 #endif
 
     if (PyType_Ready(&PyFortran_Type) < 0) {
-        return NULL;
+        return -1;
     }
 
-    return m;
+    return 0;
+}
+
+#ifndef Py_TARGET_ABI3T
+static PyModuleDef_Slot f2py_module_slots[] = {
+    {Py_mod_exec, (void*)f2py_module_exec},
+#ifdef Py_GIL_DISABLED
+    {Py_mod_gil, (void*)#gil_used#},
+#endif
+#if (defined(Py_LIMITED_API) && Py_LIMITED_API >= 0x030C0000) || (!defined(Py_LIMITED_API) && PY_VERSION_HEX >= 0x030C0000)
+    {Py_mod_multiple_interpreters, Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED},
+#endif
+    {0, NULL}
+};
+
+static struct PyModuleDef moduledef = {
+    PyModuleDef_HEAD_INIT,
+    "#modulename#",
+    NULL,
+    0,
+    f2py_module_methods,
+    f2py_module_slots,
+    NULL,
+    NULL,
+    NULL
+};
+
+PyMODINIT_FUNC PyInit_#modulename#(void) {
+    return PyModuleDef_Init(&moduledef);
 }
+#endif
+
+#if (defined(Py_LIMITED_API) && Py_LIMITED_API >= 0x030F0000) || (!defined(Py_LIMITED_API) && PY_VERSION_HEX >= 0x030F0000)
+PyABIInfo_VAR(f2py_abi_info);
+
+static PySlot f2py_module_pyslots[] = {
+    PySlot_PTR_STATIC(Py_mod_abi, &f2py_abi_info),
+    PySlot_PTR_STATIC(Py_mod_name, "#modulename#"),
+#if defined(Py_GIL_DISABLED) || defined(Py_TARGET_ABI3T)
+    PySlot_PTR(Py_mod_gil, #gil_used#),
+#endif
+    PySlot_PTR_STATIC(Py_mod_methods, f2py_module_methods),
+    PySlot_PTR(Py_mod_exec, f2py_module_exec),
+    PySlot_END
+};
+
+
+PyMODEXPORT_FUNC PyModExport_#modulename#(void)
+{
+    return f2py_module_pyslots;
+}
+#endif
+
 #ifdef __cplusplus
 }
 #endif

numpy/f2py/tests/test_usercode.py

@@ -0,0 +1,26 @@
+from . import util
+
+
+class TestUserCode(util.F2PyTest):
+    suffix = ".pyf"
+    module_name = "user_code_success"
+
+    # The failure path in this code isn't expected to happen (and would be
+    # untestable if it did, because it would happen in the test setup).
+    # However, it does need to compile correctly.
+    code = f"""
+python module {module_name}
+    interface
+        usercode '''
+        {{
+            PyObject *value = PyUnicode_FromString("Hello from the user code");
+            if (!value) return NULL;
+            if (PyModule_AddObjectRef(m, "foo", value) < 0) return NULL;
+        }}
+        '''
+    end interface
+end python module {module_name}
+    """
+
+    def test_user_code_success(self):
+        assert self.module.foo == "Hello from the user code"