Fix `frontend` deprecation warnings in several examples

docs/examples/frontend/inprocess_qtconsole.py

@@ -1,58 +1,58 b''
 """ A simple example of using the Qt console with an in-process kernel.
 
 We shall see how to create the frontend widget, create an in-process kernel,
 push Python objects into the kernel's namespace, and execute code in the
 kernel, both directly and via the frontend widget.
 """
 
 from IPython.kernel.inprocess.ipkernel import InProcessKernel
-from IPython.frontend.qt.console.rich_ipython_widget import RichIPythonWidget
-from IPython.frontend.qt.inprocess_kernelmanager import QtInProcessKernelManager
+from IPython.qt.console.rich_ipython_widget import RichIPythonWidget
+from IPython.qt.inprocess_kernelmanager import QtInProcessKernelManager
 from IPython.lib import guisupport
 
 
 def main():
     app = guisupport.get_app_qt4()
 
     # Create a kernel. 
     #
     # Setting the GUI is not necessary for the normal operation of the kernel,
     # but it is used for IPython GUI's integration, particularly in pylab. By
     # default, the inline backend is used, which is safe under all toolkits.
     #
     # WARNING: Under no circumstances should another GUI toolkit, like wx, be
     # used when running a Qt application. This will lead to unexpected behavior,
     # including segfaults.
     kernel = InProcessKernel(gui='qt4')
 
     # Populate the kernel's namespace.
     kernel.shell.push({'x': 0, 'y': 1, 'z': 2})
 
     # Create a kernel manager for the frontend and register it with the kernel.
     km = QtInProcessKernelManager(kernel=kernel)
     km.start_channels()
     kernel.frontends.append(km)
 
     # Create the Qt console frontend.
     control = RichIPythonWidget()
     control.exit_requested.connect(app.quit)
     control.kernel_manager = km
     control.show()
 
     # Execute some code directly. Note where the output appears.
     kernel.shell.run_cell('print "x=%r, y=%r, z=%r" % (x,y,z)')
 
     # Execute some code through the frontend (once the event loop is
     # running). Again, note where the output appears.
     do_later(control.execute, '%who')
 
     guisupport.start_event_loop_qt4(app)
 
 
 def do_later(func, *args, **kwds):
     from IPython.external.qt import QtCore
     QtCore.QTimer.singleShot(0, lambda: func(*args, **kwds))
 
 
 if __name__ == '__main__':
     main()

examples/core/example-embed-short.py

@@ -1,47 +1,47 b''
 """Quick code snippets for embedding IPython into other programs.
 
 See example-embed.py for full details, this file has the bare minimum code for
 cut and paste use once you understand how to use the system."""
 
 #---------------------------------------------------------------------------
 # This code loads IPython but modifies a few things if it detects it's running
 # embedded in another IPython session (helps avoid confusion)
 
 try:
     get_ipython
 except NameError:
     banner=exit_msg=''
 else:
     banner = '*** Nested interpreter ***'
     exit_msg = '*** Back in main IPython ***'
 
 # First import the embed function
-from IPython.frontend.terminal.embed import InteractiveShellEmbed
+from IPython.terminal.embed import InteractiveShellEmbed
 # Now create the IPython shell instance. Put ipshell() anywhere in your code
 # where you want it to open.
 ipshell = InteractiveShellEmbed(banner1=banner, exit_msg=exit_msg)
                             
 #---------------------------------------------------------------------------
 # This code will load an embeddable IPython shell always with no changes for
 # nested embededings.
 
 from IPython import embed
 # Now embed() will open IPython anywhere in the code.
 
 #---------------------------------------------------------------------------
 # This code loads an embeddable shell only if NOT running inside
 # IPython. Inside IPython, the embeddable shell variable ipshell is just a
 # dummy function.
 
 try:
     get_ipython
 except NameError:
-    from IPython.frontend.terminal.embed import InteractiveShellEmbed
+    from IPython.terminal.embed import InteractiveShellEmbed
     ipshell = InteractiveShellEmbed()
     # Now ipshell() will open IPython anywhere in the code
 else:
     # Define a dummy ipshell() so the same code doesn't crash inside an
     # interactive IPython
     def ipshell(): pass
 
 #******************* End of file <example-embed-short.py> ********************

examples/core/example-embed.py

@@ -1,138 +1,138 b''
 #!/usr/bin/env python
 
 """An example of how to embed an IPython shell into a running program.
 
 Please see the documentation in the IPython.Shell module for more details.
 
 The accompanying file example-embed-short.py has quick code fragments for
 embedding which you can cut and paste in your code once you understand how
 things work.
 
 The code in this file is deliberately extra-verbose, meant for learning."""
 from __future__ import print_function
 
 # The basics to get you going:
 
 # IPython sets the __IPYTHON__ variable so you can know if you have nested
 # copies running.
 
 # Try running this code both at the command line and from inside IPython (with
 # %run example-embed.py)
 from IPython.config.loader import Config
 try:
     get_ipython
 except NameError:
     nested = 0
     cfg = Config()
     prompt_config = cfg.PromptManager
     prompt_config.in_template = 'In <\\#>: '
     prompt_config.in2_template = '   .\\D.: '
     prompt_config.out_template = 'Out<\\#>: '
 else:
     print("Running nested copies of IPython.")
     print("The prompts for the nested copy have been modified")
     cfg = Config()
     nested = 1
 
 # First import the embeddable shell class
-from IPython.frontend.terminal.embed import InteractiveShellEmbed
+from IPython.terminal.embed import InteractiveShellEmbed
 
 # Now create an instance of the embeddable shell. The first argument is a
 # string with options exactly as you would type them if you were starting
 # IPython at the system command line. Any parameters you want to define for
 # configuration can thus be specified here.
 ipshell = InteractiveShellEmbed(config=cfg,
                        banner1 = 'Dropping into IPython',
                        exit_msg = 'Leaving Interpreter, back to program.')
 
 # Make a second instance, you can have as many as you want.
 cfg2 = cfg.copy()
 prompt_config = cfg2.PromptManager
 prompt_config.in_template = 'In2<\\#>: '
 if not nested:
     prompt_config.in_template = 'In2<\\#>: '
     prompt_config.in2_template = '   .\\D.: '
     prompt_config.out_template = 'Out<\\#>: '
 ipshell2 = InteractiveShellEmbed(config=cfg,
                         banner1 = 'Second IPython instance.')
 
 print('\nHello. This is printed from the main controller program.\n')
 
 # You can then call ipshell() anywhere you need it (with an optional
 # message):
 ipshell('***Called from top level. '
         'Hit Ctrl-D to exit interpreter and continue program.\n'
         'Note that if you use %kill_embedded, you can fully deactivate\n'
         'This embedded instance so it will never turn on again')
 
 print('\nBack in caller program, moving along...\n')
 
 #---------------------------------------------------------------------------
 # More details:
 
 # InteractiveShellEmbed instances don't print the standard system banner and
 # messages. The IPython banner (which actually may contain initialization
 # messages) is available as get_ipython().banner in case you want it.
 
 # InteractiveShellEmbed instances print the following information everytime they
 # start:
 
 # - A global startup banner.
 
 # - A call-specific header string, which you can use to indicate where in the
 # execution flow the shell is starting.
 
 # They also print an exit message every time they exit.
 
 # Both the startup banner and the exit message default to None, and can be set
 # either at the instance constructor or at any other time with the
 # by setting the banner and exit_msg attributes.
 
 # The shell instance can be also put in 'dummy' mode globally or on a per-call
 # basis. This gives you fine control for debugging without having to change
 # code all over the place.
 
 # The code below illustrates all this.
 
 
 # This is how the global banner and exit_msg can be reset at any point
 ipshell.banner = 'Entering interpreter - New Banner'
 ipshell.exit_msg = 'Leaving interpreter - New exit_msg'
 
 def foo(m):
     s = 'spam'
     ipshell('***In foo(). Try %whos, or print s or m:')
     print('foo says m = ',m)
 
 def bar(n):
     s = 'eggs'
     ipshell('***In bar(). Try %whos, or print s or n:')
     print('bar says n = ',n)
     
 # Some calls to the above functions which will trigger IPython:
 print('Main program calling foo("eggs")\n')
 foo('eggs')
 
 # The shell can be put in 'dummy' mode where calls to it silently return. This
 # allows you, for example, to globally turn off debugging for a program with a
 # single call.
 ipshell.dummy_mode = True
 print('\nTrying to call IPython which is now "dummy":')
 ipshell()
 print('Nothing happened...')
 # The global 'dummy' mode can still be overridden for a single call
 print('\nOverriding dummy mode manually:')
 ipshell(dummy=False)
 
 # Reactivate the IPython shell
 ipshell.dummy_mode = False
 
 print('You can even have multiple embedded instances:')
 ipshell2()
 
 print('\nMain program calling bar("spam")\n')
 bar('spam')
 
 print('Main program finished. Bye!')
 
 #********************** End of file <example-embed.py> ***********************

examples/inprocess/embedded_qtconsole.py

@@ -1,45 +1,45 b''
 import os
 
-from IPython.frontend.qt.console.rich_ipython_widget import RichIPythonWidget
-from IPython.frontend.qt.inprocess import QtInProcessKernelManager
+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()
 
 
 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,30 b''
 import os
 
 from IPython.kernel.inprocess import InProcessKernelManager
-from IPython.frontend.terminal.console.interactiveshell import ZMQTerminalInteractiveShell
+from IPython.terminal.console.interactiveshell import ZMQTerminalInteractiveShell
 
 
 def print_process_id():
     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/tests/embed/embed3.py

@@ -1,7 +1,7 b''
 """This tests passing local_ns and global_ns (for backwards compatibility only)
 at activation of an embedded shell."""
-from IPython.frontend.terminal.embed import InteractiveShellEmbed
+from IPython.terminal.embed import InteractiveShellEmbed
 
 user_ns = dict(cookie='monster')
 ISE = InteractiveShellEmbed(banner1='check cookie in locals, and globals empty')
 ISE(local_ns=user_ns, global_ns={})