Qt is a cross platform application framework that is made up of not only a GUI widget toolkit, but also classes for working with OpenGL, SQL databases, threading, network protocols (HTTP, FTP, UDP, TCP) and much more. Currently Python has two separate bindings for the Qt framework: Pyside and PyQt. In this post we look at Pyside and PyQt and the resources that exist for learning them.

Pyside or PyQt?

Both Pyside and PyQt have full Python bindings for Qt 4.7 and are available for Mac, Windows and Linux. The main difference between the two is how they are licensed. PyQt is developed by River Bank Computing and is available under the GPL or a commercial license. This means that if your application is open source you can use the free GPL version, but if your application is closed source you need to buy the commercial license (350 GBP). Pyside is licensed under the LGPL so it can be used in both open and closed source applications with no cost. In addition to the standard Desktop bindings, Pyside is also available for the Maemo and MeeGo mobile platforms.

Because Pyside is a relatively young project the majority of articles and tutorials on the web are titled with PyQt. Don’t let this put you off if you intend only to use Pyside. For the most part PyQt and Pyside are API compatible and all differences between the two projects are listed on the official wiki.

Qt Designer

Qt Designer is a layout and forms GUI builder. Developers can drag and drop Qt widgets (buttons, lists, tables, menus, inputs etc.) onto a window and then resize and position them how they want their application to look. Once the GUI is designed it can then be exported to an XML dialect and loaded into PyQt or Pyside. The following tutorials are for getting started and using Qt Designer:

• Getting to know Qt Designer
• Qt Designer quick start
• Qt Designer Manual
• Creating GUI applications with PyQt and Qt Designer

Learning Python Qt

An Introduction to PyQt by Mark Mruss of LearningPython is an excellent beginners introduction to PyQt. It assumes no prior knowledge of PyQt or GUI programming and walks you through creating a basic hello world window.

Jan Bodnar of Zetcode has written a great series of tutorials introducing PyQt 4. They cover menus, signals, layouts, basic widgets and concludes by writing a tetris game. Zetcode is probably the best single resource for learning PyQt as it covers much of the API. All of the tutorials are well written and have clear code snippets and screenshots to accompany each example.

PyQt By Example, by Roberto Alsina, is a five part tutorial that walks you through creating a to-do list application. It is extremely detailed and covers things like database interaction using Elixer/SQLAlchemy and designing the UI in Qt Designer. This tutorial shows you how to build a full featured GUI application using PyQt and is perfect for those who are new to Qt and have done little to no GUI programming before.

Books

There are currently two books that cover Python Qt4.X and one book that covers Python Qt2.X. GUI Programming with Python: QT by Boudewijn Rempt was written in 2001 and covers the PyQt 2.X and some 3.X bindings. Although this is outdated and not available for print anymore, it is free to read online so you may pick up some tips or tricks. Rapid GUI Programming with Python and Qt: The Definitive Guide to PyQt Programming by Mark Summerfield was written in October 2007 and covers PyQt 4.2 and 4.3. This is probably the single most useful resource as it covers the majority of the PyQt API as well as GUI programming design patterns. Summerfield has provided updated code examples from the book that are compatible with PyQt 4.7 and Pyside, they are available on the book’s website. Advanced PyQt4, by Jan Bodnar (writer of Zetcode), is a 248 page ebook that focuses on some of the lesser documented and advanced parts of PyQt. This includes graphics, layout management and model/view widgets such as QTableView, QListView and QTreeView. Although I have not read it, the summary, authors reputation and price ($23) suggests this would be a very good book to buy.

Setup

We need the Python package django-dojoserializer. This can be installed by downloading the source and running

python setup.py install

or with setuptools using

easy_install django-dojoserializer

or with pip using

pip install django-dojoserializer

Then add django-dojoserializer to the INSTALLED_APPS tuple in settings.py.

Dojo will need to be linked correctly in the Django template. We need to require the dojox.grid.DataGrid and dojo.data.ItemFileReadStore classes.

<script src="/static/libs/dojo/dojo.js" djConfig="parseOnLoad: true">%lt;/script>
<script type="text/javascript">
dojo.require('dojox.grid.DataGrid');
dojo.require('dojo.data.ItemFileReadStore');
</script>

Django Model

PROXY_TYPE_CHOICES = (

	('SOCKS4', 'SOCKS4'),
	('SOCKS5', 'SOCKS5'),
	('HTTP', 'HTTP'),

)

class Proxy(models.Model):
	ip = models.CharField(max_length=50)
	type = models.CharField(max_length=6, choices=PROXY_TYPE_CHOICES)
	alive = models.BooleanField(default=False)
	added = models.DateTimeField(auto_now=False, auto_now_add=True)
	last_checked = models.DateTimeField(auto_now=True, auto_now_add=False)

	def __unicode__(self):
		return self.ip

Django View

The view needs to display data from our model as JSON which is correctly formatted for the Dojo DataTable. Simply encoding the Django queryset as a JSON object would not work. Thankfully django-dojoserializer provides the dojoserializer.serialize() method which correctly formats our the queryset in a format the DataTable can read. The route /render/proxies maps to the following view:

from django.http import HttpResponse
from proxies.models import Proxy
from dojoserializer import serialize

def render_json(request):

	proxies = Proxy.objects.filter(alive=True)

	json_data = serialize(proxies)

	return HttpResponse(json_data, mimetype="application/json")

This gives the following output:

Defining the DataTable

We define the Dojo DataTable in two parts. The first is a Javascript representation of the structure of the DataTable, the second part is a <div> for where the DataTable will sit in markup. Note that each field attribute is the exact name of the corresponding field from the Django model. If the names do match the data will not display in the table.

var layoutProxies = [
            [{
                field: "ip",
                name: "IP",
                width: 'auto'
            },
            {
                field: "type",
                name: "Type",
                width: 'auto'
            },
            {
                field: "last_checked",
                name: "Last Checked",
                width: 10
            },
            {
                field: "alive",
                name: "Alive",
                width: 'auto'
            }

            ]];

Note the structure attribute of the div is set to the value of our structure. We will define proxyStore, the value of the store attribute below.

<div id="proxyGrid" dojoType="dojox.grid.DataGrid" store="proxyStore" structure="layoutProxies" query="{}" rowsPerPage="40"></div>

Connecting the DataTable to The Proxy Data

Finally we need to specify the proxyStore variable for the table to pull its data from. proxyStore is an instance of dojo.data.ItemFileReadStore(). We pass the URL of our JSON file and set urlPreventCache to true.

proxyStore = new dojo.data.ItemFileReadStore({url: '/render/proxies', urlPreventCache: true});

Which gives the final product:

In a recent Django project I needed to issue some HTTP requests to a website, save the results and then display the information to the user. I could have issued those HTTP requests in a Django view, however the requests could take up to 10 seconds to return, and I didn’t want the page hanging that long for the user. I ended up using Celery, an asynchronous task queue written in Python, to execute the requests.

Installation

Celery
Celery is in pypi so installation is simple.

easy_install celery

pip install celery

Or download the source code, extract it and

python setup.py install

Django + Celery
In a high traffic production environment Celery should be paired with the RabbitMQ backend. However for my low traffic application I went with the django-kombu backend. django-kombu uses the Django database as a message store and requires very little configuration compared to other backends. We also need the djcelery package.

easy_install django-kombu

easy_install django-celery

Configuration

Before we can start using Celery we need configure our Django project. In settings.py make sure you add djkombu and djcelery to the INSTALLED_APPS tuple. Also make sure your database is configured and working.

Also add the following lines to settings.py.

import djcelery
djcelery.setup_loader()

BROKER_BACKEND = "djkombu.transport.DatabaseTransport"
#celery
BROKER_HOST = "localhost"
BROKER_PORT = 5672
BROKER_USER = "guest"
BROKER_PASSWORD = "guest"
BROKER_VHOST = "/"

Defining Tasks

All Celery tasks should be defined in PROJECT/APPNAME/tasks.py. You can define your tasks as methods with a Celery decorator, or as classes which inherit from a base Celery Task class. I prefer the class definitions. Each task must define a run method (which is called when the task is executed). Finally, each task must be registered with Celery so that they can be found. Below is a modified version of one of my Tasks.

import pycurl
from celery.task import Task
from celery.registry import tasks
from website.models import Website

class CheckWebsiteTask(Task):

	def run(self, ip, **kwargs):

		p, created = Website.objects.get_or_create(ip=ip)

		try:
			c = pycurl.Curl()
			c.setopt(pycurl.URL, ip)
			c.setopt(pycurl.TIMEOUT, 10)

			c.perform()

			p.alive = True

		except Exception, e:
			print e
			p.alive = False

		p.save()

tasks.register(CheckWebsiteTask)

Calling Tasks

Typically you will want to call your tasks somewhere in your view code. Just import your task and call it’s delay method, passing in the arguments that you specified in the run method of your task. The task will then be added to the queue within 5 or 10 seconds and the queue will then start to clear itself.

from django.http import HttpResponseRedirect

from website.tasks import CheckWebsiteTask
from website.models import Website

def check(request,id):

	website = Website.objects.get(id=id)

	CheckWebsiteTask.delay(website.ip)

	return HttpResponseRedirect('/')

Starting Celery

python manage.py celeryd -l info --settings=settings

Celery In The Real World

If you want to learn more about Celery then I recommend you read up on the various articles and tutorials on the Celery website. There is a list of Django apps that use Celery in one way or another, you may be able to use some of these in your own applications. Finally you can browse the source code of celery and django-celery on github to learn how they work under the hood.

1. HTML5Lib
HTML5Lib is a Python implementation of a HTML parser based on the WHATWG HTML5 specification. It includes HTML and CSS sanitizer, DOM to SAX convertor, character encoding detection and filtering and serializing of tress.

2. Django-CMS
This is perhaps the best CMS based on Django. The installation is little tricky and you need to be familiar with Python and Django to successfully install Django-CMS. Once done, it’s easy to use and configure. Some of the major features include Flexible Plugin Architecture, SEO Optimization, Editorial Workflow, Versioning and support for custom extensions.
Get more information about Django-CMS at – http://www.django-cms.org

3. Tornado
From their website – “Tornado is an open source version of the scalable, non-blocking web server and tools that power FriendFeed. The framework is distinct from most mainstream web server frameworks because it is non-blocking and reasonably fast.  Because it is non-blocking and uses epoll, it can handle 1000s of simultaneous standing connections, which means the framework is ideal for real-time web services.”
P.S – I am currently playing with Tornado and would soon post a detailed article about it. Stay tuned!

4. Multi-Mechanize
This one is my favorite! Multi-Mechanize is an open source framework for web performance and load testing. It allows you to run simultaneous python scripts to generate load (synthetic transactions) against a web site or web service.You programmatically create test scripts to simulate virtual user activity. Your scripts will then generate HTTP requests to intelligently navigate a web site or send requests to a web service. The reports and graphs are really impressive and can help you a lot in monitoring the performance of your website. You should really take a shot at this project! Highly recommended!

Some other interesting projects include:
1. Facebook Python SDK
2. Python-OAuth
3. Django Social Auth
4. Boto

In the Python Web Framework Django, template tags can be used to modify data that is about to be output in a Django template file. In this tutorial we will learn how to create and use our own template tags in a Django application.

Setting Up

Template tag definitions are stored in Django apps. The template tags in each app should be relevant to the models and views in that app. You shouldn’t have one app that stores every single template tag you use throughout your website. Each app can contain a directory called templatetags and assuming the app is added to settings.INSTALLED_APPS, Django will automatically search that appname/templatetags/ directory for template tag definitions. Remember to put an __init__.py file in each templatetags directory because the template tags inside them are imported.

Example

In an application I worked on recently I needed to display some data about a World Of Warcraft character such as their race, class and gender. The information about the character was stored in a database table and was referenced like so:

This means that if the character was a Male Orc Shaman, then the gender column would read 0, the race column would read 2 and the class column would read 64. If I were to output this information on the screen, the numbers wouldn’t mean anything to anybody. In order to turn those numbers into something meaningful (an actual word for the gender/race/class) I would either need to manipulate the data in the appropriate Django view, or in the template. Writing a template tag to do this is quick, easy and gives a tidy result so I decided to do this.

Usage Example

If we had a Django template with information about the Male Orc Shaman stored in the character object.

{{ character.class }}

Would output 64. However using the template tag (that we are about to write)..

 {% load char_utils %}
{{ character.class|class_name }}

would output Shaman. Notice the {% load char_utils %}. char_utils refers to the name of the python file we define the template tags in (appname/templatetags/char_utils.py).

Writing the Template Tag

We will define the template tags in the file *appname*/templatetags/char_utils.py. At the top of this file we need to import the django.template module and set up Django’s template tag registry.

from django import template

register = template.Library()

Template tag definitions are just standard Python functions. The argument the function accepts is what the template tag is applied to (in the above example class_name was applied to character.class). Our template tags will accept one parameter, the numerical id (eg 64 for Shaman) and will turn that number into the appropriate name.

def race_name(id):
    races = {

    1 : 'human',
    2 : 'orc',
    4 : 'dwarf',
    5 : 'undead',
    6 : 'tauren',
    8 : 'nightelf',
    16 : 'undead',
    32 : 'tauren',
    64 : 'gnome',
    128 : 'troll',
    512 : 'bloodelf',
    1024 : 'draenai',

    }

    return races.get(id)

def class_name(id):

    classes = {

    1 : 'warrior',
    2 : 'paladin',
    4 : 'hunter',
    6 : 'deathknight',
    8 : 'rogue',
    16 : 'priest',
    32 : 'deathknight',
    64 : 'shaman',
    128 : 'mage',
    256 : 'warlock',
    1024 : 'druid',
    }

    return classes.get(id)

def gender_name(id):

    genders = {
    0 : 'male',
    1 : 'female',
    }

    return genders.get(id)

Finally we need to register the template tags with Django so that it knows that we want to use them.

register.filter('race_name', race_name)
register.filter('class_name', class_name)
register.filter('gender_name', gender_name)

The template tags will now work. If you have any questions or feedback please leave them in the comments below.

Installation

Skype4Py is a normal Python module and is listed in the Python package index (Pypi). To install it with setuptools enter the following in a command prompt.

easy_install Skype4Py

To install it with pip enter the following in a command prompt.

pip install Skype4Py

Getting Started

Skype4Py interacts with the Skype client running on your desktop, it doesn’t talk directly to the Skype servers. For any of the scripts we cover in this tutorial to work the Skype application must be running and you need to be logged in. You can either start Skype yourself or use the following snippet to start it using Skype4Py.

s = Skype4Py.Skype()

if not s.Client.IsRunning:
	s.Client.Start()

Before we can interact with the Skype client from Skype2Py, we need to connect Skype4Py to the instance of Skype running on your desktop. This is done using the Attach method.

import Skype4Py

s = Skype4Py.Skype()
s.Attach()

After executing this you need to check the Skype client on your desktop. A notification similar to the one below will appear. This ensures that no virus or 3rd party program can use your Skype account without your knowledge. Click ‘Allow access’.

User Information

Skype4Py provides a User class which represents a user’s Skype account. We can access information such as the user’s full name, their Skype status and when they were last logged into Skype. To get the person who is currently logged into the Skype client’s information we need to use the CurrentUser class.

import Skype4Py
s = Skype4Py.Skype()
s.Attach()

print 'Full Name: %s' % s.CurrentUser.FullName
print 'Skype Status: %s' % s.CurrentUser.OnlineStatus
print 'Country: %s' % s.CurrentUser.Country

To access information about the current Skype user’s friends, we need to use the Friends class. The snippet below iterates over all of the current Skype user’s friends and prints some information about them.

import Skype4Py
s = Skype4Py.Skype()
s.Attach()

for f in s.Friends:
	print 'Full Name: %s' % f.FullName
	print 'Skype Status: %s' % f.OnlineStatus
	print 'Country: %s' % f.Country

Sending SMS Messages

Skype4Py can also be used to send SMS messages. Only Skype users who have credit in their Skype account can send SMS. Be sure to check local SMS rates on the Skype website before using and never put this code in a loop without double checking it first. Make sure you include your country’s international prefix at the beginning of the number variable. After using this code my phone received the SMS 20 seconds later (NZ carrier).

import Skype4Py
s = Skype4Py.Skype()
s.Attach()

message = 'Hello SMS from Query7'
number = '+641234567890' 

m = s.CreateSms(Skype4Py.smsMessageTypeOutgoing, number)
m.Body = message

m.Send()

What Else Can Skype4Py Do?

• Download and play voice mail messages
• Transfer files between Skype clients
• Interact with Skype chat messages

Today, Python is being extensively used at Google, Yahoo, CERN, NASA and ITA. It has been successfully embedded in a number of software products as a scripting language including Maya,MotionBuilder, SoftImage, Cinema4D, Blender, GIMP and Paint Shop Pro. Python has also been actively used for writing web applications. Some of the most sophisticated Python web frameworks include Django, Pylons, TurboGears and Web2Py.

In this article, I’ll provide you some resources, which will help you get started with Python:

Google Code: Getting Started – Python
Python Programming Tutorials
A Gentle Introduction to Programming Using Python
Dive Into Python
How to think like a computer scientist – Learning with Python

I hope these resources will give you a hang of Python.We would be soon starting a series on web application and blog development using the Django framework. I hope you would be pretty much familiar with Python by that time! See you soon with more Python awesomeness!

Getting Started

Authentication backends are pure python classes. Given a username and password, they are expected to validate them against an authentication source (such as a database) and return a User object. There is no requirement as to where the class is placed, however I always put it in the same directory as the application that handles registrations and logging in.
When a user logs in, Django will check the AUTHENTICATION_BACKENDS (tuple) setting and iterate through all backends until one returns true. The default authentication backend is django.contrib.auth.backends.ModelBackend.

Writing Our Backend

Our backend must have two methods: authenticate and get_user

authenticate takes two arguments – username and password. It is expected to return a User instance or None. The authenticate method should check the given username and password against the user table of the legacy application. If the credentials match, then create a new User instance, save it, and return it. If they don’t match then return None.

get_user takes one argument – user_id. It is expected to return a User object.

Example

Below is an auth backend I have written for a legacy application. The application had a different password encryption algorithm and no permissions structure.

authenticate first tests the username and password in the legacy database. If it is valid then it will check if a User instance exists in the Django authentication system. If there is no record of the user in the Django User table, then we create a new user.

from account.models import Account
from account.utils import trinity_password
from django.contrib.auth.models import User

class AuthBackend(object):

   def authenticate(self, username, password):

       try:
           account = Account.objects.using('realmd').get(username=username, sha_pass_hash=trinity_password(username, password))

           try:
               user = User.objects.get(username=username)

           except User.DoesNotExist:

               user = User(username=account.username)
               user.is_staff = False
               user.is_superuser = False
               user.set_unusable_password()
               user.save()

           return user

       except Account.DoesNotExist:

           return None

   def get_user(self, id):
       try:
           return User.objects.get(id=id)
       except User.DoesNotExist:
           return None

To use our authentication backend we just need to add it to the AUTHENTICATION_BACKENDS tuple like so:

AUTHENTICATION_BACKENDS = (

'pythonicPath.to.AuthBackend',
‘django.contrib.auth.backends.ModelBackend’,

)

Conclusion

The Django authentication system is very flexible and allows you to easily write your own backend. If you have any questions about writing your own Django auth backend, or need any help doing so, feel free to comment below.

• It’s not how much and what you know; but what you can do with what you know, which’s important.

• Ability to implement Polymorphism, Inheritance, private, public namespaces, static methods etc is no guarantee you are a good OO developer.

• OOP is useless if you don’t use it to create good software design (architecture).

• Using packages, classes, etc does not guarantee good software design.

• When designing your software, think of it as an electronic device you are designing.

• Sketch out the ‘electronic device’. Label the different components, list their functionalities.

• Stay hungry, stay foolish.

That’s it for today. I hope you are blessed with more knowledge, and the ability to make the best use of them.  Adios!