Merging with upstream trunk-dev, which is the base for this branch

IPython/utils/baseutils.py

@@ -0,0 +1,51 b''
+"""Base utilities support for IPython.
+
+Warning: this is a module that other utilities modules will import from, so it
+can ONLY depend on the standard library, and NOTHING ELSE.  In particular, this
+module can NOT import anything from IPython, or circular dependencies will arise.
+"""
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+import subprocess
+
+#-----------------------------------------------------------------------------
+# Functions
+#-----------------------------------------------------------------------------
+
+def getoutputerror(cmd,verbose=0,debug=0,header='',split=0):
+    """Return (standard output,standard error) of executing cmd in a shell.
+
+    Accepts the same arguments as system(), plus:
+
+    - split(0): if true, each of stdout/err is returned as a list split on
+    newlines.
+
+    Note: a stateful version of this function is available through the
+    SystemExec class."""
+
+    if verbose or debug: print header+cmd
+    if not cmd:
+        if split:
+            return [],[]
+        else:
+            return '',''
+    if not debug:
+        p = subprocess.Popen(cmd, shell=True,
+                             stdin=subprocess.PIPE,
+                             stdout=subprocess.PIPE,
+                             stderr=subprocess.PIPE,
+                             close_fds=True)
+        pin, pout, perr = (p.stdin, p.stdout, p.stderr)
+
+        tout = pout.read().rstrip()
+        terr = perr.read().rstrip()
+        pin.close()
+        pout.close()
+        perr.close()
+        if split:
+            return tout.split('\n'),terr.split('\n')
+        else:
+            return tout,terr

iptest.py

@@ -0,0 +1,26 b''
+#!/usr/bin/env python
+"""Test script for IPython.
+
+The actual ipython test script to be installed with 'python setup.py install'
+is in './scripts' directory, and will test IPython from an importable
+location.
+
+This file is here (ipython source root directory) to facilitate non-root
+'zero-installation testing and development' (just copy the source tree
+somewhere and run iptest.py).
+
+You can run this script directly, type -h to see all options."""
+
+# Ensure that the imported IPython packages come from *THIS* IPython, not some
+# other one that may exist system-wide
+import os, sys
+this_dir = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, this_dir)
+
+import IPython.testing.tools as t
+import IPython.testing.iptest as ipt
+t.INSTALLED = False
+ipt.INSTALLED = False
+
+# Now proceed with execution
+execfile(os.path.join(this_dir, 'IPython', 'scripts', 'iptest'))

IPython/core/crashhandler.py

@@ -26,9 +26,12 b' from pprint import pformat'
 # Our own
 from IPython.core import release
 from IPython.core import ultratb
+from IPython.utils.genutils import sys_info
+
 from IPython.external.Itpl import itpl
 
 #****************************************************************************
+
 class CrashHandler(object):
     """Customizable crash handlers for IPython-based systems.
 
@@ -166,21 +169,13 b' $self.bug_tracker'
 
     def make_report(self,traceback):
         """Return a string containing a crash report."""
-        import platform
         
         sec_sep = self.section_sep
         
-        report = []
+        report = ['*'*75+'\n\n'+'IPython post-mortem report\n\n']
         rpt_add = report.append
+        rpt_add(sys_info())
         
-        rpt_add('*'*75+'\n\n'+'IPython post-mortem report\n\n')
-        rpt_add('IPython version: %s \n' % release.version)
-        rpt_add('BZR revision   : %s \n' % release.revision)
-        rpt_add('Platform info  : os.name -> %s, sys.platform -> %s\n' %
-                     (os.name,sys.platform) )
-        rpt_add('               : %s\n' % platform.platform())
-        rpt_add('Python info    : %s\n' % sys.version)	     
-
         try:
             config = pformat(self.app.config)
             rpt_add(sec_sep+'Current user configuration structure:\n\n')

IPython/core/history.py

@@ -85,22 +85,22 b" def magic_history(self, parameter_s = ''):"
     if 'g' in opts:
         init = 1
         final = len(input_hist)
-        parts = parameter_s.split(None,1)
+        parts = parameter_s.split(None, 1)
         if len(parts) == 1:
             parts += '*'
         head, pattern = parts
         pattern = "*" + pattern + "*"
     elif len(args) == 0:
-        final = len(input_hist)
+        final = len(input_hist)-1
         init = max(1,final-default_length)
     elif len(args) == 1:
         final = len(input_hist)
-        init = max(1,final-int(args[0]))
+        init = max(1, final-int(args[0]))
     elif len(args) == 2:
-        init,final = map(int,args)
+        init, final = map(int, args)
     else:
         warn('%hist takes 0, 1 or 2 arguments separated by spaces.')
-        print self.magic_hist.__doc__
+        print >> Term.cout, self.magic_hist.__doc__
         return
     
     width = len(str(final))
@@ -114,13 +114,14 b" def magic_history(self, parameter_s = ''):"
         sh = self.shadowhist.all()
         for idx, s in sh:
             if fnmatch.fnmatch(s, pattern):
-                print "0%d: %s" %(idx, s)
+                print >> outfile, "0%d: %s" %(idx, s)
                 found = True
     
     if found:
-        print "==="
-        print "shadow history ends, fetch by %rep <number> (must start with 0)"
-        print "=== start of normal history ==="
+        print >> outfile, "==="
+        print >> outfile, \
+              "shadow history ends, fetch by %rep <number> (must start with 0)"
+        print >> outfile, "=== start of normal history ==="
         
     for in_num in range(init,final):        
         inline = input_hist[in_num]
@@ -130,7 +131,7 b" def magic_history(self, parameter_s = ''):"
         multiline = int(inline.count('\n') > 1)
         if print_nums:
             print >> outfile, \
-                  '%s:%s' % (str(in_num).ljust(width),line_sep[multiline]),
+                  '%s:%s' % (str(in_num).ljust(width), line_sep[multiline]),
         if pyprompts:
             print >> outfile, '>>>',
             if multiline:
@@ -141,9 +142,10 b" def magic_history(self, parameter_s = ''):"
                 print >> outfile, inline,
         else:
             print >> outfile, inline,
-        output = self.shell.user_ns['Out'].get(in_num)
-        if output is not None:
-            print repr(output)
+        if print_outputs:
+            output = self.shell.user_ns['Out'].get(in_num)
+            if output is not None:
+                print >> outfile, repr(output)
 
     if close_at_end:
         outfile.close()

IPython/core/iplib.py

@@ -219,14 +219,21 b' def make_user_namespaces(user_ns=None, user_global_ns=None):'
         of the interpreter and a dict to be used as the global namespace.
     """
 
+
+    # We must ensure that __builtin__ (without the final 's') is always
+    # available and pointing to the __builtin__ *module*.  For more details:
+    # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
+
     if user_ns is None:
         # Set __name__ to __main__ to better match the behavior of the
         # normal interpreter.
         user_ns = {'__name__'     :'__main__',
+                   '__builtin__' : __builtin__,
                    '__builtins__' : __builtin__,
                   }
     else:
         user_ns.setdefault('__name__','__main__')
+        user_ns.setdefault('__builtin__',__builtin__)
         user_ns.setdefault('__builtins__',__builtin__)
 
     if user_global_ns is None:
@@ -970,8 +977,20 b' class InteractiveShell(Component, Magic):'
         # user_ns, and we sync that contents into user_config_ns so that these
         # initial variables aren't shown by %who.  After the sync, we add the
         # rest of what we *do* want the user to see with %who even on a new
-        # session.
-        ns = {}
+        # session (probably nothing, so theye really only see their own stuff)
+
+        # The user dict must *always* have a __builtin__ reference to the
+        # Python standard __builtin__ namespace,  which must be imported.
+        # This is so that certain operations in prompt evaluation can be
+        # reliably executed with builtins.  Note that we can NOT use
+        # __builtins__ (note the 's'),  because that can either be a dict or a
+        # module, and can even mutate at runtime, depending on the context
+        # (Python makes no guarantees on it).  In contrast, __builtin__ is
+        # always a module object, though it must be explicitly imported.
+        
+        # For more details:
+        # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
+        ns = dict(__builtin__ = __builtin__)
         
         # Put 'help' in the user namespace
         try:
@@ -987,20 +1006,23 b' class InteractiveShell(Component, Magic):'
 
         ns['_sh'] = shadowns
 
-        # Sync what we've added so far to user_config_ns so these aren't seen
-        # by %who
-        self.user_config_ns.update(ns)
-
-        # Now, continue adding more contents
-
-        # user aliases to input and output histories
+        # user aliases to input and output histories.  These shouldn't show up
+        # in %who, as they can have very large reprs.
         ns['In']  = self.input_hist
         ns['Out'] = self.output_hist
 
         # Store myself as the public api!!!
         ns['get_ipython'] = self.get_ipython
+
+        # Sync what we've added so far to user_config_ns so these aren't seen
+        # by %who
+        self.user_config_ns.update(ns)
+
+        # Anything put into ns now would show up in %who.  Think twice before
+        # putting anything here, as we really want %who to show the user their
+        # stuff, not our variables.
         
-        # And update the real user's namespace
+        # Finally, update the real user's namespace
         self.user_ns.update(ns)
 
 

IPython/core/magic.py

@@ -2537,6 +2537,9 b' Defaulting color scheme to \'NoColor\'"""'
 
         self.shell.ask_exit()
 
+    # Add aliases as magics so all common forms work: exit, quit, Exit, Quit.
+    magic_exit = magic_quit = magic_Quit = magic_Exit
+
     #......................................................................
     # Functions to implement unix shell-type things
 

IPython/core/prompts.py

@@ -131,8 +131,14 b' prompt_specials_color = {'
     # Prompt/history count, with the actual digits replaced by dots.  Used
     # mainly in continuation prompts (prompt_in2)
     #r'\D': '${"."*len(str(self.cache.prompt_count))}',
-    # More robust form of the above expression, that uses __builtins__
-    r'\D': '${"."*__builtins__.len(__builtins__.str(self.cache.prompt_count))}',
+
+    # More robust form of the above expression, that uses the __builtin__
+    # module.  Note that we can NOT use __builtins__ (note the 's'), because
+    # that can either be a dict or a module, and can even mutate at runtime,
+    # depending on the context (Python makes no guarantees on it).  In
+    # contrast, __builtin__ is always a module object, though it must be
+    # explicitly imported.
+    r'\D': '${"."*__builtin__.len(__builtin__.str(self.cache.prompt_count))}',
 
     # Current working directory
     r'\w': '${os.getcwd()}',
@@ -215,6 +221,7 b' def str_safe(arg):'
             out = '<ERROR: %s>' % msg
     except Exception,msg:
         out = '<ERROR: %s>' % msg
+        #raise  # dbg
     return out
 
 class BasePrompt(object):

IPython/core/release.py

@@ -23,7 +23,7 b" name = 'ipython'"
 development = True    # change this to False to do a release
 version_base = '0.11'
 branch = 'ipython'
-revision = '1321'
+revision = '1346'
 
 if development:
     if branch == 'ipython':

IPython/core/tests/tclass.py

@@ -13,7 +13,7 b' class C(object):'
         
     def __del__(self):
         print 'tclass.py: deleting object:',self.name
-
+        sys.stdout.flush()
 
 try:
     name = sys.argv[1]
@@ -28,3 +28,4 b' else:'
 # This next print statement is NOT debugging, we're making the check on a
 # completely separate process so we verify by capturing stdout:
 print 'ARGV 1-:', sys.argv[1:]
+sys.stdout.flush()

IPython/core/tests/test_magic.py

@@ -153,7 +153,6 b' def doctest_hist_op():'
     >>> ss
     <...s instance at ...>
     >>> 
-    >>> get_ipython().magic("hist -op")
     """
 
 def test_shist():

IPython/core/tests/test_run.py

@@ -67,7 +67,7 b' def doctest_run_builtins():'
 
     In [6]: t1 = type(__builtins__)
 
-    In [7]: %run "$fname"
+    In [7]: %run $fname
 
     In [7]: f.close()
 
@@ -101,7 +101,7 b' class TestMagicRunPass(tt.TempFileMixin):'
         _ip = get_ipython()
         # This fails on Windows if self.tmpfile.name has spaces or "~" in it.
         # See below and ticket https://bugs.launchpad.net/bugs/366353
-        _ip.magic('run "%s"' % self.fname)
+        _ip.magic('run %s' % self.fname)
 
     def test_builtins_id(self):
         """Check that %run doesn't damage __builtins__ """

IPython/frontend/tests/test_prefilterfrontend.py

@@ -20,7 +20,7 b' import sys'
 from nose.tools import assert_equal
 
 from IPython.frontend.prefilterfrontend import PrefilterFrontEnd
-from IPython.core.ipapi import get as get_ipython0
+from IPython.testing.globalipapp import get_ipython
 from IPython.testing.tools import default_argv
 
 #-----------------------------------------------------------------------------
@@ -60,7 +60,7 b' def isolate_ipython0(func):'
         with arguments.
     """
     def my_func():
-        ip0 = get_ipython0()
+        ip0 = get_ipython()
         if ip0 is None:
             return func()
         # We have a real ipython running...
@@ -169,7 +169,7 b' def test_magic():'
     f.input_buffer += '%who'
     f._on_enter()
     out_value = f.out.getvalue()
-    assert_equal(out_value, 'In\tOut\tget_ipython\t\n')
+    assert_equal(out_value, 'Interactive namespace is empty.\n')
 
 
 @isolate_ipython0

IPython/kernel/__init__.py

@@ -22,4 +22,4 b' __docformat__ = "restructuredtext en"'
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
-from IPython.kernel.error import TaskRejectError
  No newline at end of file
+from IPython.kernel.error import TaskRejectError

IPython/kernel/clusterdir.py

@@ -20,6 +20,7 b' from __future__ import with_statement'
 import os
 import shutil
 import sys
+import warnings
 
 from twisted.python import log
 
@@ -27,13 +28,25 b' from IPython.core import release'
 from IPython.config.loader import PyFileConfigLoader
 from IPython.core.application import Application
 from IPython.core.component import Component
+from IPython.utils.genutils import get_ipython_dir, get_ipython_package_dir
 from IPython.utils.traitlets import Unicode, Bool
 from IPython.utils import genutils
 
 #-----------------------------------------------------------------------------
-# Imports
+# 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)
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
 
 class ClusterDirError(Exception):
     pass
@@ -352,9 +365,6 b' class ApplicationWithClusterDir(Application):'
         self.default_config.Global.cluster_dir = self.cluster_dir
         self.command_line_config.Global.cluster_dir = self.cluster_dir
 
-        # Set the search path to the cluster directory
-        self.config_file_paths = (self.cluster_dir,)
-
     def find_config_file_name(self):
         """Find the config file name for this application."""
         # For this type of Application it should be set as a class attribute.
@@ -362,8 +372,11 b' class ApplicationWithClusterDir(Application):'
             self.log.critical("No config filename found")
 
     def find_config_file_paths(self):
-        # Set the search path to the cluster directory
-        self.config_file_paths = (self.cluster_dir,)
+        # Include our own config directory last, so that users can still find
+        # our shipped copies of builtin config files even if they don't have
+        # them in their ipython cluster directory.
+        conf_dir = os.path.join(get_ipython_package_dir(), 'config', 'default')
+        self.config_file_paths = (self.cluster_dir, conf_dir)
 
     def pre_construct(self):
         # The log and security dirs were set earlier, but here we put them

IPython/kernel/error.py

@@ -17,8 +17,6 b' __test__ = {}'
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
-from twisted.python import failure
-
 from IPython.kernel.core import error
 
 #-------------------------------------------------------------------------------
@@ -179,6 +177,8 b' class CompositeError(KernelError):'
             raise et, ev, etb
 
 def collect_exceptions(rlist, method):
+    from twisted.python import failure
+
     elist = []
     for r in rlist:
         if isinstance(r, failure.Failure):

IPython/scripts/iptest

@@ -3,6 +3,22 b''
 """IPython Test Suite Runner.
 """
 
-from IPython.testing import iptest
+# The tests can't even run if nose isn't available, so might as well  give the
+# user a civilized error message in that case.
 
-iptest.main()
+try:
+    import nose
+except ImportError:
+    error = """\
+ERROR: The IPython test suite requires nose to run.
+
+Please install nose on your system first and try again.
+For information on installing nose, see:
+http://somethingaboutorange.com/mrl/projects/nose
+
+Exiting."""
+    import sys
+    print >> sys.stderr, error
+else:
+    from IPython.testing import iptest
+    iptest.main()

IPython/testing/iptest.py

@@ -16,8 +16,6 b' For now, this script requires that both nose and twisted are installed. This'
 will change in the future.
 """
 
-from __future__ import absolute_import
-
 #-----------------------------------------------------------------------------
 # Module imports
 #-----------------------------------------------------------------------------
@@ -25,6 +23,7 b' from __future__ import absolute_import'
 # Stdlib
 import os
 import os.path as path
+import platform
 import signal
 import sys
 import subprocess
@@ -32,24 +31,46 b' 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 . import nosepatch
+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.core import release
 from IPython.utils import genutils
 from IPython.utils.platutils import find_cmd, FindCmdError
-from . import globalipapp
-from . import tools
-from .plugin.ipdoctest import IPythonDoctest
+from IPython.testing import globalipapp
+from IPython.testing import tools
+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
 #-----------------------------------------------------------------------------
@@ -62,6 +83,10 b" warnings.filterwarnings('ignore', 'the sets module is deprecated',"
 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
 #-----------------------------------------------------------------------------
@@ -70,22 +95,59 b' def test_for(mod):'
     """Test to see if mod is importable."""
     try:
         __import__(mod)
-    except ImportError:
+    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 = [ genutils.sys_info() ]
+
+    out.append('\nRunning from an installed IPython: %s\n' % INSTALLED)
+
+    avail = []
+    not_avail = []
     
-have_curses = test_for('_curses')
-have_wx = test_for('wx')
-have_wx_aui = test_for('wx.aui')
-have_zi = 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')
+    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():
@@ -103,6 +165,10 b' def make_exclude():'
     
     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'),
@@ -118,18 +184,18 b' def make_exclude():'
                   ipjoin('config', 'profile'),
                   ]
 
-    if not have_wx:
+    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:
+    if not have['gtk'] or not have['gobject']:
         exclusions.append(ipjoin('lib', 'inputhookgtk'))
 
-    if not have_wx_aui:
+    if not have['wx.aui']:
         exclusions.append(ipjoin('gui', 'wx', 'wxIPython'))
 
-    if not have_objc:
+    if not have['objc']:
         exclusions.append(ipjoin('frontend', 'cocoa'))
 
     if not sys.platform == 'win32':
@@ -144,14 +210,14 b' def make_exclude():'
     if not os.name == 'posix':
         exclusions.append(ipjoin('utils', 'platutils_posix'))
 
-    if not have_pexpect:
+    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_zi and have_foolscap):
+    if not (have['twisted'] and have['zope.interface'] and have['foolscap']):
         exclusions.extend(
             [ipjoin('frontend', 'asyncfrontendbase'),
              ipjoin('frontend', 'prefilterfrontend'),
@@ -173,10 +239,6 b' def make_exclude():'
     return exclusions
 
 
-#-----------------------------------------------------------------------------
-# Functions and classes
-#-----------------------------------------------------------------------------
-
 class IPTester(object):
     """Call that calls iptest or trial in a subprocess.
     """
@@ -189,24 +251,27 b' class IPTester(object):'
     #: list, process ids of subprocesses we start (for cleanup)
     pids = None
     
-    def __init__(self,runner='iptest',params=None):
+    def __init__(self, runner='iptest', params=None):
         """Create new test runner."""
+        p = os.path
         if runner == 'iptest':
-            # Find our own 'iptest' script OS-level entry point
-            try:
-                iptest_path = os.path.abspath(find_cmd('iptest'))
-            except FindCmdError:
-                # Script not installed (may be the case for testing situations
-                # that are running from a source tree only), pull from internal
-                # path:
-                pak_dir = os.path.abspath(genutils.get_ipython_package_dir())
-                iptest_path = pjoin(pak_dir, 'scripts', 'iptest')
-            self.runner = tools.cmd2argv(iptest_path) + ['-v']
+            if INSTALLED:
+                self.runner = tools.cmd2argv(
+                    p.abspath(find_cmd('iptest'))) + 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 = tools.cmd2argv(script) + sys.argv[1:]
+                
         else:
-            self.runner = tools.cmd2argv(os.path.abspath(find_cmd('trial')))
+            # For trial, it needs to be installed system-wide
+            self.runner = tools.cmd2argv(p.abspath(find_cmd('trial')))
         if params is None:
             params = []
-        if isinstance(params,str):
+        if isinstance(params, str):
             params = [params]
         self.params = params
 
@@ -228,6 +293,7 b' class IPTester(object):'
             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
@@ -266,31 +332,34 b' def make_runners():'
     """Define the top-level packages that need to be tested.
     """
 
-    nose_packages = ['config', 'core', 'extensions', 'frontend', 'lib',
-                     'scripts', 'testing', 'utils',
-                     # Note that we list the kernel here, though the bulk of it
-                     # is twisted-based, because nose picks up doctests that
-                     # twisted doesn't.
-                     'kernel']
-    trial_packages = ['kernel']
-
-    if have_wx:
-        nose_packages.append('gui')
-
-    #nose_packages = ['core']  # dbg
-    #trial_packages = []  # dbg 
+    # 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 = []
 
-    nose_packages = ['IPython.%s' % m for m in nose_packages ]
-    trial_packages = ['IPython.%s' % m for m in trial_packages ]
+    if have['wx']:
+        nose_pkg_names.append('gui')
 
-    # Make runners, most with nose
-    nose_testers = [IPTester(params=v) for v in nose_packages]
-    runners = dict(zip(nose_packages, nose_testers))
     # And add twisted ones if conditions are met
-    if have_zi and have_twisted and have_foolscap:
-        trial_testers = [IPTester('trial',params=v) for v in trial_packages]
-        runners.update(dict(zip(trial_packages,trial_testers)))
-                                 
+    if have['zope.interface'] and have['twisted'] and have['foolscap']:
+        # Note that we list the kernel here, though the bulk of it is
+        # twisted-based, because nose picks up doctests that twisted doesn't.
+        nose_pkg_names.append('kernel')
+        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
 
 
@@ -305,15 +374,14 b' def run_iptest():'
     warnings.filterwarnings('ignore', 
         'This will be removed soon.  Use IPython.testing.util instead')
 
-    argv = sys.argv + [ '--detailed-errors',
+    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',
                         
-                        #'-x','-s',  # dbg
-                        
                         # 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,
@@ -323,21 +391,19 b' def run_iptest():'
                         '--exe',
                         ]
 
-    # Detect if any tests were required by explicitly calling an IPython
-    # submodule or giving a specific path
-    has_tests = False
-    for arg in sys.argv:
-        if 'IPython' in arg or arg.endswith('.py') or \
-           (':' in arg and  '.py' in arg):
-            has_tests = True
-            break
-        
-    # If nothing was specifically requested, test full IPython
-    if not has_tests:
-        argv.append('IPython')
-
-    ## # Construct list of plugins, omitting the existing doctest plugin, which
-    ## # ours replaces (and extends).
+    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()
@@ -348,7 +414,7 b' def run_iptest():'
     # We need a global ipython running in this process
     globalipapp.start_ipython()
     # Now nose can run
-    TestProgram(argv=argv,plugins=plugins)
+    TestProgram(argv=argv, plugins=plugins)
 
 
 def run_iptestall():
@@ -371,15 +437,15 b' def run_iptestall():'
     os.chdir(testdir)
 
     # Run all test runners, tracking execution time
-    failed = {}
+    failed = []
     t_start = time.time()
     try:
-        for name,runner in runners.iteritems():
-            print '*'*77
+        for (name, runner) in runners:
+            print '*'*70
             print 'IPython test group:',name
             res = runner.run()
             if res:
-                failed[name] = res
+                failed.append( (name, runner) )
     finally:
         os.chdir(curdir)
     t_end = time.time()
@@ -388,17 +454,19 b' def run_iptestall():'
     nfail = len(failed)
     # summarize results
     print
-    print '*'*77
+    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 in failed:
-            failed_runner = runners[name]
+        for name, failed_runner in failed:
             print '-'*40
             print 'Runner failed:',name
             print 'You may wish to rerun this one individually, with:'
@@ -407,13 +475,13 b' def run_iptestall():'
 
 
 def main():
-    if len(sys.argv) == 1:
-        run_iptestall()
-    else:
-        if sys.argv[1] == 'all':
-            run_iptestall()
-        else:
+    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__':

IPython/testing/tests/test_decorators.py

@@ -114,11 +114,12 b' def test_skip_dt_decorator():'
     # Fetch the docstring from doctest_bad after decoration.
     val = doctest_bad.__doc__
     
-    assert check==val,"doctest_bad docstrings don't match"
+    nt.assert_equal(check,val,"doctest_bad docstrings don't match")
+
 
 # Doctest skipping should work for class methods too
-class foo(object):
-    """Foo
+class FooClass(object):
+    """FooClass
 
     Example:
 
@@ -128,22 +129,22 b' class foo(object):'
 
     @dec.skip_doctest
     def __init__(self,x):
-        """Make a foo.
+        """Make a FooClass.
 
         Example:
 
-        >>> f = foo(3)
+        >>> f = FooClass(3)
         junk
         """
-        print 'Making a foo.'
+        print 'Making a FooClass.'
         self.x = x
         
     @dec.skip_doctest
     def bar(self,y):
         """Example:
 
-        >>> f = foo(3)
-        >>> f.bar(0)
+        >>> ff = FooClass(3)
+        >>> ff.bar(0)
         boom!
         >>> 1/0
         bam!
@@ -153,15 +154,14 b' class foo(object):'
     def baz(self,y):
         """Example:
 
-        >>> f = foo(3)
-        Making a foo.
-        >>> f.baz(3)
+        >>> ff2 = FooClass(3)
+        Making a FooClass.
+        >>> ff2.baz(3)
         True
         """
         return self.x==y
 
 
-
 def test_skip_dt_decorator2():
     """Doctest-skipping decorator should preserve function signature.
     """

IPython/testing/tools.py

@@ -49,6 +49,13 b' 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.
 
@@ -209,14 +216,10 b" def temp_pyfile(src, ext='.py'):"
 def default_argv():
     """Return a valid default argv for creating testing instances of ipython"""
 
-    # Get the install directory for the user configuration and tell ipython to
-    # use the default profile from there.
-    from IPython.config import default
-    ipcdir = os.path.dirname(default.__file__)
-    ipconf = os.path.join(ipcdir,'ipython_config.py')
-    return ['--colors=NoColor', '--no-term-title','--no-banner',
-            '--config-file="%s"' % ipconf, '--autocall=0',
-            '--prompt-out=""']
+    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 ipexec(fname, options=None):
@@ -240,22 +243,32 b' def ipexec(fname, options=None):'
     (stdout, stderr) of ipython subprocess.
     """
     if options is None: options = []
-    cmdargs = ' '.join(default_argv() + 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
-    ipython_package_dir = genutils.get_ipython_package_dir()
-    ipython_script = os.path.join(ipython_package_dir,'scripts','ipython')
-    ipython_cmd = 'python "%s"' % ipython_script
+    p = os.path
+    if INSTALLED:
+        ipython_cmd = platutils.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
     # Absolute path for filename
-    full_fname = os.path.join(test_dir, fname)
-    full_cmd = '%s %s "%s"' % (ipython_cmd, cmdargs, full_fname)
+    full_fname = p.join(test_dir, fname)
+    full_cmd = '%s %s %s' % (ipython_cmd, cmdargs, full_fname)
+    #print >> sys.stderr, 'FULL CMD:', full_cmd # dbg
     return genutils.getoutputerror(full_cmd)
 
 
-def ipexec_validate(fname, expected_out, expected_err=None,
+def ipexec_validate(fname, expected_out, expected_err='',
                     options=None):
     """Utility to call 'ipython filename' and validate output/error.
 
@@ -285,9 +298,18 b' def ipexec_validate(fname, expected_out, expected_err=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())
-    if expected_err:
-        nt.assert_equals(err.strip(), expected_err.strip())
 
 
 class TempFileMixin(object):

IPython/utils/genutils.py

@@ -11,6 +11,7 b' these things are also convenient when working at the command line.'
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
+from __future__ import absolute_import
 
 #****************************************************************************
 # required modules from the Python standard library
@@ -41,11 +42,12 b' else:'
 
 # Other IPython utilities
 import IPython
+from IPython.core import release
 from IPython.external.Itpl import itpl,printpl
 from IPython.utils import platutils
 from IPython.utils.generics import result_display
 from IPython.external.path import path
-
+from .baseutils import getoutputerror
 
 #****************************************************************************
 # Exceptions
@@ -194,21 +196,49 b' def warn(msg,level=2,exit_val=1):'
             print >> Term.cerr,'Exiting.\n'
             sys.exit(exit_val)
 
+            
 def info(msg):
     """Equivalent to warn(msg,level=1)."""
 
     warn(msg,level=1)
 
+    
 def error(msg):
     """Equivalent to warn(msg,level=3)."""
 
     warn(msg,level=3)
 
+    
 def fatal(msg,exit_val=1):
     """Equivalent to warn(msg,exit_val=exit_val,level=4)."""
 
     warn(msg,exit_val=exit_val,level=4)
 
+def sys_info():
+    """Return useful information about IPython and the system, as a string.
+
+    Examples
+    --------
+    In [1]: print(sys_info())
+    IPython version: 0.11.bzr.r1340   # random
+    BZR revision   : 1340
+    Platform info  : os.name -> posix, sys.platform -> linux2
+                   : Linux-2.6.31-17-generic-i686-with-Ubuntu-9.10-karmic
+    Python info    : 2.6.4 (r264:75706, Dec  7 2009, 18:45:15) 
+    [GCC 4.4.1]
+    """
+    import platform
+    out = []
+    out.append('IPython version: %s' % release.version)
+    out.append('BZR revision   : %s' % release.revision)
+    out.append('Platform info  : os.name -> %s, sys.platform -> %s' %
+               (os.name,sys.platform) )
+    out.append('               : %s' % platform.platform())
+    out.append('Python info    : %s' % sys.version)
+    out.append('')  # ensure closing newline
+    return '\n'.join(out)
+    
+
 #---------------------------------------------------------------------------
 # Debugging routines
 #
@@ -282,6 +312,7 b' except ImportError:'
         This just returns clock() and zero."""
         return time.clock(),0.0
 
+    
 def timings_out(reps,func,*args,**kw):
     """timings_out(reps,func,*args,**kw) -> (t_total,t_per_call,output)
 
@@ -310,6 +341,7 b' def timings_out(reps,func,*args,**kw):'
     av_time = tot_time / reps
     return tot_time,av_time,out
 
+
 def timings(reps,func,*args,**kw):
     """timings(reps,func,*args,**kw) -> (t_total,t_per_call)
 
@@ -319,6 +351,7 b' def timings(reps,func,*args,**kw):'
 
     return timings_out(reps,func,*args,**kw)[0:2]
 
+
 def timing(func,*args,**kw):
     """timing(func,*args,**kw) -> t_total
 
@@ -348,6 +381,7 b' def arg_split(s,posix=False):'
     lex.whitespace_split = True
     return list(lex)
 
+
 def system(cmd,verbose=0,debug=0,header=''):
     """Execute a system command, return its exit status.
 
@@ -369,6 +403,7 b" def system(cmd,verbose=0,debug=0,header=''):"
     if not debug: stat = os.system(cmd)
     return stat
 
+
 def abbrev_cwd():
     """ Return abbreviated version of cwd, e.g. d:mydir """
     cwd = os.getcwd().replace('\\','/')
@@ -439,6 +474,7 b" if os.name in ('nt','dos'):"
 
     shell.__doc__ = shell_ori.__doc__
 
+    
 def getoutput(cmd,verbose=0,debug=0,header='',split=0):
     """Dummy substitute for perl's backquotes.
 
@@ -468,45 +504,11 b" def getoutput(cmd,verbose=0,debug=0,header='',split=0):"
         else:
             return output
 
-def getoutputerror(cmd,verbose=0,debug=0,header='',split=0):
-    """Return (standard output,standard error) of executing cmd in a shell.
-
-    Accepts the same arguments as system(), plus:
-
-    - split(0): if true, each of stdout/err is returned as a list split on
-    newlines.
-
-    Note: a stateful version of this function is available through the
-    SystemExec class."""
-
-    if verbose or debug: print header+cmd
-    if not cmd:
-        if split:
-            return [],[]
-        else:
-            return '',''
-    if not debug:
-        p = subprocess.Popen(cmd, shell=True,
-                             stdin=subprocess.PIPE,
-                             stdout=subprocess.PIPE,
-                             stderr=subprocess.PIPE,
-                             close_fds=True)
-        pin, pout, perr = (p.stdin, p.stdout, p.stderr)
-
-        tout = pout.read().rstrip()
-        terr = perr.read().rstrip()
-        pin.close()
-        pout.close()
-        perr.close()
-        if split:
-            return tout.split('\n'),terr.split('\n')
-        else:
-            return tout,terr
-
 # for compatibility with older naming conventions
 xsys = system
 bq = getoutput
 
+
 class SystemExec:
     """Access the system and getoutput functions through a stateful interface.
 
@@ -635,9 +637,9 b' def filefind(filename, path_dirs=None):'
         testname = expand_path(os.path.join(path, filename))
         if os.path.isfile(testname):
             return os.path.abspath(testname)
-    raise IOError("File does not exist in any "
-                  "of the search paths: %r, %r" % \
-                  (filename, path_dirs))
+        
+    raise IOError("File %r does not exist in any of the search paths: %r" % 
+                  (filename, path_dirs) )
 
 
 #----------------------------------------------------------------------------

IPython/utils/platutils_posix.py

@@ -11,12 +11,25 b' to use these functions in platform agnostic fashion.'
 #  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 sys
 import os
 
+from .baseutils import getoutputerror
+
+#-----------------------------------------------------------------------------
+# Globals
+#-----------------------------------------------------------------------------
+
 ignore_termtitle = True
 
+#-----------------------------------------------------------------------------
+# Functions
+#-----------------------------------------------------------------------------
 
 def _dummy_op(*a, **b):
     """ A no-op function """
@@ -36,7 +49,7 b' else:'
 
 def find_cmd(cmd):
     """Find the full path to a command using which."""
-    return os.popen('which %s' % cmd).read().strip()
+    return getoutputerror('/usr/bin/env which %s' % cmd)[0]
 
 
 def get_long_path_name(path):

IPython/utils/tests/test_imports.py

@@ -1,4 +1,3 b''
-#!/usr/bin/env python
 # encoding: utf-8
 
 def test_import_coloransi():

MANIFEST.in

@@ -1,4 +1,5 b''
 include ipython.py
+include iptest.py
 include setupbase.py
 include setupegg.py
 

README.txt

@@ -5,7 +5,25 b' IPython README'
 Overview
 ========
 
-Welcome to IPython. Our documentation can be found in the docs/source
-subdirectory. We also have ``.html`` and ``.pdf`` versions of this
-documentation available on the IPython `website <http://ipython.scipy.org>`_.
+Welcome to IPython. Our full documentation can be found in the ``docs/dist``
+subdirectory in ``.html`` and ``.pdf`` formats, also available online at our
+`website <http://ipython.scipy.org>`_.  The ``docs/source`` directory contains
+the plaintext version of these manuals.
 
+
+Instant running and testing
+===========================
+
+You can run IPython from this directory without even installing it system-wide
+by typing at the terminal:
+
+.. code-block:: bash
+
+   python ipython.py
+
+and similarly, you can execute the built-in test suite with:
+   
+.. code-block:: bash
+
+   python iptest.py
+   
  No newline at end of file

docs/source/development/testing.txt

@@ -42,7 +42,25 b' manages the Twisted reactor correctly.'
 For the impatient: running the tests
 ====================================
 
-The simplest way to test IPython is to type at the command line:
+You can run IPython from the source download directory without even installing
+it system-wide or having configure anything, by typing at the terminal:
+
+.. code-block:: bash
+
+   python ipython.py
+
+and similarly, you can execute the built-in test suite with:
+   
+.. code-block:: bash
+
+   python iptest.py
+
+
+This script manages intelligently both nose and trial, choosing the correct
+test system for each of IPython's components.
+
+Once you have either installed it or at least configured your system to be
+able to import IPython, you can run the tests with:
 
 .. code-block:: bash
 
@@ -50,57 +68,72 b' The simplest way to test IPython is to type at the command line:'
 
 This should work as long as IPython can be imported, even if you haven't fully
 installed the user-facing scripts yet (common in a development environment).
-After a lot of output, you should see something like:
+Once you have installed IPython, you will have available system-wide a script
+called :file:`iptest` that does the exact same as the :file:`iptest.py` script
+in the source directory, so you can then test simply with:
 
 .. code-block:: bash
-  
-    ************************************************************************
-    Ran 10 test groups in 35.228s
 
-    OK
+   iptest  [args]
 
-If not, there will be a message indicating which test group failed and how to
-rerun that group individually.
 
-But IPython ships with an entry point script called :file:`iptest` that offers
-fine-grain control over the test process and is particularly useful for
-developers; this script also manages intelligently both nose and trial,
-choosing the correct test system for each of IPython's components.  Running
-:file:`iptest` without arguments gives output identical to that above, but with
-it, you can also run specific tests with fine control.  The :file:`iptest`
-script is installed with IPython, but if you are running from a source tree,
-you can find it in the :file:`IPython/scripts` directory and you can run
-directly from there.
+Regardless of how you run things, you should eventually see something like:
 
-For example, this tests the :mod:`IPython.utils` subpackage, the :option:`-v`
-option shows progress indicators:
+.. code-block:: bash
+
+   **********************************************************************
+   Test suite completed for system with the following information:
+   IPython version: 0.11.bzr.r1340
+   BZR revision   : 1340
+   Platform info  : os.name -> posix, sys.platform -> linux2
+		  : Linux-2.6.31-17-generic-i686-with-Ubuntu-9.10-karmic
+   Python info    : 2.6.4 (r264:75706, Dec  7 2009, 18:45:15) 
+   [GCC 4.4.1]
+
+   Running from an installed IPython: True
+
+   Tools and libraries available at test time:
+      curses foolscap gobject gtk pexpect twisted wx wx.aui zope.interface
+
+   Tools and libraries NOT available at test time:
+      objc
+
+   Ran 11 test groups in 36.244s
+
+   Status:
+   OK
+
+If not, there will be a message indicating which test group failed and how to
+rerun that group individually.  For example, this tests the
+:mod:`IPython.utils` subpackage, the :option:`-v` option shows progress
+indicators:
 
 .. code-block:: bash
 
-    maqroll[ipython]> cd IPython/scripts/
-    maqroll[scripts]> ./iptest -v IPython.utils
-    ..........................SS..SSS............................S.S.........
-    ...................................................
-    ----------------------------------------------------------------------
-    Ran 125 tests in 0.070s
+   $ python iptest.py -v IPython.utils
+   ..........................SS..SSS............................S.S...
+   .........................................................
+   ----------------------------------------------------------------------
+   Ran 125 tests in 0.119s
+
+   OK (SKIP=7)
 
-    OK (SKIP=7)
 
-Because :file:`iptest` is based on nose, you can use all nose options and
-syntax, typing ``iptest -h`` shows all available options.  For example, this
-lets you run the specific test :func:`test_rehashx` inside the
+Because the IPython test machinery is based on nose, you can use all nose
+options and syntax, typing ``iptest -h`` shows all available options.  For
+example, this lets you run the specific test :func:`test_rehashx` inside the
 :mod:`test_magic` module:
 
 .. code-block:: bash
 
-    maqroll[scripts]> ./iptest -vv IPython.core.tests.test_magic:test_rehashx
-    IPython.core.tests.test_magic.test_rehashx(True,) ... ok
-    IPython.core.tests.test_magic.test_rehashx(True,) ... ok
+   $ python iptest.py -vv IPython.core.tests.test_magic:test_rehashx
+   IPython.core.tests.test_magic.test_rehashx(True,) ... ok
+   IPython.core.tests.test_magic.test_rehashx(True,) ... ok
 
-    ----------------------------------------------------------------------
-    Ran 2 tests in 0.101s
+   ----------------------------------------------------------------------
+   Ran 2 tests in 0.100s
 
-    OK
+   OK
 
 When developing, the :option:`--pdb` and :option:`--pdb-failures` of nose are
 particularly useful, these drop you into an interactive pdb session at the

ipython.py

@@ -7,6 +7,10 b" in './scripts' directory. This file is here (ipython source root directory)"
 to facilitate non-root 'zero-installation' (just copy the source tree
 somewhere and run ipython.py) and development. """
 
-from IPython.core.ipapp import launch_new_instance
+# Ensure that the imported IPython is the local one, not a system-wide one
+import os, sys
+this_dir = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, this_dir)
 
-launch_new_instance()
+# Now proceed with execution
+execfile(os.path.join(this_dir, 'IPython', 'scripts', 'ipython'))

setup.py

@@ -13,6 +13,23 b' requires utilities which are not available under Windows."""'
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
+#-----------------------------------------------------------------------------
+# Minimal Python version sanity check
+#-----------------------------------------------------------------------------
+
+import sys
+
+# This check is also made in IPython/__init__, don't forget to update both when
+# changing Python version requirements.
+if sys.version[0:3] < '2.5':
+    error = """\
+ERROR: 'IPython requires Python Version 2.5 or above.'
+Exiting."""
+    print >> sys.stderr, error
+    sys.exit(1)
+
+# At least we're on Python 2.5 or newer, move on.
+
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
@@ -20,7 +37,6 b' requires utilities which are not available under Windows."""'
 # Stdlib imports
 import os
 import shutil
-import sys
 
 from glob import glob
 
@@ -30,6 +46,7 b" if os.path.exists('MANIFEST'): os.remove('MANIFEST')"
 
 from distutils.core import setup
 
+# Our own imports
 from IPython.utils.genutils import target_update
 
 from setupbase import (