Suggested refactoring

line_profiler/Python_wrapper.h
    Added back-port for `PyThreadState_GetInterpreter()` (doesn't matter
    since we're only using it for Python 3.12+ anyway)

line_profiler/_line_profiler.pyx
    disable_line_events()
        Updated implemnentation to deal with wrappers created by
        `_LineProfilerManager.wrap_local_f_trace()`
    _LineProfilerManager.__call__(), .wrap_local_f_trace()
        - Added annotations
        - Now supporting disabling passing the events onto
          `trace_func()` if the `.disable_line_events` attribute of the
          wrapper is set to true

line_profiler/c_trace_callbacks.{c,h}
    populate_callback()
        Renamed from `fetch_callback()`
    nullify_callback()
        Added check against NULL
    call_callback()
        - Updated call signature; instead of loading
          `line_profiler._line_profiler.disable_line_events()` by
          importing the module and accessing the attribute, now just
          taking it as an argument
        - Simplified implementation
        - Now using
          `PyObject_SetAttrString(<PyObject *>py_frame, 'f_trace', ...)`
          instead of directly manipulating `py_frame->f_trace` to ensure
          that the appropriate side effects are invoked
    set_local_trace()
        Now using
        `PyObject_SetAttrString(<PyObject *>py_frame, 'f_trace', ...)`
        instead of directly manipulating `py_frame->f_trace` to ensure
        that the appropriate side effects are invoked
    monitoring_restart_version()
        Now using `PyThreadState_GetInterpreter()` instead of directly
        manipulating `tstate->interp`

Author: TTsangSC

line_profiler/Python_wrapper.h

@@ -32,6 +32,11 @@
         PyObject_CallMethodObjArgs(obj, name, NULL)
 #endif
 
+#if PY_VERSION_HEX < 0x030900a5  // 3.9.0a5
+#   define PyThreadState_GetInterpreter(tstate) \
+        ((tstate)->interp)
+#endif
+
 #if PY_VERSION_HEX < 0x030900b1  // 3.9.0b1
     /*
      * Notes:

line_profiler/_line_profiler.pyx

@@ -101,10 +101,11 @@ cdef extern from "c_trace_callbacks.c":  # Legacy tracing
 
     cdef TraceCallback *alloc_callback() except *
     cdef void free_callback(TraceCallback *callback)
-    cdef void fetch_callback(TraceCallback *callback)
+    cdef void populate_callback(TraceCallback *callback)
     cdef void restore_callback(TraceCallback *callback)
-    cdef int call_callback(TraceCallback *callback, PyFrameObject *py_frame,
-                           int what, PyObject *arg)
+    cdef int call_callback(
+        PyObject *disabler, TraceCallback *callback,
+        PyFrameObject *py_frame, int what, PyObject *arg)
     cdef void set_local_trace(PyObject *manager, PyFrameObject *py_frame)
     cdef Py_uintptr_t monitoring_restart_version()
 
@@ -219,19 +220,33 @@ def find_cython_source_file(cython_func):
 
 def disable_line_events(trace_func: Callable) -> Callable:
     """
-    Return a thin wrapper around ``trace_func()`` which withholds line
-    events.  This is for when a frame-local
-    :py:attr:`~frame.f_trace` disables
-    :py:attr:`~frame.f_trace_lines` -- we would like to keep
-    line events enabled (so that line profiling works) while
-    "unsubscribing" the trace function from it.
+    Returns:
+        trace_func (Callable)
+            If it is a wrapper created by
+            :py:attr:`_LineProfilerManager.wrap_local_f_trace`;
+            ``trace_func.disable_line_events`` is also set to true
+        wrapper (Callable)
+            Otherwise, a thin wrapper around ``trace_func()`` which
+            withholds line events.
+
+    Note:
+        This is for when a frame-local :py:attr:`~frame.f_trace`
+        disables :py:attr:`~frame.f_trace_lines` -- we would like to
+        keep line events enabled (so that line profiling works) while
+        "unsubscribing" the trace function from it.
     """
     @wraps(trace_func)
     def wrapper(frame, event, arg):
         if event == 'line':
             return
         return trace_func(frame, event, arg)
 
+    try:  # Disable the wrapper directly
+        if hasattr(trace_func, '__line_profiler_manager__'):
+            trace_func.disable_line_events = True
+            return trace_func
+    except AttributeError:
+        pass
     return wrapper
 
 
@@ -535,7 +550,7 @@ sys.monitoring.html#monitoring-event-RERAISE
         self.set_frame_local_trace = set_frame_local_trace
 
     @cython.profile(False)
-    def __call__(self, frame, event, arg):
+    def __call__(self, frame: types.FrameType, event: str, arg):
         """
         Calls |legacy_trace_callback|_.  If :py:func:`sys.gettrace`
         returns this instance, replaces the default C-level trace
@@ -568,7 +583,7 @@ main/Python/sysmodule.c
             PyEval_SetTrace(legacy_trace_callback, self)
         return self
 
-    def wrap_local_f_trace(self, trace_func):
+    def wrap_local_f_trace(self, trace_func: Callable) -> Callable:
         """
         Arguments:
             trace_func (Callable[[frame, str, Any], Any])
@@ -584,16 +599,22 @@ main/Python/sysmodule.c
                 :py:attr:`~.set_frame_local_trace` is true.
 
         Note:
-            The ``.__line_profiler_manager__`` attribute of the returned
-            wrapper is set to the instance.
+            * The ``.__line_profiler_manager__`` attribute of the
+              returned wrapper is set to the instance.
+            * Line events are not passed to the wrapped callable if
+              ``wrapper.disable_line_events`` is set to true.
         """
         @wraps(trace_func)
         def wrapper(frame, event, arg):
-            result = trace_func(frame, event, arg)
+            if wrapper.disable_line_events and event == 'line':
+                result = None
+            else:
+                result = trace_func(frame, event, arg)
             self(frame, event, arg)
             return result
 
         wrapper.__line_profiler_manager__ = self
+        wrapper.disable_line_events = False
         try:  # Unwrap the wrapper
             if trace_func.__line_profiler_manager__ is self:
                 trace_func = trace_func.__wrapped__
@@ -717,7 +738,7 @@ sys.monitoring.html#monitoring-event-RERAISE
             return
         if USE_LEGACY_TRACE:
             legacy_callback = alloc_callback()
-            fetch_callback(legacy_callback)
+            populate_callback(legacy_callback)
             self.legacy_callback = legacy_callback
             PyEval_SetTrace(legacy_trace_callback, self)
         else:
@@ -1403,10 +1424,12 @@ pystate.h#L16
     # Call the trace callback that we're wrapping around where
     # appropriate
     if manager_._wrap_trace:
-        result = call_callback(manager_.legacy_callback, py_frame, what, arg)
+        result = call_callback(
+            <PyObject *>disable_line_events, manager_.legacy_callback,
+            py_frame, what, arg)
     else:
         result = 0
-    
+
     # Prevent other trace functions from overwritting `manager`;
     # if there is a frame-local trace function, create a wrapper calling
     # both it and `manager`

line_profiler/c_trace_callbacks.c

@@ -29,7 +29,7 @@ void free_callback(TraceCallback *callback)
     return;
 }
 
-void fetch_callback(TraceCallback *callback)
+void populate_callback(TraceCallback *callback)
 {
     /* Store the members `.c_tracefunc` and `.c_traceobj` of the
      * current thread on `callback`.
@@ -48,6 +48,7 @@ void fetch_callback(TraceCallback *callback)
 
 void nullify_callback(TraceCallback *callback)
 {
+    if (callback == NULL) return;
     // No need for NULL check with `Py_XDECREF()`
     Py_XDECREF(callback->c_traceobj);
     callback->c_tracefunc = NULL;
@@ -78,6 +79,7 @@ inline int is_null_callback(TraceCallback *callback)
 }
 
 int call_callback(
+    PyObject *disabler,
     TraceCallback *callback,
     PyFrameObject *py_frame,
     int what,
@@ -103,7 +105,7 @@ int call_callback(
      *       trace callback errors out, `sys.settrace(None)` is called.
      *     - If a frame-local callback sets the `.f_trace_lines` to
      *       false, `.f_trace_lines` is reverted but `.f_trace` is
-     *       wrapped so that it no loger sees line events.
+     *       wrapped/altered so that it no longer sees line events.
      *
      * Notes:
      *     It is tempting to assume said current callback value to be
@@ -120,13 +122,13 @@ int call_callback(
     if (is_null_callback(callback)) return 0;
 
     f_trace_lines = py_frame->f_trace_lines;
-    fetch_callback(&before);
+    populate_callback(&before);
     result = (callback->c_tracefunc)(
         callback->c_traceobj, py_frame, what, arg
     );
 
     // Check if the callback has unset itself; if so, nullify `callback`
-    fetch_callback(&after);
+    populate_callback(&after);
     if (is_null_callback(&after)) nullify_callback(callback);
     nullify_callback(&after);
     restore_callback(&before);
@@ -142,44 +144,23 @@ int call_callback(
         py_frame->f_trace_lines = f_trace_lines;
         if (py_frame->f_trace != NULL && py_frame->f_trace != Py_None)
         {
-            // FIXME: can we get more performance by stashing a somewhat
-            // permanent reference to
-            // `line_profiler._line_profiler.disable_line_events()`
-            // somewhere?
-            mod = PyImport_AddModuleRef(CYTHON_MODULE);
-            if (mod == NULL)
-            {
-                RAISE_IN_CALL(
-                    "call_callback",
-                    PyExc_ImportError,
-                    "cannot import `" CYTHON_MODULE "`"
-                );
-                result = -1;
-                goto cleanup;
-            }
-            dle = PyObject_GetAttrString(mod, DISABLE_CALLBACK);
-            if (dle == NULL)
-            {
-                RAISE_IN_CALL(
-                    "call_callback",
-                    PyExc_AttributeError,
-                    "`line_profiler._line_profiler` has no "
-                    "attribute `" DISABLE_CALLBACK "`"
-                );
-                result = -1;
-                goto cleanup;
-            }
             // Note: DON'T `Py_[X]DECREF()` the pointer! Nothing else is
             // holding a reference to it.
-            f_trace = PyObject_CallOneArg(dle, py_frame->f_trace);
+            f_trace = PyObject_CallOneArg(disabler, py_frame->f_trace);
             if (f_trace == NULL)
             {
                 // No need to raise another exception, it's already
                 // raised in the call
                 result = -1;
                 goto cleanup;
             }
-            py_frame->f_trace = f_trace;
+            // No need to raise another exception, it's already
+            // raised in the call
+            if (PyObject_SetAttrString(
+                (PyObject *)py_frame, "f_trace", f_trace))
+            {
+                result = -1;
+            }
         }
     }
 cleanup:
@@ -213,9 +194,12 @@ inline void set_local_trace(PyObject *manager, PyFrameObject *py_frame)
         goto cleanup;
     }
     // Wrap the trace function
+    // (No need to raise another exception in case the call or the
+    // `setattr()` failed, it's already raised in the call)
     method = PyUnicode_FromString("wrap_local_f_trace");
-    py_frame->f_trace = PyObject_CallMethodOneArg(
-        manager, method, py_frame->f_trace);
+    PyObject_SetAttrString(
+        (PyObject *)py_frame, "f_trace",
+        PyObject_CallMethodOneArg(manager, method, py_frame->f_trace));
 cleanup:
     Py_XDECREF(method);
     return;
@@ -226,7 +210,8 @@ inline Py_uintptr_t monitoring_restart_version()
 {
     /* Get the `.last_restart_version` of the interpretor state.
      */
-    return PyThreadState_Get()->interp->last_restart_version;
+    return PyThreadState_GetInterpreter(
+        PyThreadState_Get())->last_restart_version;
 }
 #else
 { return (Py_uintptr_t)0; }  // Dummy implementation

line_profiler/c_trace_callbacks.h

@@ -57,9 +57,10 @@ typedef struct TraceCallback
 
 TraceCallback *alloc_callback();
 void free_callback(TraceCallback *callback);
-void fetch_callback(TraceCallback *callback);
+void populate_callback(TraceCallback *callback);
 void restore_callback(TraceCallback *callback);
 int call_callback(
+    PyObject *disabler,
     TraceCallback *callback,
     PyFrameObject *py_frame,
     int what,