Improve Python 3 compatibility for example scripts.

examples/core/appconfig.py

@@ -1,101 +1,99 b''
 """A simple example of how to use IPython.config.application.Application.
 
 This should serve as a simple example that shows how the IPython config
 system works. The main classes are:
 
 * IPython.config.configurable.Configurable
 * IPython.config.configurable.SingletonConfigurable
 * IPython.config.loader.Config
 * IPython.config.application.Application
 
 To see the command line option help, run this program from the command line::
 
     $ python appconfig.py -h
 
 To make one of your classes configurable (from the command line and config
 files) inherit from Configurable and declare class attributes as traits (see
 classes Foo and Bar below). To make the traits configurable, you will need
 to set the following options:
 
 * ``config``: set to ``True`` to make the attribute configurable.
 * ``shortname``: by default, configurable attributes are set using the syntax
   "Classname.attributename". At the command line, this is a bit verbose, so
   we allow "shortnames" to be declared. Setting a shortname is optional, but
   when you do this, you can set the option at the command line using the
   syntax: "shortname=value".
 * ``help``: set the help string to display a help message when the ``-h``
   option is given at the command line. The help string should be valid ReST.
 
 When the config attribute of an Application is updated, it will fire all of
 the trait's events for all of the config=True attributes.
 """
 
-import sys
-
 from IPython.config.configurable import Configurable
 from IPython.config.application import Application
 from IPython.utils.traitlets import (
     Bool, Unicode, Int, Float, List, Dict
 )
 
 
 class Foo(Configurable):
     """A class that has configurable, typed attributes.
 
     """
 
     i = Int(0, config=True, help="The integer i.")
     j = Int(1, config=True, help="The integer j.")
     name = Unicode(u'Brian', config=True, help="First name.")
 
 
 class Bar(Configurable):
 
     enabled = Bool(True, config=True, help="Enable bar.")
 
 
 class MyApp(Application):
 
     name = Unicode(u'myapp')
     running = Bool(False, config=True,
                    help="Is the app running?")
     classes = List([Bar, Foo])
     config_file = Unicode(u'', config=True,
                    help="Load this config file")
     
     aliases = Dict(dict(i='Foo.i',j='Foo.j',name='Foo.name', running='MyApp.running',
                         enabled='Bar.enabled', log_level='MyApp.log_level'))
     
     flags = Dict(dict(enable=({'Bar': {'enabled' : True}}, "Enable Bar"),
                   disable=({'Bar': {'enabled' : False}}, "Disable Bar"),
                   debug=({'MyApp':{'log_level':10}}, "Set loglevel to DEBUG")
             ))
     
     def init_foo(self):
         # Pass config to other classes for them to inherit the config.
         self.foo = Foo(config=self.config)
 
     def init_bar(self):
         # Pass config to other classes for them to inherit the config.
         self.bar = Bar(config=self.config)
 
     def initialize(self, argv=None):
         self.parse_command_line(argv)
         if self.config_file:
             self.load_config_file(self.config_file)
         self.init_foo()
         self.init_bar()
     
     def start(self):
-        print "app.config:"
-        print self.config
+        print("app.config:")
+        print(self.config)
 
 
 def main():
     app = MyApp()
     app.initialize()
     app.start()
 
 
 if __name__ == "__main__":
     main()

examples/core/ipython-get-history.py

@@ -1,38 +1,37 b''
 #!/usr/bin/env python
 """Extract a session from the IPython input history.
 
 Usage:
   ipython-get-history.py sessionnumber [outputfile]
 
 If outputfile is not given, the relevant history is written to stdout. If
 outputfile has a .py extension, the translated history (without IPython's
 special syntax) will be extracted.
 
 Example:
   ./ipython-get-history.py 57 record.ipy
 
 
 This script is a simple demonstration of HistoryAccessor. It should be possible
 to build much more flexible and powerful tools to browse and pull from the
 history database.
 """
 import sys
-import codecs
 
 from IPython.core.history import HistoryAccessor
 
 session_number = int(sys.argv[1])
 if len(sys.argv) > 2:
     dest = open(sys.argv[2], "w")
     raw = not sys.argv[2].endswith('.py')
 else:
     dest = sys.stdout
     raw = True
 dest.write("# coding: utf-8\n")
 
 # Profiles other than 'default' can be specified here with a profile= argument:
 hist = HistoryAccessor()
 
 for session, lineno, cell in hist.get_range(session=session_number, raw=raw):
-    # To use this in Python 3, remove the .encode() here:
-    dest.write(cell.encode('utf-8') + '\n')
+    cell = cell.encode('utf-8')  # This line is only needed on Python 2.
+    dest.write(cell + '\n')

examples/inprocess/embedded_qtconsole.py

@@ -1,45 +1,46 b''
+from __future__ import print_function
 import os
 
 from IPython.qt.console.rich_ipython_widget import RichIPythonWidget
 from IPython.qt.inprocess import QtInProcessKernelManager
 from IPython.lib import guisupport
 
 
 def print_process_id():
-    print 'Process ID is:', os.getpid()
+    print('Process ID is:', os.getpid())
 
 
 def main():
     # Print the ID of the main process
     print_process_id()
 
     app = guisupport.get_app_qt4()
 
     # Create an in-process kernel
     # >>> print_process_id()
     # will print the same process ID as the main process
     kernel_manager = QtInProcessKernelManager()
     kernel_manager.start_kernel()
     kernel = kernel_manager.kernel
     kernel.gui = 'qt4'
     kernel.shell.push({'foo': 43, 'print_process_id': print_process_id})
 
     kernel_client = kernel_manager.client()
     kernel_client.start_channels()
 
     def stop():
         kernel_client.stop_channels()
         kernel_manager.shutdown_kernel()
         app.exit()
 
     control = RichIPythonWidget()
     control.kernel_manager = kernel_manager
     control.kernel_client = kernel_client
     control.exit_requested.connect(stop)
     control.show()
 
     guisupport.start_event_loop_qt4(app)
 
 
 if __name__ == '__main__':
     main()

examples/inprocess/embedded_terminal.py

@@ -1,30 +1,31 b''
+from __future__ import print_function
 import os
 
 from IPython.kernel.inprocess import InProcessKernelManager
 from IPython.terminal.console.interactiveshell import ZMQTerminalInteractiveShell
 
 
 def print_process_id():
-    print 'Process ID is:', os.getpid()
+    print('Process ID is:', os.getpid())
 
 
 def main():
     print_process_id()
 
     # Create an in-process kernel
     # >>> print_process_id()
     # will print the same process ID as the main process
     kernel_manager = InProcessKernelManager()
     kernel_manager.start_kernel()
     kernel = kernel_manager.kernel
     kernel.gui = 'qt4'
     kernel.shell.push({'foo': 43, 'print_process_id': print_process_id})
     client = kernel_manager.client()
     client.start_channels()
 
     shell = ZMQTerminalInteractiveShell(manager=kernel_manager, client=client)
     shell.mainloop()
 
 
 if __name__ == '__main__':
     main()

examples/lib/gui-qt.py

@@ -1,41 +1,40 b''
 #!/usr/bin/env python
 """Simple Qt4 example to manually test event loop integration.
 
 This is meant to run tests manually in ipython as:
 
 In [5]: %gui qt
 
 In [6]: %run gui-qt.py
 
 Ref: Modified from http://zetcode.com/tutorials/pyqt4/firstprograms/
 """
 
-import sys
 from PyQt4 import QtGui, QtCore
 
 class SimpleWindow(QtGui.QWidget):
     def __init__(self, parent=None):
         QtGui.QWidget.__init__(self, parent)
 
         self.setGeometry(300, 300, 200, 80)
         self.setWindowTitle('Hello World')
 
         quit = QtGui.QPushButton('Close', self)
         quit.setGeometry(10, 10, 60, 35)
 
         self.connect(quit, QtCore.SIGNAL('clicked()'),
                      self, QtCore.SLOT('close()'))
 
 if __name__ == '__main__':
     app = QtCore.QCoreApplication.instance()
     if app is None:
         app = QtGui.QApplication([])
 
     sw = SimpleWindow()
     sw.show()
 
     try:
         from IPython.lib.guisupport import start_event_loop_qt4
         start_event_loop_qt4(app)
     except ImportError:
         app.exec_()

examples/lib/gui-tk.py

@@ -1,32 +1,35 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 *
+try:
+    from tkinter import *  # Python 3
+except ImportError:
+    from Tkinter import *  # Python 2
 
 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!")
 
 root = Tk()
 
 app = MyApp(root)
 
 try:
     from IPython.lib.inputhook import enable_tk; enable_tk(root)
 except ImportError:
     root.mainloop()

examples/lib/internal_ipkernel.py

@@ -1,59 +1,58 b''
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
-import subprocess
 import sys
 
 from IPython.lib.kernel import connect_qtconsole
 from IPython.kernel.zmq.kernelapp 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***")
-        for k, v in self.namespace.iteritems():
+        for k, v in self.namespace.items():
             if k not in self._init_keys and not k.startswith('_'):
                 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()