Ideas for TurboGears GSoC 2008 Projects

Status: Contributed, Please add your Ideas

Contents

On this page we will collect ideas for student projects for the Google Summer of Code (GSoC) 2008. If you are a student and you are interested in working together with the TurboGears project on any of the projects listed here or you want to discuss an idea of your own with us, we strongly suggest that you get in touch with us through our trunk mailing list or write to the listed TurboGears GSoC Mentors (or - as a last resort - to the TurboGears GSoC project administrators) before you go ahead with the application.

You may also want to visit our main GSoC project organization page.

When you are adding a new idea to this page, please use the following template:

Project Title
-------------

Summary
    One-line summary of the project
Tags
    comma-separated list of keywords, e.g. "core task, controllers, advanced"
Status
    E.g. "Draft", "Accepted", "Claimed", "Rejected"
Mentor
    Name and contact info of proposed project mentor

Description
    A longer description of the project, including goals, tasks, and
    requirements.

TurboGears Content Management System

Summary
Create a Content Management System (CMS) based on TurboGears.
Tags
cms, toscawidgets, ajax, content management system, registration, administration
Status
Draft
Mentor
Mark Ramm, Chris Perkins, Kevin Horn, Patrick Lewis
Description
There is a huge interest in such a system, but no one has yet been able to get a CMS off the ground for TurboGears. Propose a content management system which has a working administration system, access control, work flow, as well as a place to create and manage documents and you can create a winning CMS. All components must be pluggable, (read: Gadgets) into existing TurboGears applications. The idea is to create a library where the components of the cms would be extensible outside the CMS framework. It is highly recommended that the student(s) of this project collaborate with developers working on twTools and DBmechanic/DBSprockets. How the cms is to be implemented is left up to your proposal.
Current Administration Gadget Information

TurboGears on Jython

Summary
TurboGears components need changes to run on Jython
Tags
genshi, templating, xml
Status
Draft
Mentors
Philip Jenvey, Jim Baker, Frank Wierzbicki
Description
There is an effort underway to get TurboGears up and running on the Jython platform. One of the main challenges in this task is to bring Genshi on Jython. This will likely include changes to both Genshi, and Jython, but most of the Jython changes that would be required have already been made. Other tasks could include getting TurboGears components like TurboJSON and ToscaWidgets updated so that they too work on Jython.

DBSprockets User Interface

Summary
Modify the dbmechanic controllers to support more javascript interaction.
Tags
dbsprockets, dbmechanic, sqlalchemy, toscawidgets, controller
Status
Draft
Mentor
Christopher Perkins, Michael Brickenstein
Description
DBSprockets is a package which implements a number of tools to help developers create web content much more quickly. The idea is that if we know what the database definition is already, we have a lot of information about what the user interface should look like. Those things that we cannot guess ahead of time should be easy for the developer to customize.

DBMechanic Interactivity

DBMechanic is a series of pages which act as a direct portal to your database. The intended user is an Administer, and it provides a great way to boot-strap data into the TurboGears system. Most of the attention has gone into the design of the system, and not into the User Interface. Enabling Ajax in DBMechanic would enhance user interaction and could make it a lot more appealing to the eye. Providing a clean user interface with tabbing would go a long way to help the usability as well. DBMechanic is intended to be a replacement for both Catwalk and Model Designer, so it would be great to have a front end which in its current state of functionality shows the same level of complete-ness. All functionality should be rendered with Toscawidgets, to show the power of this useful library. Collaboration with TwTools project members may allow considerable code-reuse and provide a testing ground for both technologies.

Querying System

The ability to have a generic and robust querying system for DBMechanic and DBSprockets in general would be very valuable. Picture a table of records, and below it you have the ability to add criteria in order to pare-down the resultant table. The table should change as you update the query, without reloading the entire page. It would also be important to take into account table relationships and how they affect the table. You will need a solid understanding of Ajax and querying with sqlalchemy to accomplish this goal.

DataGrid

Imagine a table full of values, whereby if you click on a cell you can modify the contents in-line. When you click away from the record, the database should be updated, after checking for field validation as defined by the database. Furthermore, a new primitive should be provided so that users can create datagrids in their own applications, with the ability to customize validation and other aspects of the grid.

TwTools

Summary
Show the power of Toscawidgets and provide devlopers with a useful toolset.
Tags
javascript, css, toscawidgets
Status
Draft
Mentors
Christopher Perkins, Sean O'Donnell
Description

TwTools is a Toscawidgets library which allow the user to easily create content utilizing well-known javascript libraries. The idea here is to free the python programmer to concentrate model and controller interaction, providing a clear and easy path to generate the view component of the MVC paradigm. Currently support is being added for:

  • MooTools
  • Lightwindow
  • Google Maps
  • Yahoo! Maps
  • jQuery
  • jExt
  • Dojo

A student could pick one or more of these Javascript libraries and create a set of widgets which would help a web developer create a content-rich website. It would be a good idea to coordinate with the developers working on the DBMechanic so that both projects could benefit.

TurboGears Quality Assurance Initiative

Summary
Set up buildbots for automating unit tests, packaging, test installation, project quickstart tests and project test suites.
Tags
quality assurance, qa, systems administration, buildbot, testing
Status
Draft
Mentor
Christopher Arndt and Andy Webster
Description

TurboGears installation is a complex process because of the high number of required third-party modules. Although we try to hide most of the complexities from the user by providing the tgsetup.py installation script, there are too many constellations where installation could fail, to test them all manually even under only the major operating systems and Python versions.

We therefore need a process to automate the running of the project's unit tests and run them periodically or whenever the SVN repository changes in certain ways. We further need to automate the building of distribution packages (eggs) of TurboGears proper and also binary eggs for all C-extension dependencies on as many combinations of operating system, architecture and Python version as possible.

The next step is to automate test installation under all system configurations, for which we are able to build dependency packages, in a clean, separated Python environment. The last two automation steps are the quickstarting of new project with all possible combinations of quickstart options and the running of the test suites of the quickstarted projects.

General infrastructure:

  • Use buildbot as the general automation framework.
  • Use zc.buildout or virtualenv for providing clean installation environments.
  • Integrate with PyBots project?
  • Use Qemu for buildbot slaves if possible. If not, use other virtual machine systems (e.g. vmware etc.) instead or, as a last resort, real machines.

Tasks:

  • Create buildbot slaves for:

    • Windows (at least 2000, XP, maybe Vista)
    • Mac OS X (10.4 ppp/i386, 10.5)
    • Linux (i686, x86_64, ia64, armtelv5)
    • Solaris (i386, sparc5)
    • FreeBSD?
    • NetBSD?
    • OpenBSD?

  • Automate the following build tasks:

    • Do TurboGears Subversion repository checkout.
    • Run TurboGears core tests.
    • Build eggs for Python 2.3, 2.4 and 2.5 for TurboGears and binary dependencies.
    • Run TurboGears installation in virtual environment (with zc.buildout or virtualenv).
    • Build quickstart projects, combining the following options: - SQLObject / SQLAlchemy - With or without identity - Kid / Genshi

  • Integrate buildbot reports into TurboGears documentation wiki and/or TurboGears trac.

  • Generate wiki page with tables for supported operating systems (see current manual supported systems overview)

Students applying for this project must be experienced with setting up services in a Unix, Windows and Mac environment or be able to familiarize themselves with new systems quickly. The must go about this task methodically, implementing the basic automation framework properly first and then setting up the different automation task one after another, testing and verifying the proper function of each before they go on to the next. They must also interact with the TurboGears developers, release managers and systems admins to implement any necessary changes to adapt the current manual testing and build process and to integrate the buildbot services with the rest of the technical project infrastructure. Besides Python coding, this task may also include a fair amount of Shell scripting or similar techniques on non-Unix systems.

The server infrastructure for setting up the buildbot and some of the buildbot slave systems will be provided by the TurboGears project through its systems administrator.

References

Documentation Production System

Summary
Create a re-usable tutorial and API documentation production system
Tags
documentation, testing, tool, docutils, markdown, pygments
Status
Draft
Mentor
Mark Ramm, Christopher Arndt, Armin Ronacher
Description

Doctests are great for documenting libraries, and framework components in a testable, usable way. But they are limited when it comes to providing framework level documentation, or tutorial type documentation for components. What is needed is a tool which can take working tested code from a sample project and include it inline with tutorial text. Ideally this would work well with ApyDia so that both tutorial style documents, and API documentation can be quickly produced using the same set of tools, with similar output. ApyDia allows you to use ReST and Markdown in docstrings, so both of those markup languages should be supported.

Another way to approach this might be to use Sphinx, the new documentation tool for the official Python documentation, and extend it with the necessary functionality.

Genshi Compatibility and Performance

Summary
Genshi needs more speed!
Tags
genshi, templating, xml
Status
Draft
Mentors
Christopher Lenz, Armin Ronacher
Description
Genshi is one of, if not the most powerful xml-based templating engines. While it outperforms Kid 10-1, it still cannot compete with the likes of Cheetah, and Mako, which are text-based. A student working on this project should understand the strategy for Genshi optimization and may also add their own ideas. More notes on Genshi Performance

Add Object Dispatch to Routes2 Middleware

Summary
create a way to hand off a root object and generate a set of routes
Tags
dispatch, routes, pylons
Status
Draft
Mentor
Mark Ramm, and Florent Aide, and ???
Description
Currently TurboGears inspects the object tree at call time and picks a controller method to call based on that information. Routes builds up regular expressions to do the same job. It would be helpful if these two dispatch mechanisms were merged, and there would likely be a performance enhancement provided by walking the tree only at the time when Routes is initialized.

Elixir - Raw SQLAlchemy Objects Code Generation

Summary
Implement code generation of raw SQLAlchemy objects in Elixir
Tags
sqlalchemy, elixir, orm, debugging tools
Status
Draft
Mentor
To be done...
Description
Elixir provides a very convenient syntax for defining your tables, your mapped objects, and the mappers between them all at once. And it goes beyond that by providing a very programmable "statements" interface which can add all kinds of behavior to your resulting objects, as well as creating the extra tables and relations needed for those behaviors. The end result is that it can occasionally be difficult to determine what the underlying object and mappers look like. So, Elixir needs a way to generate human-readable code for each of the objects it creates for you.

weMap - Mashup Gadget Components for TurboGears

Summary
Create widgets and Gadgets for GIS web applications
Tags
GIS, geocoding, database, harmonize, mapping, selector, administration, data duplication
Status
Draft
Mentor
Andrey Petrov, Greg Wilson
Description
The weMap project facilitates the process of finding social services in the community, allowing users easy access to a wide array of social services in an interactive map format. While working on developing our mashup using TurboGears we've noticed that TurboGears lacks a number of Gadgets that would facilitate development of such applications. Some features we've found that would be of use include a mapping widget to integrate TurboGears with mapping software such as Google Maps and Yahoo! Maps, a column selector/mapping widget and a data harmonization Gadget.
Tasks

  • Add support and documentation for mapping software integration with TurboGears, perhaps by improving TWtools To support at least Google Maps and Yahoo! Maps

  • Develop a widget to facilitate column mapping between source and target structures:
    • Allow users to dynamically order multiple field mappings (e.g., mapping street_number, street_name, city from source A to an address field in source B and enforcing the correct column ordering)
  • Build a data harmonization Gadget that would find duplicate records:
    • Duplicates are to be identified based on a criteria established by the administrator
    • Duplicates are to be flagged for further processing

Additional information about weMap: http://wemap.wordpress.com/

A pluggable WebMail manager/reader

Summary
TurboGears needs more ready to use commodity applications
Tags
Application, WebMail
Status
Draft
Mentors
Florent Aide and ???
Description

As we said already on our mailing lists, TurboGears needs all the commodity applications it can to increase its visibility. After all, a lot of sysadmins end-up with PHP installed on their machines because they need to install a specific application (be it a CRM, CMS or webmail).

One important part of this is already existing: TurboMail provides a ready to use multi-threaded email sender.

What is left to implement is a WebMail interface that would enable people to read their mailboxes ala Imp from the Horde project.

Ideally this WebMail application would at least support IMAP and POP3. As a bonus it could offer a Mail filtering editor ala Ingo that would support Sieve and possibly Procmail filters.

As a requirementthis WebMail would definitly need to play nice with the CMS project (see the first project of this page) and be pluggable into an existing application by just a few imports, instanciation and config options.

Topics which are left to the student to propose

FormEncode
Create a JavaScript validation helper library. Sean O'Donnell has already done some work on this, so track him down for more information.
Docudo
Help with the rewrite of docudo for TurboGears 2.
Beaker
To be done...
WebHelpers
To be done...
SQLAlchemy-Migrations
To be done...
Improve the TurboGears Website
See TurboGears Website Spruce Up
Authority
To be done...

GSoC/Ideas2008 (last edited 2008-03-31 20:00:40 by localhost)