code: def create_inputhook_qt4(mgr, app=None):
      """Create an input hook for running the Qt4 application event loop.
  
      Parameters
      ----------
      mgr : an InputHookManager
  
      app : Qt Application, optional.
          Running application to use.  If not given, we probe Qt for an
          existing application object, and create a new one if none is found.
  
      Returns
      -------
      A pair consisting of a Qt Application (either the one given or the
      one found or created) and a inputhook.
  
      Notes
      -----
      We use a custom input hook instead of PyQt4's default one, as it
      interacts better with the readline packages (issue #481).
  
      The inputhook function works in tandem with a 'pre_prompt_hook'
      which automatically restores the hook as an inputhook in case the
      latter has been temporarily disabled after having intercepted a
      KeyboardInterrupt.
      """
  
      if app is None:
          app = QtCore.QCoreApplication.instance()
          if app is None:
              app = QtGui.QApplication([" "])
  
      # Re-use previously created inputhook if any
      ip = InteractiveShell.instance()
      if hasattr(ip, "_inputhook_qt4"):
          return app, ip._inputhook_qt4
  
      # Otherwise create the inputhook_qt4/preprompthook_qt4 pair of
      # hooks (they both share the got_kbdint flag)
  
      def inputhook_qt4():
          """PyOS_InputHook python hook for Qt4.
  
          Process pending Qt events and if there's no pending keyboard
          input, spend a short slice of time (50ms) running the Qt event
          loop.
  
          As a Python ctypes callback can't raise an exception, we catch
          the KeyboardInterrupt and temporarily deactivate the hook,
          which will let a *second* CTRL+C be processed normally and go
          back to a clean prompt line.
          """
          try:
              allow_CTRL_C()
              app = QtCore.QCoreApplication.instance()
              if (
                  not app
              ):  # shouldn't happen, but safer if it happens anyway...
                  return 0
              app.processEvents(QtCore.QEventLoop.AllEvents, 300)
              if not stdin_ready():
                  # Generally a program would run QCoreApplication::exec()
                  # from main() to enter and process the Qt event loop until
                  # quit() or exit() is called and the program terminates.
                  #
                  # For our input hook integration, we need to repeatedly
                  # enter and process the Qt event loop for only a short
                  # amount of time (say 50ms) to ensure that Python stays
                  # responsive to other user inputs.
                  #
                  # A naive approach would be to repeatedly call
                  # QCoreApplication::exec(), using a timer to quit after a
                  # short amount of time. Unfortunately, QCoreApplication
                  # emits an aboutToQuit signal before stopping, which has
                  # the undesirable effect of closing all modal windows.
                  #
                  # To work around this problem, we instead create a
                  # QEventLoop and call QEventLoop::exec(). Other than
                  # setting some state variables which do not seem to be
                  # used anywhere, the only thing QCoreApplication adds is
                  # the aboutToQuit signal which is precisely what we are
                  # trying to avoid.
                  timer = QtCore.QTimer()
                  event_loop = QtCore.QEventLoop()
                  timer.timeout.connect(event_loop.quit)
                  while not stdin_ready():
                      timer.start(50)
                      event_loop.exec_()
                      timer.stop()
          except KeyboardInterrupt:
              global got_kbdint, sigint_timer
  
              ignore_CTRL_C()
              got_kbdint = True
              mgr.clear_inputhook()
  
              # This generates a second SIGINT so the user doesn't have to
              # press CTRL+C twice to get a clean prompt.
              #
              # Since we can't catch the resulting KeyboardInterrupt here
              # (because this is a ctypes callback), we use a timer to
              # generate the SIGINT after we leave this callback.
              #
              # Unfortunately this doesn't work on Windows (SIGINT kills
              # Python and CTRL_C_EVENT doesn't work).
              if os.name == "posix":
                  pid = os.getpid()
                  if not sigint_timer:
                      sigint_timer = threading.Timer(
                          0.01, os.kill, args=[pid, signal.SIGINT]
                      )
                      sigint_timer.start()
              else:
                  print(
                      "\nKeyboardInterrupt - Ctrl-C again for new prompt"
                  )
  
          except:  # NO exceptions are allowed to escape from a ctypes callback
              ignore_CTRL_C()
              from traceback import print_exc
  
              print_exc()
              print("Got exception from inputhook_qt4, unregistering.")
              mgr.clear_inputhook()
          finally:
              allow_CTRL_C()
          return 0
  
      def preprompthook_qt4(ishell):
          """'pre_prompt_hook' used to restore the Qt4 input hook
  
          (in case the latter was temporarily deactivated after a
          CTRL+C)
          """
          global got_kbdint, sigint_timer
  
          if sigint_timer:
              sigint_timer.cancel()
              sigint_timer = None
  
          if got_kbdint:
              mgr.set_inputhook(inputhook_qt4)
          got_kbdint = False
  
      ip._inputhook_qt4 = inputhook_qt4
      ip.set_hook("pre_prompt_hook", preprompthook_qt4)
  
      return app, inputhook_qt4
  
imports: import os
  import signal
  import threading
  from IPython.core.interactiveshell import InteractiveShell
  from IPython.external.qt_for_kernel import QtCore, QtGui
  from IPython.lib.inputhook import allow_CTRL_C, ignore_CTRL_C, stdin_ready
label_desc: Use image node_id 1 for calling a global function with example usage: create_inputhook_qt4(mgr, app) and returns: app,  inputhook_qt4, app,  ip, int, int