GSoC/GCI Archive
Google Summer of Code 2013

Python Software Foundation

Web Page:

Mailing List:

Python is an interpreted, general-purpose high-level programming language whose design philosophy emphasizes code readability. Python aims to combine "remarkable power with very clear syntax", and its standard library is large and comprehensive. Its use of indentation for block delimiters is unique among popular programming languages.


The Python Software Foundation serves as an umbrella organization for a number of Python projects:


  • Core Python
  • ASCEND  
  • Astropy
  • GNU Mailman
  • Kivy
  • MNE-Python
  • OpenHatch 
  • PyDy 
  • PyPy
  • Pyramid Web Framework / Pylons Project
  • scikit-image
  • scikit-learn
  • SciPy/NumPy
  • SfePy
  • statsmodels 
  • SunPy
  • Tahoe-LAFS
  • Twisted

When applying with us, please make sure to indicate the sub-org that interests you.


  • ASCEND: dynamic modelling improvements There are models with variable structure which are currently not supported by ASCEND. These are, for example, models with hysteresis or with complex boundary conditions. More generally, they have not only region behavior (for which ASCEND has WHEN statements), but also boundary behavior: some actions should be performed exactly at the boundaries. After thinking over the problem I made a conclusion that there are two main types of actions: solving systems of boundary equations and assigning values to some variables. In order to implement this ASCEND needs new syntax and new solver behavior.
  • Astropy: Develop the Astroquery toolkit into a coherent package Astroquery is an affiliated package of Astropy developed to allow astronomers to access online Astronomical databases. This is a most useful toolkit, but requires extensive refactoring, testing, documentation and implementation of new services before it conforms to a clean and consistent API and becomes suitable for a stable release. This project intends to do exhaustive work on the Astroquery package to get it into a usable and stable form for fruitful utilization by the Astronomical community.
  • AstroPy: Extending the functionality of the photutils package. AstroPy is an Open Source package for the analysis of astronomical data. It allready provides numerous features but up to now the functionatlity of the photutils package, which allows photometry on astronomical images, is still very limited. During GSoC2013 I plan to extend the photometry capabilities of AstroPy.
  • Data Driven Mentorship App Create a mentorship tracker app where new contributors in an open source project are in a state between least to most experienced. Notes are kept on the new contributors and they can be promoted to the next stage by mentors. This allows coordination between different mentors.
  • GNU Mailman - Integration of OpenPGP This project aims to implement signing/encryption of the emails sent to a mailing list. This creates of a secure through-the-email channel for the distribution of information among a group of people. The messages in this channel are authenticated( verified that message is indeed sent by the user in the from field) and/or encrypted( during the transmission) . It uses public-key encryption standard like OpenPGP to encrypt and/or sign the messages.
  • IDLE Improvements The proposal on IDLE improvements project listed in Core Python. Describes the two parts of works which will be covered throughout the project, the Initiation of unit test framework for IDLE and integration of Pep8 style checker tool for IDLE editor.
  • IDLE Improvements Unit test framework and UI improvements to the built in runtime environment IDLE.
  • Improvements to the sparse package of Scipy: support for bool dtype and better interaction with NumPy This proposal has two parts: 1. Add support for bool dtype to sparse matrices, as well as boolean operations so that sparse matrices behave more like NumPy ndarrays. 2. Improve interaction of sparse matrix objects and NumPy ndarray objects and ufuncs. This will make, .multiply, etc. work with sparse matrices, making generic sparse and dense matrix code much easier to write.
  • Kivy: Kivy Designer Kivy Designer is a GUI Designer for designing Kivy Applications. It is written in Python using Kivy. This will help users create GUI easily and dynamically. Low resources would then be required to create GUI. Moreover, with this the processes of Creating UI and Writing code for an application could be done separately.
  • Mailman: Authenticated REST-API in Postorius/Django. The aim of the project is to expose a public-facing REST API for Postorius, which might be used for future clients of Postorius to handle/control the actions of the Mailing lists.
  • MNE-Python: Implement time-frequency beamformers MNE-Python implements time domain beamformers for imaging sources of brain activity recorded with M/EEG. The goal of this project is to extend the beamformer module to support frequency domain implementations. It will involve implementing computation of cross-spectral density in consecutive time windows, refactoring current beamforming code as well as preparation of examples and tests for the time-frequency beamformer functionality.
  • OpenHatch: Rewrite training missions using oppia (Training missions, version 2) Convert oppia into a django app. Plug it into the openhatch codebase and use it to create, edit and run training missions.
  • Porting to gtk3 and GUI improvements The proposal covers ideas of porting the ascend application to gtk3 and some improvements in the GUI. This includes re-structuring the design of the GUI, improving the IPython console (to make it more powerful) and adding some more functionalities like error reporter module.
  • PyDy: Visualization of the simulated motion of multibody systems Currently, mechanics module from SymPy(sympy.physics.mechanics) is used for generating Equations of Motions(EoM's) of multibody systems using other python tools, in a workflow(PyDy). The aim of this project is to provide a module for visualizing the motion of 3-Dimensional Multibody systems using output data from the mechanics module, after introducing some relevant code-refractoring for allowing mechanics package to interact with the above said module. The plugin would be able to render the animations in a WebGL compatible browser. Will also require patching as well as some fresh code on sympy.physics.mechanics side to complete the visualization workflow..
  • PyOBJus The goal of this project is to provide API written in Cython for generic access to Objective C classes and libraries. This will allow users to access anything in for example iOS API from Python. This is big feature for Kivy, and I am sure that Kivy with this feature will become more popular in area of development cross-platform applications, and this will open new way to access iOS from Python.
  • Pyramid - Better Debug tools Improve the pyramid debug toolbar. Main tasks are to add a better extension support for debugtoolbar and make a web-interactive extension like pdb.
  • PySoy: Improve Android and HTML5 Soy clients I will finish PySoy's Android client (SweetSoy) and HTML5 browser plug-in client (WebSoy) so they are ready for general use. Basic, but unusable, clients for both platforms are already implemented.
  • Real-time Machine Learning for MEG in MNE-Python The main objective of the project is to construct a real-time machine-learning pipeline for magnetoencephalography (MEG), which is a well-known technique for recording magnetic signals produced by electrical currents inside the brain. The end result will be an additional real-time classification module to MNE-Python, and a set of companion scripts for unit-tests and examples.
  • scikit-image : Implementation of STAR and Binary Feature Detectors and Descriptors Feature Detectors and Descriptors are at the center of many tasks in Image Processing and Computer Vision. Good Feature Detectors extract out the keypoints that are robust to image transformations like scaling, different viewpoints, change in intensity etc. Good Feature Descriptors extract a compact description of a keypoint which can be used to accurately match or correspond keypoints in multiple images and hence are widely used for tasks like Image Registration, Object Recognition and Tracking, Stereo Vision etc. This project focuses on implementing STAR(CenSurE) and Binary feature detectors and descriptors like BRIEF, ORB(Oriented BRIEF) and FREAK to extend the features module in scikit-image.
  • scikit-image: Image Inpainting for Restoration This provides a detailed overview of my proposal to the Python Software Foundation (PSF) serving as an umbrella organization for scikit-image as part of the Google Summer of Code 2013. This project aims to add inpainting abilities to scikit-image library. This would serve as a tool for restoration of damaged information in an image. It can be used to effectively remove overlaying text, cracks in the image and also complete objects from the image. To make it easier for users, we even provide a 'demo_' file to inpaint interactively and test it out.
  • scikit-image: Segmentation Algorithms as a basis for an OpenCL feasible study Image segmentation algorithms, specifically Graph-cut are a top priority for inclusion in scikit-image. Additionally, although the barrier to entry for GPU computing how lowered significantly and image-processing being a natural application of GPGPU, the scikit-image project has remained a CPU-only library. This project aims to conduct a feasible study for the inclusion of OpenCL by comparing the performance of CPU and GPU versions of the segmentation algorithms Graph-cut, Grow-cut and QuickShift
  • scikit-learn: Biclustering algorithms, scoring, and data generation Biclustering is an unsupervised learning method that simultaneously clusters samples and features. It has become a popular technique in various fields including bioinformatics and text mining. I propose to add biclustering capabilities to scikit-learn by implementing popular algorithms, scoring metrics, and data generation functions.
  • SciPy/NumPy : Performance parity between numpy arrays and Python scalars Small numpy arrays are very similar to Python scalars but numpy incurs a fair amount of extra overhead for simple operations. For large arrays this doesn't matter, but for code that manipulates a lot of small pieces of data, it can be a serious bottleneck.
  • SfePy: Enhancing the solver to simulate solid-liquid phase change phenomenon in convective-diffusive situations SfePy is a well known python package for solving systems of coupled partial differential equations (PDEs) by the finite element method in 2D and 3D. Currently it is used for solving problems related to porous media convection, acoustics, incompressible flows and various other engineering problems. My goal is to make the solver even stronger by adding capabilities to tackle convection-diffusion and phase change phenomena.
  • Statsmodels: Discrete choice models The aim of this project is to add discrete choice models to statsmodels and fill a gap in the set of discrete models that are currently available. We want to bring to the comunity a BSD licensed tool, which based on hypothetical or real world choices, can study the causes of the choice among alternatives and forecast market behavior. This project is intended, first, work on the currently implemented Multinomial Logit and the Nested Logit algorithms and, then, implement Mixed Logit algorithms. Also,it is proposed to implement flexible model specification and several supporting functions for the summary of the model, the statistics result, and statistical tests to check heteroscedasticity, the nesting structures and random parameters of the model. Implement Mixed Logit model will do possible study complex markets and, provide a user friendly way, define complex discrete choice models. This will catapult to statsmodels to rank between the best tools for discrete choice model estimation.
  • Statsmodels: Time Series Analysis Extensions (esp. regime-switching models) This project would add support for several of the most popular non-linear time series models (SETAR, STAR, and Markov Switching models) to the statsmodels project, as well as statistical tests for nonlinearity including especially the BDS portmanteau test, and some support for forecasting. Particular attention will be paid to Markov Switching models.
  • Substance D improvements This proposal focuses on improving Substance D application server in several aspects. The goal is to improve code base and make project more interesting to future user base. Work is focused on three areas: merging deform_bootstrap with deform into deform2, writing/improving documentation and creating a migration helpers for importing content from Plone. Any extra time will be spent on features that will be coordinated with mentor(s).
  • SunPy - Interfacing with Heliocphysics Databases The SunPy project includes a toolkit that is used to query a web service and download appropriate solar data. This summer I would like to help expand this service by adding more complex queries for the web service, add methods to augment the efficiency of handling the results and meta-data, and to utilize the resulting meta-data to form further queries.
  • SunPy: Database of local data The SunPy package offers the module vso (Virtual Solar Observatory) which represents an interface to query and download astronomical data from multiple data providers simultaneously. This project will add a database interface for downloading data to save bandwidth if the same data is requested multiple times. It will also offer a handy way to group results which met certain conditions. Multiple conditions may be chained together using logical operators such as "and", "or", "not". Note: the link in the field "additional info" points to a PDF of my curriculum vitae.
  • Twisted: Deferred Cancellation Deferreds are Twisted's abstraction for an eventual result of a task. They provide a cancellation API to add a hook for cancelling the task. However, many Twisted APIs that return Deferreds don't use this cancellation API which means they don't provide cancellation support. This project would add cancellation support to as many APIs as possible (though I will focus on SMTP, POP3, IMAP4, DNS, HTTP related APIs), starting with easy cases and moving on to more difficult ones.
  • Twisted: Switching to Formal Parsers Currently Twisted uses ad-hoc parsing methods to parse protocols. The ad-hoc parsing often produces scattered code and makes the code difficult to read and debug. To overcome this problem, I will use Parsley to rewrite the parsing part. In the rewritten version, there will be unified parsing grammar and dedicated classes that handle parsing logic. Thus, the parsing code will be less error-prone and more concise. Moreover, parsing performance will be easily improved by enhancing Parsley itself.
  • Upload Strategy of Happiness in Tahoe-LAFS Currently the share placement algorithm is not designed to meet the criteria established by the "servers of happiness" test. This leads to various issues in which share placement does not satisfy the test even though it is possible to do so. Implementing a new share placement algorithm would fix these types of issues.
  • wxPython Bindings for PyPy using CFFI There are currently no GUI toolkits that properly support PyPy. Although the existing wxPython and Tkinter implementations have some partial compatibility, they are supported via the CPython extension emulation layer. The goal of this project will be to create wxPython bindings which are compatible with PyPy. These bindings will use the CFFI library to interface with the native code and will be based off of wxPython Phoenix, a work-in-progress re-write of the original bindings.