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, nine, and 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.
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
<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).
pip install eight
from eight import * from eight import queue from eight.collections import UserList, deque
If you use
from __future__ import (print_function, division, unicode_literals, absolute_import)
Eight provides wrappers for
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
refer to the underlying streams that accept bytes. Eight uses the io module
to do the same for you, but subclasses the TextIOWrapper class for
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:
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 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:
import eight eight.decode_command_line_args()
The call to
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
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 and typing
import eight, then
eight.<TAB>. Here is a full list of what's available:
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
from eight import <name> when needed:
The following modules have attributes which resided elsewhere in Python 2: TODO
Python-future for doing a bunch of heavy lifting on backports of Python 3 features.
Please report bugs, issues, feature requests, etc. on GitHub.
Licensed under the terms of the Apache License, Version 2.0.