Hi all,
After last week's sprint I wanted to get you up-to-speed about the
current state of porting Django to Python 3.
As some may be aware Martin von Löwis has been working on a port for
a while [1] but only recently I've had the chance to meet with him and
talk through the porting process.
I'm not going to hide the fact that it'll be a long process, but I'm
also convinced it's an important step for Django to make. I'm writing
this in the hope to find volunteers to join the porting efforts.
Goals
-----
To allow Django to run on Python 3 there are several goals to achieve,
some of which are our respsonsibility, some depend on 3rd party libraries
we use internally and some left to the users that use Django to build
their websites. It's my understanding that we can't solve everything
at once, so take this with a grain of salt:
- get Django to run on Python 3
- provide helpers and docs for porting Django-based projects
- help out 3rd party projects we rely only to make the jump (if needed)
Porting strategies
------------------
As you can imagine there are still quite a few open questions at
the moment about specific porting problems but taking from the
experience in the Python community I think we have a good general
strategy.
There are a few assumptions we're applying either because it's
unrealistic or impossible to maintain as long as Python 2.X is in
use for the forseeable future; so these strategy *don't* work:
- Create a Python 3 only port ("burning the bridges")
This is outright a no-go since it would leave all the Python 2.X
projects in dead water. Instead we need to provide a migration
path for them.
- Maintaing a separate Python 3 branch ("dual releases")
While this would allow for new projects to use Python 3, I'm
convinced this has the potential to split the community. It'd
also be a major burden for the core team to maintain both
branches. Instead we need a combined effort.
So as a result of that the only viable option is to support both major
versions of Python at the same time, with the same code base.
Fortunately the Python community gained lots of experience in the past
years to make this happen (e.g. Lennart Regebro's book [4]). There are
also tools to ease the transition of Django and the Django-based
projects. Some of which are:
- six [3] -- a compatibility library that includes many (if not all)
needed import proxies and utilities to prepare Django and Django-based
projects to be ported to Python 3.X. This only applies to API that
isn't syntactically changed, but only moved or enhanced in 3.X.
- 2to3 [2] -- an extensible library which is able to translate the rest
of the Python 2 code to the Python 3 equivalent. For every Django
specific feature that isn't covered by the default 2to3 "fixers" we can
write our own if needed. It integrates with distutils (in Python 3.X)
and is able to convert Django at installation time. Installing Django
with Python 2 wouldn't trigger the translation process, of course.
Code status
-----------
During the sprint we've moved Martin's code from a Bitbucket clone to
an own SVN branch:
https://code.djangoproject.com/browser/django/branches/features/py3k/
Some notable changes:
- a modified ``setup.py`` which automatically calls 2to3 during installation
- a ``py3ktest`` helper bash script which -- for now -- installs Django in
a directory called "3k" in the same directory to trigger the translation
from Python 2 to Python 3 code and then run the tests from the build
directory directly because they are not part of the installation in "3k"
because we don't include it. This script should be seen a temporary
workaround till we've found a better way to run the tests (Could we use
tox instead? [5]).
- a new django.utils.py3 module which contains some helpers that are used
throughout the code as a common API to ease the pain of maintaining a
project that runs on both Python 2 and 3. I expect it to grow in size
while we port Django, but even then it may not be complete enough to
be useful for Django-based user projects. Which is why I think Django
should ship the "six" library [3] instead, on the long run ("six" has
the advantage of being maintained by a Python core developer).
A good overview of the current changes can be seen on Bitbucket:
https://bitbucket.org/django/django/compare/features/py3k..default
Right now it's mostly changes to how byte and unicode strings are handled
by using a b() and u() function instead of the 'u' prefix. That said,
this is far from complete.
How to help
-----------
We have multiple big pieces of the puzzle to solve:
- Try out the branch by running the tests with the ``py3ktest`` script
and fix the failed tests (needs an installed ``python3`` binary), one
by one. This may be repetitive work, but could also be the chance for
you to dive into the internals of Django.
- Write a tutorial to prepare a Django app to for Python 3 by using one
of the tools we provide. Have a look at the official porting guides [6]
for inspiration.
- Help port the 3rd party libraries we rely on in Django (e.g. MySQLdb [7])
by getting in touch with their community.
There are probably lots of other small steps to make, but I'm confident that
we'll figure them out on the way.
Let's start the porting, Python 3 is waiting for us,
Jannis
1: https://bitbucket.org/loewis/django-3k/
2: http://docs.python.org/library/2to3.html
3: http://pypi.python.org/pypi/six
4: http://python3porting.com/
5: http://tox.readthedocs.org/
6: http://docs.python.org/py3k/howto/pyporting.html
7: http://sourceforge.net/projects/mysql-python/forums/forum/70460/topic/3831691
--
You received this message because you are subscribed to the Google Groups
"Django developers" group.
To post to this group, send email to django-developers@googlegroups.com.
To unsubscribe from this group, send email to
django-developers+unsubscr...@googlegroups.com.
For more options, visit this group at
http://groups.google.com/group/django-developers?hl=en.
