Start Ringo
High level web application framework

About

Ringo is a Python based high level web application framework build on top of Pyramid. The framework can be used to build form based management or administration software.

Major scope of application for Ringo are form based and data driven management and administration applications.

Ringo started in 2013 as a coding pet project of Torsten Irländer. He looks back on almost 10 years of python web application development. Having enough from building web applications with similar needs like user administration, permissions systems or nice forms with validation from scratch every time he decided to build Ringo as a high level web framework which provides typical features often needed in web applications.


Strength

Ringo provides a building block architecture and "Ready to Use" components.. This allows fast and flexible development.

With main focus on form based application Ringo uses formbar as form library. This opens great capabilities on form layout, validation and workflows.

Together this makes Ringo a great tool in a rapid development process.

Who uses Ringo

Ringo is currently used in various areas of social casework:

  • eFa – Specialist application to support data acquisition and evolution within in Case Management like processes.
  • Various implementation like WASKA, PWE, SIB based on eFa.
  • Prospi – Project management and monitoring software focused on projects in social work.

Further management software:

  • Plorma – Task management software with aspects to support agile software development in SCRUM like product management.

Status

Ringo is ready for the use in productive environment and is continuously developed through various projects.

  • Stable Version: 1.4

The development currently happens exclusive on the head of the source repository. There is no maintenance on older versions yet.

Features


Building block system

Write less code! The key idea behind Ringo is to provide a building block system which allows you to easily add and link Modules which will handle data persistence and business logic. Adding modules is very easy and you will not even need to write a single line of code to get started to store data in your application.

Batteries included

Many of often used features in web applications like Logging, Versioning, Comments, File uploads, Print templates, Tags, Nested Elements are already included in Ringo. They can easily be added to your modules through mixins.

User management

Manage your Users in Usergroups and store Profiles along with them in the web interface. Optionally provide new user a User registration and allow users to reset their password using a email based Password reset function in case they forget their password.

Permission system

A fine graded role based permission system allows you define who is allowed to do what on each single item in your application.

Powerful forms

In data driven application forms are one of the most important elements in your application. Ringo uses the Formbar library, which gives to large freedom to design and validate your forms.

Workflows

A state machine in Ringo let you define the business logic in your application. Define actions when doing transitions between states and ensure with conditions that a certain state can only reached if your defined preconditions are fulfilled.

Configurable

Changing the layout of the GUI? Changing the default behaviour of a particular module action? Not problem. Ringo provides many ways to adapt the default application to your need. Further Ringo come with a administration UI which which let you configure many aspects of your application.

REST INTERFACE

A Ringo based application is not only traditional web applications with an integrated GUI. Every module also has a REST-Interface for every core method which can be used from external clients.

Extensible

Using the plugin mechanism of Ringo developers have the option to write external extensions for Ringo which can be plugged into your application to add some general functionality.

Get started!


The following steps will show you how easy it is to create a Ringo based application using a PostgreSQL database and start storing your data in a new module. The new application will be called Foo

0. Requirements

This setup is tested on Ubuntu 12.10 but should (hopefully) work on other distributions too.

  • Python 2.7.8
  • A PostgreSQL or any other "real" database. With version 1.2.0 SQLite is no longer supported!. The setup of the database is out of scope of this short introducion. Please refer to the documentation of your database.
    The default configuration expects that the user who starts the application is allowed to connect to configured database without a password using unix sockets. If you want a different behaviour you can change the db connection in the development.ini file.
  • Virtualenv (Tested with version 1.11.6)
  • On installation at least lxml and psycopg2 (PostgreSQL Driver for Postgres) will be compiled so you might need some extra libraries (dev packages) and tools... Will add more details soon.

1. Create a home for your development

First start with creating some folders where your ringo application development can happen.

                  mkdir Foo
                  cd Foo
                  # Create a virtualenv for your new Foo application
                  virtualenv env
                  # Activate the virtual env and continue the next steps with
                  # activated virtual env.
                  source env/bin/activate
                  

2. Download and install Ringo

Get the source from Bitbucket and install Ringo.

                  hg clone https://bitbucket.org/ti/ringo
                  cd ringo
                  python setup.py develop
                  # Leave the ringo directory to continue with the next step.
                  cd ..
                  

3. Create a new Ringo based application

Ringo comes with an application scaffold which make it easy to create a new Ringo based application.

                  pcreate -t ringo Foo
                  cd Foo
                  python setup.py develop
                  

To be able to do the next steps you need to install your new application too.

4. Initialise the database and start the application.

Initialise the database by invoking one of the nice administration commands. After that we can start our fresh created application for the first time.

                  createdb foo
                  foo-admin db init
                  pserve development.ini
                  

Stop the server by pressing CTRL-C

5. Create a new module for your application

Wow that was easy! But wait. We want to create a new module to store some custom items in our application. Let's say we want to store bar items. Creating a new module is easy. Thanks to the administration command its simply a question of doing the following.

                  # First we will backup the database.
                  pg_admin foo > foo.sql
                  # Then invoke the command to add a new modul to your
                  # application
                  foo-admin modul add bar
                  # Please follow the instructions printed on the console
                  # after invoking the command.
                  # Touch and apply the generated alembic migration script to
                  # update your database. Touching is currently crucial for a
                  # working migration!
                  touch /path/to/the/generated/migrationscript.py
                  foo-admin db upgrade
                  

This command will create a new module called "bar" and also creates default LCRUDIE (List, Create, Read, Delete, Import and Export) views!

6. Customize the new module.

This step is optional. If just want to get a fast impression of a Ringo based application skip over to step 7.

Otherwise this step is a good starting point if you want to actually safe something useful in your new module. The created module is still empty. It just has the basic attribute like an internal ID. It is waiting to be filled with life ;)
The next steps are

  1. Extending the model of the module by adding new fields.
  2. Designing nice forms.
  3. Configuring the overview page.
Step 1 and 2 can be seen as one step which is described in the Ringo documentation. See Adding new fields to the model section.

7. Start your new application

Here we are! Its time to launch the application.

                  pserve --reload development.ini