Fix all remaining imports that used `IPython.frontend`.

IPython/__main__.py

@@ -1,14 +1,14 b''
 # encoding: utf-8
 """Terminal-based IPython entry point.
 """
 #-----------------------------------------------------------------------------
 #  Copyright (c) 2012, IPython Development Team.
 #
 #  Distributed under the terms of the Modified BSD License.
 #
 #  The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
-from IPython.frontend.terminal.ipapp import launch_new_instance
+from IPython.terminal.ipapp import launch_new_instance
 
 launch_new_instance()

IPython/consoleapp.py

@@ -1,391 +1,391 b''
 """ A minimal application base mixin for all ZMQ based IPython frontends.
 
 This is not a complete console app, as subprocess will not be able to receive
 input, there is no real readline support, among other limitations. This is a
-refactoring of what used to be the IPython/frontend/qt/console/qtconsoleapp.py
+refactoring of what used to be the IPython/qt/console/qtconsoleapp.py
 
 Authors:
 
 * Evan Patterson
 * Min RK
 * Erik Tollerud
 * Fernando Perez
 * Bussonnier Matthias
 * Thomas Kluyver
 * Paul Ivanov
 
 """
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # stdlib imports
 import atexit
 import json
 import os
 import shutil
 import signal
 import sys
 import uuid
 
 
 # Local imports
 from IPython.config.application import boolean_flag
 from IPython.config.configurable import Configurable
 from IPython.core.profiledir import ProfileDir
 from IPython.kernel.blocking import BlockingKernelClient
 from IPython.kernel import KernelManager
 from IPython.kernel import tunnel_to_kernel, find_connection_file, swallow_argv
 from IPython.utils.path import filefind
 from IPython.utils.py3compat import str_to_bytes
 from IPython.utils.traitlets import (
     Dict, List, Unicode, CUnicode, Int, CBool, Any, CaselessStrEnum
 )
 from IPython.kernel.zmq.kernelapp import (
     kernel_flags,
     kernel_aliases,
     IPKernelApp
 )
 from IPython.kernel.zmq.session import Session, default_secure
 from IPython.kernel.zmq.zmqshell import ZMQInteractiveShell
 
 #-----------------------------------------------------------------------------
 # Network Constants
 #-----------------------------------------------------------------------------
 
 from IPython.utils.localinterfaces import LOCALHOST, LOCAL_IPS
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 
 
 #-----------------------------------------------------------------------------
 # Aliases and Flags
 #-----------------------------------------------------------------------------
 
 flags = dict(kernel_flags)
 
 # the flags that are specific to the frontend
 # these must be scrubbed before being passed to the kernel,
 # or it will raise an error on unrecognized flags
 app_flags = {
     'existing' : ({'IPythonConsoleApp' : {'existing' : 'kernel*.json'}},
             "Connect to an existing kernel. If no argument specified, guess most recent"),
 }
 app_flags.update(boolean_flag(
     'confirm-exit', 'IPythonConsoleApp.confirm_exit',
     """Set to display confirmation dialog on exit. You can always use 'exit' or 'quit',
        to force a direct exit without any confirmation.
     """,
     """Don't prompt the user when exiting. This will terminate the kernel
        if it is owned by the frontend, and leave it alive if it is external.
     """
 ))
 flags.update(app_flags)
 
 aliases = dict(kernel_aliases)
 
 # also scrub aliases from the frontend
 app_aliases = dict(
     ip = 'KernelManager.ip',
     transport = 'KernelManager.transport',
     hb = 'IPythonConsoleApp.hb_port',
     shell = 'IPythonConsoleApp.shell_port',
     iopub = 'IPythonConsoleApp.iopub_port',
     stdin = 'IPythonConsoleApp.stdin_port',
     existing = 'IPythonConsoleApp.existing',
     f = 'IPythonConsoleApp.connection_file',
 
 
     ssh = 'IPythonConsoleApp.sshserver',
 )
 aliases.update(app_aliases)
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # IPythonConsole
 #-----------------------------------------------------------------------------
 
 classes = [IPKernelApp, ZMQInteractiveShell, KernelManager, ProfileDir, Session]
 
 try:
     from IPython.kernel.zmq.pylab.backend_inline import InlineBackend
 except ImportError:
     pass
 else:
     classes.append(InlineBackend)
 
 class IPythonConsoleApp(Configurable):
     name = 'ipython-console-mixin'
     default_config_file_name='ipython_config.py'
 
     description = """
         The IPython Mixin Console.
         
         This class contains the common portions of console client (QtConsole,
         ZMQ-based terminal console, etc).  It is not a full console, in that
         launched terminal subprocesses will not be able to accept input.
         
         The Console using this mixing supports various extra features beyond
         the single-process Terminal IPython shell, such as connecting to
         existing kernel, via:
         
             ipython <appname> --existing
         
         as well as tunnel via SSH
         
     """
 
     classes = classes
     flags = Dict(flags)
     aliases = Dict(aliases)
     kernel_manager_class = KernelManager
     kernel_client_class = BlockingKernelClient
 
     kernel_argv = List(Unicode)
     # frontend flags&aliases to be stripped when building kernel_argv
     frontend_flags = Any(app_flags)
     frontend_aliases = Any(app_aliases)
 
     # create requested profiles by default, if they don't exist:
     auto_create = CBool(True)
     # connection info:
     
     sshserver = Unicode('', config=True,
         help="""The SSH server to use to connect to the kernel.""")
     sshkey = Unicode('', config=True,
         help="""Path to the ssh key to use for logging in to the ssh server.""")
     
     hb_port = Int(0, config=True,
         help="set the heartbeat port [default: random]")
     shell_port = Int(0, config=True,
         help="set the shell (ROUTER) port [default: random]")
     iopub_port = Int(0, config=True,
         help="set the iopub (PUB) port [default: random]")
     stdin_port = Int(0, config=True,
         help="set the stdin (DEALER) port [default: random]")
     connection_file = Unicode('', config=True,
         help="""JSON file in which to store connection info [default: kernel-<pid>.json]
 
         This file will contain the IP, ports, and authentication key needed to connect
         clients to this kernel. By default, this file will be created in the security-dir
         of the current profile, but can be specified by absolute path.
         """)
     def _connection_file_default(self):
         return 'kernel-%i.json' % os.getpid()
 
     existing = CUnicode('', config=True,
         help="""Connect to an already running kernel""")
 
     confirm_exit = CBool(True, config=True,
         help="""
         Set to display confirmation dialog on exit. You can always use 'exit' or 'quit',
         to force a direct exit without any confirmation.""",
     )
 
 
     def build_kernel_argv(self, argv=None):
         """build argv to be passed to kernel subprocess"""
         if argv is None:
             argv = sys.argv[1:]
         self.kernel_argv = swallow_argv(argv, self.frontend_aliases, self.frontend_flags)
         # kernel should inherit default config file from frontend
         self.kernel_argv.append("--IPKernelApp.parent_appname='%s'" % self.name)
     
     def init_connection_file(self):
         """find the connection file, and load the info if found.
         
         The current working directory and the current profile's security
         directory will be searched for the file if it is not given by
         absolute path.
         
         When attempting to connect to an existing kernel and the `--existing`
         argument does not match an existing file, it will be interpreted as a
         fileglob, and the matching file in the current profile's security dir
         with the latest access time will be used.
         
         After this method is called, self.connection_file contains the *full path*
         to the connection file, never just its name.
         """
         if self.existing:
             try:
                 cf = find_connection_file(self.existing)
             except Exception:
                 self.log.critical("Could not find existing kernel connection file %s", self.existing)
                 self.exit(1)
             self.log.info("Connecting to existing kernel: %s" % cf)
             self.connection_file = cf
         else:
             # not existing, check if we are going to write the file
             # and ensure that self.connection_file is a full path, not just the shortname
             try:
                 cf = find_connection_file(self.connection_file)
             except Exception:
                 # file might not exist
                 if self.connection_file == os.path.basename(self.connection_file):
                     # just shortname, put it in security dir
                     cf = os.path.join(self.profile_dir.security_dir, self.connection_file)
                 else:
                     cf = self.connection_file
                 self.connection_file = cf
         
         # should load_connection_file only be used for existing?
         # as it is now, this allows reusing ports if an existing
         # file is requested
         try:
             self.load_connection_file()
         except Exception:
             self.log.error("Failed to load connection file: %r", self.connection_file, exc_info=True)
             self.exit(1)
     
     def load_connection_file(self):
         """load ip/port/hmac config from JSON connection file"""
         # this is identical to IPKernelApp.load_connection_file
         # perhaps it can be centralized somewhere?
         try:
             fname = filefind(self.connection_file, ['.', self.profile_dir.security_dir])
         except IOError:
             self.log.debug("Connection File not found: %s", self.connection_file)
             return
         self.log.debug(u"Loading connection file %s", fname)
         with open(fname) as f:
             cfg = json.load(f)
         
         self.config.KernelManager.transport = cfg.get('transport', 'tcp')
         self.config.KernelManager.ip = cfg.get('ip', LOCALHOST)
         
         for channel in ('hb', 'shell', 'iopub', 'stdin'):
             name = channel + '_port'
             if getattr(self, name) == 0 and name in cfg:
                 # not overridden by config or cl_args
                 setattr(self, name, cfg[name])
         if 'key' in cfg:
             self.config.Session.key = str_to_bytes(cfg['key'])
     
     def init_ssh(self):
         """set up ssh tunnels, if needed."""
         if not self.existing or (not self.sshserver and not self.sshkey):
             return
         
         self.load_connection_file()
         
         transport = self.config.KernelManager.transport
         ip = self.config.KernelManager.ip
         
         if transport != 'tcp':
             self.log.error("Can only use ssh tunnels with TCP sockets, not %s", transport)
             sys.exit(-1)
         
         if self.sshkey and not self.sshserver:
             # specifying just the key implies that we are connecting directly
             self.sshserver = ip
             ip = LOCALHOST
         
         # build connection dict for tunnels:
         info = dict(ip=ip,
                     shell_port=self.shell_port,
                     iopub_port=self.iopub_port,
                     stdin_port=self.stdin_port,
                     hb_port=self.hb_port
         )
         
         self.log.info("Forwarding connections to %s via %s"%(ip, self.sshserver))
         
         # tunnels return a new set of ports, which will be on localhost:
         self.config.KernelManager.ip = LOCALHOST
         try:
             newports = tunnel_to_kernel(info, self.sshserver, self.sshkey)
         except:
             # even catch KeyboardInterrupt
             self.log.error("Could not setup tunnels", exc_info=True)
             self.exit(1)
         
         self.shell_port, self.iopub_port, self.stdin_port, self.hb_port = newports
         
         cf = self.connection_file
         base,ext = os.path.splitext(cf)
         base = os.path.basename(base)
         self.connection_file = os.path.basename(base)+'-ssh'+ext
         self.log.critical("To connect another client via this tunnel, use:")
         self.log.critical("--existing %s" % self.connection_file)
     
     def _new_connection_file(self):
         cf = ''
         while not cf:
             # we don't need a 128b id to distinguish kernels, use more readable
             # 48b node segment (12 hex chars).  Users running more than 32k simultaneous
             # kernels can subclass.
             ident = str(uuid.uuid4()).split('-')[-1]
             cf = os.path.join(self.profile_dir.security_dir, 'kernel-%s.json' % ident)
             # only keep if it's actually new.  Protect against unlikely collision
             # in 48b random search space
             cf = cf if not os.path.exists(cf) else ''
         return cf
 
     def init_kernel_manager(self):
         # Don't let Qt or ZMQ swallow KeyboardInterupts.
         if self.existing:
             self.kernel_manager = None
             return
         signal.signal(signal.SIGINT, signal.SIG_DFL)
 
         # Create a KernelManager and start a kernel.
         self.kernel_manager = self.kernel_manager_class(
                                 shell_port=self.shell_port,
                                 iopub_port=self.iopub_port,
                                 stdin_port=self.stdin_port,
                                 hb_port=self.hb_port,
                                 connection_file=self.connection_file,
                                 config=self.config,
         )
         self.kernel_manager.client_factory = self.kernel_client_class
         self.kernel_manager.start_kernel(extra_arguments=self.kernel_argv)
         atexit.register(self.kernel_manager.cleanup_ipc_files)
 
         if self.sshserver:
             # ssh, write new connection file
             self.kernel_manager.write_connection_file()
 
         # in case KM defaults / ssh writing changes things:
         km = self.kernel_manager
         self.shell_port=km.shell_port
         self.iopub_port=km.iopub_port
         self.stdin_port=km.stdin_port
         self.hb_port=km.hb_port
         self.connection_file = km.connection_file
 
         atexit.register(self.kernel_manager.cleanup_connection_file)
 
     def init_kernel_client(self):
         if self.kernel_manager is not None:
             self.kernel_client = self.kernel_manager.client()
         else:
             self.kernel_client = self.kernel_client_class(
                                 shell_port=self.shell_port,
                                 iopub_port=self.iopub_port,
                                 stdin_port=self.stdin_port,
                                 hb_port=self.hb_port,
                                 connection_file=self.connection_file,
                                 config=self.config,
             )
 
         self.kernel_client.start_channels()
 
 
 
     def initialize(self, argv=None):
         """
         Classes which mix this class in should call:
                IPythonConsoleApp.initialize(self,argv)
         """
         self.init_connection_file()
         default_secure(self.config)
         self.init_ssh()
         self.init_kernel_manager()
         self.init_kernel_client()
 

IPython/core/profileapp.py

@@ -1,306 +1,306 b''
 # encoding: utf-8
 """
 An application for managing IPython profiles.
 
 To be invoked as the `ipython profile` subcommand.
 
 Authors:
 
 * Min RK
 
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import os
 
 from IPython.config.application import Application
 from IPython.core.application import (
     BaseIPythonApplication, base_flags
 )
 from IPython.core.profiledir import ProfileDir
 from IPython.utils.path import get_ipython_dir, get_ipython_package_dir
 from IPython.utils.traitlets import Unicode, Bool, Dict
 
 #-----------------------------------------------------------------------------
 # Constants
 #-----------------------------------------------------------------------------
 
 create_help = """Create an IPython profile by name
 
 Create an ipython profile directory by its name or
 profile directory path. Profile directories contain
 configuration, log and security related files and are named
 using the convention 'profile_<name>'. By default they are
 located in your ipython directory. Once created, you will
 can edit the configuration files in the profile
 directory to configure IPython. Most users will create a
 profile directory by name,
 `ipython profile create myprofile`, which will put the directory
 in `<ipython_dir>/profile_myprofile`.
 """
 list_help = """List available IPython profiles
 
 List all available profiles, by profile location, that can
 be found in the current working directly or in the ipython
 directory. Profile directories are named using the convention
 'profile_<profile>'.
 """
 profile_help = """Manage IPython profiles
 
 Profile directories contain
 configuration, log and security related files and are named
 using the convention 'profile_<name>'. By default they are
 located in your ipython directory.  You can create profiles
 with `ipython profile create <name>`, or see the profiles you
 already have with `ipython profile list`
 
 To get started configuring IPython, simply do:
 
 $> ipython profile create
 
 and IPython will create the default profile in <ipython_dir>/profile_default,
 where you can edit ipython_config.py to start configuring IPython.
 
 """
 
 _list_examples = "ipython profile list  # list all profiles"
 
 _create_examples = """
 ipython profile create foo         # create profile foo w/ default config files
 ipython profile create foo --reset # restage default config files over current
 ipython profile create foo --parallel # also stage parallel config files
 """
 
 _main_examples = """
 ipython profile create -h  # show the help string for the create subcommand
 ipython profile list -h    # show the help string for the list subcommand
 
 ipython locate profile foo # print the path to the directory for profile 'foo'
 """
 
 #-----------------------------------------------------------------------------
 # Profile Application Class (for `ipython profile` subcommand)
 #-----------------------------------------------------------------------------
 
 
 def list_profiles_in(path):
     """list profiles in a given root directory"""
     files = os.listdir(path)
     profiles = []
     for f in files:
         full_path = os.path.join(path, f)
         if os.path.isdir(full_path) and f.startswith('profile_'):
             profiles.append(f.split('_',1)[-1])
     return profiles
 
 
 def list_bundled_profiles():
     """list profiles that are bundled with IPython."""
     path = os.path.join(get_ipython_package_dir(), u'config', u'profile')
     files = os.listdir(path)
     profiles = []
     for profile in files:
         full_path = os.path.join(path, profile)
         if os.path.isdir(full_path) and profile != "__pycache__":
             profiles.append(profile)
     return profiles
 
 
 class ProfileLocate(BaseIPythonApplication):
     description = """print the path an IPython profile dir"""
     
     def parse_command_line(self, argv=None):
         super(ProfileLocate, self).parse_command_line(argv)
         if self.extra_args:
             self.profile = self.extra_args[0]
     
     def start(self):
         print self.profile_dir.location
 
 
 class ProfileList(Application):
     name = u'ipython-profile'
     description = list_help
     examples = _list_examples
 
     aliases = Dict({
         'ipython-dir' : 'ProfileList.ipython_dir',
         'log-level' : 'Application.log_level',
     })
     flags = Dict(dict(
         debug = ({'Application' : {'log_level' : 0}},
             "Set Application.log_level to 0, maximizing log output."
         )
     ))
 
     ipython_dir = Unicode(get_ipython_dir(), config=True,
         help="""
         The name of the IPython directory. This directory is used for logging
         configuration (through profiles), history storage, etc. The default
         is usually $HOME/.ipython. This options can also be specified through
         the environment variable IPYTHONDIR.
         """
     )
 
 
     def _print_profiles(self, profiles):
         """print list of profiles, indented."""
         for profile in profiles:
             print '    %s' % profile
 
     def list_profile_dirs(self):
         profiles = list_bundled_profiles()
         if profiles:
             print
             print "Available profiles in IPython:"
             self._print_profiles(profiles)
             print
             print "    The first request for a bundled profile will copy it"
             print "    into your IPython directory (%s)," % self.ipython_dir
             print "    where you can customize it."
         
         profiles = list_profiles_in(self.ipython_dir)
         if profiles:
             print
             print "Available profiles in %s:" % self.ipython_dir
             self._print_profiles(profiles)
         
         profiles = list_profiles_in(os.getcwdu())
         if profiles:
             print
             print "Available profiles in current directory (%s):" % os.getcwdu()
             self._print_profiles(profiles)
         
         print
         print "To use any of the above profiles, start IPython with:"
         print "    ipython --profile=<name>"
         print
 
     def start(self):
         self.list_profile_dirs()
 
 
 create_flags = {}
 create_flags.update(base_flags)
 # don't include '--init' flag, which implies running profile create in other apps
 create_flags.pop('init')
 create_flags['reset'] = ({'ProfileCreate': {'overwrite' : True}},
                         "reset config files in this profile to the defaults.")
 create_flags['parallel'] = ({'ProfileCreate': {'parallel' : True}},
                         "Include the config files for parallel "
                         "computing apps (ipengine, ipcontroller, etc.)")
 
 
 class ProfileCreate(BaseIPythonApplication):
     name = u'ipython-profile'
     description = create_help
     examples = _create_examples
     auto_create = Bool(True, config=False)
 
     def _copy_config_files_default(self):
         return True
 
     parallel = Bool(False, config=True,
         help="whether to include parallel computing config files")
     def _parallel_changed(self, name, old, new):
         parallel_files = [   'ipcontroller_config.py',
                             'ipengine_config.py',
                             'ipcluster_config.py'
                         ]
         if new:
             for cf in parallel_files:
                 self.config_files.append(cf)
         else:
             for cf in parallel_files:
                 if cf in self.config_files:
                     self.config_files.remove(cf)
 
     def parse_command_line(self, argv):
         super(ProfileCreate, self).parse_command_line(argv)
         # accept positional arg as profile name
         if self.extra_args:
             self.profile = self.extra_args[0]
 
     flags = Dict(create_flags)
 
     classes = [ProfileDir]
 
     def init_config_files(self):
         super(ProfileCreate, self).init_config_files()
         # use local imports, since these classes may import from here
-        from IPython.frontend.terminal.ipapp import TerminalIPythonApp
+        from IPython.terminal.ipapp import TerminalIPythonApp
         apps = [TerminalIPythonApp]
         try:
-            from IPython.frontend.qt.console.qtconsoleapp import IPythonQtConsoleApp
+            from IPython.qt.console.qtconsoleapp import IPythonQtConsoleApp
         except Exception:
             # this should be ImportError, but under weird circumstances
             # this might be an AttributeError, or possibly others
             # in any case, nothing should cause the profile creation to crash.
             pass
         else:
             apps.append(IPythonQtConsoleApp)
         try:
-            from IPython.frontend.html.notebook.notebookapp import NotebookApp
+            from IPython.html.notebook.notebookapp import NotebookApp
         except ImportError:
             pass
         except Exception:
             self.log.debug('Unexpected error when importing NotebookApp',
                            exc_info=True
             )
         else:
             apps.append(NotebookApp)
         if self.parallel:
             from IPython.parallel.apps.ipcontrollerapp import IPControllerApp
             from IPython.parallel.apps.ipengineapp import IPEngineApp
             from IPython.parallel.apps.ipclusterapp import IPClusterStart
             from IPython.parallel.apps.iploggerapp import IPLoggerApp
             apps.extend([
                 IPControllerApp,
                 IPEngineApp,
                 IPClusterStart,
                 IPLoggerApp,
             ])
         for App in apps:
             app = App()
             app.config.update(self.config)
             app.log = self.log
             app.overwrite = self.overwrite
             app.copy_config_files=True
             app.profile = self.profile
             app.init_profile_dir()
             app.init_config_files()
 
     def stage_default_config_file(self):
         pass
 
 
 class ProfileApp(Application):
     name = u'ipython-profile'
     description = profile_help
     examples = _main_examples
 
     subcommands = Dict(dict(
         create = (ProfileCreate, ProfileCreate.description.splitlines()[0]),
         list = (ProfileList, ProfileList.description.splitlines()[0]),
     ))
 
     def start(self):
         if self.subapp is None:
             print "No subcommand specified. Must specify one of: %s"%(self.subcommands.keys())
             print
             self.print_description()
             self.print_subcommands()
             self.exit(1)
         else:
             return self.subapp.start()
 

IPython/frontend.py

@@ -1,73 +1,73 b''
 """
 Shim to maintain backwards compatibility with old frontend imports.
 
 We have moved all contents of the old `frontend` subpackage into top-level
-subpackages (`html`, `qt` and `terminal`).  This will let code that was making
-`from IPython.frontend...` calls continue working, though a warning will be
-printed.
+subpackages (`html`, `qt` and `terminal`).  
+
+This will let code that was making `from IPython.frontend...` calls continue
+working, though a warning will be printed.
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (c) 2013, IPython Development Team.
 #
 #  Distributed under the terms of the Modified BSD License.
 #
 #  The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 from __future__ import print_function
 
 # Stdlib
 import sys
 import types
 from warnings import warn
 
 warn("The top-level `frontend` package has been deprecated. "
      "All its subpackages have been moved to the top `IPython` level.")
 
-1/0
 #-----------------------------------------------------------------------------
 # Class declarations
 #-----------------------------------------------------------------------------
 
 class ShimModule(types.ModuleType):
 
     def __getattribute__(self, key):
         # Use the equivalent of import_item(name), see below
         name = 'IPython.' + key
 
         # NOTE: the code below is copied *verbatim* from
         # importstring.import_item. For some very strange reason that makes no
         # sense to me, if we call it *as a function*, it doesn't work.  This
         # has something to do with the deep bowels of the import machinery and
         # I couldn't find a way to make the code work as a standard function
         # call.  But at least since it's an unmodified copy of import_item,
         # which is used extensively and has a test suite, we can be reasonably
         # confident this is OK.  If anyone finds how to call the function, all
         # the below could be replaced simply with:
         #
         # from IPython.utils.importstring import import_item
         # return import_item('IPython.' + key)
         
         parts = name.rsplit('.', 1)
         if len(parts) == 2:
             # called with 'foo.bar....'
             package, obj = parts
             module = __import__(package, fromlist=[obj])
             try:
                 pak = module.__dict__[obj]
             except KeyError:
                 raise ImportError('No module named %s' % obj)
             return pak
         else:
             # called with un-dotted string
             return __import__(parts[0])
 
 
 # Unconditionally insert the shim into sys.modules so that further import calls
 # trigger the custom attribute access above
 
 sys.modules['IPython.frontend'] = ShimModule('frontend')

IPython/html/notebook/README.md

@@ -1,73 +1,73 b''
 # IPython Notebook development
 
 ## Development dependencies
 
 Developers of the IPython Notebook will need to install the following tools:
 
 * fabric
 * node.js
 * less (`npm install -g less`)
 * bower (`npm install -g bower`)
 
 ## Components
 
 We are moving to a model where our JavaScript dependencies are managed using 
 [bower](http://bower.io/). These packages are installed in `static/components`
 and commited into our git repo. Our dependencies are described in the file
 `static/bower.json`. To update our bower packages, run `fab components` in this
 directory.
 
 Because CodeMirror does not use proper semantic versioning for its GitHub tags,
 we maintain our own fork of CodeMirror that is used with bower. This fork should
 track the upstream CodeMirror exactly; the only difference is that we are adding
 semantic versioned tags to our repo.
 
 ## less
 
 If you edit our `.less` files you will need to run the less compiler to build
 our minified css files.  This can be done by running `fab css` from this directory.
 
 ## JavaScript Documentation
 
 
 How to  Build/ view the doc  for JavaScript. JavaScript documentation  should follow a
 style close  to JSDoc  one, so you  should be  able to build  them with  your favorite
 documentation builder. Still  the documentation comment are mainly written  to be read
 with YUI  doc. You can either  build a static version,  or start a YUIdoc  server that
 will live update the doc at every page request.
 
 
 
 To do so, you will need to install YUIdoc.
 
 ### Install NodeJS
 
 Node is a browser less javascript interpreter. To install it please refer to
 the documentation for your platform. Install also NPM (node package manager) if
 it does not come bundled with it.  
 
 ### Get YUIdoc
 
 npm does by default install package in `./node_modules` instead of doing a
 system wide install. I'll leave you to yuidoc docs if you want to make a system
 wide install.
 
 First, cd into js directory :
 ```bash
-cd IPython/frontend/html/notebook/static/js/
+cd IPython/html/notebook/static/js/
 # install yuidoc
 npm install yuidocjs
 ```
 
 
 ### Run YUIdoc server
 
-From IPython/frontend/html/notebook/static/js/
+From IPython/html/notebook/static/js/
 ```bash
 # run yuidoc for install dir 
 ./node_modules/yuidocjs/lib/cli.js --server .
 ```
 
 Follow the instruction and the documentation should be available on localhost:3000
 
 Omitting `--server` will build a static version in the `out` folder by default.

IPython/kernel/connect.py

@@ -1,540 +1,540 b''
 """Utilities for connecting to kernels
 
 Authors:
 
 * Min Ragan-Kelley
 
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2013  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from __future__ import absolute_import
 
 import glob
 import json
 import os
 import socket
 import sys
 from getpass import getpass
 from subprocess import Popen, PIPE
 import tempfile
 
 import zmq
 
 # external imports
 from IPython.external.ssh import tunnel
 
 # IPython imports
 # from IPython.config import Configurable
 from IPython.core.profiledir import ProfileDir
 from IPython.utils.localinterfaces import LOCALHOST
 from IPython.utils.path import filefind, get_ipython_dir
 from IPython.utils.py3compat import str_to_bytes, bytes_to_str
 from IPython.utils.traitlets import (
     Bool, Integer, Unicode, CaselessStrEnum,
     HasTraits,
 )
 
 
 #-----------------------------------------------------------------------------
 # Working with Connection Files
 #-----------------------------------------------------------------------------
 
 def write_connection_file(fname=None, shell_port=0, iopub_port=0, stdin_port=0, hb_port=0,
                          control_port=0, ip=LOCALHOST, key=b'', transport='tcp'):
     """Generates a JSON config file, including the selection of random ports.
     
     Parameters
     ----------
 
     fname : unicode
         The path to the file to write
 
     shell_port : int, optional
         The port to use for ROUTER (shell) channel.
 
     iopub_port : int, optional
         The port to use for the SUB channel.
 
     stdin_port : int, optional
         The port to use for the ROUTER (raw input) channel.
 
     control_port : int, optional
         The port to use for the ROUTER (control) channel.
 
     hb_port : int, optional
         The port to use for the heartbeat REP channel.
 
     ip  : str, optional
         The ip address the kernel will bind to.
 
     key : str, optional
         The Session key used for HMAC authentication.
 
     """
     # default to temporary connector file
     if not fname:
         fname = tempfile.mktemp('.json')
     
     # Find open ports as necessary.
     
     ports = []
     ports_needed = int(shell_port <= 0) + \
                    int(iopub_port <= 0) + \
                    int(stdin_port <= 0) + \
                    int(control_port <= 0) + \
                    int(hb_port <= 0)
     if transport == 'tcp':
         for i in range(ports_needed):
             sock = socket.socket()
             sock.bind(('', 0))
             ports.append(sock)
         for i, sock in enumerate(ports):
             port = sock.getsockname()[1]
             sock.close()
             ports[i] = port
     else:
         N = 1
         for i in range(ports_needed):
             while os.path.exists("%s-%s" % (ip, str(N))):
                 N += 1
             ports.append(N)
             N += 1
     if shell_port <= 0:
         shell_port = ports.pop(0)
     if iopub_port <= 0:
         iopub_port = ports.pop(0)
     if stdin_port <= 0:
         stdin_port = ports.pop(0)
     if control_port <= 0:
         control_port = ports.pop(0)
     if hb_port <= 0:
         hb_port = ports.pop(0)
     
     cfg = dict( shell_port=shell_port,
                 iopub_port=iopub_port,
                 stdin_port=stdin_port,
                 control_port=control_port,
                 hb_port=hb_port,
               )
     cfg['ip'] = ip
     cfg['key'] = bytes_to_str(key)
     cfg['transport'] = transport
     
     with open(fname, 'w') as f:
         f.write(json.dumps(cfg, indent=2))
     
     return fname, cfg
 
 
 def get_connection_file(app=None):
     """Return the path to the connection file of an app
     
     Parameters
     ----------
     app : IPKernelApp instance [optional]
         If unspecified, the currently running app will be used
     """
     if app is None:
         from IPython.kernel.zmq.kernelapp import IPKernelApp
         if not IPKernelApp.initialized():
             raise RuntimeError("app not specified, and not in a running Kernel")
 
         app = IPKernelApp.instance()
     return filefind(app.connection_file, ['.', app.profile_dir.security_dir])
 
 
 def find_connection_file(filename, profile=None):
     """find a connection file, and return its absolute path.
     
     The current working directory and the profile's security
     directory will be searched for the file if it is not given by
     absolute path.
     
     If profile is unspecified, then the current running application's
     profile will be used, or 'default', if not run from IPython.
     
     If the argument does not match an existing file, it will be interpreted as a
     fileglob, and the matching file in the profile's security dir with
     the latest access time will be used.
     
     Parameters
     ----------
     filename : str
         The connection file or fileglob to search for.
     profile : str [optional]
         The name of the profile to use when searching for the connection file,
         if different from the current IPython session or 'default'.
     
     Returns
     -------
     str : The absolute path of the connection file.
     """
     from IPython.core.application import BaseIPythonApplication as IPApp
     try:
         # quick check for absolute path, before going through logic
         return filefind(filename)
     except IOError:
         pass
     
     if profile is None:
         # profile unspecified, check if running from an IPython app
         if IPApp.initialized():
             app = IPApp.instance()
             profile_dir = app.profile_dir
         else:
             # not running in IPython, use default profile
             profile_dir = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), 'default')
     else:
         # find profiledir by profile name:
         profile_dir = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), profile)
     security_dir = profile_dir.security_dir
     
     try:
         # first, try explicit name
         return filefind(filename, ['.', security_dir])
     except IOError:
         pass
     
     # not found by full name
     
     if '*' in filename:
         # given as a glob already
         pat = filename
     else:
         # accept any substring match
         pat = '*%s*' % filename
     matches = glob.glob( os.path.join(security_dir, pat) )
     if not matches:
         raise IOError("Could not find %r in %r" % (filename, security_dir))
     elif len(matches) == 1:
         return matches[0]
     else:
         # get most recent match, by access time:
         return sorted(matches, key=lambda f: os.stat(f).st_atime)[-1]
 
 
 def get_connection_info(connection_file=None, unpack=False, profile=None):
     """Return the connection information for the current Kernel.
     
     Parameters
     ----------
     connection_file : str [optional]
         The connection file to be used. Can be given by absolute path, or
         IPython will search in the security directory of a given profile.
         If run from IPython, 
         
         If unspecified, the connection file for the currently running
         IPython Kernel will be used, which is only allowed from inside a kernel.
     unpack : bool [default: False]
         if True, return the unpacked dict, otherwise just the string contents
         of the file.
     profile : str [optional]
         The name of the profile to use when searching for the connection file,
         if different from the current IPython session or 'default'.
         
     
     Returns
     -------
     The connection dictionary of the current kernel, as string or dict,
     depending on `unpack`.
     """
     if connection_file is None:
         # get connection file from current kernel
         cf = get_connection_file()
     else:
         # connection file specified, allow shortnames:
         cf = find_connection_file(connection_file, profile=profile)
     
     with open(cf) as f:
         info = f.read()
     
     if unpack:
         info = json.loads(info)
         # ensure key is bytes:
         info['key'] = str_to_bytes(info.get('key', ''))
     return info
 
 
 def connect_qtconsole(connection_file=None, argv=None, profile=None):
     """Connect a qtconsole to the current kernel.
     
     This is useful for connecting a second qtconsole to a kernel, or to a
     local notebook.
     
     Parameters
     ----------
     connection_file : str [optional]
         The connection file to be used. Can be given by absolute path, or
         IPython will search in the security directory of a given profile.
         If run from IPython, 
         
         If unspecified, the connection file for the currently running
         IPython Kernel will be used, which is only allowed from inside a kernel.
     argv : list [optional]
         Any extra args to be passed to the console.
     profile : str [optional]
         The name of the profile to use when searching for the connection file,
         if different from the current IPython session or 'default'.
     
     
     Returns
     -------
     subprocess.Popen instance running the qtconsole frontend
     """
     argv = [] if argv is None else argv
     
     if connection_file is None:
         # get connection file from current kernel
         cf = get_connection_file()
     else:
         cf = find_connection_file(connection_file, profile=profile)
     
     cmd = ';'.join([
-        "from IPython.frontend.qt.console import qtconsoleapp",
+        "from IPython.qt.console import qtconsoleapp",
         "qtconsoleapp.main()"
     ])
     
     return Popen([sys.executable, '-c', cmd, '--existing', cf] + argv,
         stdout=PIPE, stderr=PIPE, close_fds=True,
     )
 
 
 def tunnel_to_kernel(connection_info, sshserver, sshkey=None):
     """tunnel connections to a kernel via ssh
     
     This will open four SSH tunnels from localhost on this machine to the
     ports associated with the kernel.  They can be either direct
     localhost-localhost tunnels, or if an intermediate server is necessary,
     the kernel must be listening on a public IP.
     
     Parameters
     ----------
     connection_info : dict or str (path)
         Either a connection dict, or the path to a JSON connection file
     sshserver : str
         The ssh sever to use to tunnel to the kernel. Can be a full
         `user@server:port` string. ssh config aliases are respected.
     sshkey : str [optional]
         Path to file containing ssh key to use for authentication.
         Only necessary if your ssh config does not already associate
         a keyfile with the host.
     
     Returns
     -------
     
     (shell, iopub, stdin, hb) : ints
         The four ports on localhost that have been forwarded to the kernel.
     """
     if isinstance(connection_info, basestring):
         # it's a path, unpack it
         with open(connection_info) as f:
             connection_info = json.loads(f.read())
     
     cf = connection_info
     
     lports = tunnel.select_random_ports(4)
     rports = cf['shell_port'], cf['iopub_port'], cf['stdin_port'], cf['hb_port']
     
     remote_ip = cf['ip']
     
     if tunnel.try_passwordless_ssh(sshserver, sshkey):
         password=False
     else:
         password = getpass("SSH Password for %s: "%sshserver)
     
     for lp,rp in zip(lports, rports):
         tunnel.ssh_tunnel(lp, rp, sshserver, remote_ip, sshkey, password)
     
     return tuple(lports)
 
 
 #-----------------------------------------------------------------------------
 # Mixin for classes that work with connection files
 #-----------------------------------------------------------------------------
 
 channel_socket_types = {
     'hb' : zmq.REQ,
     'shell' : zmq.DEALER,
     'iopub' : zmq.SUB,
     'stdin' : zmq.DEALER,
     'control': zmq.DEALER,
 }
 
 port_names = [ "%s_port" % channel for channel in ('shell', 'stdin', 'iopub', 'hb', 'control')]
 
 class ConnectionFileMixin(HasTraits):
     """Mixin for configurable classes that work with connection files"""
 
     # The addresses for the communication channels
     connection_file = Unicode('')
     _connection_file_written = Bool(False)
 
     transport = CaselessStrEnum(['tcp', 'ipc'], default_value='tcp', config=True)
 
     ip = Unicode(LOCALHOST, config=True,
         help="""Set the kernel\'s IP address [default localhost].
         If the IP address is something other than localhost, then
         Consoles on other machines will be able to connect
         to the Kernel, so be careful!"""
     )
 
     def _ip_default(self):
         if self.transport == 'ipc':
             if self.connection_file:
                 return os.path.splitext(self.connection_file)[0] + '-ipc'
             else:
                 return 'kernel-ipc'
         else:
             return LOCALHOST
 
     def _ip_changed(self, name, old, new):
         if new == '*':
             self.ip = '0.0.0.0'
 
     # protected traits
 
     shell_port = Integer(0)
     iopub_port = Integer(0)
     stdin_port = Integer(0)
     control_port = Integer(0)
     hb_port = Integer(0)
 
     @property
     def ports(self):
         return [ getattr(self, name) for name in port_names ]
 
     #--------------------------------------------------------------------------
     # Connection and ipc file management
     #--------------------------------------------------------------------------
 
     def get_connection_info(self):
         """return the connection info as a dict"""
         return dict(
             transport=self.transport,
             ip=self.ip,
             shell_port=self.shell_port,
             iopub_port=self.iopub_port,
             stdin_port=self.stdin_port,
             hb_port=self.hb_port,
             control_port=self.control_port,
         )
 
     def cleanup_connection_file(self):
         """Cleanup connection file *if we wrote it*
 
         Will not raise if the connection file was already removed somehow.
         """
         if self._connection_file_written:
             # cleanup connection files on full shutdown of kernel we started
             self._connection_file_written = False
             try:
                 os.remove(self.connection_file)
             except (IOError, OSError, AttributeError):
                 pass
 
     def cleanup_ipc_files(self):
         """Cleanup ipc files if we wrote them."""
         if self.transport != 'ipc':
             return
         for port in self.ports:
             ipcfile = "%s-%i" % (self.ip, port)
             try:
                 os.remove(ipcfile)
             except (IOError, OSError):
                 pass
 
     def write_connection_file(self):
         """Write connection info to JSON dict in self.connection_file."""
         if self._connection_file_written:
             return
 
         self.connection_file, cfg = write_connection_file(self.connection_file,
             transport=self.transport, ip=self.ip, key=self.session.key,
             stdin_port=self.stdin_port, iopub_port=self.iopub_port,
             shell_port=self.shell_port, hb_port=self.hb_port,
             control_port=self.control_port,
         )
         # write_connection_file also sets default ports:
         for name in port_names:
             setattr(self, name, cfg[name])
 
         self._connection_file_written = True
 
     def load_connection_file(self):
         """Load connection info from JSON dict in self.connection_file."""
         with open(self.connection_file) as f:
             cfg = json.loads(f.read())
 
         self.transport = cfg.get('transport', 'tcp')
         self.ip = cfg['ip']
         for name in port_names:
             setattr(self, name, cfg[name])
         self.session.key = str_to_bytes(cfg['key'])
 
     #--------------------------------------------------------------------------
     # Creating connected sockets
     #--------------------------------------------------------------------------
 
     def _make_url(self, channel):
         """Make a ZeroMQ URL for a given channel."""
         transport = self.transport
         ip = self.ip
         port = getattr(self, '%s_port' % channel)
 
         if transport == 'tcp':
             return "tcp://%s:%i" % (ip, port)
         else:
             return "%s://%s-%s" % (transport, ip, port)
 
     def _create_connected_socket(self, channel, identity=None):
         """Create a zmq Socket and connect it to the kernel."""
         url = self._make_url(channel)
         socket_type = channel_socket_types[channel]
         self.log.info("Connecting to: %s" % url)
         sock = self.context.socket(socket_type)
         if identity:
             sock.identity = identity
         sock.connect(url)
         return sock
 
     def connect_iopub(self, identity=None):
         """return zmq Socket connected to the IOPub channel"""
         sock = self._create_connected_socket('iopub', identity=identity)
         sock.setsockopt(zmq.SUBSCRIBE, b'')
         return sock
 
     def connect_shell(self, identity=None):
         """return zmq Socket connected to the Shell channel"""
         return self._create_connected_socket('shell', identity=identity)
 
     def connect_stdin(self, identity=None):
         """return zmq Socket connected to the StdIn channel"""
         return self._create_connected_socket('stdin', identity=identity)
 
     def connect_hb(self, identity=None):
         """return zmq Socket connected to the Heartbeat channel"""
         return self._create_connected_socket('hb', identity=identity)
 
     def connect_control(self, identity=None):
         """return zmq Socket connected to the Heartbeat channel"""
         return self._create_connected_socket('control', identity=identity)
 
 
 __all__ = [
     'write_connection_file',
     'get_connection_file',
     'find_connection_file',
     'get_connection_info',
     'connect_qtconsole',
     'tunnel_to_kernel',
 ]

IPython/qt/console/tests/test_ansi_code_processor.py

@@ -1,171 +1,171 b''
 # Standard library imports
 import unittest
 
 # Local imports
-from IPython.frontend.qt.console.ansi_code_processor import AnsiCodeProcessor
+from IPython.qt.console.ansi_code_processor import AnsiCodeProcessor
 
 
 class TestAnsiCodeProcessor(unittest.TestCase):
 
     def setUp(self):
         self.processor = AnsiCodeProcessor()
 
     def test_clear(self):
         """ Do control sequences for clearing the console work?
         """
         string = '\x1b[2J\x1b[K'
         i = -1
         for i, substring in enumerate(self.processor.split_string(string)):
             if i == 0:
                 self.assertEqual(len(self.processor.actions), 1)
                 action = self.processor.actions[0]
                 self.assertEqual(action.action, 'erase')
                 self.assertEqual(action.area, 'screen')
                 self.assertEqual(action.erase_to, 'all')
             elif i == 1:
                 self.assertEqual(len(self.processor.actions), 1)
                 action = self.processor.actions[0]
                 self.assertEqual(action.action, 'erase')
                 self.assertEqual(action.area, 'line')
                 self.assertEqual(action.erase_to, 'end')
             else:
                 self.fail('Too many substrings.')
         self.assertEqual(i, 1, 'Too few substrings.')
 
     def test_colors(self):
         """ Do basic controls sequences for colors work?
         """
         string = 'first\x1b[34mblue\x1b[0mlast'
         i = -1
         for i, substring in enumerate(self.processor.split_string(string)):
             if i == 0:
                 self.assertEqual(substring, 'first')
                 self.assertEqual(self.processor.foreground_color, None)
             elif i == 1:
                 self.assertEqual(substring, 'blue')
                 self.assertEqual(self.processor.foreground_color, 4)
             elif i == 2:
                 self.assertEqual(substring, 'last')
                 self.assertEqual(self.processor.foreground_color, None)
             else:
                 self.fail('Too many substrings.')
         self.assertEqual(i, 2, 'Too few substrings.')
 
     def test_colors_xterm(self):
         """ Do xterm-specific control sequences for colors work?
         """
         string = '\x1b]4;20;rgb:ff/ff/ff\x1b' \
             '\x1b]4;25;rgbi:1.0/1.0/1.0\x1b'
         substrings = list(self.processor.split_string(string))
         desired = { 20 : (255, 255, 255),
                     25 : (255, 255, 255) }
         self.assertEqual(self.processor.color_map, desired)
 
         string = '\x1b[38;5;20m\x1b[48;5;25m'
         substrings = list(self.processor.split_string(string))
         self.assertEqual(self.processor.foreground_color, 20)
         self.assertEqual(self.processor.background_color, 25)
 
     def test_scroll(self):
         """ Do control sequences for scrolling the buffer work?
         """
         string = '\x1b[5S\x1b[T'
         i = -1
         for i, substring in enumerate(self.processor.split_string(string)):
             if i == 0:
                 self.assertEqual(len(self.processor.actions), 1)
                 action = self.processor.actions[0]
                 self.assertEqual(action.action, 'scroll')
                 self.assertEqual(action.dir, 'up')
                 self.assertEqual(action.unit, 'line')
                 self.assertEqual(action.count, 5)
             elif i == 1:
                 self.assertEqual(len(self.processor.actions), 1)
                 action = self.processor.actions[0]
                 self.assertEqual(action.action, 'scroll')
                 self.assertEqual(action.dir, 'down')
                 self.assertEqual(action.unit, 'line')
                 self.assertEqual(action.count, 1)
             else:
                 self.fail('Too many substrings.')
         self.assertEqual(i, 1, 'Too few substrings.')
 
     def test_formfeed(self):
         """ Are formfeed characters processed correctly?
         """
         string = '\f' # form feed
         self.assertEqual(list(self.processor.split_string(string)), [''])
         self.assertEqual(len(self.processor.actions), 1)
         action = self.processor.actions[0]
         self.assertEqual(action.action, 'scroll')
         self.assertEqual(action.dir, 'down')
         self.assertEqual(action.unit, 'page')
         self.assertEqual(action.count, 1)
 
     def test_carriage_return(self):
         """ Are carriage return characters processed correctly?
         """
         string = 'foo\rbar' # carriage return
         splits = []
         actions = []
         for split in self.processor.split_string(string):
             splits.append(split)
             actions.append([action.action for action in self.processor.actions])
         self.assertEqual(splits, ['foo', None, 'bar'])
         self.assertEqual(actions, [[], ['carriage-return'], []])
 
     def test_carriage_return_newline(self):
         """transform CRLF to LF"""
         string = 'foo\rbar\r\ncat\r\n\n' # carriage return and newline
         # only one CR action should occur, and '\r\n' should transform to '\n'
         splits = []
         actions = []
         for split in self.processor.split_string(string):
             splits.append(split)
             actions.append([action.action for action in self.processor.actions])
         self.assertEqual(splits, ['foo', None, 'bar', '\r\n', 'cat', '\r\n', '\n'])
         self.assertEqual(actions, [[], ['carriage-return'], [], ['newline'], [], ['newline'], ['newline']])
 
     def test_beep(self):
         """ Are beep characters processed correctly?
         """
         string = 'foo\abar' # bell
         splits = []
         actions = []
         for split in self.processor.split_string(string):
             splits.append(split)
             actions.append([action.action for action in self.processor.actions])
         self.assertEqual(splits, ['foo', None, 'bar'])
         self.assertEqual(actions, [[], ['beep'], []])
 
     def test_backspace(self):
         """ Are backspace characters processed correctly?
         """
         string = 'foo\bbar' # backspace
         splits = []
         actions = []
         for split in self.processor.split_string(string):
             splits.append(split)
             actions.append([action.action for action in self.processor.actions])
         self.assertEqual(splits, ['foo', None, 'bar'])
         self.assertEqual(actions, [[], ['backspace'], []])
 
     def test_combined(self):
         """ Are CR and BS characters processed correctly in combination?
 
         BS is treated as a change in print position, rather than a
         backwards character deletion.  Therefore a BS at EOL is
         effectively ignored.
         """
         string = 'abc\rdef\b' # CR and backspace
         splits = []
         actions = []
         for split in self.processor.split_string(string):
             splits.append(split)
             actions.append([action.action for action in self.processor.actions])
         self.assertEqual(splits, ['abc', None, 'def', None])
         self.assertEqual(actions, [[], ['carriage-return'], [], ['backspace']])
 
 
 if __name__ == '__main__':
     unittest.main()

IPython/qt/console/tests/test_completion_lexer.py

@@ -1,47 +1,47 b''
 # Standard library imports
 import unittest
 
 # System library imports
 from pygments.lexers import CLexer, CppLexer, PythonLexer
 
 # Local imports
-from IPython.frontend.qt.console.completion_lexer import CompletionLexer
+from IPython.qt.console.completion_lexer import CompletionLexer
 
 
 class TestCompletionLexer(unittest.TestCase):
     
     def testPython(self):
         """ Does the CompletionLexer work for Python?
         """
         lexer = CompletionLexer(PythonLexer())
 
         # Test simplest case.
         self.assertEqual(lexer.get_context("foo.bar.baz"),
                           [ "foo", "bar", "baz" ])
 
         # Test trailing period.
         self.assertEqual(lexer.get_context("foo.bar."), [ "foo", "bar", "" ])
 
         # Test with prompt present.
         self.assertEqual(lexer.get_context(">>> foo.bar.baz"),
                           [ "foo", "bar", "baz" ])
 
         # Test spacing in name.
         self.assertEqual(lexer.get_context("foo.bar. baz"), [ "baz" ])
 
         # Test parenthesis.
         self.assertEqual(lexer.get_context("foo("), [])
 
     def testC(self):
         """ Does the CompletionLexer work for C/C++?
         """
         lexer = CompletionLexer(CLexer())
         self.assertEqual(lexer.get_context("foo.bar"), [ "foo", "bar" ])
         self.assertEqual(lexer.get_context("foo->bar"), [ "foo", "bar" ])
 
         lexer = CompletionLexer(CppLexer())
         self.assertEqual(lexer.get_context("Foo::Bar"), [ "Foo", "Bar" ])
 
 
 if __name__ == '__main__':
     unittest.main()

IPython/qt/console/tests/test_console_widget.py

@@ -1,80 +1,80 b''
 # Standard library imports
 import unittest
 
 # System library imports
 from IPython.external.qt import QtCore, QtGui
 
 # Local imports
-from IPython.frontend.qt.console.console_widget import ConsoleWidget
+from IPython.qt.console.console_widget import ConsoleWidget
 
 
 class TestConsoleWidget(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
         """ Create the application for the test case.
         """
         cls._app = QtGui.QApplication.instance()
         if cls._app is None:
             cls._app = QtGui.QApplication([])
         cls._app.setQuitOnLastWindowClosed(False)
 
     @classmethod
     def tearDownClass(cls):
         """ Exit the application.
         """
         QtGui.QApplication.quit()
 
     def test_special_characters(self):
         """ Are special characters displayed correctly?
         """
         w = ConsoleWidget()
         cursor = w._get_prompt_cursor()
 
         test_inputs = ['xyz\b\b=\n', 'foo\b\nbar\n', 'foo\b\nbar\r\n', 'abc\rxyz\b\b=']
         expected_outputs = [u'x=z\u2029', u'foo\u2029bar\u2029', u'foo\u2029bar\u2029', 'x=z']
         for i, text in enumerate(test_inputs):
             w._insert_plain_text(cursor, text)
             cursor.select(cursor.Document)
             selection = cursor.selectedText()
             self.assertEqual(expected_outputs[i], selection)
             # clear all the text
             cursor.insertText('')
 
     def test_link_handling(self):
         noKeys = QtCore.Qt
         noButton = QtCore.Qt.MouseButton(0)
         noButtons = QtCore.Qt.MouseButtons(0)
         noModifiers = QtCore.Qt.KeyboardModifiers(0)
         MouseMove = QtCore.QEvent.MouseMove
         QMouseEvent = QtGui.QMouseEvent
         
         w = ConsoleWidget()
         cursor = w._get_prompt_cursor()
         w._insert_html(cursor, '<a href="http://python.org">written in</a>')
         obj = w._control
         tip = QtGui.QToolTip
         self.assertEqual(tip.text(), u'')
         
         # should be somewhere else
         elsewhereEvent = QMouseEvent(MouseMove, QtCore.QPoint(50,50),
                                      noButton, noButtons, noModifiers)
         w.eventFilter(obj, elsewhereEvent)
         self.assertEqual(tip.isVisible(), False)
         self.assertEqual(tip.text(), u'')
         
         #self.assertEqual(tip.text(), u'')
         # should be over text
         overTextEvent = QMouseEvent(MouseMove, QtCore.QPoint(1,5),
                                     noButton, noButtons, noModifiers)
         w.eventFilter(obj, overTextEvent)
         self.assertEqual(tip.isVisible(), True)
         self.assertEqual(tip.text(), "http://python.org")
         
         # should still be over text
         stillOverTextEvent = QMouseEvent(MouseMove, QtCore.QPoint(1,5),
                                          noButton, noButtons, noModifiers)
         w.eventFilter(obj, stillOverTextEvent)
         self.assertEqual(tip.isVisible(), True)
         self.assertEqual(tip.text(), "http://python.org")
         

IPython/qt/console/tests/test_kill_ring.py

@@ -1,85 +1,85 b''
 # Standard library imports
 import unittest
 
 # System library imports
 from IPython.external.qt import QtCore, QtGui
 
 # Local imports
-from IPython.frontend.qt.console.kill_ring import KillRing, QtKillRing
+from IPython.qt.console.kill_ring import KillRing, QtKillRing
 
 
 class TestKillRing(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
         """ Create the application for the test case.
         """
         cls._app = QtGui.QApplication.instance()
         if cls._app is None:
             cls._app = QtGui.QApplication([])
         cls._app.setQuitOnLastWindowClosed(False)
 
     @classmethod
     def tearDownClass(cls):
         """ Exit the application.
         """
         QtGui.QApplication.quit()
 
     def test_generic(self):
         """ Does the generic kill ring work?
         """
         ring = KillRing()
         self.assertTrue(ring.yank() is None)
         self.assertTrue(ring.rotate() is None)
 
         ring.kill('foo')
         self.assertEqual(ring.yank(), 'foo')
         self.assertTrue(ring.rotate() is None)
         self.assertEqual(ring.yank(), 'foo')
 
         ring.kill('bar')
         self.assertEqual(ring.yank(), 'bar')
         self.assertEqual(ring.rotate(), 'foo')
 
         ring.clear()
         self.assertTrue(ring.yank() is None)
         self.assertTrue(ring.rotate() is None)
 
     def test_qt_basic(self):
         """ Does the Qt kill ring work?
         """
         text_edit = QtGui.QPlainTextEdit()
         ring = QtKillRing(text_edit)
 
         ring.kill('foo')
         ring.kill('bar')
         ring.yank()
         ring.rotate()
         ring.yank()
         self.assertEqual(text_edit.toPlainText(), 'foobar')
 
         text_edit.clear()
         ring.kill('baz')
         ring.yank()
         ring.rotate()
         ring.rotate()
         ring.rotate()
         self.assertEqual(text_edit.toPlainText(), 'foo')
 
     def test_qt_cursor(self):
         """ Does the Qt kill ring maintain state with cursor movement?
         """
         text_edit = QtGui.QPlainTextEdit()
         ring = QtKillRing(text_edit)
         
         ring.kill('foo')
         ring.kill('bar')
         ring.yank()
         text_edit.moveCursor(QtGui.QTextCursor.Left)
         ring.rotate()
         self.assertEqual(text_edit.toPlainText(), 'bar')
 
 
 if __name__ == '__main__':
     import nose
     nose.main()

IPython/terminal/console/tests/test_image_handler.py

@@ -1,95 +1,94 b''
 #-----------------------------------------------------------------------------
 # Copyright (C) 2012 The IPython Development Team
 #
 # Distributed under the terms of the BSD License. The full license is in
 # the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 import os
 import sys
 import unittest
 import base64
 
 from IPython.kernel import KernelClient
-from IPython.frontend.terminal.console.interactiveshell \
-    import ZMQTerminalInteractiveShell
+from IPython.terminal.console.interactiveshell import ZMQTerminalInteractiveShell
 from IPython.utils.tempdir import TemporaryDirectory
 from IPython.testing.tools import monkeypatch
 from IPython.testing.decorators import skip_without
 from IPython.utils.ipstruct import Struct
 
 
 SCRIPT_PATH = os.path.join(
     os.path.abspath(os.path.dirname(__file__)), 'writetofile.py')
 
 
 class ZMQTerminalInteractiveShellTestCase(unittest.TestCase):
 
     def setUp(self):
         client = KernelClient()
         self.shell = ZMQTerminalInteractiveShell(kernel_client=client)
         self.raw = b'dummy data'
         self.mime = 'image/png'
         self.data = {self.mime: base64.encodestring(self.raw).decode('ascii')}
 
     def test_no_call_by_default(self):
         def raise_if_called(*args, **kwds):
             assert False
 
         shell = self.shell
         shell.handle_image_PIL = raise_if_called
         shell.handle_image_stream = raise_if_called
         shell.handle_image_tempfile = raise_if_called
         shell.handle_image_callable = raise_if_called
 
         shell.handle_image(None, None)  # arguments are dummy
 
     @skip_without('PIL')
     def test_handle_image_PIL(self):
         import PIL.Image
 
         open_called_with = []
         show_called_with = []
 
         def fake_open(arg):
             open_called_with.append(arg)
             return Struct(show=lambda: show_called_with.append(None))
 
         with monkeypatch(PIL.Image, 'open', fake_open):
             self.shell.handle_image_PIL(self.data, self.mime)
 
         self.assertEqual(len(open_called_with), 1)
         self.assertEqual(len(show_called_with), 1)
         self.assertEqual(open_called_with[0].getvalue(), self.raw)
 
     def check_handler_with_file(self, inpath, handler):
         shell = self.shell
         configname = '{0}_image_handler'.format(handler)
         funcname = 'handle_image_{0}'.format(handler)
 
         assert hasattr(shell, configname)
         assert hasattr(shell, funcname)
 
         with TemporaryDirectory() as tmpdir:
             outpath = os.path.join(tmpdir, 'data')
             cmd = [sys.executable, SCRIPT_PATH, inpath, outpath]
             setattr(shell, configname, cmd)
             getattr(shell, funcname)(self.data, self.mime)
             # cmd is called and file is closed.  So it's safe to open now.
             with open(outpath, 'rb') as file:
                 transferred = file.read()
 
         self.assertEqual(transferred, self.raw)
 
     def test_handle_image_stream(self):
         self.check_handler_with_file('-', 'stream')
 
     def test_handle_image_tempfile(self):
         self.check_handler_with_file('{file}', 'tempfile')
 
     def test_handle_image_callable(self):
         called_with = []
         self.shell.callable_image_handler = called_with.append
         self.shell.handle_image_callable(self.data, self.mime)
         self.assertEqual(len(called_with), 1)
         assert called_with[0] is self.data

IPython/testing/globalipapp.py

@@ -1,176 +1,176 b''
 """Global IPython app to support test running.
 
 We must start our own ipython object and heavily muck with it so that all the
 modifications IPython makes to system behavior don't send the doctest machinery
 into a fit.  This code should be considered a gross hack, but it gets the job
 done.
 """
 from __future__ import absolute_import
 from __future__ import print_function
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2009-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # stdlib
 import __builtin__ as builtin_mod
 import os
 import sys
 
 # our own
 from . import tools
 
 from IPython.core import page
 from IPython.utils import io
 from IPython.utils import py3compat
-from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
+from IPython.terminal.interactiveshell import TerminalInteractiveShell
 
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
 
 class StreamProxy(io.IOStream):
     """Proxy for sys.stdout/err.  This will request the stream *at call time*
     allowing for nose's Capture plugin's redirection of sys.stdout/err.
 
     Parameters
     ----------
     name : str
         The name of the stream. This will be requested anew at every call
     """
 
     def __init__(self, name):
         self.name=name
 
     @property
     def stream(self):
         return getattr(sys, self.name)
 
     def flush(self):
         self.stream.flush()
 
 # Hack to modify the %run command so we can sync the user's namespace with the
 # test globals.  Once we move over to a clean magic system, this will be done
 # with much less ugliness.
 
 class py_file_finder(object):
     def __init__(self,test_filename):
         self.test_filename = test_filename
 
     def __call__(self,name,win32=False):
         from IPython.utils.path import get_py_filename
         try:
             return get_py_filename(name,win32=win32)
         except IOError:
             test_dir = os.path.dirname(self.test_filename)
             new_path = os.path.join(test_dir,name)
             return get_py_filename(new_path,win32=win32)
 
 
 def _run_ns_sync(self,arg_s,runner=None):
     """Modified version of %run that syncs testing namespaces.
 
     This is strictly needed for running doctests that call %run.
     """
     #print('in run_ns_sync', arg_s, file=sys.stderr)  # dbg
     finder = py_file_finder(arg_s)
     return get_ipython().magic_run_ori(arg_s, runner, finder)
 
 
 def get_ipython():
     # This will get replaced by the real thing once we start IPython below
     return start_ipython()
 
 
 # A couple of methods to override those in the running IPython to interact
 # better with doctest (doctest captures on raw stdout, so we need to direct
 # various types of output there otherwise it will miss them).
 
 def xsys(self, cmd):
     """Replace the default system call with a capturing one for doctest.
     """
     # We use getoutput, but we need to strip it because pexpect captures
     # the trailing newline differently from commands.getoutput
     print(self.getoutput(cmd, split=False, depth=1).rstrip(), end='', file=sys.stdout)
     sys.stdout.flush()
 
 
 def _showtraceback(self, etype, evalue, stb):
     """Print the traceback purely on stdout for doctest to capture it.
     """
     print(self.InteractiveTB.stb2text(stb), file=sys.stdout)
 
 
 def start_ipython():
     """Start a global IPython shell, which we need for IPython-specific syntax.
     """
     global get_ipython
 
     # This function should only ever run once!
     if hasattr(start_ipython, 'already_called'):
         return
     start_ipython.already_called = True
 
     # Store certain global objects that IPython modifies
     _displayhook = sys.displayhook
     _excepthook = sys.excepthook
     _main = sys.modules.get('__main__')
 
     # Create custom argv and namespaces for our IPython to be test-friendly
     config = tools.default_config()
 
     # Create and initialize our test-friendly IPython instance.
     shell = TerminalInteractiveShell.instance(config=config,
                                               )
 
     # A few more tweaks needed for playing nicely with doctests...
 
     # remove history file
     shell.tempfiles.append(config.HistoryManager.hist_file)
 
     # These traps are normally only active for interactive use, set them
     # permanently since we'll be mocking interactive sessions.
     shell.builtin_trap.activate()
 
     # Modify the IPython system call with one that uses getoutput, so that we
     # can capture subcommands and print them to Python's stdout, otherwise the
     # doctest machinery would miss them.
     shell.system = py3compat.MethodType(xsys, shell)
     
     shell._showtraceback = py3compat.MethodType(_showtraceback, shell)
 
     # IPython is ready, now clean up some global state...
 
     # Deactivate the various python system hooks added by ipython for
     # interactive convenience so we don't confuse the doctest system
     sys.modules['__main__'] = _main
     sys.displayhook = _displayhook
     sys.excepthook = _excepthook
 
     # So that ipython magics and aliases can be doctested (they work by making
     # a call into a global _ip object).  Also make the top-level get_ipython
     # now return this without recursively calling here again.
     _ip = shell
     get_ipython = _ip.get_ipython
     builtin_mod._ip = _ip
     builtin_mod.get_ipython = get_ipython
 
     # To avoid extra IPython messages during testing, suppress io.stdout/stderr
     io.stdout = StreamProxy('stdout')
     io.stderr = StreamProxy('stderr')
     
     # Override paging, so we don't require user interaction during the tests.
     def nopage(strng, start=0, screen_lines=0, pager_cmd=None):
         print(strng)
     
     page.orig_page = page.page
     page.page = nopage
 
     return _ip

IPython/utils/process.py

@@ -1,122 +1,122 b''
 # encoding: utf-8
 """
 Utilities for working with external processes.
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 from __future__ import print_function
 
 # Stdlib
 import os
 import sys
 import shlex
 
 # Our own
 if sys.platform == 'win32':
     from ._process_win32 import _find_cmd, system, getoutput, AvoidUNCPath, arg_split
 else:
     from ._process_posix import _find_cmd, system, getoutput, arg_split
 
 
 from ._process_common import getoutputerror
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 
 class FindCmdError(Exception):
     pass
 
 
 def find_cmd(cmd):
     """Find absolute path to executable cmd in a cross platform manner.
 
     This function tries to determine the full path to a command line program
     using `which` on Unix/Linux/OS X and `win32api` on Windows.  Most of the
     time it will use the version that is first on the users `PATH`.
 
     Warning, don't use this to find IPython command line programs as there
     is a risk you will find the wrong one.  Instead find those using the
     following code and looking for the application itself::
 
         from IPython.utils.path import get_ipython_module_path
         from IPython.utils.process import pycmd2argv
-        argv = pycmd2argv(get_ipython_module_path('IPython.frontend.terminal.ipapp'))
+        argv = pycmd2argv(get_ipython_module_path('IPython.terminal.ipapp'))
 
     Parameters
     ----------
     cmd : str
         The command line program to look for.
     """
     try:
         path = _find_cmd(cmd).rstrip()
     except OSError:
         raise FindCmdError('command could not be found: %s' % cmd)
     # which returns empty if not found
     if path == '':
         raise FindCmdError('command could not be found: %s' % cmd)
     return os.path.abspath(path)
 
 
 def is_cmd_found(cmd):
     """Check whether executable `cmd` exists or not and return a bool."""
     try:
         find_cmd(cmd)
         return True
     except FindCmdError:
         return False
 
 
 def pycmd2argv(cmd):
     r"""Take the path of a python command and return a list (argv-style).
 
     This only works on Python based command line programs and will find the
     location of the ``python`` executable using ``sys.executable`` to make
     sure the right version is used.
 
     For a given path ``cmd``, this returns [cmd] if cmd's extension is .exe,
     .com or .bat, and [, cmd] otherwise.
 
     Parameters
     ----------
     cmd : string
       The path of the command.
 
     Returns
     -------
     argv-style list.
     """
     ext = os.path.splitext(cmd)[1]
     if ext in ['.exe', '.com', '.bat']:
         return [cmd]
     else:
         return [sys.executable, cmd]
 
 
 def abbrev_cwd():
     """ Return abbreviated version of cwd, e.g. d:mydir """
     cwd = os.getcwdu().replace('\\','/')
     drivepart = ''
     tail = cwd
     if sys.platform == 'win32':
         if len(cwd) < 4:
             return cwd
         drivepart,tail = os.path.splitdrive(cwd)
 
 
     parts = tail.split('/')
     if len(parts) > 2:
         tail = '/'.join(parts[-2:])
 
     return (drivepart + (
         cwd == '/' and '/' or tail))

IPython/utils/tests/test_path.py

@@ -1,560 +1,560 b''
 # encoding: utf-8
 """Tests for IPython.utils.path.py"""
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from __future__ import with_statement
 
 import os
 import shutil
 import sys
 import tempfile
 from io import StringIO
 from contextlib import contextmanager
 
 from os.path import join, abspath, split
 
 import nose.tools as nt
 
 from nose import with_setup
 
 import IPython
 from IPython.testing import decorators as dec
 from IPython.testing.decorators import skip_if_not_win32, skip_win32
 from IPython.testing.tools import make_tempfile, AssertPrints
 from IPython.utils import path, io
 from IPython.utils import py3compat
 from IPython.utils.tempdir import TemporaryDirectory
 
 # Platform-dependent imports
 try:
     import _winreg as wreg
 except ImportError:
     #Fake _winreg module on none windows platforms
     import types
     wr_name = "winreg" if py3compat.PY3 else "_winreg"
     sys.modules[wr_name] = types.ModuleType(wr_name)
     import _winreg as wreg
     #Add entries that needs to be stubbed by the testing code
     (wreg.OpenKey, wreg.QueryValueEx,) = (None, None)
 
 try:
     reload
 except NameError:   # Python 3
     from imp import reload
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 env = os.environ
 TEST_FILE_PATH = split(abspath(__file__))[0]
 TMP_TEST_DIR = tempfile.mkdtemp()
 HOME_TEST_DIR = join(TMP_TEST_DIR, "home_test_dir")
 XDG_TEST_DIR = join(HOME_TEST_DIR, "xdg_test_dir")
 XDG_CACHE_DIR = join(HOME_TEST_DIR, "xdg_cache_dir")
 IP_TEST_DIR = join(HOME_TEST_DIR,'.ipython')
 #
 # Setup/teardown functions/decorators
 #
 
 def setup():
     """Setup testenvironment for the module:
 
             - Adds dummy home dir tree
     """
     # Do not mask exceptions here.  In particular, catching WindowsError is a
     # problem because that exception is only defined on Windows...
     os.makedirs(IP_TEST_DIR)
     os.makedirs(os.path.join(XDG_TEST_DIR, 'ipython'))
     os.makedirs(os.path.join(XDG_CACHE_DIR, 'ipython'))
 
 
 def teardown():
     """Teardown testenvironment for the module:
 
             - Remove dummy home dir tree
     """
     # Note: we remove the parent test dir, which is the root of all test
     # subdirs we may have created.  Use shutil instead of os.removedirs, so
     # that non-empty directories are all recursively removed.
     shutil.rmtree(TMP_TEST_DIR)
 
 
 def setup_environment():
     """Setup testenvironment for some functions that are tested
     in this module. In particular this functions stores attributes
     and other things that we need to stub in some test functions.
     This needs to be done on a function level and not module level because
     each testfunction needs a pristine environment.
     """
     global oldstuff, platformstuff
     oldstuff = (env.copy(), os.name, sys.platform, path.get_home_dir, IPython.__file__, os.getcwd())
 
     if os.name == 'nt':
         platformstuff = (wreg.OpenKey, wreg.QueryValueEx,)
 
 
 def teardown_environment():
     """Restore things that were remebered by the setup_environment function
     """
     (oldenv, os.name, sys.platform, path.get_home_dir, IPython.__file__, old_wd) = oldstuff
     os.chdir(old_wd)
     reload(path)
 
     for key in env.keys():
         if key not in oldenv:
             del env[key]
     env.update(oldenv)
     if hasattr(sys, 'frozen'):
         del sys.frozen
     if os.name == 'nt':
         (wreg.OpenKey, wreg.QueryValueEx,) = platformstuff
 
 # Build decorator that uses the setup_environment/setup_environment
 with_environment = with_setup(setup_environment, teardown_environment)
 
 @skip_if_not_win32
 @with_environment
 def test_get_home_dir_1():
     """Testcase for py2exe logic, un-compressed lib
     """
     sys.frozen = True
 
     #fake filename for IPython.__init__
     IPython.__file__ = abspath(join(HOME_TEST_DIR, "Lib/IPython/__init__.py"))
 
     home_dir = path.get_home_dir()
     nt.assert_equal(home_dir, abspath(HOME_TEST_DIR))
 
 
 @skip_if_not_win32
 @with_environment
 def test_get_home_dir_2():
     """Testcase for py2exe logic, compressed lib
     """
     sys.frozen = True
     #fake filename for IPython.__init__
     IPython.__file__ = abspath(join(HOME_TEST_DIR, "Library.zip/IPython/__init__.py")).lower()
 
     home_dir = path.get_home_dir(True)
     nt.assert_equal(home_dir, abspath(HOME_TEST_DIR).lower())
 
 
 @with_environment
 def test_get_home_dir_3():
     """get_home_dir() uses $HOME if set"""
     env["HOME"] = HOME_TEST_DIR
     home_dir = path.get_home_dir(True)
     # get_home_dir expands symlinks
     nt.assert_equal(home_dir, os.path.realpath(env["HOME"]))
 
 
 @with_environment
 def test_get_home_dir_4():
     """get_home_dir() still works if $HOME is not set"""
 
     if 'HOME' in env: del env['HOME']
     # this should still succeed, but we don't care what the answer is
     home = path.get_home_dir(False)
 
 @with_environment
 def test_get_home_dir_5():
     """raise HomeDirError if $HOME is specified, but not a writable dir"""
     env['HOME'] = abspath(HOME_TEST_DIR+'garbage')
     # set os.name = posix, to prevent My Documents fallback on Windows
     os.name = 'posix'
     nt.assert_raises(path.HomeDirError, path.get_home_dir, True)
 
 
 # Should we stub wreg fully so we can run the test on all platforms?
 @skip_if_not_win32
 @with_environment
 def test_get_home_dir_8():
     """Using registry hack for 'My Documents', os=='nt'
 
     HOMESHARE, HOMEDRIVE, HOMEPATH, USERPROFILE and others are missing.
     """
     os.name = 'nt'
     # Remove from stub environment all keys that may be set
     for key in ['HOME', 'HOMESHARE', 'HOMEDRIVE', 'HOMEPATH', 'USERPROFILE']:
         env.pop(key, None)
 
     #Stub windows registry functions
     def OpenKey(x, y):
         class key:
             def Close(self):
                 pass
         return key()
     def QueryValueEx(x, y):
         return [abspath(HOME_TEST_DIR)]
 
     wreg.OpenKey = OpenKey
     wreg.QueryValueEx = QueryValueEx
 
     home_dir = path.get_home_dir()
     nt.assert_equal(home_dir, abspath(HOME_TEST_DIR))
 
 
 @with_environment
 def test_get_ipython_dir_1():
     """test_get_ipython_dir_1, Testcase to see if we can call get_ipython_dir without Exceptions."""
     env_ipdir = os.path.join("someplace", ".ipython")
     path._writable_dir = lambda path: True
     env['IPYTHONDIR'] = env_ipdir
     ipdir = path.get_ipython_dir()
     nt.assert_equal(ipdir, env_ipdir)
 
 
 @with_environment
 def test_get_ipython_dir_2():
     """test_get_ipython_dir_2, Testcase to see if we can call get_ipython_dir without Exceptions."""
     path.get_home_dir = lambda : "someplace"
     path.get_xdg_dir = lambda : None
     path._writable_dir = lambda path: True
     os.name = "posix"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env.pop('XDG_CONFIG_HOME', None)
     ipdir = path.get_ipython_dir()
     nt.assert_equal(ipdir, os.path.join("someplace", ".ipython"))
 
 @with_environment
 def test_get_ipython_dir_3():
     """test_get_ipython_dir_3, use XDG if defined, and .ipython doesn't exist."""
     path.get_home_dir = lambda : "someplace"
     path._writable_dir = lambda path: True
     os.name = "posix"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env['XDG_CONFIG_HOME'] = XDG_TEST_DIR
     ipdir = path.get_ipython_dir()
     if sys.platform == "darwin":
         expected = os.path.join("someplace", ".ipython")
     else:
         expected = os.path.join(XDG_TEST_DIR, "ipython")
     nt.assert_equal(ipdir, expected)
 
 @with_environment
 def test_get_ipython_dir_4():
     """test_get_ipython_dir_4, use XDG if both exist."""
     path.get_home_dir = lambda : HOME_TEST_DIR
     os.name = "posix"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env['XDG_CONFIG_HOME'] = XDG_TEST_DIR
     ipdir = path.get_ipython_dir()
     if sys.platform == "darwin":
         expected = os.path.join(HOME_TEST_DIR, ".ipython")
     else:
         expected = os.path.join(XDG_TEST_DIR, "ipython")
     nt.assert_equal(ipdir, expected)
 
 @with_environment
 def test_get_ipython_dir_5():
     """test_get_ipython_dir_5, use .ipython if exists and XDG defined, but doesn't exist."""
     path.get_home_dir = lambda : HOME_TEST_DIR
     os.name = "posix"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env['XDG_CONFIG_HOME'] = XDG_TEST_DIR
     os.rmdir(os.path.join(XDG_TEST_DIR, 'ipython'))
     ipdir = path.get_ipython_dir()
     nt.assert_equal(ipdir, IP_TEST_DIR)
 
 @with_environment
 def test_get_ipython_dir_6():
     """test_get_ipython_dir_6, use XDG if defined and neither exist."""
     xdg = os.path.join(HOME_TEST_DIR, 'somexdg')
     os.mkdir(xdg)
     shutil.rmtree(os.path.join(HOME_TEST_DIR, '.ipython'))
     path.get_home_dir = lambda : HOME_TEST_DIR
     path.get_xdg_dir = lambda : xdg
     os.name = "posix"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env.pop('XDG_CONFIG_HOME', None)
     xdg_ipdir = os.path.join(xdg, "ipython")
     ipdir = path.get_ipython_dir()
     nt.assert_equal(ipdir, xdg_ipdir)
 
 @with_environment
 def test_get_ipython_dir_7():
     """test_get_ipython_dir_7, test home directory expansion on IPYTHONDIR"""
     path._writable_dir = lambda path: True
     home_dir = os.path.normpath(os.path.expanduser('~'))
     env['IPYTHONDIR'] = os.path.join('~', 'somewhere')
     ipdir = path.get_ipython_dir()
     nt.assert_equal(ipdir, os.path.join(home_dir, 'somewhere'))
 
 @skip_win32
 @with_environment
 def test_get_ipython_dir_8():
     """test_get_ipython_dir_8, test / home directory"""
     old = path._writable_dir, path.get_xdg_dir
     try:
         path._writable_dir = lambda path: bool(path)
         path.get_xdg_dir = lambda: None
         env.pop('IPYTHON_DIR', None)
         env.pop('IPYTHONDIR', None)
         env['HOME'] = '/'
         nt.assert_equal(path.get_ipython_dir(), '/.ipython')
     finally:
         path._writable_dir, path.get_xdg_dir = old
 
 @with_environment
 def test_get_xdg_dir_0():
     """test_get_xdg_dir_0, check xdg_dir"""
     reload(path)
     path._writable_dir = lambda path: True
     path.get_home_dir = lambda : 'somewhere'
     os.name = "posix"
     sys.platform = "linux2"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env.pop('XDG_CONFIG_HOME', None)
 
     nt.assert_equal(path.get_xdg_dir(), os.path.join('somewhere', '.config'))
 
 
 @with_environment
 def test_get_xdg_dir_1():
     """test_get_xdg_dir_1, check nonexistant xdg_dir"""
     reload(path)
     path.get_home_dir = lambda : HOME_TEST_DIR
     os.name = "posix"
     sys.platform = "linux2"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env.pop('XDG_CONFIG_HOME', None)
     nt.assert_equal(path.get_xdg_dir(), None)
 
 @with_environment
 def test_get_xdg_dir_2():
     """test_get_xdg_dir_2, check xdg_dir default to ~/.config"""
     reload(path)
     path.get_home_dir = lambda : HOME_TEST_DIR
     os.name = "posix"
     sys.platform = "linux2"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env.pop('XDG_CONFIG_HOME', None)
     cfgdir=os.path.join(path.get_home_dir(), '.config')
     if not os.path.exists(cfgdir):
         os.makedirs(cfgdir)
 
     nt.assert_equal(path.get_xdg_dir(), cfgdir)
 
 @with_environment
 def test_get_xdg_dir_3():
     """test_get_xdg_dir_3, check xdg_dir not used on OS X"""
     reload(path)
     path.get_home_dir = lambda : HOME_TEST_DIR
     os.name = "posix"
     sys.platform = "darwin"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env.pop('XDG_CONFIG_HOME', None)
     cfgdir=os.path.join(path.get_home_dir(), '.config')
     if not os.path.exists(cfgdir):
         os.makedirs(cfgdir)
 
     nt.assert_equal(path.get_xdg_dir(), None)
 
 def test_filefind():
     """Various tests for filefind"""
     f = tempfile.NamedTemporaryFile()
     # print 'fname:',f.name
     alt_dirs = path.get_ipython_dir()
     t = path.filefind(f.name, alt_dirs)
     # print 'found:',t
 
 @with_environment
 def test_get_ipython_cache_dir():
     os.environ["HOME"] = HOME_TEST_DIR
     if os.name == 'posix' and sys.platform != 'darwin':
         # test default
         os.makedirs(os.path.join(HOME_TEST_DIR, ".cache"))
         os.environ.pop("XDG_CACHE_HOME", None)
         ipdir = path.get_ipython_cache_dir()
         nt.assert_equal(os.path.join(HOME_TEST_DIR, ".cache", "ipython"),
                         ipdir)
         nt.assert_true(os.path.isdir(ipdir))
 
         # test env override
         os.environ["XDG_CACHE_HOME"] = XDG_CACHE_DIR
         ipdir = path.get_ipython_cache_dir()
         nt.assert_true(os.path.isdir(ipdir))
         nt.assert_equal(ipdir, os.path.join(XDG_CACHE_DIR, "ipython"))
     else:
         nt.assert_equal(path.get_ipython_cache_dir(),
                         path.get_ipython_dir())
 
 def test_get_ipython_package_dir():
     ipdir = path.get_ipython_package_dir()
     nt.assert_true(os.path.isdir(ipdir))
 
 
 def test_get_ipython_module_path():
-    ipapp_path = path.get_ipython_module_path('IPython.frontend.terminal.ipapp')
+    ipapp_path = path.get_ipython_module_path('IPython.terminal.ipapp')
     nt.assert_true(os.path.isfile(ipapp_path))
 
 
 @dec.skip_if_not_win32
 def test_get_long_path_name_win32():
     p = path.get_long_path_name('c:\\docume~1')
     nt.assert_equal(p,u'c:\\Documents and Settings')
 
 
 @dec.skip_win32
 def test_get_long_path_name():
     p = path.get_long_path_name('/usr/local')
     nt.assert_equal(p,'/usr/local')
 
 @dec.skip_win32 # can't create not-user-writable dir on win
 @with_environment
 def test_not_writable_ipdir():
     tmpdir = tempfile.mkdtemp()
     os.name = "posix"
     env.pop('IPYTHON_DIR', None)
     env.pop('IPYTHONDIR', None)
     env.pop('XDG_CONFIG_HOME', None)
     env['HOME'] = tmpdir
     ipdir = os.path.join(tmpdir, '.ipython')
     os.mkdir(ipdir)
     os.chmod(ipdir, 600)
     with AssertPrints('is not a writable location', channel='stderr'):
         ipdir = path.get_ipython_dir()
     env.pop('IPYTHON_DIR', None)
 
 def test_unquote_filename():
     for win32 in (True, False):
         nt.assert_equal(path.unquote_filename('foo.py', win32=win32), 'foo.py')
         nt.assert_equal(path.unquote_filename('foo bar.py', win32=win32), 'foo bar.py')
     nt.assert_equal(path.unquote_filename('"foo.py"', win32=True), 'foo.py')
     nt.assert_equal(path.unquote_filename('"foo bar.py"', win32=True), 'foo bar.py')
     nt.assert_equal(path.unquote_filename("'foo.py'", win32=True), 'foo.py')
     nt.assert_equal(path.unquote_filename("'foo bar.py'", win32=True), 'foo bar.py')
     nt.assert_equal(path.unquote_filename('"foo.py"', win32=False), '"foo.py"')
     nt.assert_equal(path.unquote_filename('"foo bar.py"', win32=False), '"foo bar.py"')
     nt.assert_equal(path.unquote_filename("'foo.py'", win32=False), "'foo.py'")
     nt.assert_equal(path.unquote_filename("'foo bar.py'", win32=False), "'foo bar.py'")
 
 @with_environment
 def test_get_py_filename():
     os.chdir(TMP_TEST_DIR)
     for win32 in (True, False):
         with make_tempfile('foo.py'):
             nt.assert_equal(path.get_py_filename('foo.py', force_win32=win32), 'foo.py')
             nt.assert_equal(path.get_py_filename('foo', force_win32=win32), 'foo.py')
         with make_tempfile('foo'):
             nt.assert_equal(path.get_py_filename('foo', force_win32=win32), 'foo')
             nt.assert_raises(IOError, path.get_py_filename, 'foo.py', force_win32=win32)
         nt.assert_raises(IOError, path.get_py_filename, 'foo', force_win32=win32)
         nt.assert_raises(IOError, path.get_py_filename, 'foo.py', force_win32=win32)
         true_fn = 'foo with spaces.py'
         with make_tempfile(true_fn):
             nt.assert_equal(path.get_py_filename('foo with spaces', force_win32=win32), true_fn)
             nt.assert_equal(path.get_py_filename('foo with spaces.py', force_win32=win32), true_fn)
             if win32:
                 nt.assert_equal(path.get_py_filename('"foo with spaces.py"', force_win32=True), true_fn)
                 nt.assert_equal(path.get_py_filename("'foo with spaces.py'", force_win32=True), true_fn)
             else:
                 nt.assert_raises(IOError, path.get_py_filename, '"foo with spaces.py"', force_win32=False)
                 nt.assert_raises(IOError, path.get_py_filename, "'foo with spaces.py'", force_win32=False)
                 
 def test_unicode_in_filename():
     """When a file doesn't exist, the exception raised should be safe to call
     str() on - i.e. in Python 2 it must only have ASCII characters.
     
     https://github.com/ipython/ipython/issues/875
     """
     try:
         # these calls should not throw unicode encode exceptions
         path.get_py_filename(u'fooéè.py',  force_win32=False)
     except IOError as ex:
         str(ex)
 
 
 class TestShellGlob(object):
 
     @classmethod
     def setUpClass(cls):
         cls.filenames_start_with_a = map('a{0}'.format, range(3))
         cls.filenames_end_with_b = map('{0}b'.format, range(3))
         cls.filenames = cls.filenames_start_with_a + cls.filenames_end_with_b
         cls.tempdir = TemporaryDirectory()
         td = cls.tempdir.name
 
         with cls.in_tempdir():
             # Create empty files
             for fname in cls.filenames:
                 open(os.path.join(td, fname), 'w').close()
 
     @classmethod
     def tearDownClass(cls):
         cls.tempdir.cleanup()
 
     @classmethod
     @contextmanager
     def in_tempdir(cls):
         save = os.getcwdu()
         try:
             os.chdir(cls.tempdir.name)
             yield
         finally:
             os.chdir(save)
 
     def check_match(self, patterns, matches):
         with self.in_tempdir():
             # glob returns unordered list. that's why sorted is required.
             nt.assert_equals(sorted(path.shellglob(patterns)),
                              sorted(matches))
 
     def common_cases(self):
         return [
             (['*'], self.filenames),
             (['a*'], self.filenames_start_with_a),
             (['*c'], ['*c']),
             (['*', 'a*', '*b', '*c'], self.filenames
                                       + self.filenames_start_with_a
                                       + self.filenames_end_with_b
                                       + ['*c']),
             (['a[012]'], self.filenames_start_with_a),
         ]
 
     @skip_win32
     def test_match_posix(self):
         for (patterns, matches) in self.common_cases() + [
                 ([r'\*'], ['*']),
                 ([r'a\*', 'a*'], ['a*'] + self.filenames_start_with_a),
                 ([r'a\[012]'], ['a[012]']),
                 ]:
             yield (self.check_match, patterns, matches)
 
     @skip_if_not_win32
     def test_match_windows(self):
         for (patterns, matches) in self.common_cases() + [
                 # In windows, backslash is interpreted as path
                 # separator.  Therefore, you can't escape glob
                 # using it.
                 ([r'a\*', 'a*'], [r'a\*'] + self.filenames_start_with_a),
                 ([r'a\[012]'], [r'a\[012]']),
                 ]:
             yield (self.check_match, patterns, matches)
 
 
 def test_unescape_glob():
     nt.assert_equals(path.unescape_glob(r'\*\[\!\]\?'), '*[!]?')
     nt.assert_equals(path.unescape_glob(r'\\*'), r'\*')
     nt.assert_equals(path.unescape_glob(r'\\\*'), r'\*')
     nt.assert_equals(path.unescape_glob(r'\\a'), r'\a')
     nt.assert_equals(path.unescape_glob(r'\a'), r'\a')