Removed the top-level iptest.py and INSTALLED logic.

Fernando's branch introduced the ability to run the test suite
from a top-level iptest.py script. This allowed IPython to be tested
without installation. The implementation was fragile and we also
decided that we *want* people to install IPython as part of testing
it, so we removed this feature.

IPython/core/ipapp.py

@@ -1,651 +1,654 b''
 #!/usr/bin/env python
 # encoding: utf-8
 """
 The :class:`~IPython.core.application.Application` object for the command
 line :command:`ipython` program.
 
 Authors
 -------
 
 * Brian Granger
 * Fernando Perez
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2010  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 logging
 import os
 import sys
 
 from IPython.core import release
 from IPython.core.crashhandler import CrashHandler
 from IPython.core.application import Application, BaseAppConfigLoader
 from IPython.core.iplib import InteractiveShell
 from IPython.config.loader import (
     Config,
     PyFileConfigLoader
 )
 from IPython.lib import inputhook
 from IPython.utils.path import filefind, get_ipython_dir
 from . import usage
 
 #-----------------------------------------------------------------------------
 # Globals, utilities and helpers
 #-----------------------------------------------------------------------------
 
 #: The default config file name for this application.
 default_config_file_name = u'ipython_config.py'
 
 
 class IPAppConfigLoader(BaseAppConfigLoader):
 
     def _add_arguments(self):
         super(IPAppConfigLoader, self)._add_arguments()
         paa = self.parser.add_argument
         paa('-p', 
             '--profile', dest='Global.profile', type=unicode,
             help=
             """The string name of the ipython profile to be used.  Assume that your
             config file is ipython_config-<name>.py (looks in current dir first,
             then in IPYTHON_DIR). This is a quick way to keep and load multiple
             config files for different tasks, especially if include your basic one
             in your more specialized ones.  You can keep a basic
             IPYTHON_DIR/ipython_config.py file and then have other 'profiles' which
             include this one and load extra things for particular tasks.""",
             metavar='Global.profile')
         paa('--config-file', 
             dest='Global.config_file', type=unicode,
             help=
             """Set the config file name to override default.  Normally IPython
             loads ipython_config.py (from current directory) or
             IPYTHON_DIR/ipython_config.py.  If the loading of your config file
             fails, IPython starts with a bare bones configuration (no modules
             loaded at all).""",
             metavar='Global.config_file')
         paa('--autocall', 
             dest='InteractiveShell.autocall', type=int, 
             help=
             """Make IPython automatically call any callable object even if you
             didn't type explicit parentheses. For example, 'str 43' becomes
             'str(43)' automatically.  The value can be '0' to disable the feature,
             '1' for 'smart' autocall, where it is not applied if there are no more
             arguments on the line, and '2' for 'full' autocall, where all callable
             objects are automatically called (even if no arguments are present).
             The default is '1'.""",
             metavar='InteractiveShell.autocall')
         paa('--autoindent',
             action='store_true', dest='InteractiveShell.autoindent',
             help='Turn on autoindenting.')
         paa('--no-autoindent',
             action='store_false', dest='InteractiveShell.autoindent',
             help='Turn off autoindenting.')
         paa('--automagic',
             action='store_true', dest='InteractiveShell.automagic',
             help=
             """Turn on the auto calling of magic commands. Type %%magic at the
             IPython  prompt  for  more information.""")
         paa('--no-automagic',
             action='store_false', dest='InteractiveShell.automagic',
             help='Turn off the auto calling of magic commands.')
         paa('--autoedit-syntax',
             action='store_true', dest='InteractiveShell.autoedit_syntax',
             help='Turn on auto editing of files with syntax errors.')
         paa('--no-autoedit-syntax',
             action='store_false', dest='InteractiveShell.autoedit_syntax',
             help='Turn off auto editing of files with syntax errors.')
         paa('--banner',
             action='store_true', dest='Global.display_banner',
             help='Display a banner upon starting IPython.')
         paa('--no-banner',
             action='store_false', dest='Global.display_banner',
             help="Don't display a banner upon starting IPython.")
         paa('--cache-size',
             type=int, dest='InteractiveShell.cache_size',
             help=
             """Set the size of the output cache.  The default is 1000, you can
             change it permanently in your config file.  Setting it to 0 completely
             disables the caching system, and the minimum value accepted is 20 (if
             you provide a value less than 20, it is reset to 0 and a warning is
             issued).  This limit is defined because otherwise you'll spend more
             time re-flushing a too small cache than working""",
             metavar='InteractiveShell.cache_size')
         paa('--classic',
             action='store_true', dest='Global.classic',
             help="Gives IPython a similar feel to the classic Python prompt.")
         paa('--colors',
             type=str, dest='InteractiveShell.colors',
             help="Set the color scheme (NoColor, Linux, and LightBG).",
             metavar='InteractiveShell.colors')
         paa('--color-info',
             action='store_true', dest='InteractiveShell.color_info',
             help=
             """IPython can display information about objects via a set of func-
             tions, and optionally can use colors for this, syntax highlighting
             source code and various other elements.  However, because this
             information is passed through a pager (like 'less') and many pagers get
             confused with color codes, this option is off by default.  You can test
             it and turn it on permanently in your ipython_config.py file if it
             works for you.  Test it and turn it on permanently if it works with
             your system.  The magic function %%color_info allows you to toggle this
             inter- actively for testing.""")
         paa('--no-color-info',
             action='store_false', dest='InteractiveShell.color_info',
             help="Disable using colors for info related things.")
         paa('--confirm-exit',
             action='store_true', dest='InteractiveShell.confirm_exit',
             help=
             """Set to confirm when you try to exit IPython with an EOF (Control-D
             in Unix, Control-Z/Enter in Windows). By typing 'exit', 'quit' or
             '%%Exit', you can force a direct exit without any confirmation.""")
         paa('--no-confirm-exit',
             action='store_false', dest='InteractiveShell.confirm_exit',
             help="Don't prompt the user when exiting.")
         paa('--deep-reload',
             action='store_true', dest='InteractiveShell.deep_reload',
             help=
             """Enable deep (recursive) reloading by default. IPython can use the
             deep_reload module which reloads changes in modules recursively (it
             replaces the reload() function, so you don't need to change anything to
             use it). deep_reload() forces a full reload of modules whose code may
             have changed, which the default reload() function does not.  When
             deep_reload is off, IPython will use the normal reload(), but
             deep_reload will still be available as dreload(). This fea- ture is off
             by default [which means that you have both normal reload() and
             dreload()].""")
         paa('--no-deep-reload',
             action='store_false', dest='InteractiveShell.deep_reload',
             help="Disable deep (recursive) reloading by default.")
         paa('--editor',
             type=str, dest='InteractiveShell.editor',
             help="Set the editor used by IPython (default to $EDITOR/vi/notepad).",
             metavar='InteractiveShell.editor')
         paa('--log','-l', 
             action='store_true', dest='InteractiveShell.logstart',
             help="Start logging to the default log file (./ipython_log.py).")
         paa('--logfile','-lf',
             type=unicode, dest='InteractiveShell.logfile',
             help="Start logging to logfile with this name.",
             metavar='InteractiveShell.logfile')
         paa('--log-append','-la',
             type=unicode, dest='InteractiveShell.logappend',
             help="Start logging to the given file in append mode.",
             metavar='InteractiveShell.logfile')
         paa('--pdb',
             action='store_true', dest='InteractiveShell.pdb',
             help="Enable auto calling the pdb debugger after every exception.")
         paa('--no-pdb',
             action='store_false', dest='InteractiveShell.pdb',
             help="Disable auto calling the pdb debugger after every exception.")
         paa('--pprint',
             action='store_true', dest='InteractiveShell.pprint',
             help="Enable auto pretty printing of results.")
         paa('--no-pprint',
             action='store_false', dest='InteractiveShell.pprint',
             help="Disable auto auto pretty printing of results.")
         paa('--prompt-in1','-pi1',
             type=str, dest='InteractiveShell.prompt_in1',
             help=
             """Set the main input prompt ('In [\#]: ').  Note that if you are using
             numbered prompts, the number is represented with a '\#' in the string.
             Don't forget to quote strings with spaces embedded in them. Most
             bash-like escapes can be used to customize IPython's prompts, as well
             as a few additional ones which are IPython-spe- cific.  All valid
             prompt escapes are described in detail in the Customization section of
             the IPython manual.""",
             metavar='InteractiveShell.prompt_in1')
         paa('--prompt-in2','-pi2',
             type=str, dest='InteractiveShell.prompt_in2',
             help=
             """Set the secondary input prompt (' .\D.: ').  Similar to the previous
             option, but used for the continuation prompts. The special sequence
             '\D' is similar to '\#', but with all digits replaced by dots (so you
             can have your continuation prompt aligned with your input prompt).
             Default: ' .\D.: ' (note three spaces at the start for alignment with
             'In [\#]')""",
             metavar='InteractiveShell.prompt_in2')
         paa('--prompt-out','-po',
             type=str, dest='InteractiveShell.prompt_out',
             help="Set the output prompt ('Out[\#]:')",
             metavar='InteractiveShell.prompt_out')
         paa('--quick',
             action='store_true', dest='Global.quick',
             help="Enable quick startup with no config files.")
         paa('--readline',
             action='store_true', dest='InteractiveShell.readline_use',
             help="Enable readline for command line usage.")
         paa('--no-readline',
             action='store_false', dest='InteractiveShell.readline_use',
             help="Disable readline for command line usage.")
         paa('--screen-length','-sl',
             type=int, dest='InteractiveShell.screen_length',
             help=
             """Number of lines of your screen, used to control printing of very
             long strings.  Strings longer than this number of lines will be sent
             through a pager instead of directly printed.  The default value for
             this is 0, which means IPython will auto-detect your screen size every
             time it needs to print certain potentially long strings (this doesn't
             change the behavior of the 'print' keyword, it's only triggered
             internally). If for some reason this isn't working well (it needs
             curses support), specify it yourself. Otherwise don't change the
             default.""",
             metavar='InteractiveShell.screen_length')
         paa('--separate-in','-si',
             type=str, dest='InteractiveShell.separate_in',
             help="Separator before input prompts.  Default '\\n'.",
             metavar='InteractiveShell.separate_in')
         paa('--separate-out','-so',
             type=str, dest='InteractiveShell.separate_out',
             help="Separator before output prompts.  Default 0 (nothing).",
             metavar='InteractiveShell.separate_out')
         paa('--separate-out2','-so2', 
             type=str, dest='InteractiveShell.separate_out2',
             help="Separator after output prompts.  Default 0 (nonight).",
             metavar='InteractiveShell.separate_out2')
         paa('-no-sep',
             action='store_true', dest='Global.nosep',
             help="Eliminate all spacing between prompts.")
         paa('--term-title',
             action='store_true', dest='InteractiveShell.term_title',
             help="Enable auto setting the terminal title.")
         paa('--no-term-title',
             action='store_false', dest='InteractiveShell.term_title',
             help="Disable auto setting the terminal title.")
         paa('--xmode',
             type=str, dest='InteractiveShell.xmode',
             help=
             """Exception reporting mode ('Plain','Context','Verbose').  Plain:
             similar to python's normal traceback printing.  Context: prints 5 lines
             of context source code around each line in the traceback.  Verbose:
             similar to Context, but additionally prints the variables currently
             visible where the exception happened (shortening their strings if too
             long).  This can potentially be very slow, if you happen to have a huge
             data structure whose string representation is complex to compute.
             Your computer may appear to freeze for a while with cpu usage at 100%%.
             If this occurs, you can cancel the traceback with Ctrl-C (maybe hitting
             it more than once).
             """,
             metavar='InteractiveShell.xmode')
         paa('--ext',
             type=str, dest='Global.extra_extension',
             help="The dotted module name of an IPython extension to load.",
             metavar='Global.extra_extension')
         paa('-c',
             type=str, dest='Global.code_to_run',
             help="Execute the given command string.",
             metavar='Global.code_to_run')
         paa('-i',
             action='store_true', dest='Global.force_interact',
             help=
             "If running code from the command line, become interactive afterwards.")
 
         # Options to start with GUI control enabled from the beginning
         paa('--gui',
             type=str, dest='Global.gui',
             help="Enable GUI event loop integration ('qt', 'wx', 'gtk').",
             metavar='gui-mode')
         paa('--pylab','-pylab',
             type=str, dest='Global.pylab',
             nargs='?', const='auto', metavar='gui-mode',
             help="Pre-load matplotlib and numpy for interactive use. "+
             "If no value is given, the gui backend is matplotlib's, else use "+
             "one of:  ['tk', 'qt', 'wx', 'gtk'].")
 
         # Legacy GUI options.  Leave them in for backwards compatibility, but the
         # 'thread' names are really a misnomer now.
         paa('--wthread', '-wthread',
             action='store_true', dest='Global.wthread',
             help=
             """Enable wxPython event loop integration. (DEPRECATED, use --gui wx)""")
         paa('--q4thread', '--qthread', '-q4thread', '-qthread',
             action='store_true', dest='Global.q4thread',
             help=
             """Enable Qt4 event loop integration. Qt3 is no longer supported.
             (DEPRECATED, use --gui qt)""")
         paa('--gthread', '-gthread',
             action='store_true', dest='Global.gthread',
             help=
             """Enable GTK event loop integration. (DEPRECATED, use --gui gtk)""")
 
 
 #-----------------------------------------------------------------------------
 # Crash handler for this application
 #-----------------------------------------------------------------------------
 
 
 _message_template = """\
 Oops, $self.app_name crashed. We do our best to make it stable, but...
 
 A crash report was automatically generated with the following information:
   - A verbatim copy of the crash traceback.
   - A copy of your input history during this session.
   - Data on your current $self.app_name configuration.
 
 It was left in the file named:
 \t'$self.crash_report_fname'
 If you can email this file to the developers, the information in it will help
 them in understanding and correcting the problem.
 
 You can mail it to: $self.contact_name at $self.contact_email
 with the subject '$self.app_name Crash Report'.
 
 If you want to do it now, the following command will work (under Unix):
 mail -s '$self.app_name Crash Report' $self.contact_email < $self.crash_report_fname
 
 To ensure accurate tracking of this issue, please file a report about it at:
 $self.bug_tracker
 """
 
 class IPAppCrashHandler(CrashHandler):
     """sys.excepthook for IPython itself, leaves a detailed report on disk."""
 
     message_template = _message_template
 
     def __init__(self, app):
         contact_name = release.authors['Fernando'][0]
         contact_email = release.authors['Fernando'][1]
         bug_tracker = 'https://bugs.launchpad.net/ipython/+filebug'
         super(IPAppCrashHandler,self).__init__(
             app, contact_name, contact_email, bug_tracker
         )
 
     def make_report(self,traceback):
         """Return a string containing a crash report."""
 
         sec_sep = self.section_sep
         # Start with parent report
         report = [super(IPAppCrashHandler, self).make_report(traceback)]
         # Add interactive-specific info we may have
         rpt_add = report.append
         try:
             rpt_add(sec_sep+"History of session input:")
             for line in self.app.shell.user_ns['_ih']:
                 rpt_add(line)
             rpt_add('\n*** Last line of input (may not be in above history):\n')
             rpt_add(self.app.shell._last_input_line+'\n')
         except:
             pass
 
         return ''.join(report)
 
 
 #-----------------------------------------------------------------------------
 # Main classes and functions
 #-----------------------------------------------------------------------------
 
 class IPythonApp(Application):
     name = u'ipython'
     #: argparse formats better the 'usage' than the 'description' field
     description = None
     usage = usage.cl_usage
     command_line_loader = IPAppConfigLoader
     config_file_name = default_config_file_name
     crash_handler_class = IPAppCrashHandler
 
     def create_default_config(self):
         super(IPythonApp, self).create_default_config()
         # Eliminate multiple lookups
         Global = self.default_config.Global
 
         # Set all default values
         Global.display_banner = True
         
         # If the -c flag is given or a file is given to run at the cmd line
         # like "ipython foo.py", normally we exit without starting the main
         # loop.  The force_interact config variable allows a user to override
         # this and interact.  It is also set by the -i cmd line flag, just
         # like Python.
         Global.force_interact = False
 
         # By default always interact by starting the IPython mainloop.
         Global.interact = True
 
         # No GUI integration by default
         Global.gui = False
         # Pylab off by default
         Global.pylab = False
 
         # Deprecated versions of gui support that used threading, we support
         # them just for bacwards compatibility as an alternate spelling for
         # '--gui X'
         Global.qthread = False
         Global.q4thread = False
         Global.wthread = False
         Global.gthread = False
 
     def load_file_config(self):
         if hasattr(self.command_line_config.Global, 'quick'):
             if self.command_line_config.Global.quick:
                 self.file_config = Config()
                 return
         super(IPythonApp, self).load_file_config()
 
     def post_load_file_config(self):
         if hasattr(self.command_line_config.Global, 'extra_extension'):
             if not hasattr(self.file_config.Global, 'extensions'):
                 self.file_config.Global.extensions = []
             self.file_config.Global.extensions.append(
                 self.command_line_config.Global.extra_extension)
             del self.command_line_config.Global.extra_extension
 
     def pre_construct(self):
         config = self.master_config
 
         if hasattr(config.Global, 'classic'):
             if config.Global.classic:
                 config.InteractiveShell.cache_size = 0
                 config.InteractiveShell.pprint = 0
                 config.InteractiveShell.prompt_in1 = '>>> '
                 config.InteractiveShell.prompt_in2 = '... '
                 config.InteractiveShell.prompt_out = ''
                 config.InteractiveShell.separate_in = \
                     config.InteractiveShell.separate_out = \
                     config.InteractiveShell.separate_out2 = ''
                 config.InteractiveShell.colors = 'NoColor'
                 config.InteractiveShell.xmode = 'Plain'
 
         if hasattr(config.Global, 'nosep'):
             if config.Global.nosep:
                 config.InteractiveShell.separate_in = \
                 config.InteractiveShell.separate_out = \
                 config.InteractiveShell.separate_out2 = ''
 
         # if there is code of files to run from the cmd line, don't interact
         # unless the -i flag (Global.force_interact) is true.
         code_to_run = config.Global.get('code_to_run','')
         file_to_run = False
         if self.extra_args and self.extra_args[0]:
                 file_to_run = True
         if file_to_run or code_to_run:
             if not config.Global.force_interact:
                 config.Global.interact = False
 
     def construct(self):
         # I am a little hesitant to put these into InteractiveShell itself.
         # But that might be the place for them
         sys.path.insert(0, '')
 
         # Create an InteractiveShell instance
         self.shell = InteractiveShell(None, self.master_config)
 
     def post_construct(self):
         """Do actions after construct, but before starting the app."""
         config = self.master_config
         
         # shell.display_banner should always be False for the terminal 
         # based app, because we call shell.show_banner() by hand below
         # so the banner shows *before* all extension loading stuff.
         self.shell.display_banner = False
 
         if config.Global.display_banner and \
             config.Global.interact:
             self.shell.show_banner()
 
         # Make sure there is a space below the banner.
         if self.log_level <= logging.INFO: print
 
         # Now a variety of things that happen after the banner is printed.
         self._enable_gui_pylab()
         self._load_extensions()
         self._run_exec_lines()
         self._run_exec_files()
         self._run_cmd_line_code()
 
     def _enable_gui_pylab(self):
         """Enable GUI event loop integration, taking pylab into account."""
         Global = self.master_config.Global
 
         # Select which gui to use
         if Global.gui:
             gui = Global.gui
         # The following are deprecated, but there's likely to be a lot of use
         # of this form out there, so we might as well support it for now.  But
         # the --gui option above takes precedence.
         elif Global.wthread:
             gui = inputhook.GUI_WX
         elif Global.qthread:
             gui = inputhook.GUI_QT
         elif Global.gthread:
             gui = inputhook.GUI_GTK
         else:
             gui = None
 
         # Using --pylab will also require gui activation, though which toolkit
         # to use may be chosen automatically based on mpl configuration.
         if Global.pylab:
             activate = self.shell.enable_pylab
             if Global.pylab == 'auto':
                 gui = None
             else:
                 gui = Global.pylab
         else:
             # Enable only GUI integration, no pylab
             activate = inputhook.enable_gui
 
         if gui or Global.pylab:
             try:
                 self.log.info("Enabling GUI event loop integration, "
                               "toolkit=%s, pylab=%s" % (gui, Global.pylab) )
                 activate(gui)
             except:
                 self.log.warn("Error in enabling GUI event loop integration:")
                 self.shell.showtraceback()
 
     def _load_extensions(self):
         """Load all IPython extensions in Global.extensions.
 
         This uses the :meth:`InteractiveShell.load_extensions` to load all
         the extensions listed in ``self.master_config.Global.extensions``.
         """
         try:
             if hasattr(self.master_config.Global, 'extensions'):
                 self.log.debug("Loading IPython extensions...")
                 extensions = self.master_config.Global.extensions
                 for ext in extensions:
                     try:
                         self.log.info("Loading IPython extension: %s" % ext)                        
                         self.shell.load_extension(ext)
                     except:
                         self.log.warn("Error in loading extension: %s" % ext)
                         self.shell.showtraceback()
         except:
             self.log.warn("Unknown error in loading extensions:")
             self.shell.showtraceback()
 
     def _run_exec_lines(self):
         """Run lines of code in Global.exec_lines in the user's namespace."""
         try:
             if hasattr(self.master_config.Global, 'exec_lines'):
                 self.log.debug("Running code from Global.exec_lines...")
                 exec_lines = self.master_config.Global.exec_lines
                 for line in exec_lines:
                     try:
                         self.log.info("Running code in user namespace: %s" % line)
                         self.shell.runlines(line)
                     except:
                         self.log.warn("Error in executing line in user namespace: %s" % line)
                         self.shell.showtraceback()
         except:
             self.log.warn("Unknown error in handling Global.exec_lines:")
             self.shell.showtraceback()
 
     def _exec_file(self, fname):
         full_filename = filefind(fname, [u'.', self.ipython_dir])
         if os.path.isfile(full_filename):
             if full_filename.endswith(u'.py'):
                 self.log.info("Running file in user namespace: %s" % full_filename)
                 self.shell.safe_execfile(full_filename, self.shell.user_ns)
             elif full_filename.endswith('.ipy'):
                 self.log.info("Running file in user namespace: %s" % full_filename)
                 self.shell.safe_execfile_ipy(full_filename)
             else:
                 self.log.warn("File does not have a .py or .ipy extension: <%s>" % full_filename)
 
     def _run_exec_files(self):
         try:
             if hasattr(self.master_config.Global, 'exec_files'):
                 self.log.debug("Running files in Global.exec_files...")
                 exec_files = self.master_config.Global.exec_files
                 for fname in exec_files:
                     self._exec_file(fname)
         except:
             self.log.warn("Unknown error in handling Global.exec_files:")
             self.shell.showtraceback()
 
     def _run_cmd_line_code(self):
         if hasattr(self.master_config.Global, 'code_to_run'):
             line = self.master_config.Global.code_to_run
             try:
                 self.log.info("Running code given at command line (-c): %s" % line)
                 self.shell.runlines(line)
             except:
                 self.log.warn("Error in executing line in user namespace: %s" % line)
                 self.shell.showtraceback()
             return
         # Like Python itself, ignore the second if the first of these is present
         try:
             fname = self.extra_args[0]
         except:
             pass
         else:
             try:
                 self._exec_file(fname)
             except:
                 self.log.warn("Error in executing file in user namespace: %s" % fname)
                 self.shell.showtraceback()
 
     def start_app(self):
         if self.master_config.Global.interact:
             self.log.debug("Starting IPython's mainloop...")
             self.shell.mainloop()
         else:
             self.log.debug("IPython not interactive, start_app is no-op...")
 
 
 def load_default_config(ipython_dir=None):
     """Load the default config file from the default ipython_dir.
 
     This is useful for embedded shells.
     """
     if ipython_dir is None:
         ipython_dir = get_ipython_dir()
     cl = PyFileConfigLoader(default_config_file_name, ipython_dir)
     config = cl.load_config()
     return config
 
 
 def launch_new_instance():
     """Create and run a full blown IPython instance"""
     app = IPythonApp()
     app.start()
 
+
+if __name__ == '__main__':
+    launch_new_instance()

IPython/kernel/error.py

@@ -1,207 +1,207 b''
 # encoding: utf-8
 
 """Classes and functions for kernel related errors and exceptions."""
 
 __docformat__ = "restructuredtext en"
 
 # Tell nose to skip this module
 __test__ = {}
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  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 IPython.kernel.core import error
 
 #-------------------------------------------------------------------------------
 # Error classes
 #-------------------------------------------------------------------------------
 
 class KernelError(error.IPythonError):
     pass
 
 class NotDefined(KernelError):
     def __init__(self, name):
         self.name = name
         self.args = (name,)
 
     def __repr__(self):
         return '<NotDefined: %s>' % self.name
     
     __str__ = __repr__
 
 class QueueCleared(KernelError):
     pass
 
 class IdInUse(KernelError):
     pass
 
 class ProtocolError(KernelError):
     pass
 
 class ConnectionError(KernelError):
     pass
 
 class InvalidEngineID(KernelError):
     pass
     
 class NoEnginesRegistered(KernelError):
     pass
     
 class InvalidClientID(KernelError):
     pass
     
 class InvalidDeferredID(KernelError):
     pass
     
 class SerializationError(KernelError):
     pass
     
 class MessageSizeError(KernelError):
     pass
     
 class PBMessageSizeError(MessageSizeError):
     pass
     
 class ResultNotCompleted(KernelError):
     pass
     
 class ResultAlreadyRetrieved(KernelError):
     pass
     
 class ClientError(KernelError):
     pass
 
 class TaskAborted(KernelError):
     pass
 
 class TaskTimeout(KernelError):
     pass
 
 class NotAPendingResult(KernelError):
     pass
 
 class UnpickleableException(KernelError):
     pass
 
 class AbortedPendingDeferredError(KernelError):
     pass
 
 class InvalidProperty(KernelError):
     pass
 
 class MissingBlockArgument(KernelError):
     pass
 
 class StopLocalExecution(KernelError):
     pass
 
 class SecurityError(KernelError):
     pass
 
 class FileTimeoutError(KernelError):
     pass
 
 class TaskRejectError(KernelError):
     """Exception to raise when a task should be rejected by an engine.
     
     This exception can be used to allow a task running on an engine to test
     if the engine (or the user's namespace on the engine) has the needed
     task dependencies.  If not, the task should raise this exception.  For
     the task to be retried on another engine, the task should be created
     with the `retries` argument > 1.
     
     The advantage of this approach over our older properties system is that
     tasks have full access to the user's namespace on the engines and the
     properties don't have to be managed or tested by the controller.
     """
 
 class CompositeError(KernelError):
     def __init__(self, message, elist):
         Exception.__init__(self, *(message, elist))
         # Don't use pack_exception because it will conflict with the .message
         # attribute that is being deprecated in 2.6 and beyond.
         self.msg = message
         self.elist = elist
 
     def _get_engine_str(self, ev):
         try:
             ei = ev._ipython_engine_info
         except AttributeError:
             return '[Engine Exception]'
         else:
             return '[%i:%s]: ' % (ei['engineid'], ei['method'])
 
     def _get_traceback(self, ev):
         try:
             tb = ev._ipython_traceback_text
         except AttributeError:
             return 'No traceback available'
         else:
             return tb
 
     def __str__(self):
         s = str(self.msg)
         for et, ev, etb in self.elist:
             engine_str = self._get_engine_str(ev)
             s = s + '\n' + engine_str + str(et.__name__) + ': ' + str(ev)
         return s
 
     def print_tracebacks(self, excid=None):
         if excid is None:
             for (et,ev,etb) in self.elist:
                 print self._get_engine_str(ev)
                 print self._get_traceback(ev)
                 print
         else:
             try:
                 et,ev,etb = self.elist[excid]
             except:
                 raise IndexError("an exception with index %i does not exist"%excid)
             else:
                 print self._get_engine_str(ev)
                 print self._get_traceback(ev)
     
     def raise_exception(self, excid=0):
         try:
             et,ev,etb = self.elist[excid]
         except:
             raise IndexError("an exception with index %i does not exist"%excid)
         else:
             raise et, ev, etb
 
 def collect_exceptions(rlist, method):
     from twisted.python import failure
 
     elist = []
     for r in rlist:
         if isinstance(r, failure.Failure):
             r.cleanFailure()
             et, ev, etb = r.type, r.value, r.tb
             # Sometimes we could have CompositeError in our list.  Just take
             # the errors out of them and put them in our new list.  This 
             # has the effect of flattening lists of CompositeErrors into one
             # CompositeError
             if et==CompositeError:
                 for e in ev.elist:
                     elist.append(e)
             else:
                 elist.append((et, ev, etb))
     if len(elist)==0:
         return rlist
     else:
         msg = "one or more exceptions from call to method: %s" % (method)
         # This silliness is needed so the debugger has access to the exception
         # instance (e in this case)
         try:
             raise CompositeError(msg, elist)
         except CompositeError, e:
             raise e
-            
 

IPython/testing/iptest.py

@@ -1,488 +1,471 b''
 # -*- coding: utf-8 -*-
 """IPython Test Suite Runner.
 
 This module provides a main entry point to a user script to test IPython
 itself from the command line. There are two ways of running this script:
 
 1. With the syntax `iptest all`.  This runs our entire test suite by
    calling this script (with different arguments) or trial recursively.  This
    causes modules and package to be tested in different processes, using nose
    or trial where appropriate.
 2. With the regular nose syntax, like `iptest -vvs IPython`.  In this form
    the script simply calls nose, but with special command line flags and
    plugins loaded.
 
 For now, this script requires that both nose and twisted are installed.  This
 will change in the future.
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2009  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 os
 import os.path as path
 import signal
 import sys
 import subprocess
 import tempfile
 import time
 import warnings
 
 
 # Ugly,  but necessary hack to ensure the test suite finds our version of
 # IPython and not a possibly different one that may exist system-wide.
 # Note that this must be done here, so the imports that come next work
 # correctly even if IPython isn't installed yet.
 p = os.path
 ippath = p.abspath(p.join(p.dirname(__file__),'..','..'))
 sys.path.insert(0, ippath)
 
 # Note: monkeypatch!
 # We need to monkeypatch a small problem in nose itself first, before importing
 # it for actual use.  This should get into nose upstream, but its release cycle
 # is slow and we need it for our parametric tests to work correctly.
 from IPython.testing import nosepatch
 # Now, proceed to import nose itself
 import nose.plugins.builtin
 from nose.core import TestProgram
 
 # Our own imports
 from IPython.utils.path import get_ipython_module_path
 from IPython.utils.process import find_cmd, pycmd2argv
 from IPython.utils.sysinfo import sys_info
 
 from IPython.testing import globalipapp
 from IPython.testing.plugin.ipdoctest import IPythonDoctest
 
 pjoin = path.join
 
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 
-# By default, we assume IPython has been installed.  But if the test suite is
-# being run from a source tree that has NOT been installed yet, this flag can
-# be set to False by the entry point scripts, to let us know that we must call
-# the source tree versions of the scripts which manipulate sys.path instead of
-# assuming that things exist system-wide.
-INSTALLED = True
 
 #-----------------------------------------------------------------------------
 # Warnings control
 #-----------------------------------------------------------------------------
 # Twisted generates annoying warnings with Python 2.6, as will do other code
 # that imports 'sets' as of today
 warnings.filterwarnings('ignore', 'the sets module is deprecated',
                         DeprecationWarning )
 
 # This one also comes from Twisted
 warnings.filterwarnings('ignore', 'the sha module is deprecated',
                         DeprecationWarning)
 
 # Wx on Fedora11 spits these out
 warnings.filterwarnings('ignore', 'wxPython/wxWidgets release number mismatch',
                         UserWarning)
 
 #-----------------------------------------------------------------------------
 # Logic for skipping doctests
 #-----------------------------------------------------------------------------
 
 def test_for(mod):
     """Test to see if mod is importable."""
     try:
         __import__(mod)
     except (ImportError, RuntimeError):
         # GTK reports Runtime error if it can't be initialized even if  it's
         # importable.
         return False
     else:
         return True
 
 # Global dict where we can store information on what we have and what we don't
 # have available at test run time
 have = {}
 
 have['curses'] = test_for('_curses')
 have['wx'] = test_for('wx')
 have['wx.aui'] = test_for('wx.aui')
 have['zope.interface'] = test_for('zope.interface')
 have['twisted'] = test_for('twisted')
 have['foolscap'] = test_for('foolscap')
 have['objc'] = test_for('objc')
 have['pexpect'] = test_for('pexpect')
 have['gtk'] = test_for('gtk')
 have['gobject'] = test_for('gobject')
 
 #-----------------------------------------------------------------------------
 # Functions and classes
 #-----------------------------------------------------------------------------
 
 def report():
     """Return a string with a summary report of test-related variables."""
 
     out = [ sys_info() ]
 
-    out.append('\nRunning from an installed IPython: %s\n' % INSTALLED)
-
     avail = []
     not_avail = []
     
     for k, is_avail in have.items():
         if is_avail:
             avail.append(k)
         else:
             not_avail.append(k)
 
     if avail:
         out.append('\nTools and libraries available at test time:\n')
         avail.sort()
         out.append('   ' + ' '.join(avail)+'\n')
 
     if not_avail:
         out.append('\nTools and libraries NOT available at test time:\n')
         not_avail.sort()
         out.append('   ' + ' '.join(not_avail)+'\n')
         
     return ''.join(out)
 
 
 def make_exclude():
     """Make patterns of modules and packages to exclude from testing.
     
     For the IPythonDoctest plugin, we need to exclude certain patterns that
     cause testing problems.  We should strive to minimize the number of
     skipped modules, since this means untested code.  As the testing
     machinery solidifies, this list should eventually become empty.
     These modules and packages will NOT get scanned by nose at all for tests.
     """
     # Simple utility to make IPython paths more readably, we need a lot of
     # these below
     ipjoin = lambda *paths: pjoin('IPython', *paths)
     
     exclusions = [ipjoin('external'),
                   ipjoin('frontend', 'process', 'winprocess.py'),
                   # Deprecated old Shell and iplib modules, skip to avoid
                   # warnings
                   ipjoin('Shell'),
                   ipjoin('iplib'),
                   pjoin('IPython_doctest_plugin'),
                   ipjoin('quarantine'),
                   ipjoin('deathrow'),
                   ipjoin('testing', 'attic'),
                   # This guy is probably attic material
                   ipjoin('testing', 'mkdoctests'),
                   # Testing inputhook will need a lot of thought, to figure out
                   # how to have tests that don't lock up with the gui event
                   # loops in the picture
                   ipjoin('lib', 'inputhook'),
                   # Config files aren't really importable stand-alone
                   ipjoin('config', 'default'),
                   ipjoin('config', 'profile'),
                   ]
 
     if not have['wx']:
         exclusions.append(ipjoin('gui'))
         exclusions.append(ipjoin('frontend', 'wx'))
         exclusions.append(ipjoin('lib', 'inputhookwx'))
 
     if not have['gtk'] or not have['gobject']:
         exclusions.append(ipjoin('lib', 'inputhookgtk'))
 
     if not have['wx.aui']:
         exclusions.append(ipjoin('gui', 'wx', 'wxIPython'))
 
     if not have['objc']:
         exclusions.append(ipjoin('frontend', 'cocoa'))
 
     # These have to be skipped on win32 because the use echo, rm, cd, etc.
     # See ticket https://bugs.launchpad.net/bugs/366982
     if sys.platform == 'win32':
         exclusions.append(ipjoin('testing', 'plugin', 'test_exampleip'))
         exclusions.append(ipjoin('testing', 'plugin', 'dtexample'))
 
     if not have['pexpect']:
         exclusions.extend([ipjoin('scripts', 'irunner'),
                            ipjoin('lib', 'irunner')])
 
     # This is scary.  We still have things in frontend and testing that
     # are being tested by nose that use twisted.  We need to rethink
     # how we are isolating dependencies in testing.
     if not (have['twisted'] and have['zope.interface'] and have['foolscap']):
         exclusions.extend(
             [ipjoin('frontend', 'asyncfrontendbase'),
              ipjoin('frontend', 'prefilterfrontend'),
              ipjoin('frontend', 'frontendbase'),
              ipjoin('frontend', 'linefrontendbase'),
              ipjoin('frontend', 'tests', 'test_linefrontend'),
              ipjoin('frontend', 'tests', 'test_frontendbase'),
              ipjoin('frontend', 'tests', 'test_prefilterfrontend'),
              ipjoin('frontend', 'tests', 'test_asyncfrontendbase'),
              ipjoin('testing', 'parametric'),
              ipjoin('testing', 'util'),
              ipjoin('testing', 'tests', 'test_decorators_trial'),
              ] )
 
     # This is needed for the reg-exp to match on win32 in the ipdoctest plugin.
     if sys.platform == 'win32':
         exclusions = [s.replace('\\','\\\\') for s in exclusions]
 
     return exclusions
 
 
 class IPTester(object):
     """Call that calls iptest or trial in a subprocess.
     """
     #: string, name of test runner that will be called
     runner = None
     #: list, parameters for test runner
     params = None
     #: list, arguments of system call to be made to call test runner
     call_args = None
     #: list, process ids of subprocesses we start (for cleanup)
     pids = None
     
     def __init__(self, runner='iptest', params=None):
         """Create new test runner."""
         p = os.path
         if runner == 'iptest':
-            if INSTALLED:
-                iptest_app = get_ipython_module_path('IPython.testing.iptest')
-                self.runner = pycmd2argv(iptest_app) + sys.argv[1:]
-            else:
-                # Find our own 'iptest' script OS-level entry point.  Don't
-                # look system-wide, so we are sure we pick up *this one*.  And
-                # pass through to subprocess call our own sys.argv
-                ippath = p.abspath(p.join(p.dirname(__file__),'..','..'))
-                script = p.join(ippath, 'iptest.py')
-                self.runner = pycmd2argv(script) + sys.argv[1:]
-                
+            iptest_app = get_ipython_module_path('IPython.testing.iptest')
+            self.runner = pycmd2argv(iptest_app) + sys.argv[1:]
         else:
             # For trial, it needs to be installed system-wide
             self.runner = pycmd2argv(p.abspath(find_cmd('trial')))
         if params is None:
             params = []
         if isinstance(params, str):
             params = [params]
         self.params = params
 
         # Assemble call
         self.call_args = self.runner+self.params
 
         # Store pids of anything we start to clean up on deletion, if possible
         # (on posix only, since win32 has no os.kill)
         self.pids = []
 
     if sys.platform == 'win32':
         def _run_cmd(self):
             # On Windows, use os.system instead of subprocess.call, because I
             # was having problems with subprocess and I just don't know enough
             # about win32 to debug this reliably.  Os.system may be the 'old
             # fashioned' way to do it, but it works just fine.  If someone
             # later can clean this up that's fine, as long as the tests run
             # reliably in win32.
             return os.system(' '.join(self.call_args))
     else:
         def _run_cmd(self):
             #print >> sys.stderr, '*** CMD:', ' '.join(self.call_args) # dbg
             subp = subprocess.Popen(self.call_args)
             self.pids.append(subp.pid)
             # If this fails, the pid will be left in self.pids and cleaned up
             # later, but if the wait call succeeds, then we can clear the
             # stored pid.
             retcode = subp.wait()
             self.pids.pop()
             return retcode
         
     def run(self):
         """Run the stored commands"""
         try:
             return self._run_cmd()
         except:
             import traceback
             traceback.print_exc()
             return 1  # signal failure
 
     def __del__(self):
         """Cleanup on exit by killing any leftover processes."""
 
         if not hasattr(os, 'kill'):
             return
         
         for pid in self.pids:
             try:
                 print 'Cleaning stale PID:', pid
                 os.kill(pid, signal.SIGKILL)
             except OSError:
                 # This is just a best effort, if we fail or the process was
                 # really gone, ignore it.
                 pass     
 
 
 def make_runners():
     """Define the top-level packages that need to be tested.
     """
 
     # Packages to be tested via nose, that only depend on the stdlib
     nose_pkg_names = ['config', 'core', 'extensions', 'frontend', 'lib',
                      'scripts', 'testing', 'utils' ]
     # The machinery in kernel needs twisted for real testing
     trial_pkg_names = []
 
     if have['wx']:
         nose_pkg_names.append('gui')
 
     # And add twisted ones if conditions are met
     if have['zope.interface'] and have['twisted'] and have['foolscap']:
         # We only list IPython.kernel for testing using twisted.trial as
         # nose and twisted.trial have conflicts that make the testing system
         # unstable.
         trial_pkg_names.append('kernel')
 
     # For debugging this code, only load quick stuff
     #nose_pkg_names = ['core', 'extensions']  # dbg
     #trial_pkg_names = []  # dbg 
 
     # Make fully qualified package names prepending 'IPython.' to our name lists
     nose_packages = ['IPython.%s' % m for m in nose_pkg_names ]
     trial_packages = ['IPython.%s' % m for m in trial_pkg_names ]
 
     # Make runners
     runners = [ (v, IPTester('iptest', params=v)) for v in nose_packages ]
     runners.extend([ (v, IPTester('trial', params=v)) for v in trial_packages ])
     
     return runners
 
 
 def run_iptest():
     """Run the IPython test suite using nose.
     
     This function is called when this script is **not** called with the form
     `iptest all`.  It simply calls nose with appropriate command line flags
     and accepts all of the standard nose arguments.
     """
 
     warnings.filterwarnings('ignore', 
         'This will be removed soon.  Use IPython.testing.util instead')
 
     argv = sys.argv + [ '--detailed-errors',  # extra info in tracebacks
                                                 
                         # Loading ipdoctest causes problems with Twisted, but
                         # our test suite runner now separates things and runs
                         # all Twisted tests with trial.
                         '--with-ipdoctest',
                         '--ipdoctest-tests','--ipdoctest-extension=txt',
                         
                         # We add --exe because of setuptools' imbecility (it
                         # blindly does chmod +x on ALL files).  Nose does the
                         # right thing and it tries to avoid executables,
                         # setuptools unfortunately forces our hand here.  This
                         # has been discussed on the distutils list and the
                         # setuptools devs refuse to fix this problem!
                         '--exe',
                         ]
 
     if nose.__version__ >= '0.11':
         # I don't fully understand why we need this one, but depending on what
         # directory the test suite is run from, if we don't give it, 0 tests
         # get run.  Specifically, if the test suite is run from the source dir
         # with an argument (like 'iptest.py IPython.core', 0 tests are run,
         # even if the same call done in this directory works fine).  It appears
         # that if the requested package is in the current dir, nose bails early
         # by default.  Since it's otherwise harmless, leave it in by default
         # for nose >= 0.11, though unfortunately nose 0.10 doesn't support it.
         argv.append('--traverse-namespace')
 
     # Construct list of plugins, omitting the existing doctest plugin, which
     # ours replaces (and extends).
     plugins = [IPythonDoctest(make_exclude())]
     for p in nose.plugins.builtin.plugins:
         plug = p()
         if plug.name == 'doctest':
             continue
         plugins.append(plug)
 
     # We need a global ipython running in this process
     globalipapp.start_ipython()
     # Now nose can run
     TestProgram(argv=argv, plugins=plugins)
 
 
 def run_iptestall():
     """Run the entire IPython test suite by calling nose and trial.
     
     This function constructs :class:`IPTester` instances for all IPython
     modules and package and then runs each of them.  This causes the modules
     and packages of IPython to be tested each in their own subprocess using
     nose or twisted.trial appropriately.
     """
 
     runners = make_runners()
 
     # Run the test runners in a temporary dir so we can nuke it when finished
     # to clean up any junk files left over by accident.  This also makes it
     # robust against being run in non-writeable directories by mistake, as the
     # temp dir will always be user-writeable.
     curdir = os.getcwd()
     testdir = tempfile.gettempdir()
     os.chdir(testdir)
 
     # Run all test runners, tracking execution time
     failed = []
     t_start = time.time()
     try:
         for (name, runner) in runners:
             print '*'*70
             print 'IPython test group:',name
             res = runner.run()
             if res:
                 failed.append( (name, runner) )
     finally:
         os.chdir(curdir)
     t_end = time.time()
     t_tests = t_end - t_start
     nrunners = len(runners)
     nfail = len(failed)
     # summarize results
     print
     print '*'*70
     print 'Test suite completed for system with the following information:'
     print report()
     print 'Ran %s test groups in %.3fs' % (nrunners, t_tests)
     print
     print 'Status:'
     if not failed:
         print 'OK'
     else:
         # If anything went wrong, point out what command to rerun manually to
         # see the actual errors and individual summary
         print 'ERROR - %s out of %s test groups failed.' % (nfail, nrunners)
         for name, failed_runner in failed:
             print '-'*40
             print 'Runner failed:',name
             print 'You may wish to rerun this one individually, with:'
             print ' '.join(failed_runner.call_args)
             print
 
 
 def main():
     for arg in sys.argv[1:]:
         if arg.startswith('IPython'):
             # This is in-process
             run_iptest()
     else:
         # This starts subprocesses
         run_iptestall()
 
 
 if __name__ == '__main__':
     main()

IPython/testing/tools.py

@@ -1,292 +1,277 b''
 """Generic testing tools that do NOT depend on Twisted.
 
 In particular, this module exposes a set of top-level assert* functions that
 can be used in place of nose.tools.assert* in method generators (the ones in
 nose can not, at least as of nose 0.10.4).
 
 Note: our testing package contains testing.util, which does depend on Twisted
 and provides utilities for tests that manage Deferreds.  All testing support
 tools that only depend on nose, IPython or the standard library should go here
 instead.
 
 
 Authors
 -------
 - Fernando Perez <[e-mail]>
 """
 
 from __future__ import absolute_import
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2009  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
 import re
 import sys
 
 try:
     # These tools are used by parts of the runtime, so we make the nose
     # dependency optional at this point.  Nose is a hard dependency to run the
     # test suite, but NOT to use ipython itself.
     import nose.tools as nt
     has_nose = True
 except ImportError:
     has_nose = False
 
 from IPython.config.loader import Config
 from IPython.utils.process import find_cmd, getoutputerror
 from IPython.utils.text import list_strings
 from IPython.utils.io import temp_pyfile
 
 from . import decorators as dec
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 
-# By default, we assume IPython has been installed.  But if the test suite is
-# being run from a source tree that has NOT been installed yet, this flag can
-# be set to False by the entry point scripts, to let us know that we must call
-# the source tree versions of the scripts which manipulate sys.path instead of
-# assuming that things exist system-wide.
-INSTALLED = True
-
 # Make a bunch of nose.tools assert wrappers that can be used in test
 # generators.  This will expose an assert* function for each one in nose.tools.
 
 _tpl = """
 def %(name)s(*a,**kw):
     return nt.%(name)s(*a,**kw)
 """
 
 if has_nose:
     for _x in [a for a in dir(nt) if a.startswith('assert')]:
         exec _tpl % dict(name=_x)
 
 #-----------------------------------------------------------------------------
 # Functions and classes
 #-----------------------------------------------------------------------------
 
 # The docstring for full_path doctests differently on win32 (different path
 # separator) so just skip the doctest there.  The example remains informative.
 doctest_deco = dec.skip_doctest if sys.platform == 'win32' else dec.null_deco
 
 @doctest_deco
 def full_path(startPath,files):
     """Make full paths for all the listed files, based on startPath.
 
     Only the base part of startPath is kept, since this routine is typically
     used with a script's __file__ variable as startPath.  The base of startPath
     is then prepended to all the listed files, forming the output list.
 
     Parameters
     ----------
       startPath : string
         Initial path to use as the base for the results.  This path is split
       using os.path.split() and only its first component is kept.
 
       files : string or list
         One or more files.
 
     Examples
     --------
 
     >>> full_path('/foo/bar.py',['a.txt','b.txt'])
     ['/foo/a.txt', '/foo/b.txt']
 
     >>> full_path('/foo',['a.txt','b.txt'])
     ['/a.txt', '/b.txt']
 
     If a single file is given, the output is still a list:
     >>> full_path('/foo','a.txt')
     ['/a.txt']
     """
 
     files = list_strings(files)
     base = os.path.split(startPath)[0]
     return [ os.path.join(base,f) for f in files ]
 
 
 def parse_test_output(txt):
     """Parse the output of a test run and return errors, failures.
 
     Parameters
     ----------
     txt : str
       Text output of a test run, assumed to contain a line of one of the
       following forms::
         'FAILED (errors=1)'
         'FAILED (failures=1)'
         'FAILED (errors=1, failures=1)'
 
     Returns
     -------
     nerr, nfail: number of errors and failures.
     """
 
     err_m = re.search(r'^FAILED \(errors=(\d+)\)', txt, re.MULTILINE)
     if err_m:
         nerr = int(err_m.group(1))
         nfail = 0
         return  nerr, nfail
     
     fail_m = re.search(r'^FAILED \(failures=(\d+)\)', txt, re.MULTILINE)
     if fail_m:
         nerr = 0
         nfail = int(fail_m.group(1))
         return  nerr, nfail
 
     both_m = re.search(r'^FAILED \(errors=(\d+), failures=(\d+)\)', txt,
                        re.MULTILINE)
     if both_m:
         nerr = int(both_m.group(1))
         nfail = int(both_m.group(2))
         return  nerr, nfail
     
     # If the input didn't match any of these forms, assume no error/failures
     return 0, 0
 
 
 # So nose doesn't think this is a test
 parse_test_output.__test__ = False
 
 
 def default_argv():
     """Return a valid default argv for creating testing instances of ipython"""
 
     return ['--quick', # so no config file is loaded
             # Other defaults to minimize side effects on stdout
             '--colors=NoColor', '--no-term-title','--no-banner',
             '--autocall=0']
 
 
 def default_config():
     """Return a config object with good defaults for testing."""
     config = Config()
     config.InteractiveShell.colors = 'NoColor'
     config.InteractiveShell.term_title = False,
     config.InteractiveShell.autocall = 0
     return config
 
 
 def ipexec(fname, options=None):
     """Utility to call 'ipython filename'.
 
     Starts IPython witha minimal and safe configuration to make startup as fast
     as possible.
 
     Note that this starts IPython in a subprocess!
 
     Parameters
     ----------
     fname : str
       Name of file to be executed (should have .py or .ipy extension).
 
     options : optional, list
       Extra command-line flags to be passed to IPython.
 
     Returns
     -------
     (stdout, stderr) of ipython subprocess.
     """
     if options is None: options = []
     
     # For these subprocess calls, eliminate all prompt printing so we only see
     # output from script execution
     prompt_opts = ['--prompt-in1=""', '--prompt-in2=""', '--prompt-out=""']
     cmdargs = ' '.join(default_argv() + prompt_opts + options)
     
     _ip = get_ipython()
     test_dir = os.path.dirname(__file__)
 
-    # Find the ipython script from the package we're using, so that the test
-    # suite can be run from the source tree without an installed IPython
-    p = os.path
-    if INSTALLED:
-        ipython_cmd = find_cmd('ipython')
-    else:
-        ippath = p.abspath(p.join(p.dirname(__file__),'..','..'))
-        ipython_script = p.join(ippath, 'ipython.py')
-        ipython_cmd = 'python "%s"' % ipython_script
+    ipython_cmd = find_cmd('ipython')
     # Absolute path for filename
-    full_fname = p.join(test_dir, fname)
+    full_fname = os.path.join(test_dir, fname)
     full_cmd = '%s %s %s' % (ipython_cmd, cmdargs, full_fname)
     #print >> sys.stderr, 'FULL CMD:', full_cmd # dbg
     return getoutputerror(full_cmd)
 
 
 def ipexec_validate(fname, expected_out, expected_err='',
                     options=None):
     """Utility to call 'ipython filename' and validate output/error.
 
     This function raises an AssertionError if the validation fails.
 
     Note that this starts IPython in a subprocess!
 
     Parameters
     ----------
     fname : str
       Name of the file to be executed (should have .py or .ipy extension).
 
     expected_out : str
       Expected stdout of the process.
 
     expected_err : optional, str
       Expected stderr of the process.
 
     options : optional, list
       Extra command-line flags to be passed to IPython.
 
     Returns
     -------
     None
     """
 
     import nose.tools as nt
     
     out, err = ipexec(fname)
     #print 'OUT', out  # dbg
     #print 'ERR', err  # dbg
     # If there are any errors, we must check those befor stdout, as they may be
     # more informative than simply having an empty stdout.
     if err:
         if expected_err:
             nt.assert_equals(err.strip(), expected_err.strip())
         else:
             raise ValueError('Running file %r produced error: %r' %
                              (fname, err))
     # If no errors or output on stderr was expected, match stdout
     nt.assert_equals(out.strip(), expected_out.strip())
 
 
 class TempFileMixin(object):
     """Utility class to create temporary Python/IPython files.
 
     Meant as a mixin class for test cases."""
     
     def mktmp(self, src, ext='.py'):
         """Make a valid python temp file."""
         fname, f = temp_pyfile(src, ext)
         self.tmpfile = f
         self.fname = fname
 
     def teardown(self):
         if hasattr(self, 'tmpfile'):
             # If the tmpfile wasn't made because of skipped tests, like in
             # win32, there's nothing to cleanup.
             self.tmpfile.close()
             try:
                 os.unlink(self.fname)
             except:
                 # On Windows, even though we close the file, we still can't
                 # delete it.  I have no clue why
                 pass