RF: Factor out keyboard interrupt catch

IPython/terminal/pt_inputhooks/wx.py

@@ -8,13 +8,25 b' from timeit import default_timer as clock'
 import wx
 
 
+def ignore_keyboardinterrupts(func):
+    """Decorator which causes KeyboardInterrupt exceptions to be
+    ignored during execution of the decorated function.
+    """
+    def wrapper(*args, **kwargs):
+        try:
+            func(*args, **kwargs)
+        except KeyboardInterrupt:
+            pass
+    return wrapper
+
+
+@ignore_keyboardinterrupts
 def inputhook_wx1(context):
     """Run the wx event loop by processing pending events only.
 
     This approach seems to work, but its performance is not great as it
     relies on having PyOS_InputHook called regularly.
     """
-    try:
         app = wx.GetApp()
         if app is not None:
             assert wx.Thread_IsMain()
@@ -28,10 +40,9 b' def inputhook_wx1(context):'
                 evtloop.Dispatch()
             app.ProcessIdle()
             del ea
-    except KeyboardInterrupt:
-        pass
     return 0
 
+
 class EventLoopTimer(wx.Timer):
 
     def __init__(self, func):
@@ -41,6 +52,7 b' class EventLoopTimer(wx.Timer):'
     def Notify(self):
         self.func()
 
+
 class EventLoopRunner(object):
 
     def Run(self, time, input_is_ready):
@@ -55,6 +67,8 b' class EventLoopRunner(object):'
             self.timer.Stop()
             self.evtloop.Exit()
 
+
+@ignore_keyboardinterrupts
 def inputhook_wx2(context):
     """Run the wx event loop, polling for stdin.
 
@@ -69,7 +83,6 b' def inputhook_wx2(context):'
     but eventually performance would suffer from calling select/kbhit too
     often.
     """
-    try:
         app = wx.GetApp()
         if app is not None:
             assert wx.Thread_IsMain()
@@ -78,10 +91,10 b' def inputhook_wx2(context):'
             # CPU load goes up.  10 ms seems like a good compromise.
             elr.Run(time=10,  # CHANGE time here to control polling interval
                     input_is_ready=context.input_is_ready)
-    except KeyboardInterrupt:
-        pass
     return 0
 
+
+@ignore_keyboardinterrupts
 def inputhook_wx3(context):
     """Run the wx event loop by processing pending events only.
 
@@ -90,9 +103,6 b' def inputhook_wx3(context):'
     time.sleep is inserted.  This is needed, otherwise, CPU usage is at 100%.
     This sleep time should be tuned though for best performance.
     """
-    # We need to protect against a user pressing Control-C when IPython is
-    # idle and this is running. We trap KeyboardInterrupt and pass.
-    try:
         app = wx.GetApp()
         if app is not None:
             assert wx.Thread_IsMain()
@@ -133,11 +143,10 b' def inputhook_wx3(context):'
                     # Many GUI events coming in, so sleep only very little
                     time.sleep(0.001)
             del ea
-    except KeyboardInterrupt:
-        pass
     return 0
 
 
+@ignore_keyboardinterrupts
 def inputhook_wxphoenix(context):
     """Run the wx event loop until the user provides more input.
 
@@ -183,6 +192,7 b' def inputhook_wxphoenix(context):'
 
     app.MainLoop()
 
+
 # Get the major wx version number to figure out what input hook we should use.
 major_version = 3
 try: