eight

eight: Python 2 to the power of 3

Eight is a Python module that provides a minimalist compatibility layer between Python 3 and 2. Eight lets you write code for Python 3.3+ while providing limited compatibility with Python 2.7 with no code changes. Eight is inspired by six <https://pythonhosted.org/six/>, nine <https://github.com/nandoflorestan/nine>, and python-future <https://github.com/PythonCharmers/python-future>_, but provides better internationalization (i18n) support, is more lightweight, easier to use, and unambiguously biased toward Python 3 code: if you remove eight from your code, it will continue to function exactly as it did with eight on Python 3.

To write code for Python 3 that is portable to Python 2, you may also want to read Armin Ronacher's excellent Python 3 porting guide <http://lucumr.pocoo.org/2013/5/21/porting-to-python-3-redux/>, as well as the official porting guide <http://docs.python.org/3/howto/pyporting.html>.

Writing from eight import * in your code is a no-op in Python 3. In Python 2, it binds a bunch of Python 3 names to their Python 2 equivalents. Also, if you need to import a module or module member that was renamed in Python 3, writing from eight import <module> will do the right thing (equivalent to import <module> on Python 3 and import <old_name> as <module> on Python 2). Finally, eight can optionally wrap your standard streams and environment variable I/O to use text, not bytes (see below).

Installation

::

pip install eight

Synopsis

.. code-block:: python

from eight import *
from eight import queue
from eight.collections import UserList, deque

If you use print, division, non-ASCII literals, or relative imports, you should also add this future import <http://docs.python.org/3/library/__future__.html>_ at the top of each source file:

.. code-block:: python

from __future__ import (print_function, division, unicode_literals, absolute_import)

Wrapping stdio

Eight provides wrappers for sys.stdin, sys.stdout, and sys.stderr to make them (and methods that use them) behave like they do on Python 3. Specifically, in Python 3 these streams accept text data, and their .buffer attributes refer to the underlying streams that accept bytes. Eight uses the io <http://docs.python.org/2/library/io.html>_ module to do the same for you, but subclasses the TextIOWrapper class for sys.stdout and sys.stderr to coerce non-unicode input to unicode on Python 2 (otherwise, because of the Python 2 semantics, things like exception printing cease to work).

To enable stdio wrapping, use the following:

.. code-block:: python

import eight
eight.wrap_stdio()

To revert the effects of this on any of the streams, use the detach method, e.g. sys.stdin = sys.stdin.detach() (but remember to condition this on eight.USING_PYTHON2). See the io module documentation <http://docs.python.org/2/library/io.html>_ for more information.

Decoding command-line arguments

Eight provides a utility function to decode the contents of sys.argv on Python 2 (as Python 3 does). It uses sys.stdin.encoding as the encoding to do so:

.. code-block:: python

import eight
eight.decode_command_line_args()

The call to decode_command_line_args() replaces sys.argv with its decoded contents and returns the new contents. On Python 3, the call is a no-op (it returns sys.argv and leaves it intact).

Wrapping environment variable getters and setters

Eight provides utility wrappers to help bring Python 2 environment variable access and assignment in line with Python 3: encode the input to os.putenv (which is used for statements like os.environ[x] = y) and decode the output of os.getenv (used for x = os.environ[y]). Use wrap_os_environ_io() to monkey-patch these wrappers into the os module:

.. code-block:: python

import eight
eight.wrap_os_environ_io()

On Python 3, the call is a no-op.

Selecting from the buffet

You can see what from eight import * will do by running IPython <https://github.com/ipython/ipython>_ and typing import eight, then eight.<TAB>. Here is a full list of what's available:

• ascii
• bytes
• chr
• filter
• hex
• input
• int
• map
• oct
• open
• range
• round
• str
• super
• zip

You can import these symbols by listing them explicitly. If for any reason you see an issue with importing them all (which is recommended), you can of course import a subset.

In addition to names imported by from eight import *, the following modules are available and should be imported by name using from eight import <name> when needed:

• queue (old name: Queue)
• builtins (old name: __builtin__)
• copyreg (old name: copy_reg)
• configparser (old name: ConfigParser)
• reprlib (old name: repr)
• winreg (old name: _winreg)
• _thread (old name: thread)
• _dummy_thread (old name: dummy_thread)

The following modules have attributes which resided elsewhere in Python 2: TODO

Acknowledgments

Python-future <https://github.com/PythonCharmers/python-future>_ for doing a bunch of heavy lifting on backports of Python 3 features.

Links

• Project home page (GitHub) <https://github.com/kislyuk/eight>_
• Documentation (Read the Docs) <https://eight.readthedocs.io/en/latest/>_
• Package distribution (PyPI) <https://pypi.python.org/pypi/eight>_

Bugs

Please report bugs, issues, feature requests, etc. on `GitHub <https://github.com/kislyuk/eight/issues>`_.

License
-------
Licensed under the terms of the `Apache License, Version 2.0 <http://www.apache.org/licenses/LICENSE-2.0>`_.

.. image:: https://img.shields.io/travis/kislyuk/eight.svg
        :target: https://travis-ci.org/kislyuk/eight
.. image:: https://codecov.io/github/kislyuk/eight/coverage.svg?branch=master
        :target: https://codecov.io/github/kislyuk/eight?branch=master
.. image:: https://img.shields.io/pypi/v/eight.svg
        :target: https://pypi.python.org/pypi/eight
.. image:: https://img.shields.io/pypi/l/eight.svg
        :target: https://pypi.python.org/pypi/eight
.. image:: https://readthedocs.org/projects/eight/badge/?version=latest
        :target: https://eight.readthedocs.io/