CeRTAE SoftMachine est une application web qui consiste à réaliser les interfaces d’une application par la construction de vues à partir d’un modèle de données normalisée.

pip install django-softmachine==1.0.6



Coverage Status

Dj-SoftMachine proposes an approach based on DATARUN method. This approach consists in achieving the interfaces of an application by the contruction of views from a standard data model.

Dj-SoftMachine is in practice a knowledge management system relating to the construction, operation and evolution of information resources (IR). Is a sort of Swiss Army knife to evolve the information system of an organization in accordance with its strategic plans.

You can prototype and export a new application model. The system architecture is a Web MVC variant, this means that we use the basic concepts of Model, View and Controller adapted to a Web App.

Dj Softmachine was developed by the center of research and knowledge transfer in business architecture ( CEntre de Recherche et de Transfert en Architecture d'Entreprise CeRTAE ) of Laval University (Québec, CA.).

GPL License V3

Suggested IDE : Aptana Studio 3

Table of contents

Get Started

SoftMachine can be installed and used in two ways:

  1. Using pip to install a standalone Python package you can reuse in new projects
  2. Deploying as a Django application

Software requirements:

  • Ext JS 4.2.1
  • Python 2.7
  • Django 1.6.1
  • graphviz ([OPTION] For export database diagram)
  • south ([OPTION] For export database migration)

For testing:

$ pip install requests

Install using pip

SoftMachine is best installed via PyPI. To install the latest version, run:

pip install django-softmachine

or Install from github source:

pip install git+git://

Edit your file and add protoLib and prototypeur to your INSTALLED_APPS section:


Also edit your and add the following url patterns:

urlpatterns = patterns('',
    # ... omited code
    url(r'^', include('protoLib.urls')),
    url(r'^protoDiagram/', include('dbDesigner.urls')),

See Setup a new project section for a detailed description.

Deploying as Django app

Production requirements:

  • Python-mysqldb / PyGreSQL / ... ( DbServerConector )
  • Apache
  • Mod_wsgi


Those steps are based on a Ubuntu server, but it is applicable to others Linux distributions.

Hands-on: start by checking Python version in a server terminal, usually Ubuntu comes with Python 2.7. The next step is Django installation, in a terminal type:

sudo apt-get install python-setuptools python-dev build-essential
sudo easy_install pip
sudo pip install Django==1.6.1

To verify that Django can be seen by Python, type python from your shell. Then at the Python prompt, try to import Django

>>> import django
>>> print django.get_version()

Install South by the command:

sudo pip install south

If you are going to use MySQL, you must install the python driver:

sudo apt-get install python-mysqldb

We assume that Apache web server is already installed, if not:

sudo apt-get install apache2

And for an easy deploy install:

sudo apt-get install libapache2-mod-wsgi

Now we are going to configure the web server:

sudo vi /etc/apache2/sites-available/default

Inside the tag <VirtualHost *:80> insert those lines:

Alias /static/admin/ /usr/local/lib/python2.7/dist-packages/django/contrib/admin/static/admin/ WSGIScriptAlias / /var/www/prototypeur/ProtoExt/src/softmachine/prototypeur.wsgi

We are almost there, go to the home folder: cd /var/www/ create a new prototypeur directory mkdir prototypeur and extract the (downloaded from code inside the prototypeur folder, rename the new folder to ProtoExt. Go to the new folder and make sure that is following the security remarks mentioned below. The App won't work is this file is configured improperly.

Download Ext JS from, extract it in /var/www/prototypeur/ProtoExt/static and rename the extracted folder to extjs. Synchronize the database: python src/ syncdb

Make sure that all steps were executed and restart the web server: sudo /etc/init.d/apache2 restart

Open chrome or firefox :

If running from aptana :

If using Apache : http://<server_ip>/protoExt

Security remarks

In order to achieve the security requirements, the should be modified before deploying the Django project.

SECRET_KEY Instead of hardcoding the secret key in the settings module, we are going to load it from a file:

with open('/etc/secret_key.txt') as f:

This file will be generated by CeRTAE upon request.

DEBUG Never enable debug in production so set it to False (DEBUG = False)

Split configuration is used to avoid sending sensitive data to GitHub. This configuration is based on DEBUG variable. If debug is enabled the System is going to load “” otherwise it will import “”.

if DEBUG :
    from softmachine.settings_development import *
    with open( PPATH + '/src/softmachine/secret_key.txt') as f:
        SECRET_KEY =
else :
    from softmachine.settings_production import *
    with open('/etc/secret_key.txt') as f:
        SECRET_KEY =


Reusing SoftMachine in customized projects

If we run the project as a simple Django application we're able to create a relational database model graphically (like DBDesigner) or via forms. More details in the docs *French only.

Once that we've defined our model, entities, attributes and relationships it's possible to create and customize a functional prototype (CRUD) based on entities.

If you're ready to generate a new App, follow the steps below. You should also check this Example

Generating an application

When the prototype is finished we can export the model to generate a new application. The output is a file containing the basics for a new Django app.

Setup a new project

Create a new Django project, if you don't know how, take a look on this Tutorial. Your new project should looks like:


At this point you should have modified those files and as mentioned in Install using pip section.

Extend a template

django-softmachine has two main templates, protoExt.html and protoDebug.html. Both have the same blocks, the difference is that protoExt.html uses minified JavaScript files. See the code bellow to understand how the template is organized (code outside blocks were omitted).

<!DOCTYPE html>
<html lang="fr">
		<meta charset="utf-8">
		{% block sitetitle %}
		<!-- put site title here. i.e.: <title>Proto Certae</title> -->
		{% endblock %}

		{% block meta %}
		<!-- put meta content here. i.e.: <meta name="author" content="CeRTAE U.Laval"> -->
		{% endblock %}
		{% block extjs %}
		<!-- Use this block to replace the extjs implementation-->
		{% endblock %}
		{% block defaultstylesheets %}
		<!-- You can replace all application stylesheets, 
		if you don't want to use the default css put something here -->
		{% endblock %}
		{% block extrastylesheets %}{% endblock %}

		{% block extjsloader %}{% endblock %}
		{% block configproperties %}<!-- You can replace application's variables here -->{% endblock %}
		{% block javascript %}{% endblock %}

Now we're going to extend the templates to customize your application. Django's template inheritance mechanism allows templates to extend other templates and replace named blocks within them. Create a new file inside your templates dir, name it debug.html (it's a good idea to start using the debug mode). Replace the blocks as you wish, for consultation, you can see the example below:

{% extends "protoDebug.html" %}

{% block sitetitle %}
<title>RAI Certae</title>
{% endblock %}

{% block meta %}
<meta name="description" content="">
<meta name="author" content="CeRTAE U.Laval">
{% endblock %}
{% block extrastylesheets %}
<link rel="stylesheet" type="text/css" href="{{ STATIC_URL }}css/rai.css">
{% endblock %}

{% block extjsloader %}
<script type="text/javascript">
// Place to use Ext.Loader methods
{% endblock %}

{% block configproperties %}
<script type="text/javascript" src="{{ STATIC_URL }}js/config/configProperties.js"></script>
{% endblock %}
{% block javascript %}
<script type="text/javascript" src="{{ STATIC_URL }}js/rai/app.js"></script>
{% endblock %}

Add a new ExtJS app

SoftMachine UI is based on ExtJS framework. If you don't like it, you're free to use whatever you want. Just keep in mind that using ExtJS could avoid a lot of hard work :)

So you've decided to use ExtJS. We suppose that you're comfortable with the concept of Single Page Application. SoftMachine UI application is also extensible, you can create your own app, but your app.js must extend ProtoUL.Application

    name: 'RAI',
    paths: {
        'RAI' : 'static/js/rai'

    extend: 'ProtoUL.Application',

    controllers: [

Once this is done you are free to create everything that you want, but to execute you code you must create an especific action inside your model Executing JavaScript.

Customizing models

Executing JavaScript

You have defined a new application and there is a need to use this code for an especific table. Create an action inside protoExt and add the parameters name, executeJS and jsCode as you can see in the cexample code :

class MyAmazingTable(ProtoModel):
    # omitted code ...

    protoExt = { 
        "actions": [
            { "name": "doAmazingAction", "selectionMode" : "single", "executeJS": True, "jsCode":"Ext.create('RAI.view.raccordement.MainWindow',{selectedModel:selectedKeys}).show();",},

If your action uses a selected row you should also add selectionMode (single or multiple). SoftMachine will validate if there is a row selected, otherwise nothing will happen. If you need to get the selected row(s), you must send the parameter selectedKeys to your Window

Dynamic window

You also can execute actions based on dynamic forms. All fields must be defined under actionParams

class OtherTable(ProtoModel):

    protoExt = { 
        "actions": [
            { "name": "doFindReplace", "selectionMode" : "multi", "refreshOnComplete" : True,
               "actionParams": [
                     {"name" : "fieldName", "type" : "string", "required": True, "tooltip" : "field name (meta)" }, 
                     {"name" : "oldText", "type" : "string", "required": True, "tooltip" : "Old values: pyreg.sub(); @all for all text" }, 
                     {"name" : "newText", "type" : "string", "required": True, "tooltip" : "New values" }, 

You should take a look on the models code to check other custom actions


If for any unknown reason you need to create another auto-increment field, you just need to add the attribute _autoIncrementField and specify which column will use the auto-increment, note that this column should be IntegerField

class Evaluation(ProtoModel):
    id_evaluation = models.IntegerField(blank = False, null = False)
    date_evaluation = models.DateField(blank = True, null = True)
    auteur_evaluation = models.CharField(blank= True, null= True, max_length= 255)
    description_evaluation = models.TextField(blank = True, null = True)

    _autoIncrementField = 'id_evaluation'


If you're ready to deploy your new App, check the security remarks and the Django documentation (Deploying Django)

Hint: To serve SoftMachine static files copy ...Python/2.7/lib/python/site-packages/protobase/static to your local static folder...