update zmq dependency to 2.1.4

IPython/zmq/__init__.py

@@ -1,25 +1,25
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2010  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING.txt, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
-# Verify zmq version dependency >= 2.0.10-1
+# Verify zmq version dependency >= 2.1.4
 #-----------------------------------------------------------------------------
 
-minimum_pyzmq_version = "2.0.10-1"
+minimum_pyzmq_version = "2.1.4"
 
 try:
     import zmq
 except ImportError:
     raise ImportError("IPython.zmq requires pyzmq >= %s"%minimum_pyzmq_version)
 
 pyzmq_version = zmq.__version__
 
 if pyzmq_version < minimum_pyzmq_version:
     raise ImportError("IPython.zmq requires pyzmq >= %s, but you have %s"%(
                     minimum_pyzmq_version, pyzmq_version))
 
 del pyzmq_version

docs/source/install/install.txt

@@ -1,332 +1,331
 Overview
 ========
 
 This document describes the steps required to install IPython.  IPython is
 organized into a number of subpackages, each of which has its own dependencies.
 All of the subpackages come with IPython, so you don't need to download and
 install them separately.  However, to use a given subpackage, you will need to
 install all of its dependencies.
 
 
 Please let us know if you have problems installing IPython or any of its
 dependencies. Officially, IPython requires Python version 2.6 or 2.7.  There
 is an experimental port of IPython for Python3 `on GitHub 
 <https://github.com/ipython/ipython-py3k>`_
 
 .. warning::
 
     Officially, IPython supports Python versions 2.6 and 2.7.
 
     IPython 0.11 has a hard syntax dependency on 2.6, and will no longer work
     on Python <= 2.5.
 
 Some of the installation approaches use the :mod:`setuptools` package and its
 :command:`easy_install` command line program.  In many scenarios, this provides
 the most simple method of installing IPython and its dependencies.  It is not
 required though.  More information about :mod:`setuptools` can be found on its
 website.
 
 More general information about installing Python packages can be found in
 Python's documentation at http://www.python.org/doc/.
 
 Quickstart
 ==========
 
 If you have :mod:`setuptools` installed and you are on OS X or Linux (not
 Windows), the following will download and install IPython *and* the main
 optional dependencies:
 
 .. code-block:: bash
 
     $ easy_install ipython[zmq,test]
 
 This will get pyzmq, which is needed for
 IPython's parallel computing features as well as the nose package, which will
 enable you to run IPython's test suite.  
 
 .. warning::
 
     IPython's test system is being refactored and currently the
     :command:`iptest` shown below does not work. More details about the
     testing situation can be found :ref:`here <testing>`
 
 To run IPython's test suite, use the :command:`iptest` command:
 
 .. code-block:: bash
 
     $ iptest
 
 Read on for more specific details and instructions for Windows.
 
 Installing IPython itself
 =========================
 
 Given a properly built Python, the basic interactive IPython shell will work
 with no external dependencies.  However, some Python distributions
 (particularly on Windows and OS X), don't come with a working :mod:`readline`
 module.  The IPython shell will work without :mod:`readline`, but will lack
 many features that users depend on, such as tab completion and command line
 editing.  If you install IPython with :mod:`setuptools`, (e.g. with `easy_install`),
 then the appropriate :mod:`readline` for your platform will be installed.
 See below for details of how to make sure you have a working :mod:`readline`.
 
 Installation using easy_install
 -------------------------------
 
 If you have :mod:`setuptools` installed, the easiest way of getting IPython is
 to simple use :command:`easy_install`:
 
 .. code-block:: bash
 
     $ easy_install ipython
 
 That's it.
 
 Installation from source
 ------------------------
 
 If you don't want to use :command:`easy_install`, or don't have it installed,
 just grab the latest stable build of IPython from `here
 <https://github.com/ipython/ipython/downloads>`_.  Then do the following:
 
 .. code-block:: bash
 
     $ tar -xzf ipython.tar.gz
     $ cd ipython
     $ python setup.py install
 
 If you are installing to a location (like ``/usr/local``) that requires higher
 permissions, you may need to run the last command with :command:`sudo`.
 
 Windows
 -------
 
 There are a few caveats for Windows users.  The main issue is that a basic
 ``python setup.py install`` approach won't create ``.bat`` file or Start Menu
 shortcuts, which most users want.  To get an installation with these, you can
 use any of the following alternatives:
 
 1. Install using :command:`easy_install`.
 
 2. Install using our binary ``.exe`` Windows installer, which can be found
    `here <http://ipython.scipy.org/dist/>`_
 
 3. Install from source, but using :mod:`setuptools` (``python setupegg.py
    install``).
 
 IPython by default runs in a terminal window, but the normal terminal
 application supplied by Microsoft Windows is very primitive.  You may want to
 download the excellent and free Console_ application instead, which is a far
 superior tool.  You can even configure Console to give you by default an
 IPython tab, which is very convenient to create new IPython sessions directly
 from the working terminal.
 
 .. _Console:  http://sourceforge.net/projects/console
 
 Note for Windows 64 bit users: you may have difficulties with the stock
 installer on 64 bit systems; in this case (since we currently do not have 64
 bit builds of the Windows installer) your best bet is to install from source
 with the setuptools method indicated in #3 above.  See `this bug report`_ for
 further details.
 
 .. _this bug report: https://bugs.launchpad.net/ipython/+bug/382214
 
    
 Installing the development version
 ----------------------------------
 
 It is also possible to install the development version of IPython from our
 `Git <http://git-scm.com/>`_ source code repository.  To do this you will
 need to have Git installed on your system.  Then just do:
 
 .. code-block:: bash
 
     $ git clone https://github.com/ipython/ipython.git
     $ cd ipython
     $ python setup.py install
 
 Again, this last step on Windows won't create ``.bat`` files or Start Menu
 shortcuts, so you will have to use one of the other approaches listed above.
 
 Some users want to be able to follow the development branch as it changes.  If
 you have :mod:`setuptools` installed, this is easy. Simply replace the last
 step by:
 
 .. code-block:: bash
 
     $ python setupegg.py develop
 
 This creates links in the right places and installs the command line script to
 the appropriate places.  Then, if you want to update your IPython at any time,
 just do:
 
 .. code-block:: bash
 
     $ git pull
 
 Basic optional dependencies
 ===========================
 
 There are a number of basic optional dependencies that most users will want to
 get.  These are:
 
 * readline (for command line editing, tab completion, etc.)
 * nose (to run the IPython test suite)
 * pexpect (to use things like irunner)
 
 If you are comfortable installing these things yourself, have at it, otherwise
 read on for more details.
 
 readline
 --------
 
 In principle, all Python distributions should come with a working
 :mod:`readline` module.  But, reality is not quite that simple.  There are two
 common situations where you won't have a working :mod:`readline` module:
 
 * If you are using the built-in Python on Mac OS X.
 
 * If you are running Windows, which doesn't have a :mod:`readline` module.
 
 When IPython is installed with :mod:`setuptools`, (e.g. with `easy_install`),
 readline is added as a dependency on OS X, and PyReadline on Windows, and will
 be installed on your system.  However, if you do not use setuptools, you may
 have to install one of these packages yourself.
 
 On OS X, the built-in Python doesn't not have :mod:`readline` because of
 license issues.  Starting with OS X 10.5 (Leopard), Apple's built-in Python has
 a BSD-licensed not-quite-compatible readline replacement. As of IPython 0.9,
 many of the issues related to the differences between readline and libedit seem
 to have been resolved.  While you may find libedit sufficient, we have
 occasional reports of bugs with it and several developers who use OS X as their
 main environment consider libedit unacceptable for productive, regular use with
 IPython.
 
 Therefore, we *strongly* recommend that on OS X you get the full
 :mod:`readline` module.  We will *not* consider completion/history problems to
 be bugs for IPython if you are using libedit.
 
 To get a working :mod:`readline` module, just do (with :mod:`setuptools`
 installed):
 
 .. code-block:: bash
 
     $ easy_install readline
 
 .. note::
 
     Other Python distributions on OS X (such as fink, MacPorts and the official
     python.org binaries) already have readline installed so you likely don't
     have to do this step.
 
 If needed, the readline egg can be build and installed from source (see the
 wiki page at http://ipython.scipy.org/moin/InstallationOSXLeopard).
 
 On Windows, you will need the PyReadline module. PyReadline is a separate,
 Windows only implementation of readline that uses native Windows calls through
 :mod:`ctypes`. The easiest way of installing PyReadline is you use the binary
 installer available `here <https://launchpad.net/pyreadline/+download>`_.
 
 nose
 ----
 
 To run the IPython test suite you will need the :mod:`nose` package.  Nose
 provides a great way of sniffing out and running all of the IPython tests.  The
 simplest way of getting nose, is to use :command:`easy_install`:
 
 .. code-block:: bash
 
     $ easy_install nose
 
 Another way of getting this is to do:
 
 .. code-block:: bash
 
     $ easy_install ipython[test]
 
 For more installation options, see the `nose website
 <http://somethingaboutorange.com/mrl/projects/nose/>`_.  
 
 .. warning::
 
     As described above, the :command:`iptest` command currently doesn't work.
 
 Once you have nose installed, you can run IPython's test suite using the
 iptest command:
 
 .. code-block:: bash
 
     $ iptest
 
 pexpect
 -------
 
 The pexpect package is used in IPython's :command:`irunner` script, as well as
 for managing subprocesses [pexpect]_. IPython now includes a version of pexpect
 in :mod:`IPython.external`, but if you have installed pexpect, IPython will use
 that instead. On Unix platforms (including OS X), just do:
 
 .. code-block:: bash
 
     $ easy_install pexpect
 
 Windows users are out of luck as pexpect does not run there.
 
 Dependencies for IPython.parallel (parallel computing)
 ======================================================
 
 :mod:`IPython.kernel` has been replaced by :mod:`IPython.parallel`, 
 which uses ZeroMQ for all communication.
 
 IPython.parallel provides a nice architecture for parallel computing.  The
 main focus of this architecture is on interactive parallel computing.  These
 features require just one package: pyzmq.  See the next section for pyzmq
 details.
 
 On a Unix style platform (including OS X), if you want to use
 :mod:`setuptools`, you can just do:
 
 .. code-block:: bash
 
     $ easy_install ipython[zmq]    # will include pyzmq
 
 Security in IPython.parallel is provided by SSH tunnels.  By default, Linux
 and OSX clients will use the shell ssh command, but on Windows, we also
 support tunneling with paramiko [paramiko]_.
 
 Dependencies for IPython.zmq
 ============================
 
 pyzmq
 -----
 
 IPython 0.11 introduced some new functionality, including a two-process
 execution model using ZeroMQ for communication [ZeroMQ]_. The Python bindings
 to ZeroMQ are found in the pyzmq project, which is easy_install-able once you
-have ZeroMQ installed (or even if you don't).
+have ZeroMQ installed.  If you are on Python 2.6 or 2.7 on OSX, or 2.7 on Windows,
+pyzmq has eggs that include ZeroMQ itself.
 
-IPython.zmq depends on pyzmq >= 2.0.10.1, but IPython.parallel requires the more
-recent 2.1.4.  2.1.4 also has binary releases for OSX and Windows, that do not
-require prior installation of libzmq.
+IPython.zmq depends on pyzmq >= 2.1.4.
 
 Dependencies for ipython-qtconsole (new GUI)
 ============================================
 
 PyQt
 ----
 
 Also with 0.11, a new GUI was added using the work in :mod:`IPython.zmq`,
 which can be launched with ``ipython-qtconsole``. The GUI is built on PyQt ,
 which can be installed from the 
 `PyQt website <http://www.riverbankcomputing.co.uk/>`_.
 
 pygments
 --------
 
 The syntax-highlighting in ``ipython-qtconsole`` is done with the pygments project, 
 which is easy_install-able [pygments]_.
 
 .. [ZeroMQ] ZeroMQ.  http://www.zeromq.org
 .. [paramiko] paramiko. https://github.com/robey/paramiko
 .. [pygments] Pygments syntax highlighting. http://pygments.org
 .. [pexpect] Pexpect. http://www.noah.org/wiki/Pexpect

setup.py

@@ -1,261 +1,261
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 """Setup script for IPython.
 
 Under Posix environments it works like a typical setup.py script. 
 Under Windows, the command sdist is not supported, since IPython 
 requires utilities which are not available under Windows."""
 
 #-----------------------------------------------------------------------------
 #  Copyright (c) 2008-2010, IPython Development Team.
 #  Copyright (c) 2001-2007, Fernando Perez <[e-mail]>
 #  Copyright (c) 2001, Janko Hauser <[e-mail]>
 #  Copyright (c) 2001, Nathaniel Gray <[e-mail]>
 #
 #  Distributed under the terms of the Modified BSD License.
 #
 #  The full license is in the file COPYING.txt, distributed with 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.6':
     error = """\
 ERROR: 'IPython requires Python Version 2.6 or above.'
 Exiting."""
     print >> sys.stderr, error
     sys.exit(1)
 
 # At least we're on the python version we need, move on.
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 # Stdlib imports
 import os
 import shutil
 
 from glob import glob
 
 # BEFORE importing distutils, remove MANIFEST. distutils doesn't properly
 # update it when the contents of directories change.
 if os.path.exists('MANIFEST'): os.remove('MANIFEST')
 
 from distutils.core import setup
 
 # Our own imports
 from IPython.utils.path import target_update
 
 from setupbase import (
     setup_args, 
     find_packages, 
     find_package_data, 
     find_scripts,
     find_data_files,
     check_for_dependencies,
     record_commit_info,
 )
 from setupext import setupext
 
 isfile = os.path.isfile
 pjoin = os.path.join
 
 #-----------------------------------------------------------------------------
 # Function definitions
 #-----------------------------------------------------------------------------
 
 def cleanup():
     """Clean up the junk left around by the build process"""
     if "develop" not in sys.argv:
         try:
             shutil.rmtree('ipython.egg-info')
         except:
             try:
                 os.unlink('ipython.egg-info')
             except:
                 pass
 
 #-------------------------------------------------------------------------------
 # Handle OS specific things
 #-------------------------------------------------------------------------------
 
 if os.name == 'posix':
     os_name = 'posix'
 elif os.name in ['nt','dos']:
     os_name = 'windows'
 else:
     print 'Unsupported operating system:',os.name
     sys.exit(1)
 
 # Under Windows, 'sdist' has not been supported.  Now that the docs build with
 # Sphinx it might work, but let's not turn it on until someone confirms that it
 # actually works.
 if os_name == 'windows' and 'sdist' in sys.argv:
     print 'The sdist command is not available under Windows.  Exiting.'
     sys.exit(1)
 
 #-------------------------------------------------------------------------------
 # Things related to the IPython documentation
 #-------------------------------------------------------------------------------
 
 # update the manuals when building a source dist
 if len(sys.argv) >= 2 and sys.argv[1] in ('sdist','bdist_rpm'):
     import textwrap
 
     # List of things to be updated. Each entry is a triplet of args for
     # target_update()
     to_update = [
                   # FIXME - Disabled for now: we need to redo an automatic way
                   # of generating the magic info inside the rst.                
                   #('docs/magic.tex',
                   #['IPython/Magic.py'],
                   #"cd doc && ./update_magic.sh" ),
 
                  ('docs/man/ipcluster.1.gz',
                   ['docs/man/ipcluster.1'],
                   'cd docs/man && gzip -9c ipcluster.1 > ipcluster.1.gz'),
 
                  ('docs/man/ipcontroller.1.gz',
                   ['docs/man/ipcontroller.1'],
                   'cd docs/man && gzip -9c ipcontroller.1 > ipcontroller.1.gz'),
 
                  ('docs/man/ipengine.1.gz',
                   ['docs/man/ipengine.1'],
                   'cd docs/man && gzip -9c ipengine.1 > ipengine.1.gz'),
 
                  ('docs/man/ipython.1.gz',
                   ['docs/man/ipython.1'],
                   'cd docs/man && gzip -9c ipython.1 > ipython.1.gz'),
 
                  ('docs/man/ipython-wx.1.gz',
                   ['docs/man/ipython-wx.1'],
                   'cd docs/man && gzip -9c ipython-wx.1 > ipython-wx.1.gz'),
 
                  ('docs/man/ipythonx.1.gz',
                   ['docs/man/ipythonx.1'],
                   'cd docs/man && gzip -9c ipythonx.1 > ipythonx.1.gz'),
 
                  ('docs/man/irunner.1.gz',
                   ['docs/man/irunner.1'],
                   'cd docs/man && gzip -9c irunner.1 > irunner.1.gz'),
 
                  ('docs/man/pycolor.1.gz',
                   ['docs/man/pycolor.1'],
                   'cd docs/man && gzip -9c pycolor.1 > pycolor.1.gz'),
                  ]
 
     # Only build the docs if sphinx is present
     try:
         import sphinx
     except ImportError:
         pass
     else:
         # The Makefile calls the do_sphinx scripts to build html and pdf, so
         # just one target is enough to cover all manual generation
 
         # First, compute all the dependencies that can force us to rebuild the
         # docs.  Start with the main release file that contains metadata
         docdeps = ['IPython/core/release.py']
         # Inculde all the reST sources
         pjoin = os.path.join
         for dirpath,dirnames,filenames in os.walk('docs/source'):
             if dirpath in ['_static','_templates']:
                 continue
             docdeps += [ pjoin(dirpath,f) for f in filenames
                          if f.endswith('.txt') ]
         # and the examples
         for dirpath,dirnames,filenames in os.walk('docs/example'):
             docdeps += [ pjoin(dirpath,f) for f in filenames
                          if not f.endswith('~') ]
         # then, make them all dependencies for the main PDF (the html will get
         # auto-generated as well).
         to_update.append(
             ('docs/dist/ipython.pdf',
              docdeps,
              "cd docs && make dist")
             )
         
     [ target_update(*t) for t in to_update ]
     
 #---------------------------------------------------------------------------
 # Find all the packages, package data, and data_files
 #---------------------------------------------------------------------------
 
 packages = find_packages()
 package_data = find_package_data()
 data_files = find_data_files()
 
 #---------------------------------------------------------------------------
 # Handle scripts, dependencies, and setuptools specific things
 #---------------------------------------------------------------------------
 
 # For some commands, use setuptools.  Note that we do NOT list install here!
 # If you want a setuptools-enhanced install, just run 'setupegg.py install'
 if len(set(('develop', 'sdist', 'release', 'bdist_egg', 'bdist_rpm',
            'bdist', 'bdist_dumb', 'bdist_wininst', 'install_egg_info',
            'build_sphinx', 'egg_info', 'easy_install', 'upload',
             )).intersection(sys.argv)) > 0:
     import setuptools
 
 # This dict is used for passing extra arguments that are setuptools 
 # specific to setup
 setuptools_extra_args = {}
 
 if 'setuptools' in sys.modules:
     setuptools_extra_args['zip_safe'] = False
     setuptools_extra_args['entry_points'] = find_scripts(True)
     setup_args['extras_require'] = dict(
         parallel = 'pyzmq>=2.1.4',
-        zmq = 'pyzmq>=2.0.10.1',
+        zmq = 'pyzmq>=2.1.4',
         doc='Sphinx>=0.3',
         test='nose>=0.10.1',
     )
     requires = setup_args.setdefault('install_requires', [])
     setupext.display_status = False
     if not setupext.check_for_readline():
         if sys.platform == 'darwin':
             requires.append('readline')
         elif sys.platform.startswith('win'):
             requires.append('pyreadline')
         else:
             pass
             # do we want to install readline here?
     
     # Script to be run by the windows binary installer after the default setup
     # routine, to add shortcuts and similar windows-only things.  Windows
     # post-install scripts MUST reside in the scripts/ dir, otherwise distutils
     # doesn't find them.
     if 'bdist_wininst' in sys.argv:
         if len(sys.argv) > 2 and \
                ('sdist' in sys.argv or 'bdist_rpm' in sys.argv):
             print >> sys.stderr, "ERROR: bdist_wininst must be run alone. Exiting."
             sys.exit(1)
         setup_args['scripts'] = [pjoin('scripts','ipython_win_post_install.py')]
 else:
     # If we are running without setuptools, call this function which will
     # check for dependencies an inform the user what is needed.  This is
     # just to make life easy for users.
     check_for_dependencies()
     setup_args['scripts'] = find_scripts(False)
 
 #---------------------------------------------------------------------------
 # Do the actual setup now
 #---------------------------------------------------------------------------
 
 setup_args['cmdclass'] = {'build_py': record_commit_info('IPython')}
 setup_args['packages'] = packages
 setup_args['package_data'] = package_data
 setup_args['data_files'] = data_files
 setup_args.update(setuptools_extra_args)
 
 
 if __name__ == '__main__':
     setup(**setup_args)
     cleanup()

setupext/setupext.py

@@ -1,163 +1,164
 # encoding: utf-8
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  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
 #-------------------------------------------------------------------------------
 
 import sys, os
 from textwrap import fill
 
 display_status=True
 
 def check_display(f):
     """decorator to allow display methods to be muted by mod.display_status"""
     def maybe_display(*args, **kwargs):
         if display_status:
             return f(*args, **kwargs)
     return maybe_display
 
 @check_display
 def print_line(char='='):
     print char * 76
 
 @check_display
 def print_status(package, status):
     initial_indent = "%22s: " % package
     indent = ' ' * 24
     print fill(str(status), width=76,
                initial_indent=initial_indent,
                subsequent_indent=indent)
 
 @check_display
 def print_message(message):
     indent = ' ' * 24 + "* "
     print fill(str(message), width=76,
                initial_indent=indent,
                subsequent_indent=indent)
 
 @check_display
 def print_raw(section):
     print section
 
 #-------------------------------------------------------------------------------
 # Tests for specific packages
 #-------------------------------------------------------------------------------
 
 def check_for_ipython():
     try:
         import IPython
     except ImportError:
         print_status("IPython", "Not found")
         return False
     else:
         print_status("IPython", IPython.__version__)
         return True
 
 def check_for_sphinx():
     try:
         import sphinx
     except ImportError:
         print_status('sphinx', "Not found (required for building documentation)")
         return False
     else:
         print_status('sphinx', sphinx.__version__) 
         return True
 
 def check_for_pygments():
     try:
         import pygments
     except ImportError:
         print_status('pygments', "Not found (required for syntax highlighting documentation)")
         return False
     else:
         print_status('pygments', pygments.__version__)
         return True
 
 def check_for_nose():
     try:
         import nose
     except ImportError:
         print_status('nose', "Not found (required for running the test suite)")
         return False
     else:
         print_status('nose', nose.__version__)
         return True
 
 def check_for_pexpect():
     try:
         import pexpect
     except ImportError:
         print_status("pexpect", "no (required for running standalone doctests)")
         return False
     else:
         print_status("pexpect", pexpect.__version__)
         return True
 
 def check_for_httplib2():
     try:
         import httplib2
     except ImportError:
         print_status("httplib2", "no (required for blocking http clients)")
         return False
     else:
         print_status("httplib2","yes")
         return True
 
 def check_for_sqlalchemy():
     try:
         import sqlalchemy
     except ImportError:
         print_status("sqlalchemy", "no (required for the ipython1 notebook)")
         return False
     else:
         print_status("sqlalchemy","yes")
         return True
 
 def check_for_simplejson():
     try:
         import simplejson
     except ImportError:
         print_status("simplejson", "no (required for the ipython1 notebook)")
         return False
     else:
         print_status("simplejson","yes")
         return True
 
 def check_for_pyzmq():
     try:
         import zmq
     except ImportError:
         print_status('pyzmq', "no (required for qtconsole and parallel computing capabilities)")
         return False
     else:
-        if zmq.__version__ < '2.0.10':
-            print_status('pyzmq', "no (require >= 2.0.10 for qtconsole and parallel computing capabilities)")
+        if zmq.__version__ < '2.1.4':
+            print_status('pyzmq', "no (have %s, but require >= 2.1.4 for"
+            " qtconsole and parallel computing capabilities)"%zmq.__version__)
             
         else:
             print_status("pyzmq", zmq.__version__)
             return True
 
 def check_for_readline():
     try:
         import readline
     except ImportError:
         try:
             import pyreadline
         except ImportError:
             print_status('readline', "no (required for good interactive behavior)")
             return False
         else:
             print_status('readline', "yes pyreadline-"+pyreadline.release.version)
             return True
     else:
         print_status('readline', "yes")
         return True