GSoC/GCI Archive
Google Summer of Code 2010

Python Software Foundation

Web Page:

Mailing List:

The mission of the Python Software Foundation is to promote, protect, and advance the Python programming language, and to support and facilitate the growth of a diverse and international community of Python programmers. The Python Software Foundation (PSF) is a non-profit membership organization devoted to advancing open source technology related to the Python programming language. It qualifies under the US Internal Revenue Code as a tax-exempt 501(c)(3) scientific and educational public charity, and conducts its business according to the rules for such organizations.


  • A new flexible, object oriented draw module for pygame and pygame2 Drawing is a central part of a game and media library like pygame. Nonetheless the the drawing capabilities of pygame are severely limited. Just a few basic shapes to draw, no flexibility and mostly ugly output. The anti-aliasing methods in the new gfxdraw module can only be used with shape outlines (width=1), not with filled shapes. All in all, the drawing functionality of pygame is too restricted to be really useful. (Not to mention the missing documentation of the gfxdraw module.)
  • A Subset of NumPy for PyPy I propose to create a module implementing a useful subset of the popular NumPy Python module in Restricted Python for use with the PyPy interpreter.
  • A Web Support Package For Sphinx Many projects would like to get more out of their Sphinx documentation than the static HTML that is currently generated. Some features that users would like implemented include server side search, commenting, and the ability to receive patches for the documentation from users. A "Web Support Package" that provides an interface to generated Sphinx documentation and these features would be of great benefit to the Python community.
  • Add x86-64 support to the PyPy JIT The PyPy JIT, which has shown substantial performance improvements over other implementations of Python, including CPython and Unladen Swallow, does not currently support the x86-64 instruction set, making it impractical to use on 64-bit x86 systems. My proposal is to extend the existing x86 JIT backend to support x86-64 as well.
  • An Extension to IDLE for Interactive Learning This supports the learning website Software Carpentry by creating an extension to IDLE for learning and teaching Python. This extension will allow IDLE to step through pre-written source code, presenting it to the user, stopping to pop up explanations, ask questions and wait for answers, mimicking the interaction between a teacher and student. This will make the development and distribution of tutorials easier by allowing students to engage with the tutorial, rather than just reading.
  • Application for the project "PyPI Testing Infrastructure" I love python, he give me the liberty to think about how to implement the solution and not in the code him self . My style of coding is to write beautiful code and understandable one, and with python it's much simple. For the open source community it's been my dream to be part of it since i began my career in computer science , and i hope that the GSOC will give me the opportunity to be part of the community , i'm willing to do my best to accomplish my mission .
  • Assumptions & Logic: Supercharging SymPy In 2009, an assumption system (AS) was introduced to SymPy so users could reason about symbolic variables in a basic existential query. Underlying the AS, a logical boolean formula is constructed in CNF, and then solved by an internal SAT solver. At present, the system is limited in the types of queries it can perform -- mainly due to the efficiency of the underlying system. I propose to improve the reasoning engine in a number of ways that will significantly increase the efficiency of the AS.
  • Contributing to distutils2 distutils2 is a replacement for the standard distutils package. This project will not focus solely on one particular component, but will rather implement several features that are essential to the project but are still missing. Furthermore, a tutorial will be created that will ease the migration to the distutils2. Finally, a list of projects will be chosen and I will help them make the transition to distutils2.
  • Cython and Python 3 This project will improve the support for Python 3 in Cython, and use the new features in Python 3 to improve Cython's user-friendliness in its pure Python mode. This includes several bug fixes, as well as the use of Python 3 function annotation and class decorators to provide type information for Cython's pure Python mode.
  • Development of the SciPy SciKit Statsmodels Statsmodels is a Python package for statistical and econometric modelling that I successfully initiated as my 2009 GSoC project. The main goals for this summer are to port statsmodels to Python 3, focus on design issues that are necessary for a mature library, and to extend the types of estimators available. The result will be a maintainable and easily extensible Python 3 package that supports most common statistical and econometric modelling in a user-friendly environment.
  • Distutils2 development Development of an improved version of distutils. The project will result in the successful implementation of pep 376, creation of a client which gets meta-data from PyPI via XML-RPC, addition of a 'configure' command, adding pre-post commit hook for installation and un-installation of packages using distutils2, replacement of the `` script with a `setup.cfg`,and promotion of distutils2 usage by helping a list of projects move over to using distutils2.
  • Distutils2 features implementation For this project, I propose to implement features for the much-needed distutils2 library. Since it is of a great importance to the Python community, the sooner it lands the better. Additional engineering effort realised as a GSOC project would help to both create it sooner and evangelize its use.
  • Distutils2: Python Distribution Utilities New APIs and Commands This application proposes to improve packaging and installing support for projects using the Python programming language by extending support code, user-visible commands and related documentation, according to existing design documents (Python Enhancement Proposals).
  • Enable automatic generation of compiled code for scientific applications of the Sympy Python library The Python 3 version of the Sympy library should allow automatic generation of compiled code for scientific research within quantum physics and chemistry. With increasing computer power, the precision of quantum simulations are often limited by tedious work to derive and implement equations, rather than hardware. Sympy may automate this for python programmers, but the physics modules need significant improvements. New functionality is needed for code generation, as well as a test suite.
  • Enhancements to the Python Issue Tracker The goal of my project is to enhance the Python Issue Tracker: * Creating a new tracker where to test changes, possibly available to all the core developers. * Implementing new features listed in the metatracker; * Fixing issues marked as 'bug' in the metatracker; * Integrating the Issue Tracker with Mercurial; * Improving its accessibility/usability.
  • Freeseer portable presentation recording station: RSS feed feature My proposal will enable Freeseer to download lists of talks from an RSS feed. This is essentially an XML file served by a web server. Freeseer will download the talks listed in the RSS feed and add them to a local XML file which will serve as the cache. This cache enables Freeseer to record talks while completely offline. Drupal will be used as a reference RSS feed.
  • Improvements to the Enthought reStructured Text Editor Improve the Enthought reStructure Text Editor by redoing partly the interface and adding many basic tools that are missing but who should be in most basic text editors. Also create installers for some majors operating system to make the editor much simpler to install than it currently is.
  • Improving lib3to2 for general use Last year, for the Google Summer of Code 2009, I completed an alpha release of lib3to2, a set of fixers for backporting Python 3 code to Python 2. Since then, I have put in some effort in improving the tool, but major improvements are necessary before I feel comfortable releasing a version deemed "stable". This GSoC proposal aims to improve the quality and completeness of lib3to2 through extensive testing.
  • IPythonQt I will implement a Qt-based Graphical User Interface (GUI) to execute Python code with an interpreter that runs in a separate process and the two systems (GUI frontend and interpreter kernel) communicating via the ZeroMQ Messaging library. The bulk of the implementation will be done without dependencies on IPython (only on Zmq). Once the key features are ready, IPython-specific features can be added using the IPython codebase.
  • Making everything love and talk to pip The goal is to make pip less error-prone, work well in python2.x and python3.x, make the tests more internet-independent, run platform independently, add needed features by developers, write more documentation and make people love it and see that easy_install's age has gone.
  • Porting IPython to a two process model using ZeroMQ IPython's execution in a command-line environment will be ported to a two process model using the ZeroMQ library for inter-process communication. This will: * prevent an interpreter crash from destroying the user session, * allow multiple clients to interact simultaneously with a single interpreter * allow IPython to reuse code for local execution and distributed computing (DC) * give us a path for Python3 support, since ZeroMQ supports Python3 while Twisted does not.
  • Porting RPy2 to Python 3 RPy2 is an interface between Python and the statistical package R. This project aims to port existing functionality of RPy2 to Python 3 as well as to improve integration by taking advantage of Python 3's features. It will be completed in three stages: porting RPy2's existing functionality, integrating new features of Python and its C API (MemoryViews, PyCapsules, ordered dictionaries) and lastly implementing an R graphical device which would be able to interface with Matplotlib.
  • PyPy - fast ctypes The main goal of the project is to rewrite ctypes in RPython with JIT support in mind. This should give another boost for PyPy performance.
  • Python 3.x tools - Speed up 2to3 Pattern Matching The 2to3 utility has been written to help convert python 2.x programs into working python 3.x programs. However, the tool currently uses inefficient matching algorithms that significantly negatively impact the execution time especially for large projects. This project aims to collect performance data about 2to3, then replace the existing matching algorithm with an algorithm based on state machines that should provide significantly improved performance.
  • Speeding up 2to3 pattern matching The 2to3 tool currently uses a brute-force algorithm for matching tree patterns. This is a proposal to implement a more efficient tree-matching algorithm using a modified version of Algorithm D developed by Hoffman & O'Donnell.
  • Sphinx Native Language Support: Toolchain for Creating, Tracking, and Viewing Internationalized Versions of Sphinx Documents Internationalization and Localization are key in order to reach a broad user base. Python's documentation has historically been maintained in English only. There have been several translation attempts which slowly become obsolete as keeping track of checkins to the reference documentation is a boring and laborious task. Developing a native language support toolchain would make Sphinx a compelling documentation system for open source projects.
  • Sphinx: Port to Python 3.x and Integration of sphinx.web Beginning with the Python documentation Sphinx managed to become the Python documentation generator for python projects, however as of now Sphinx requires Python 2.x to run. Also Sphinx has no support to allow the community of a project to participate in the documentation easily. The aim of this project is to change that by porting Sphinx to Python 3.x and by integrating sphinx.web, last years GSoC project around Sphinx, into Sphinx itself.
  • Symbolic Quantum Mechanics in SymPy SymPy will benefit greatly by having a complete framework for symbolic quantum mechanics. Quantum mechanics is a theory that describes the behavior of physical systems at the atomic scale and smaller. The mathematics of quantum mechanics has many aspects of linear algebra built into it, and like any math, calculations can be performed with abstract symbols resulting in intuitive results. By the end of the summer, the base layer for symbolic quantum mechanics in SymPy will be finished.
  • SymPy: Improving the Symbolic Integrator SymPy, a computer algebra system written and executed in Python, currently has decent heuristic support for symbolic integration. However, the integrator is slow, and being a heuristic, can often fail to find an elementary integral for a function when there is one, even in simple cases. I plan to improve SymPy’s integrator by improving the heuristics as well as implementing some of the Risch algorithm, which will guarantee elementary results if they exist.
  • Unladen Swallow - Memory Reduction Unladen Swallow offers some magnificent performance improvements over the CPython interpretation method. Unfortunately, the Just-in-Time compiler used by Unladen Swallow currently incurs a hefty memory overhead which needs to be reduced before Unladen Swallow can be merged into CPython.
  • Work on Distutils2 Distutils2 will replace DistUtils, adding new fonctionalities and bringing some backwards changes (about design), to distutils1. The goal of this summer of code is to work on the new distutils2 implementation, by working on some missing functionalities, and especially by implementing the PEP 376 [1]. See the list of task to have a complete overview of what will be done in this GSOC.