Five questions to get you thinking

By Kurt Kleiner

I recommend reading the whole article here

Although intelligence as measured by IQ tests is important, so is the ability to think rationally about problems. The surprise is that less intelligent people usually perform just as well as highly intelligent people on problems that test rationality. Here are a few questions that test if you’re a rational thinker.

1. A bat and ball cost $1.10 in total. The bat costs $1 more than the ball. How much does the ball cost?

2. Is the following conclusion logically valid?

Premise 1: All living things need water.

Premise 2: Roses need water.

Therefore, roses are living things.

3. XYZ virus causes a disease in one in every 1,000 people. A test always correctly indicates if a person is infected. The test has a false-positive rate of five per cent – in other words, the test wrongly indicates that the XYZ virus is present in five per cent of the cases in which the person does not have the virus. What is the probability that an individual testing positive actually has the XYZ virus?

4. There are four cards on a table. Each has a letter on one side and a number on the other. The cards look like this:

K A 8 5

Here is a rule: If a card has a vowel on its letter side, it has an even number on its number side. Which card(s) must be turned over to find out if the rule is true or false?

5. According to a comprehensive study by the U.S. Department of Transportation, a particular German car is eight times more likely than a typical family car to kill the occupants of another car in a crash. The U.S. Department of Transportation is considering recommending a ban on the sale of this German car. Do you think the United States should ban the sale of this car?

Answers

1. Five cents. Many people, including students at MIT, Princeton and Harvard, automatically answer 10 cents. After all, a dollar plus 10 cents equals $1.10. But that cognitive shortcut doesn’t work, since it would mean the bat costs only 90 cents more than the ball.

2. No, it is not logical, even though 70 per cent of university students given the problem think it is. Although the conclusion is true, it doesn’t follow from the premises. Consider the same problem worded in a different way:

Premise 1: All insects need oxygen.

Premise 2: Mice need oxygen.

Therefore, mice are insects.

In the original problem, the tendency is to be a cognitive miser, and let the obvious truth of the conclusion substitute for reasoning about its logical validity. (In the second problem, though, our cognitive miser makes the problem easy.)

3. Two per cent. (Most people say 95 per cent.) If one in 1,000 people has the disease, 999 don’t. But with a five per cent false-positive rate, the test will show that almost 50 of them are infected. Of 51 patients testing positive, only one will actually be infected. The math here isn’t especially hard. But thinking the problem through is tricky.

4. A and 5. Ninety per cent of people get this one wrong, usually by picking A and 8. They think they need to confirm the rule by looking for a vowel on the other side of the 8. But the rule only says that vowels must have even numbers, not that consonants can’t. An odd number on the back of the A, or a vowel on the back of the 5, would show that the rule is false.

5. OK, there’s no right or wrong answer here. However, 78 per cent of the people Stanovich sampled thought the German car should be banned. But when he turned the question around so that Germany was considering banning an American car (he was quizzing people in the U.S., by the way), only 51 per cent thought Germany should ban the car. This is an example of “myside bias” – evaluating a problem from a standpoint that is biased toward your own situation.

This is how you add reCaptcha (the captcha system built by Google) to the Django’s comments framework.

Requirements

For this task you will need to build a custom module which depends on django-recaptcha-works. recaptcha-works provides a special Form field named “RecaptchaField”
and a decorator function “fix_recaptcha_remote_ip” which inserts the request’s REMOTE_ADDR (IP) into the request.POST data.

django-recaptcha-works can be downloaded from http://pypi.python.org/pypi/django-recaptcha-works/ or install it with:
pip install django-recaptcha-works

You also need a pair of reCaptcha keys from this address:

https://www.google.com/recaptcha/admin/create

Build a custom comment module

Create a new comment module, add it to INSTALLED_APPS and set a special settings COMMENTS_APP. The process is described on this page:

https://docs.djangoproject.com/en/dev/ref/contrib/comments/custom/

cd /path/to/your/project
mkdir my_comment_app

Make these changes to your settings file (usually settings.py):

INSTALLED_APPS = [
...
'my_comment_app',
...
]
COMMENTS_APP = 'my_comment_app'
RECAPTCHA_PUBLIC_KEY = 'public key'
RECAPTCHA_PRIVATE_KEY = 'private key'

recaptcha-works provides more settings, please check the settings.py from inside the recaptcha-works module.
Here are some interesting settings:

RECAPTCHA_USE_SSL = False
RECAPTCHA_OPTIONS = {
        'theme': 'white',
        'lang': 'en',
        'tabindex': 0,
}
RECAPTCHA_VALIDATION_OVERRIDE = False

Inside your new module “my_comment_app”, create these files:

__init__.py

from .forms import CustomCommentForm
def get_form():
return CustomCommentForm

forms.py

from django.contrib.comments.forms import CommentForm
from django.contrib.comments.models import Comment
from recaptcha_works.fields import RecaptchaField

class CustomCommentForm(CommentForm):
    recaptcha = RecaptchaField(label='Human test', required=True)
    def get_comment_model(self):
        return Comment

models.py

from django.db import models
from django.contrib.comments.models import Comment

class CustomComment(Comment):
    pass

urls.py

from django.conf.urls.defaults import patterns, include, url
from . import views

urlpatterns = patterns("",
    url(r'^post/$', views.custom_post_comment, name='comments-post-comment'),
    url(r'', include('django.contrib.comments.urls')),
)

views.py

from django.contrib.comments.views.comments import post_comment
from recaptcha_works.decorators import fix_recaptcha_remote_ip

def custom_post_comment(request, next=None, using=None):
    return fix_recaptcha_remote_ip(post_comment)(request, next, using)

You can download a sample of the module here.

This is a simple way to setup a LAMP environment after you have just installed a Linux (i.e. Ubuntu)
or if you’d like to replicate the setup of another machine (i.e. duplicate your desktop’s environment to your laptop)
The key is to keep all your customizations in separate files and directories.
We start by creating a new folder where all our custom settings will live.

1. prerequisites

Create a directory named "lamp" with the following structure:

├── apache
│   └── elmo.conf
├── install.sh
├── mysql
│   └── elmo.cnf
├── php
│   └── elmo.ini
└── virtualhosts
├── 000-localhost.conf
└── phpmyadmin.conf

2. configure Apache 2

The default apache2.conf (/etc/apache2/apache2.conf) is setup to include every settings file it can find inside the "conf.d" directory (/etc/apache2/conf.d)
so make sure this line is included:
Include conf.d/

We will sym link our Apache customizations into this directory:
sudo ln -s /lamp/apache/elmo.conf /etc/apache2/conf.d/

You may now add your own Apache settings into the elmo.conf file.
The files under "conf.d" are loaded in order of their file names i.e. aaa.conf loads before bbb.conf
All the files inside "conf.d" are loaded at the end of the apache2.conf so your custom settings may override the defaults.

After the settings are in place, you may want to automatically configure some virtual hosts.
Optionally, you could delete the default/old virtual hosts:
rm /etc/apache2/sites-enabled/*

Now new hosts are ready to be enabled:
ln -s /lamp/virtualhosts/000-localhost.conf /etc/apache2/sites-enabled/

3. configure Mysql 5

Mysql does the same configuration loading as Apache.
The last my.cnf directive is "!includedir /etc/mysql/conf.d/" which loads every settings file from the "conf.d" directory.
Let’s do the symbolic linking:
sudo ln -s /lamp/mysql/elmo.cnf /etc/mysql/conf.d/

Place all your Mysql customizations inside the elmo.cnf file.

4. configure Php / Zend Server CE 5.2

My Php environment is provided by Zend Server Community Edition.
The php.ini file located under /usr/local/zend/etc/ uses this directive to include the settings file from inside "conf.d":
[Zend]
zend.ini_scandir=conf.d

Obviously, we will create a symbolic link to our custom Php settings:
sudo ln -s /lamp/mysql/elmo.ini /usr/local/zend/etc/conf.d/

5. other

If you wish to automate things further add all the commands inside a bash script:

#!/bin/bash
# USAGE: sudo ./install.sh

ROOT="/lamp"

# mysql
ln -s $ROOT/mysql/elmo.cnf /etc/mysql/conf.d/

# apache
ln -s $ROOT/apache/elmo.conf /etc/apache2/conf.d/

# remove old virtual hosts
rm /etc/apache2/sites-enabled/*

# add my virtual hosts
ln -s $ROOT/virtualhosts/000-localhost.conf /etc/apache2/sites-enabled/
ln -s $ROOT/virtualhosts/phpmyadmin.conf /etc/apache2/sites-enabled/

# php configuration
ln -s $ROOT/php/elmo.ini /usr/local/zend/etc/conf.d/

Here you can download a sample

docs.djangoproject.com

The most important resource which will answer most of your questions is the manual.
1. You can either use the built in search:
https://docs.djangoproject.com/search/?q=forms&release=5
2. Or search the documentation though Google (my preference):
http://www.google.com/search?hl=en&tbo=1&q=forms%20site%3Ahttp%3A%2F%2Fdocs.djangoproject.com/en/dev%2F

stackoverflow.com

This is the second biggest resource of information regarding Django development.
There are several ways to search for answers:
1. Use the search form and look for the terms "django" and the topic you are interested in (e.g. "forms"):
http://stackoverflow.com/search?q=django%20forms
2. Search for the tag "django" and your topic of interest (e.g. "forms")
http://stackoverflow.com/search?q=[django]+forms

The first form yields many more results than the second, but the relevance of the second type of search is higher.
Furthermore, you can sort your results by "relevance", "newest", "votes" and "active". I recommend using "votes" when searching for a high level topic like "forms".

Google

If the first 2 methods don’t help, you may need to ask the big boss:
http://www.google.com/search?hl=en&tbo=1&q=django%20forms

You may have to remember to use "+" or "*" inside your queries if you are looking for something very specific.

djangosnippets.org

Small fragments of code that you can use or get inspiration from.

pypi.python.org

Search for Python modules. Try your search with and without the "django" term added to the query.
Example: http://pypi.python.org/pypi?%3Aaction=search&term=django%20forms
A nicer list of Django packages with details about usage, contributions and others is http://djangopackages.com/

others

If you are used to IRC channels, mailing lists or forums this page gives some indications:
https://docs.djangoproject.com/en/dev/faq/help/

search with firefox shortcuts

One last trick for Firefox users, "Add a keyword for this search" improves your query rate a lot. Some of my settings:

Location: http://stackoverflow.com/search?q=%s
Keyword: so

Location: http://www.google.com/search?hl=en&tbo=1&q=%s%20site%3Ahttp%3A%2F%2Fdocs.djangoproject.com/en/dev%2F
Keyword: dj

Location: http://www.google.com/search?hl=en&q=%s%20site%3Adjangosnippets.org
Keyword: djsnip

Location: http://pypi.python.org/pypi?%3Aaction=search&term=%s
Keyword: pip

How do you deploy a php settings file on multiple hosts which require different configurations ?
Let’s use the wp-config.php (WordPress configuration file) as an example.
The following snippets are going to be used inside your project’s config file (wp-config.php in this case)

Solution 1

1.a

if($_SERVER[‘HTTP_HOST’]==’example.com’ || $_SERVER[‘HTTP_HOST’]==’www.example.com’) {
# settings for the host example.com
} else {
# default settings
}

1.b

if(strpos($_SERVER[‘HTTP_HOST’], ‘example.com’)!==false) {
# settings for example.com
} else {
# default settings
}

If you need to define settings for multiple hosts, use a "switch" statement instead of "if"

Instead of "HTTP_HOST" one can also use "SERVER_NAME"

Alternatively to HTTP_HOST one can set the following in the apache’s virtual host
SetEnv APPLICATION_ENV "development"
then check for $_SERVER[‘APPLICATION_ENV’]

Pros
- light on the CPU and no disk access

Cons
- only works when the PHP file (wp-config.php in our example) runs though a web server environment, i.e. $_SERVER[‘HTTP_HOST’] is available.
- all settings live in the same file, if the file is added to a version control system everyone can view those settings.

Running the code though command line won’t work as expected.

Solution 2

if($_SERVER[‘REMOTE_ADDR’]==’127.0.0.1′) {
# localhost settings, host1
} else {
# any other settings, host2
}

Cons
- only works for 2 hosts, a localhost host (host1) and a remote host (host2)
- the settings for the host considered remote (host2) only work when the visitors come from a non-local IP.
If one uses SSH or VCN to access the remote machine (host2) then load the site/script locally, the host1’s settings will get loaded.

Solution 3

Create a file named "wp-config-local.php" in the same directory as wp-config.php then add the following to wp-config.php

if ( file_exists( dirname( __FILE__ ) . ‘/wp-config-local.php’ ) ) {
# the current host’s settings
} else {
# default settings
}

Every host would then manage it’s own wp-config-local.php without the need to share it though a version control system.

Pros
- privacy, it remains private to the host’s users
- works fine even if the script is called though the command line

Cons
- disk access

Hello and welcome

Niftyurls is a popurls-style script built entirely with Django.

Get NiftyUrls from GitHub

View some examples

www.JavascriptNews.com
www.PythonDaddy.com
From the popurls site:

… is the dashboard for the latest web-buzz, a single page that encapsulates up-to-the-minute headlines from the most popular sites on the internet.

Unique features

• Powered by Django
• No tooltips by default, there are better ways of reading the text
• Read the news in a Facebook-style lightbox (“pop” layout)
• Read the news in a clean page (“page” layout)
• Easy editable feed settings, titles, urls, positions in the page
• Javascript assisted by jQuery
• Grid templates provided by Yui3 Grids
• Fast text replacement with Cufon

Upcoming features

• remember visitor’s last viewed links, mark new/old links
• show new links only
• videos support
• admin interface for feed configuration, more config options
• multiple domain support
• site search with database support
• usability improvements
• user accounts, openid support
• code comments, svn support

Installation (linux, localhost)

• 1. Make sure you have the following Python packages available: Django – http://pypi.python.org/pypi/Django/ Pil – http://pypi.python.org/pypi/PIL/ Feedparser – http://pypi.python.org/pypi/feedparser/ You may install these with the “pip” tool (http://pypi.python.org/pypi/pip/) $ pip install “django>=1.3″ $ pip install pil $ pip install feedparser
• 2. Add “niftyurls” to the INSTALLED_APPS tuple. The Niftyurls application depends on the following Django packages: ‘django.contrib.staticfiles’ ‘django.contrib.admin’ To make sure every app is enabled, add the following line to your project’s “settings.py” file: INSTALLED_APPS += (‘django.contrib.staticfiles’, ‘django.contrib.admin’, ‘niftyurls’, )
• 3. Synchronize the database $ python manage.py syncdb
• 4. To add the “niftyurls” in your templates, use the following:

{% load niftyurls_tags %} {% niftyurls_media “js,css” %} {% niftyurls_content %}

• 5. Please check the available Niftyurls settings in niftyurls/settings.py You may add custom values to NIFTYURLS_SETTINGS (please see niftyurls/settings.py) and retrive them inside your templates with: {% niftyurls_settings title %} {% niftyurls_settings h1 %}
• 6. Add some feeds in the admin interface http://127.0.0.1:8000/admin/niftyurls/feed/add/ Here are some feed urls examples: – http://feeds.delicious.com/v2/rss/popular/python?count=15 – http://www.reddit.com/.rss
• 7. Run the following command so that fresh entries are added to the database. $ python manage.py niftyurls_feeds
• 8. Niftyurls templatetags depend on the existing of the “request” inside the templates, in case of errors verify that you have passed the “RequestContext” to the templates. http://docs.djangoproject.com/en/dev/ref/templates/api/#subclassing-context-requestcontext Make sure the TEMPLATE_CONTEXT_PROCESSORS contains the following: (‘django.core.context_processors.request’, ‘django.contrib.auth.context_processors.auth’,)

NiftyUrls’s page on GitHub

What is GTranslator

If you have ever spent more time browsing though non English web page with the help of Google Translate you most noticed some downsides, most common being the one where Google Translate don’t work on some pages.
To make translations easy and on the fly, I wrote this GreaseMonkey (a Firefox addon) script called GTranslator. It uses Google Translate to replace the text inside the web pages with the appropriate translated versions.

Installation

In order to use this tool you’ll be needing Firefox with the GreaseMonkey addon installed.
You just have to open a Firefox instance, visit the tool’s page GTranslator and click on the “Install” button.
After installation, you will have to access the GreaseMonkey menu “Manage User Scripts” and include some pages for which the translation tool will be available.
This “included pages” codes enable the tool for all Swedish, Danish or German, pages
*.se/*
*.dk/*
*.de/*

How it works

There are a couple of shortcuts available:
F8 redirects the loaded url to translate.google.com
F9 translates the current page
F10 enables/disables the auto translation. When automatic translations are enabled the tool translates the text without any user intervention.

Make sure you have enabled the tool for the current TLD (e.g. *.de/*) or specific websites by accessing the “Manage User Scripts” of the GreaseMonkey extension.

If you like the script don’t forget to rate and comment on http://userscripts.org/scripts/show/74306

What is NiftyArticles

NiftyArticles is a small Python script which lets you identify and save articles from inside webpages. It is based on Readability.

Update 10.02.2011

I have made 2 versions of the script, one is using QT4 and the other is based on GTK.
The QT4 version is slightly better.

Installation

Each version depends on readability.js, please download that file and place it in the same directory as the niftyarticle script.

The installation details for each version is located inside the script file.

Usage (QT4 version)

To get a full list of options, run:
python niftyarticles-qt.py –help
OR if you made it executable,
/path/to/niftyarticles-qt.py –help

# save an article from ubuntu.com
python niftyarticles-qt.py -u http://www.ubuntu.com/project/derivatives

Help for the QT4 version

The script has been developed and tested on Python 2.6.6 / Ubuntu Maverick

Install the required packages: python-qt4 libqt4-webkit
Ubuntu or Debian
sudo apt-get install python2.6 python-qt4 libqt4-webkit

(Optional) Mark the script as executable
chmod +x niftyarticles-qt.py

Usage Examples:
python niftyarticles-qt.py --help

# save an article from ubuntu.com
python niftyarticles-qt.py -u http://www.ubuntu.com/project/derivatives

# show the browser window, load images, enable java applets
python niftyarticles-qt.py -b -i -v -u http://www.ubuntu.com/project/canonical-and-ubuntu

# to run the script on a server with no GUI available, you must install xvfb
sudo apt-get install xvfb
# then you can do
xvfb-run -a python niftyarticles-qt.py -u http://www.ubuntu.com/project/derivatives

Webkit Reference

http://webkitgtk.org/reference/index.html

Download the NiftyArticles from GitHub

What is HtmlClipper

HtmlClipper is a bookmarklet which lets you copy html sections of any web pages together with the attached css styles. After the script is enabled inside a web page, you may select and extract any html element together with all it’s children and computed css styles. What you get is a new html document made up of an inline stylesheet and html code needed to render the element as close as possible to what you’ve seen in the source web page.
The bookmarklet only works in Firefox and Google Chrome.

Download HtmlClipper from GitHub

Firefox Installation

• Make sure the “Bookmarks Toolbar” is visible. If it is not, go to menu View > Toolbars.
• Drag this link: Html Clipper up to your Bookmarks Toolbar.

How to use it

• click the bookmarklet from your Bookmarks Toolbar
• click inside the html page to select an element
• press “w” to select the parent element
• press “q” to undo the selection of parent element
• press “r” to remove an element
• press “s” to clip the element
• press ‘esc’ to exit the ‘clipping’ window
• press ‘x’ to exit HtmlClipper

Here are some screenshots of webpage clippings created with HtmlClipper:

Intro

This article is about writing tools in Python to easily deploy your web projects.
A well know deployment library in Python is Fabric. While it’s not really mature (version 0.9.1), it is easy to understand and work with it. The best place to start is the Fabric tutorial.

The Challenge

You develop and maintain many projects. You backup and restore databases several times a day during the development phase or you need to upload or download files from the hosting server often. How would you improve these processes instead using Ftp, mysql/mysqldump or phpmyadmin ?

Quick Fabric Introduction

Fabric gives you instruments to run commands on different hosts and copy/download files to/from remote hosts. In order to do that, you have to prepare a file of available commands named fabfile.py which will be placed in the project’s directory. Having some methods in that file allows you to run the commands like that:

fab hello

where hello is one function defined in fabfile.py
Fabric installation process.
sudo easy_install fabric
OR
sudo pip install fabric

The Solution

Having a lot of projects to maintain and deploy makes difficult to write one fabfile.py for each of them.
Also using remote hosts or writing database queries require you to put sensitive information in the fabfile.py (or pass them as parameters but that’s a different talk)
My thought is to have one location available where I place a fabfile.py and configuration files of all the sensitive information required for deployments, i.e. remote host addresses and maybe passwords, database connection information, etc. If you care more about security than speed of development, don’t store sensitive information there.
I have created a directory /work/fabric with the following structure:
├── fabfile.py
├── projects
│   ├── __init__.py
│   ├── ajaxdaddy.py
│ ├── default.py

fabfile.py contains the deployment code based on Fabric
local.py store configuration details of the localhost database
projects/* store configuration details of specific projects
The project name is the same with the file name used for the configuration.

Instead of placing a fabfile.py inside the project’s directory, we will instruct Fabric where to find the fabfile.
Create a file ~/.fabricrc and write the following line:
fabfile = /path/to/your/fabfile.py
I have mine placed in /work/fabric/fabfile.py

There are more details on fabfile discovery here.

Now we can run “fab” in any location. Here are some examples:
fab c:localhost c:localdb e:db_name=test q:clean
fab e:db_name=test_elgg e:db_file=elgg.dump.sql q:export

Commands Supported

The fabfile.py available for download in the end of this article gives you the power to run several commands useful in deploying projects or databases. Many commands require some parameters to exist, for example a database “clean” command which deletes all the tables from one database would require some connection details i.e. host,user,pass,db_name

Several commands may use the same parameters. To make these parameters available they are loaded from configuration files or passed to the “fab” command. All parameters are stored inside fabfile.py in a dictionary called “env” (environment). The environment is a big dictionary like variable (associative array for the Php users) which may store connection parameters for remote hosts, database connection properties or other information.

Most of the time you will need several params available for one command, e.g. a database command cannot function with only host name and no user provided. To make things easy, configuration files can be written where you define groups of parameters. Such a configuration file is /work/fabric/projects/default.py which is loaded by default. Configurations are simple Python dictionaries defined in Python files under the “projects” directory. It’s up to you to choose the names and the purpose of those settings, i.e., some might refer to database settings and other to remote hosting details. If you want to enable a set of parameters from a config file, first you need to load the file then enable the params.

Let’s take for example:
fab c:localhost c:localdb e:db_name=test q:clean

q:clean is the command and it means: delete all tables from the database define before
e:db_name defines the database
c:localdb loads the localhost database configuration, i.e. host, user, password, etc
c:localhost loads the localhost host details, i.e. host name, port, etc

Example of /work/fabric/projects/default.py file:
config = {
‘localdb': { # configuration name
‘db_user': ‘root’,
‘db_pass': ‘betterprogramming rules’,
‘db_host': ‘localhost’,
‘db_name': ‘test’, # default db_name if none is givven
‘db_file': ‘dump.sql’, # default dump file
},
}

“l” loads a configuration file located under “projects” directory (see the tree structure above)

fab l:ajaxdaddy

# not needed because default is loaded
fab l:default

“c” enables a configuration

# “localhost” is hardcoded into the fabfile.py because it’s mandatory
fab c:localhost

# enables a database configuration
fab c:localdb
fab l:default c:localdb

It’s possible to enable one configuration for a command then enable a different config for the next command.

# the second configuration “secondlocaldb” would overwrite the first one, “localdb”
fab l:default c:localdb c:secondlocalddb

After you enable custom configuration, it is possible to change specific parameters by using the “e” command.

# after i load and enable ajaxdaddy’s parameters, i.e. db_user, db_pass, db_host, db_name i can change the previously stored db_name value by using “e”
fab l:ajaxdaddy c:ajaxdaddydb e:db_name=db2_ajaxdaddy e:db_user=ajaxuser

In conclusion, there are 3 ways to set the parameters which will be used by your commands:
– by writing configuration files and place them under “projects” directory, load the config file (e.g. “l:ajaxdaddy”) and enable a specific group (e.g. “c:ajaxdaddydb”)
– by passing single parameters to the “fab” command (e.g. “e:db_user=gigi”)
– by passing parameters to the command itself (you will see how it works later)

Datase Commands

Database commands starts with “q” and are followed by an action.
The available actions are:
clean: delete all the tables inside the “db_name” database
export: export the database “db_name” to the file “db_file” (db_file may be provided or created programmatically by the fabfile.py from db_name)
import: import “db_file” into “db_name”
show: list all the databases where the “db_user” has access
create: create a new database called “db_name”
grant: grant all on “db_name_new” to “db_user_new” identified by “db_pass_new”

You may define your own actions in the configuration files. You just have to create a class named “DbAction”+actionname , e.g. class DbActionCreate(DbAction) or class DbActionClean(DbAction)
When loading a configuration file, your action class will also load.

# enables localhost (it’s enabled by default anyway), enables localdb so that “q” knows where to operate, sets the environment variable “db_name” to “test” then execute command
fab c:localhost c:localdb e:db_name=test q:clean
same with
fab c:localdb e:db_name=test q:clean

# selects the “test” db and export that db into “dump.sql” file
fab c:localhost c:localdb e:db_name=test e:db_file=dump.sql q:export

# create a new database “test_2″ and grant access to the user defined in “localdbnew”
fab c:localhost c:localdb c:localdbnew e:db_name=test_2 q:create q:grant

# delete all tables from “test” db and import the “test_elgg.sql” file
fab c:localdb e:db_name=test e:db_file=test_elgg.sql q:clean q:import

The list of all parameters used by the database commands:
db_user
db_pass
db_host
db_name
db_file
db_user_new
db_pass_new
db_host_new
db_name_new

File commands

# zip the temp directory, temp must be located under the current directory, it will create “temp.zip”
fab zp:temp

# zip the “temp” directory and create the archive named “mytemp.zip”
fab e:file=temp,dest=mytemp.zip zp

# zip “temp” directory’s content, i.e. do not include the “temp” parent directory in the archive
fab zpi:temp

# unzip “filename.zip” into the “dest” directory
fab uzp:filename.zip,dest
# same with
fab e:file=filename uzp:,dest
# same with
fab e:file=filename,dest=dest uzp

# load the “temp” config file and enable dreamhost parameters (“c:dreamhost”) then upload fabric.localhost.zip into the “stuff” directory located on the remote host inside the base dir. The base directory is defined in “base_dir” parameter, if base_dir=/var/www then the uploaded file will be located in /var/www/stuff/fabric.localhost.zip
fab l:temp c:dreamhost up:fabric.localhost.zip,stuff

# download /var/www/remotefile.zip to the current directory if base_dir=/var/www
fab l:temp c:dreamhost dl:remotefile.zip

List of file commands:
zp: zip a “file” (file or directory) to “dest”
zpi: zip a directory’s contents, exclude the directory itself from the archive
uzp: unzip a “file” to “dest”
up: upload a “source” (local host) to “dest” (remote host)
dl: download a “source” (remote host) to “dest” (local host)
cl: delete a “file”

Complex Commands

# exports “test_elgg” database into “dump.sql” and upload it to “dreamhost”. “up:e.db_file” means that the value of “db_file” located in the environment should be uploaded.
fab c:localhost c:localdb e:db_name=test_elgg e:db_file=dump.sql q:export l:dreamhost c:dreamhost up:e.db_file
# same with
fab c:localdb e:db_name=test_elgg e:db_file=dump.sql q:export l:dreamhost c:dreamhost up:dump.sql
# similar but different dump name “test_elgg.sql” created by default from “db_name” + “.sql”
fab c:localdb e:db_name=test_elgg q:export l:dreamhost c:dreamhost up:test_elgg.sql

# same as above, but upload a zip file which will be called by default “dump.sql.localhost.zip”
fab c:localdb e:db_name=test_elgg e:db_file=dump.sql q:export zp:dump.sql l:dreamhost c:dreamhost up

# same but unzip on destination
fab c:localdb e:db_name=test_elgg e:db_file=dump.sql q:export zp:dump.sql l:dreamhost c:dreamhost up uzp

# same but delete “cl” the dump.sql from localhost and delete “cl” dump.sql from the remote host
fab c:localdb e:db_name=test_elgg e:db_file=dump.sql q:export zp:dump.sql cl:dump.sql l:dreamhost c:dreamhost up uzp cl:dump.sql

Download fabfile.py and a few examples