Make print syntax in GUI integration examples Python 3 compatible.

docs/examples/lib/example-demo.py

@@ -1,40 +1,41 b''
 """A simple interactive demo to illustrate the use of IPython's Demo class.
 
 Any python script can be run as a demo, but that does little more than showing
 it on-screen, syntax-highlighted in one shot.  If you add a little simple
 markup, you can stop at specified intervals and return to the ipython prompt,
 resuming execution later.
 """
+from __future__ import print_function
 
-print 'Hello, welcome to an interactive IPython demo.'
-print 'Executing this block should require confirmation before proceeding,'
-print 'unless auto_all has been set to true in the demo object'
+print('Hello, welcome to an interactive IPython demo.')
+print('Executing this block should require confirmation before proceeding,')
+print('unless auto_all has been set to true in the demo object')
 
 # The mark below defines a block boundary, which is a point where IPython will
 # stop execution and return to the interactive prompt.
 # Note that in actual interactive execution, 
 # <demo> --- stop ---
 
 x = 1
 y = 2
 
 # <demo> --- stop ---
 
 # the mark below makes this block as silent
 # <demo> silent
 
-print 'This is a silent block, which gets executed but not printed.'
+print('This is a silent block, which gets executed but not printed.')
 
 # <demo> --- stop ---
 # <demo> auto
-print 'This is an automatic block.'
-print 'It is executed without asking for confirmation, but printed.'
+print('This is an automatic block.')
+print('It is executed without asking for confirmation, but printed.')
 z = x+y
 
-print 'z=',x
+print('z=',x)
 
 # <demo> --- stop ---
 # This is just another normal block.
-print 'z is now:', z
+print('z is now:', z)
 
-print 'bye!'
+print('bye!')

docs/examples/lib/gui-gtk.py

@@ -1,39 +1,39 b''
 #!/usr/bin/env python
 """Simple GTK example to manually test event loop integration.
 
 This is meant to run tests manually in ipython as:
 
 In [5]: %gui gtk
 
 In [6]: %run gui-gtk.py
 """
 
 import pygtk
 pygtk.require('2.0')
 import gtk
 
 
 def hello_world(wigdet, data=None):
-    print "Hello World"
+    print("Hello World")
 
 def delete_event(widget, event, data=None):
     return False
 
 def destroy(widget, data=None):
     gtk.main_quit()
 
 window = gtk.Window(gtk.WINDOW_TOPLEVEL)
 window.connect("delete_event", delete_event)
 window.connect("destroy", destroy)
 button = gtk.Button("Hello World")
 button.connect("clicked", hello_world, None)
 
 window.add(button)
 button.show()
 window.show()
 
 try:
     from IPython.lib.inputhook import enable_gtk
     enable_gtk()
 except ImportError:
     gtk.main()

docs/examples/lib/gui-tk.py

@@ -1,32 +1,32 b''
 #!/usr/bin/env python
 """Simple Tk example to manually test event loop integration.
 
 This is meant to run tests manually in ipython as:
 
 In [5]: %gui tk
 
 In [6]: %run gui-tk.py
 """
 
 from Tkinter import *
 
 class MyApp:
 
     def __init__(self, root):
         frame = Frame(root)
         frame.pack()
 
         self.button = Button(frame, text="Hello", command=self.hello_world)
         self.button.pack(side=LEFT)
 
     def hello_world(self):
-        print "Hello World!"
+        print("Hello World!")
 
 root = Tk()
 
 app = MyApp(root)
 
 try:
     from IPython.lib.inputhook import enable_tk; enable_tk(root)
 except ImportError:
     root.mainloop()

docs/examples/lib/gui-wx.py

@@ -1,106 +1,106 b''
 #!/usr/bin/env python
 """
 A Simple wx example to test IPython's event loop integration.
 
 To run this do:
 
 In [5]: %gui wx  # or start IPython with '--gui wx' or '--pylab wx'
 
 In [6]: %run gui-wx.py
 
 Ref: Modified from wxPython source code wxPython/samples/simple/simple.py
 """
 
 import wx
 
 
 class MyFrame(wx.Frame):
     """
     This is MyFrame.  It just shows a few controls on a wxPanel,
     and has a simple menu.
     """
     def __init__(self, parent, title):
         wx.Frame.__init__(self, parent, -1, title,
                           pos=(150, 150), size=(350, 200))
 
         # Create the menubar
         menuBar = wx.MenuBar()
 
         # and a menu
         menu = wx.Menu()
 
         # add an item to the menu, using \tKeyName automatically
         # creates an accelerator, the third param is some help text
         # that will show up in the statusbar
         menu.Append(wx.ID_EXIT, "E&xit\tAlt-X", "Exit this simple sample")
 
         # bind the menu event to an event handler
         self.Bind(wx.EVT_MENU, self.OnTimeToClose, id=wx.ID_EXIT)
 
         # and put the menu on the menubar
         menuBar.Append(menu, "&File")
         self.SetMenuBar(menuBar)
 
         self.CreateStatusBar()
 
         # Now create the Panel to put the other controls on.
         panel = wx.Panel(self)
 
         # and a few controls
         text = wx.StaticText(panel, -1, "Hello World!")
         text.SetFont(wx.Font(14, wx.SWISS, wx.NORMAL, wx.BOLD))
         text.SetSize(text.GetBestSize())
         btn = wx.Button(panel, -1, "Close")
         funbtn = wx.Button(panel, -1, "Just for fun...")
 
         # bind the button events to handlers
         self.Bind(wx.EVT_BUTTON, self.OnTimeToClose, btn)
         self.Bind(wx.EVT_BUTTON, self.OnFunButton, funbtn)
 
         # Use a sizer to layout the controls, stacked vertically and with
         # a 10 pixel border around each
         sizer = wx.BoxSizer(wx.VERTICAL)
         sizer.Add(text, 0, wx.ALL, 10)
         sizer.Add(btn, 0, wx.ALL, 10)
         sizer.Add(funbtn, 0, wx.ALL, 10)
         panel.SetSizer(sizer)
         panel.Layout()
 
 
     def OnTimeToClose(self, evt):
         """Event handler for the button click."""
-        print "See ya later!"
+        print("See ya later!")
         self.Close()
 
     def OnFunButton(self, evt):
         """Event handler for the button click."""
-        print "Having fun yet?"
+        print("Having fun yet?")
 
 
 class MyApp(wx.App):
     def OnInit(self):
         frame = MyFrame(None, "Simple wxPython App")
         self.SetTopWindow(frame)
 
-        print "Print statements go to this stdout window by default."
+        print("Print statements go to this stdout window by default.")
 
         frame.Show(True)
         return True
 
 
 if __name__ == '__main__':
 
     app = wx.GetApp()
     if app is None:
         app = MyApp(redirect=False, clearSigInt=False)
     else:
         frame = MyFrame(None, "Simple wxPython App")
         app.SetTopWindow(frame)
-        print "Print statements go to this stdout window by default."
+        print("Print statements go to this stdout window by default.")
         frame.Show(True)
 
     try:
         from IPython.lib.inputhook import enable_wx
         enable_wx(app)
     except ImportError:
         app.MainLoop()

docs/examples/lib/internal_ipkernel.py

@@ -1,59 +1,59 b''
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import subprocess
 import sys
 
 from IPython.lib.kernel import connect_qtconsole
 from IPython.zmq.ipkernel import IPKernelApp
 
 #-----------------------------------------------------------------------------
 # Functions and classes
 #-----------------------------------------------------------------------------
 def pylab_kernel(gui):
     """Launch and return an IPython kernel with pylab support for the desired gui
     """
     kernel = IPKernelApp.instance()
     kernel.initialize(['python', '--pylab=%s' % gui,
                        #'--log-level=10'
                        ])
     return kernel
 
 
 class InternalIPKernel(object):
 
     def init_ipkernel(self, backend):
         # Start IPython kernel with GUI event loop and pylab support
         self.ipkernel = pylab_kernel(backend)
         # To create and track active qt consoles
         self.consoles = []
         
         # This application will also act on the shell user namespace
         self.namespace = self.ipkernel.shell.user_ns
         # Keys present at startup so we don't print the entire pylab/numpy
         # namespace when the user clicks the 'namespace' button
         self._init_keys = set(self.namespace.keys())
 
         # Example: a variable that will be seen by the user in the shell, and
         # that the GUI modifies (the 'Counter++' button increments it):
         self.namespace['app_counter'] = 0
         #self.namespace['ipkernel'] = self.ipkernel  # dbg
 
     def print_namespace(self, evt=None):
-        print "\n***Variables in User namespace***"
+        print("\n***Variables in User namespace***")
         for k, v in self.namespace.iteritems():
             if k not in self._init_keys and not k.startswith('_'):
-                print '%s -> %r' % (k, v)
+                print('%s -> %r' % (k, v))
         sys.stdout.flush()
 
     def new_qt_console(self, evt=None):
         """start a new qtconsole connected to our kernel"""
         return connect_qtconsole(self.ipkernel.connection_file, profile=self.ipkernel.profile)
 
     def count(self, evt=None):
         self.namespace['app_counter'] += 1
 
     def cleanup_consoles(self, evt=None):
         for c in self.consoles:
             c.kill()

docs/examples/lib/ipkernel_wxapp.py

@@ -1,119 +1,119 b''
 #!/usr/bin/env python
 """Example integrating an IPython kernel into a GUI App.
 
 This trivial GUI application internally starts an IPython kernel, to which Qt
 consoles can be connected either by the user at the command line or started
 from the GUI itself, via a button.  The GUI can also manipulate one variable in
 the kernel's namespace, and print the namespace to the console.
 
 Play with it by running the script and then opening one or more consoles, and
 pushing the 'Counter++' and 'Namespace' buttons.
 
 Upon exit, it should automatically close all consoles opened from the GUI.
 
 Consoles attached separately from a terminal will not be terminated, though
 they will notice that their kernel died.
 
 Ref: Modified from wxPython source code wxPython/samples/simple/simple.py
 """
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 import sys
 
 import wx
 
 from internal_ipkernel import InternalIPKernel
 
 #-----------------------------------------------------------------------------
 # Functions and classes
 #-----------------------------------------------------------------------------
 
 class MyFrame(wx.Frame, InternalIPKernel):
     """
     This is MyFrame.  It just shows a few controls on a wxPanel,
     and has a simple menu.
     """
 
     def __init__(self, parent, title):
         wx.Frame.__init__(self, parent, -1, title,
                           pos=(150, 150), size=(350, 285))
 
         # Create the menubar
         menuBar = wx.MenuBar()
 
         # and a menu 
         menu = wx.Menu()
 
         # add an item to the menu, using \tKeyName automatically
         # creates an accelerator, the third param is some help text
         # that will show up in the statusbar
         menu.Append(wx.ID_EXIT, "E&xit\tAlt-X", "Exit this simple sample")
 
         # bind the menu event to an event handler
         self.Bind(wx.EVT_MENU, self.OnTimeToClose, id=wx.ID_EXIT)
 
         # and put the menu on the menubar
         menuBar.Append(menu, "&File")
         self.SetMenuBar(menuBar)
 
         self.CreateStatusBar()
 
         # Now create the Panel to put the other controls on.
         panel = wx.Panel(self)
 
         # and a few controls
         text = wx.StaticText(panel, -1, "Hello World!")
         text.SetFont(wx.Font(14, wx.SWISS, wx.NORMAL, wx.BOLD))
         text.SetSize(text.GetBestSize())
         qtconsole_btn = wx.Button(panel, -1, "Qt Console")
         ns_btn = wx.Button(panel, -1, "Namespace")
         count_btn = wx.Button(panel, -1, "Count++")
         close_btn = wx.Button(panel, -1, "Quit")
 
         # bind the button events to handlers
         self.Bind(wx.EVT_BUTTON, self.new_qt_console, qtconsole_btn)
         self.Bind(wx.EVT_BUTTON, self.print_namespace, ns_btn)
         self.Bind(wx.EVT_BUTTON, self.count, count_btn)
         self.Bind(wx.EVT_BUTTON, self.OnTimeToClose, close_btn)
 
         # Use a sizer to layout the controls, stacked vertically and with
         # a 10 pixel border around each
         sizer = wx.BoxSizer(wx.VERTICAL)
         for ctrl in [text, qtconsole_btn, ns_btn, count_btn, close_btn]:
             sizer.Add(ctrl, 0, wx.ALL, 10)
         panel.SetSizer(sizer)
         panel.Layout()
 
         # Start the IPython kernel with gui support
         self.init_ipkernel('wx')
 
     def OnTimeToClose(self, evt):
         """Event handler for the button click."""
-        print "See ya later!"
+        print("See ya later!")
         sys.stdout.flush()
         self.cleanup_consoles(evt)
         self.Close()
         # Not sure why, but our IPython kernel seems to prevent normal WX
         # shutdown, so an explicit exit() call is needed.
         sys.exit()
 
 
 class MyApp(wx.App):
     def OnInit(self):
         frame = MyFrame(None, "Simple wxPython App")
         self.SetTopWindow(frame)
         frame.Show(True)
         self.ipkernel = frame.ipkernel
         return True
 
 #-----------------------------------------------------------------------------
 # Main script
 #-----------------------------------------------------------------------------
 
 if __name__ == '__main__':
     app = MyApp(redirect=False, clearSigInt=False)
 
     # Very important, IPython-specific step: this gets GUI event loop
     # integration going, and it replaces calling app.MainLoop()
     app.ipkernel.start()