More changes to indicate Python 3 requirement

IPython/__init__.py

@@ -1,146 +1,146 b''
 # encoding: utf-8
 """
 IPython: tools for interactive and parallel computing in Python.
 
 http://ipython.org
 """
 #-----------------------------------------------------------------------------
 #  Copyright (c) 2008-2011, 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.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 from __future__ import absolute_import
 
 import os
 import sys
 import warnings
 
 #-----------------------------------------------------------------------------
 # Setup everything
 #-----------------------------------------------------------------------------
 
 # Don't forget to also update setup.py when this changes!
 v = sys.version_info
-if v[:2] < (2,7) or (v[0] >= 3 and v[:2] < (3,3)):
-    raise ImportError('IPython requires Python version 2.7 or 3.3 or above.')
+if v[:2] < (3,3):
+    raise ImportError('IPython requires Python version 3.3 or above.')
 del v
 
 # Make it easy to import extensions - they are always directly on pythonpath.
 # Therefore, non-IPython modules can be added to extensions directory.
 # This should probably be in ipapp.py.
 sys.path.append(os.path.join(os.path.dirname(__file__), "extensions"))
 
 #-----------------------------------------------------------------------------
 # Setup the top level names
 #-----------------------------------------------------------------------------
 
 from .core.getipython import get_ipython
 from .core import release
 from .core.application import Application
 from .terminal.embed import embed
 
 from .core.interactiveshell import InteractiveShell
 from .testing import test
 from .utils.sysinfo import sys_info
 from .utils.frame import extract_module_locals
 
 # Release data
 __author__ = '%s <%s>' % (release.author, release.author_email)
 __license__  = release.license
 __version__  = release.version
 version_info = release.version_info
 
 def embed_kernel(module=None, local_ns=None, **kwargs):
     """Embed and start an IPython kernel in a given scope.
     
     If you don't want the kernel to initialize the namespace
     from the scope of the surrounding function,
     and/or you want to load full IPython configuration,
     you probably want `IPython.start_kernel()` instead.
     
     Parameters
     ----------
     module : ModuleType, optional
         The module to load into IPython globals (default: caller)
     local_ns : dict, optional
         The namespace to load into IPython user namespace (default: caller)
     
     kwargs : various, optional
         Further keyword args are relayed to the IPKernelApp constructor,
         allowing configuration of the Kernel.  Will only have an effect
         on the first embed_kernel call for a given process.
     """
     
     (caller_module, caller_locals) = extract_module_locals(1)
     if module is None:
         module = caller_module
     if local_ns is None:
         local_ns = caller_locals
     
     # Only import .zmq when we really need it
     from ipykernel.embed import embed_kernel as real_embed_kernel
     real_embed_kernel(module=module, local_ns=local_ns, **kwargs)
 
 def start_ipython(argv=None, **kwargs):
     """Launch a normal IPython instance (as opposed to embedded)
     
     `IPython.embed()` puts a shell in a particular calling scope,
     such as a function or method for debugging purposes,
     which is often not desirable.
     
     `start_ipython()` does full, regular IPython initialization,
     including loading startup files, configuration, etc.
     much of which is skipped by `embed()`.
     
     This is a public API method, and will survive implementation changes.
     
     Parameters
     ----------
     
     argv : list or None, optional
         If unspecified or None, IPython will parse command-line options from sys.argv.
         To prevent any command-line parsing, pass an empty list: `argv=[]`.
     user_ns : dict, optional
         specify this dictionary to initialize the IPython user namespace with particular values.
     kwargs : various, optional
         Any other kwargs will be passed to the Application constructor,
         such as `config`.
     """
     from IPython.terminal.ipapp import launch_new_instance
     return launch_new_instance(argv=argv, **kwargs)
 
 def start_kernel(argv=None, **kwargs):
     """Launch a normal IPython kernel instance (as opposed to embedded)
     
     `IPython.embed_kernel()` puts a shell in a particular calling scope,
     such as a function or method for debugging purposes,
     which is often not desirable.
     
     `start_kernel()` does full, regular IPython initialization,
     including loading startup files, configuration, etc.
     much of which is skipped by `embed()`.
     
     Parameters
     ----------
     
     argv : list or None, optional
         If unspecified or None, IPython will parse command-line options from sys.argv.
         To prevent any command-line parsing, pass an empty list: `argv=[]`.
     user_ns : dict, optional
         specify this dictionary to initialize the IPython user namespace with particular values.
     kwargs : various, optional
         Any other kwargs will be passed to the Application constructor,
         such as `config`.
     """
     from IPython.kernel.zmq.kernelapp import launch_new_instance
     return launch_new_instance(argv=argv, **kwargs)
     

README.rst

@@ -1,51 +1,51 b''
 .. image:: https://codecov.io/github/ipython/ipython/coverage.svg?branch=master
     :target: https://codecov.io/github/ipython/ipython?branch=master
 
 .. image:: https://img.shields.io/pypi/dm/IPython.svg           
     :target: https://pypi.python.org/pypi/ipython
 
 .. image:: https://img.shields.io/pypi/v/IPython.svg            
     :target: https://pypi.python.org/pypi/ipython
 
 .. image:: https://img.shields.io/travis/ipython/ipython.svg    
     :target: https://travis-ci.org/ipython/ipython
 
 
 ===========================================
  IPython: Productive Interactive Computing
 ===========================================
 
 Overview
 ========
 
 Welcome to IPython.  Our full documentation is available on `ipython.readthedocs.io
 <https://ipython.readthedocs.io/en/stable/>`_ and contain information on how to install, use
 contribute to the project.
 
-Officially, IPython requires Python version 2.7, or 3.3 and above.
-IPython 1.x is the last IPython version to support Python 2.6 and 3.2.
+Officially, IPython requires Python version 3.3 and above.
+IPython 5.x is the last IPython version to support Python 2.7.
 
 The Notebook, Qt console and a number of other pieces are now parts of *Jupyter*.
 See the `Jupyter installation docs <http://jupyter.readthedocs.io/en/latest/install.html>`__
 if you want to use these.
 
 
 
 
 Developement and Instant runnimg
 ================================
 
 You can find the latest version of the development documentation on `readthedocs
 <http://ipython.readthedocs.io/en/latest/>`_. 
 
 You can run IPython from this directory without even installing it system-wide
 by typing at the terminal::
     
    $ python -m IPython
 
 Or see the `developement installation docs
 <http://ipython.readthedocs.io/en/latest/install/install.html#installing-the-development-version>`_
 for the latest revision on read the docs. 
 
 Documentation and installation instructions for older version of IPython can be
 found on the `IPython website <http://ipython.org/documentation.html>`_

docs/source/install/install.rst

@@ -1,144 +1,144 b''
 .. _install:
 
 Installing IPython
 ==================
 
 
-IPython requires Python 2.7 or ≥ 3.3.
+IPython 6 requires Python ≥ 3.3. IPython 5.x can be installed on Python 2.
 
 
 Quick Install 
 -------------
 
 With ``pip`` already installed :
 
 .. code-block:: bash
 
     $ pip install ipython
 
 This installs IPython as well as its dependencies.
 
 If you want to use IPython with notebooks or the Qt console, you should also
 install Jupyter ``pip install jupyter``.
 
 
 
 Overview
 --------
 
 This document describes in detail the steps required to install IPython. For a
 few quick ways to get started with package managers or full Python
 distributions, see `the install page <http://ipython.org/install.html>`_ of the
 IPython website.
 
 Please let us know if you have problems installing IPython or any of its
 dependencies.
 
 IPython and most dependencies should be installed via :command:`pip`.
 In many scenarios, this is the simplest method of installing Python packages.
 More information about :mod:`pip` can be found on
 `its PyPI page <https://pip.pypa.io>`__.
 
 
 More general information about installing Python packages can be found in
 `Python's documentation <http://docs.python.org>`_.
 
 .. _dependencies:
 
 Dependencies
 ~~~~~~~~~~~~
 
 IPython relies on a number of other Python packages. Installing using a package
 manager like pip or conda will ensure the necessary packages are installed.
 Manual installation without dependencies is possible, but not recommended.
 The dependencies can be viewed with package manager commands,
 such as :command:`pip show ipython` or :command:`conda info ipython`.
 
 
 Installing IPython itself
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 
 IPython requires several dependencies to work correctly, it is not recommended
 to install IPython and all its dependencies manually as this can be quite long
 and troublesome. You should use the python package manager ``pip``.
 
 Installation using pip
 ~~~~~~~~~~~~~~~~~~~~~~
 
 Make sure you have the latest version of :mod:`pip` (the Python package
 manager) installed. If you do not, head to `Pip documentation
 <https://pip.pypa.io/en/stable/installing/>`_ and install :mod:`pip` first.
 
 The quickest way to get up and running with IPython is to install it with pip:
 
 .. code-block:: bash
 
     $ pip install ipython
 
 That's it.
 
 
 Installation from source
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
 If you don't want to use :command:`pip`, or don't have it installed,
 grab the latest stable tarball of IPython `from PyPI
 <https://pypi.python.org/pypi/ipython>`__.  Then do the following:
 
 .. code-block:: bash
 
     $ tar -xzf ipython.tar.gz
     $ cd ipython
     $ pip install .
 
 Do not invoke ``setup.py`` directly as this can have undesirable consequences
 for further upgrades. Try to also avoid any usage of ``easy_install`` that can
 have similar undesirable consequences.
 
 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`. You can
 also install in user specific location by using the ``--user`` flag in
 conjunction with pip.
 
 To run IPython's test suite, use the :command:`iptest` command from outside of
 the IPython source tree:
 
 .. code-block:: bash
 
     $ iptest
 
 .. _devinstall:
 
 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 do:
 
 .. code-block:: bash
 
     $ git clone https://github.com/ipython/ipython.git
     $ cd ipython
     $ pip install -e .
 
 The :command:`pip install -e .` command allows users and developers to follow
 the development branch as it changes by creating links in the right places and
 installing the command line scripts to the appropriate locations.
 
 Then, if you want to update your IPython at any time, do:
 
 .. code-block:: bash
 
     $ git pull
 
 If the dependencies or entrypoints have changed, you may have to run
 
 .. code-block:: bash
 
     $ pip install -e .
 
 again, but this is infrequent.

setup.py

@@ -1,288 +1,289 b''
 #!/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-2011, 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.rst, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Minimal Python version sanity check
 #-----------------------------------------------------------------------------
 from __future__ import print_function
 
 import sys
 
 # This check is also made in IPython/__init__, don't forget to update both when
 # changing Python version requirements.
 v = sys.version_info
-if v[:2] < (2,7) or (v[0] >= 3 and v[:2] < (3,3)):
-    error = "ERROR: IPython requires Python version 2.7 or 3.3 or above."
+if v[:2] < (3,3):
+    error = "ERROR: IPython requires Python version 3.3 or above."
     print(error, file=sys.stderr)
     sys.exit(1)
 
 PY3 = (sys.version_info[0] >= 3)
 
 # At least we're on the python version we need, move on.
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 # Stdlib imports
 import os
 
 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 setupbase import target_update
 
 from setupbase import (
     setup_args,
     find_packages,
     find_package_data,
     check_package_data_first,
     find_entry_points,
     build_scripts_entrypt,
     find_data_files,
     git_prebuild,
     install_symlinked,
     install_lib_symlink,
     install_scripts_for_symlink,
     unsymlink,
 )
 
 isfile = os.path.isfile
 pjoin = os.path.join
 
 #-------------------------------------------------------------------------------
 # Handle OS specific things
 #-------------------------------------------------------------------------------
 
 if os.name in ('nt','dos'):
     os_name = 'windows'
 else:
     os_name = os.name
 
 # 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'):
 
     # List of things to be updated. Each entry is a triplet of args for
     # target_update()
     to_update = [
                  ('docs/man/ipython.1.gz',
                   ['docs/man/ipython.1'],
                   'cd docs/man && gzip -9c ipython.1 > ipython.1.gz'),
                  ]
 
 
     [ 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()
 
 setup_args['packages'] = packages
 setup_args['package_data'] = package_data
 setup_args['data_files'] = data_files
 
 #---------------------------------------------------------------------------
 # custom distutils commands
 #---------------------------------------------------------------------------
 # imports here, so they are after setuptools import if there was one
 from distutils.command.sdist import sdist
 from distutils.command.upload import upload
 
 class UploadWindowsInstallers(upload):
 
     description = "Upload Windows installers to PyPI (only used from tools/release_windows.py)"
     user_options = upload.user_options + [
         ('files=', 'f', 'exe file (or glob) to upload')
     ]
     def initialize_options(self):
         upload.initialize_options(self)
         meta = self.distribution.metadata
         base = '{name}-{version}'.format(
             name=meta.get_name(),
             version=meta.get_version()
         )
         self.files = os.path.join('dist', '%s.*.exe' % base)
 
     def run(self):
         for dist_file in glob(self.files):
             self.upload_file('bdist_wininst', 'any', dist_file)
 
 setup_args['cmdclass'] = {
     'build_py': \
             check_package_data_first(git_prebuild('IPython')),
     'sdist' : git_prebuild('IPython', sdist),
     'upload_wininst' : UploadWindowsInstallers,
     'symlink': install_symlinked,
     'install_lib_symlink': install_lib_symlink,
     'install_scripts_sym': install_scripts_for_symlink,
     'unsymlink': unsymlink,
 }
 
 
 #---------------------------------------------------------------------------
 # 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'
 needs_setuptools = set(('develop', 'release', 'bdist_egg', 'bdist_rpm',
            'bdist', 'bdist_dumb', 'bdist_wininst', 'bdist_wheel',
            'egg_info', 'easy_install', 'upload', 'install_egg_info',
             ))
 
 if len(needs_setuptools.intersection(sys.argv)) > 0:
     import setuptools
 
 # This dict is used for passing extra arguments that are setuptools
 # specific to setup
 setuptools_extra_args = {}
 
 # setuptools requirements
 
 extras_require = dict(
     parallel = ['ipyparallel'],
     qtconsole = ['qtconsole'],
     doc = ['Sphinx>=1.3'],
     test = ['nose>=0.10.1', 'requests', 'testpath', 'pygments', 'nbformat', 'ipykernel', 'numpy'],
     terminal = [],
     kernel = ['ipykernel'],
     nbformat = ['nbformat'],
     notebook = ['notebook', 'ipywidgets'],
     nbconvert = ['nbconvert'],
 )
 
 install_requires = [
     'setuptools>=18.5',
     'decorator',
     'pickleshare',
     'simplegeneric>0.8',
     'traitlets>=4.2',
     'prompt_toolkit>=1.0.3,<2.0.0',
     'pygments',
 ]
 
 # Platform-specific dependencies:
 # This is the correct way to specify these,
 # but requires pip >= 6. pip < 6 ignores these.
 
 extras_require.update({
     ':python_version == "2.7"': ['backports.shutil_get_terminal_size'],
     ':python_version == "2.7" or python_version == "3.3"': ['pathlib2'],
     ':sys_platform != "win32"': ['pexpect'],
     ':sys_platform == "darwin"': ['appnope'],
     ':sys_platform == "win32"': ['colorama', 'win_unicode_console>=0.5'],
     'test:python_version == "2.7"': ['mock'],
 })
 # FIXME: re-specify above platform dependencies for pip < 6
 # These would result in non-portable bdists.
 if not any(arg.startswith('bdist') for arg in sys.argv):
     if sys.version_info < (3, 3):
         extras_require['test'].append('mock')
 
     if sys.platform == 'darwin':
         install_requires.extend(['appnope'])
 
     if not sys.platform.startswith('win'):
         install_requires.append('pexpect')
 
     # workaround pypa/setuptools#147, where setuptools misspells
     # platform_python_implementation as python_implementation
     if 'setuptools' in sys.modules:
         for key in list(extras_require):
             if 'platform_python_implementation' in key:
                 new_key = key.replace('platform_python_implementation', 'python_implementation')
                 extras_require[new_key] = extras_require.pop(key)
 
 everything = set()
 for key, deps in extras_require.items():
     if ':' not in key:
         everything.update(deps)
 extras_require['all'] = everything
 
 if 'setuptools' in sys.modules:
+    setuptools_extra_args['python_requires'] = '>=3.3'
     setuptools_extra_args['zip_safe'] = False
     setuptools_extra_args['entry_points'] = {
         'console_scripts': find_entry_points(),
         'pygments.lexers': [
             'ipythonconsole = IPython.lib.lexers:IPythonConsoleLexer',
             'ipython = IPython.lib.lexers:IPythonLexer',
             'ipython3 = IPython.lib.lexers:IPython3Lexer',
         ],
     }
     setup_args['extras_require'] = extras_require
     requires = setup_args['install_requires'] = install_requires
 
     # 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("ERROR: bdist_wininst must be run alone. Exiting.", file=sys.stderr)
             sys.exit(1)
         setup_args['data_files'].append(
             ['Scripts', ('scripts/ipython.ico', 'scripts/ipython_nb.ico')])
         setup_args['scripts'] = [pjoin('scripts','ipython_win_post_install.py')]
         setup_args['options'] = {"bdist_wininst":
                                  {"install_script":
                                   "ipython_win_post_install.py"}}
 
 else:
     # scripts has to be a non-empty list, or install_scripts isn't called
     setup_args['scripts'] = [e.split('=')[0].strip() for e in find_entry_points()]
 
     setup_args['cmdclass']['build_scripts'] = build_scripts_entrypt
 
 #---------------------------------------------------------------------------
 # Do the actual setup now
 #---------------------------------------------------------------------------
 
 setup_args.update(setuptools_extra_args)
 
 
 
 def main():
     setup(**setup_args)
 
 if __name__ == '__main__':
     main()

tools/toollib.py

@@ -1,57 +1,56 b''
 """Various utilities common to IPython release and maintenance tools.
 """
 from __future__ import print_function
 
 # Library imports
 import os
 
 # Useful shorthands
 pjoin = os.path.join
 cd = os.chdir
 
 # Constants
 
 # SSH root address of the archive site
 archive_user = '[e-mail]'
 archive_dir = 'archive.ipython.org'
 archive = '%s:%s' % (archive_user, archive_dir)
 
 # Build commands
 # Source dists
 sdists = './setup.py sdist --formats=gztar,zip'
 # Binary dists
 def buildwheels():
-    for py in ('2', '3'):
-        sh('python%s setupegg.py bdist_wheel' % py)
+    sh('python3 setupegg.py bdist_wheel' % py)
 
 # Utility functions
 def sh(cmd):
     """Run system command in shell, raise SystemExit if it returns an error."""
     print("$", cmd)
     stat = os.system(cmd)
     #stat = 0  # Uncomment this and comment previous to run in debug mode
     if stat:
         raise SystemExit("Command %s failed with code: %s" % (cmd, stat))
 
 # Backwards compatibility
 c = sh
 
 def get_ipdir():
     """Get IPython directory from command line, or assume it's the one above."""
 
     # Initialize arguments and check location
     ipdir = pjoin(os.path.dirname(__file__), os.pardir)
 
     ipdir = os.path.abspath(ipdir)
 
     cd(ipdir)
     if not os.path.isdir('IPython') and os.path.isfile('setup.py'):
         raise SystemExit('Invalid ipython directory: %s' % ipdir)
     return ipdir
 
 try:
     execfile = execfile
 except NameError:
     def execfile(fname, globs, locs=None):
         locs = locs or globs
         exec(compile(open(fname).read(), fname, "exec"), globs, locs)