Hi django fridayers !

Today on python friday, we will discuss the model and data migration of django.

Many of you are probably developing the web app in python and are absolutely amazed about how easy it to create a database schema from your django models. Just run an manage.py syncdb and …voila ! Your brand new application has all the support needed in the backend database.

But let’s face it, this is not really practical when it comes to modify an application that is ALREADY online and have data (registered users, stored personal information, …).

The problem

How can you migrate from one model to another without loosing any data ?

The solution.

South

This python package will take care of most of the trouble caused by your model modifications.
With South, you can :

• Modify the schema of your database according to your model
• Migrate your data to make sure that you wont lose any data across the migration

Installing South

• download
• setup.py install (as root)
• edit your settings.py to activate “south” in the installed apps

A simple example

You can now type :

$> ./manage syncdb

to create the good tables in your database. South keep track of every migration in the project database.

Now, let’s consider that you have a the following model:

class Customer(models.Model):
    name = models.CharField(max_length= 60)

    def __unicode__(self):
        return self.name

The first thing you need to do is to initialize south so it can keep track of your
modification of models:

$> manage.py startmigration customer initial --initial

This will create your first migration (initial). The migration will basically creates the tables in your database.
Now, you can apply the migration.

$> manage.py migrate

Now, let’s assume that you want to change it into:

class Customer(models.Model):
    name = models.CharField(max_length = 60)
    password = models.CharField('this is a clear text password', max_length=60)

You have to prepare the migration with the following command:

$> ./manage.py startmigration customer add_password --auto

This creates a migration file that contains your modifications. I let you try to figure out what forward and backward methods are for. Once again, when you think that your migration file is good, you can apply the changes :

$> ./manage.py migrate

At this point, your database is totally synced with your model, so let’s create some data into it:

$> ./manage.py shell
> from customer.models import Customer
> c = Customer()
> c.name="sebastien requiem"
> c.password = "secret"
> c.save()
> Customer.objects.all()
[\]

A more complex example with DATA migration

You now decide to split the field name into firstname and lastname. The natural way would be to delete the field name and create two fields named firstname and lastname. And this is Wrong for many reasons:

1. South will not understand that you want to split the name into two distinct fields
2. South won’t be able to migrate your data forward AND backward if you want to roll back

The good (and ONLY) way to do it is to so it in three steps:

1. modify your model so you add firstname and lastname fields and migrate the schema
2. create a migration that migrate your DATA (while name, name, firstname and lastname are all accessible)
3. delete the name field

Now, let’s assume that you want to change you previous model into the following :

class Customer(models.Model):
    name = models.CharField(max_length = 60)
    firstname = models.CharField(max_length = 60)
    lastname = models.CharField(max_length = 60)
    password = models.CharField('this is a clear text pasword', length=60)

    def __unicode__(self):
        return self.firstname + ", " + self.lastname

Migrating the schema

Nothing fancy here:

$> ./manage.py startmigration customer add_first_last_name --auto
$> ./manage.py migrate

Migrate the data

$> ./manage.py startmigration customer first_last_data
now edit the migration file newly created and add the following lines :

    def forwards(self, orm):
        for customer in orm.Customer.objects.all():
            try:
                customer.first_name, customer.last_name = adopter.name.split(" ", 1)
            except ValueError:
                customer.first_name, customer.last_name = customer.name, ""
            customer.save()

    def backwards(self, orm):
        for customer in orm.Customer.objects.all():
            customer.name = customer.firstname + " " + customer.lastname
            customer.save()

As you can see, the variable “orm” is in fact the real django ORM. you can use it to write data migration in python with the usual django syntax, which is VERY convenient.

run now you data migration:

$> ./manage.py migrate

A quick django shell will ensure that we have the data present in the database where we expect it to be :

$>./manage shell
> from customer.models import Customer
> Customer.objects.all()
[]

We now just need to delete the remaining an unused field.

Change your model :

class Customer(models.Model):
    firstname = models.CharField(max_length = 60)
    lastname = models.CharField(max_length = 60)
    password = models.CharField('this is a clear text password', length=60)

and run a simple migration with –auto

$> ./manage.py startmigration customer remove_name --auto

and apply

$> ./manage.py migrate

Voila.

References:

• The South migration tools

Hi everyone,

Welcome for the first edition for python-friday ! This python friday will be dedicated to the so popular django web framework because I really have my hands in it for the time being.

Django offers a very nice User class to manage all sort of users, set rights, contact information and so on. But sometimes, you want to extend that class to add some extra information.

The problem:
You want to use your – let’s call it – Customer class as the central user class and authenticate using django’s user modules.

The solution:
Extend the user classs to add your data and configure django framework to use your new class as a middleware and authenticate on it.

Extending the class.

from django.contrib.auth.models import User, UserManager

class Customer(User):
	"""
	Model for customer.Hold administrative information
	"""
	company_name = models.CharField('company name', unique=True, max_length = 50)
	tax_number = models.CharField('tax number', max_length = 12)
	address = models.CharField('address line 1', max_length = 200)
	zip_code = models.IntegerField('zip code', max_length = 10)
	city_name = models.CharField('city name', max_length = 20)
	country = models.CharField('country', max_length = 20)
	edited_on = models.DateTimeField(auto_now=True, auto_now_add=True, editable=False)

	# We setup a manager here.. not really sure this is useful
	objects = UserManager()

	def __unicode__(self):
		return self.company_name

	# In the save function, we implement our own password
	# management. If the password is already hashed in the form
	# we just dont change anything otherwise we call the set_password()
	def save(self):
		password = ""
		r = re.compile('sha1\$.*')
		if not r.match(self.password):
			password = self.password
			self.set_password(self.password)
		User.save(self)

Now that we have extended the class, we can play a bit with it to see how things goes :

> c = Customer()
> c.username = "mms"
> c.lastname = "sauvage"
> c.firstname = "manumanu"
> c.company_name = "the Corp"
#and so on ...
and finally
> c.save()

But wait …. Haven’t we said that django has its own authentication methods ? Well, how do you want Django framework to know that it has to authenticate against the customer table and NOT against django users’ table ?

Well, django can let us redefine the authentication backend. Doing so will then change the authentication behavior the way we want to be.

Redefining djjango’s authentication backend.

First we have to declare our new authenticate backend in the settings.py. While we are in that file, we will also tell django which class to use to authenticate :

AUTHENTICATION_BACKENDS = (
    'project.auth_backend.CustomerModelBackend',
)

CUSTOM_USER_MODEL = 'accounts.Customer'

We just say here that the backend will be in the file auth_backen.py and the class will be named CustomerModelBackend.

Then create a file called auth-backend.py in your project directory and add it the following content:

from django.conf import settings
from django.contrib.auth.backends import ModelBackend
from django.core.exceptions import ImproperlyConfigured
from django.db.models import get_model

class CustomerModelBackend(ModelBackend):
	def authenticate(self, username=None, password=None):
		try:
			user = self.user_class.objects.get(username=username)
			if user.check_password(password):
				return user
		except self.user_class.DoesNotExist:
			return None

	def get_user(self, user_id):
		try:
			return self.user_class.objects.get(pk=user_id)
		except self.user_class.DoesNotExist:
			return None

	@property
	def user_class(self):
		if not hasattr(self, '_user_class'):
			self._user_class = get_model(*settings.CUSTOM_USER_MODEL.split('.', 2))
		if not self._user_class:
			raise ImproperlyConfigured('Could not get custom user model')
		return self._user_class

The authentication backend is a class with 2 methods (get_user and authenticate). This is well explained in the documentation of django framework.

Now we have a Class for our Extended users, an authentication backend that is configured through our settings.py.

Yes ! This is what we want. The most lazy of you can stop here and start coding his favorite user management webapp.

Syncdb / admin problem.

But .. wait a minute. Do you remember when you do your first syncdb ? manage.py ask you if you want to fill in an administrator. If you say yes at that point, manage.py will create a django user and now that we authenticate on Custome’s table, there is a lot of chances that the admin module will not authenticate properly (for the admin only though …).

The solution is to modify the authentication backend to authenticate on django users’ table in case of a failed authentication on customer’s table.

       def authenticate(self, username=None, password=None):
               try:
                        user = self.user_class.objects.get(username=username)
                except self.user_class.DoesNotExist:
                        try:
                                user = User.objects.get(username=username)
                        except User.DoesNotExist:
                                return None

As you can see, the code is pretty straight forward and self explanatory. The only tricky part is the “@property” but I let you dig into that yourself as you will learn a lot of things if you want to understand it completely.

Et voila !

Sometimes ago, a friend of mine recommended me to have a look at python language. Very quickly I got hooked by how easy and developer friendly is that language. The language is straight forward and the number of loadable modules is absolutely amazing.

So we go on our python serie with a small piece of code that could be useful for python developers who want to dynamically load ‘packages’ (called on the fly import)

The problem:
Being able to load dynamically (at runtime) some packages to extend your code.

Solution:
in all this tutorial, we will use the so unfamous __import__ python builtin.

First, let’s create a package that we can “autoload”.
In fact, it will be a regular (and respectful) package like there is tons for python. A package is a piece of code that realize a specific task. It has also a well defined structure.

The structure of the package will be as follow :

package_name:
-> __init__.py
-> mymodule.py


First the file __init__.py is a mandatory file that tells that your directory is in fact a package. The file mymodule.py is a regular python script that contain the class that we want to use.

Here is the code of these two file.

The first file (__init__.py)

"""
This modules should keep help use in the future
"""
__author__ = "sebastien requiem (kolios.dk)"
__license__ = "No License"
__version__ = "0.0.1"

from .mymodule import MyModule

def instantiate():
	return MyModule()

and the python module code itself (mymodule.py)

import os
import logging

class MyModule:
	"""
	This class is a very cool and helpful class
	"""
	def __init__(self):
		print "We are initializing MyModule.. w00t !"

	def mymethod(self):
		"""
		Simple routines
		"""
		print "mymethod has been called"

As you can see, there is no fancy code here. Just note that the __init__.py script contain a function call instantiate and that return an instance of the class that we need.
Now let’s see how we can make use of that module.

The following piece of code is meant to be used in a production environment but gives you a clear view on how to load dynamically.

import sys
#first we make sure that the current path is in our path.
	sys.path.append(0, '.')

# we need a placeholder for all our modules
	modules ={}
# we define a list of modules we want to load
	module_list = []
	module_list.append('mymodule')

	for module_name in module_list:
		try:
			modules[module_name] =  __import__(module_name)
			print "Successfully loaded module : %s" % module_name
		except ImportError, e:
			print e
			print "can't load %s module" % module_name)

That’s is folks, as simple as that. Let me know in the comments all the troubles you can have with that piece of code. As I am not a python expert, let me know any improvements and ideas you can have regarding this subject.

For those who want to unload any module, you should be able to do it by deleting the key in sys.modules but I must admit that I haven’t been able to notice any memory improvement after having released any modules. Does that really works ?

See ya !

references:

1. the __import__ python function : http://docs.python.org/library/functions.html#__import__
2. Python package structure : http://docs.python.org/tutorial/modules.html

New Layout… w00t.

Hi everyone,

It’s been a while since I haven’t post anything here. Well, the truth is I have been pretty busy with some projects. And I’ve been able to play with a Buffalo TeraStation Duo with 2x512GB.

But let’s dig in what we are here for, Debian Install.

A bit of specs :

• cpu : Arm9 at 800Mhz
• memory : 512MB
• Flash : 512MB
• Net : 2 Ethernet ports.

Hey ! But why the hell do you want Debian on it ??? It’s already pretty smooth and neat !
First, it’s funny, secondly, I learnt a lot by doing that and third .. well … if Buffalo Administration software
does enough for your needs, why are you reading this ??? Hmmmm ?

Well, enough ! Let’s go.

How does the buffalo works ?

The NAS use u-boot bootloader to boot. u-boot is a pretty well documented bootloader and is able to boot nearly everything.

In the normal case (99% of the time), it boots from the RAID1 array and load the kernel (and an initrd image).
In a non-normal case (the so infamous 1% – for exemple, in case of a hard disk crash), it boots another kernel (and initrd image) from the NAND device. This mode is pretty useful when you have screwed up your NAS.

If I was rich and patient, I’d bought a serial cable with a usb-serial converter to use the serial plug located in front of the device
but I am fairly poor at the moment and really excited to play with the baby.
We would have put the initrd from debian-installer and enjoy seeing the installation going smoothly.

But no, I am poor… and hopefully, we’ll find another way.

A bit of theory : How does Debian Lenny netboot works ?

Well, pretty easy. The installation disc load a kernel together with an initrd image. This initrd has a script and launch some required scripts that setup everything and finally launch debian-installer. debian-installer will then guide you through the complete process of a clean and neat debian installation.

Here is the summary of what we will do:

• Gain shell access to you TeraStation Duo
• Backup the actual kernel and initrd image
• Modify the initrd image to make sure that we will boot correctly
• Package the Debian Installer for an easy use
• Upload the necessary files
• Screwup your nas to make it start in EM mode
• Gaining access to your NAS (in EM mode)
• Prepare the chroot environment and launch the debian-installer
• a dirty Hack !
• Install DEBIAN (YEAH !)
• restore the kernel and initrd
• install the WatchDog monitor
• rebooting (and praying !)

Gaining access to you NAS:

Some (very) nice people have seen an security hole in Buffalo ACP protocol and have made a tool to exploit and thus, gain access to your NAS by resetting the root password and starting a telnet deamon.

You can find acp_commander by clicking on the link. And because you all want to gain shell access to your NAS, here is the command to use :

java -jar acp_commander.jar -t <ip_of_your_nas> -o

This should launch a telnet.

If this doesn’t work, the try the following:

java -jar acp_commander.jar -t <ip_of_your_nas> -ip <ip_of_your_nas> -pw  -o

You can now connect by issuing the following command:

telnet <ip_of_your_nas>

Backup the actual kernel and initrd image

Now that we are in, we have many possibilities. You could install the OPTWARE packages and live the rest of your life happy and in peace, or we can go further and install a Debian system. Let’s backup the kernel and the initrd image as this tutorial covers the Debian Installation but not the installation of a custom kernel.

$> scp /boot/uImage.buffalo <someone>@<somewhere>:
$> scp /boot/initrd.buffalo <someone>@<somewhere>:

Modify the initrd image to make sure that we will boot correctly

The initrd that we have just backed up, will be used when we will boot our new Debian. But if we use it has it is, the scripts contained in the image will probably do a lot of annoying things (like populating a /etc for no reason, saving the configuration, checking the filesystem). We don’t want that. So we use the technique described here ( How to modify an initrd ) to modify the linuxrc script.

HddRoot()
{
    echo "-HddRoot-"
    if [ "${SUPPORT_RAID}" = on ] ; then
    AssembleSysMd boot
    fi
    fsck_disks
#    HasUpdatedFile
#    if [ $? != 0 ]; then
#        echo "** has Updated Files **"
#        echo "** Creating system hotadd pending flag **"
#        touch /tmp/need_firmup
#        echo "0x100" >/proc/sys/kernel/real-root-dev
#        return
#    fi
    if [ "${SUPPORT_RAID}" = on ] ; then
    AssembleSysMd
    fi
#    TestRootfs
#    if [ $? != 0 ]; then
#        echo "0x100" > /proc/sys/kernel/real-root-dev
#    else
    if [ "${SUPPORT_RAID}" = on ] ; then
    echo "0x901" > /proc/sys/kernel/real-root-dev
    else
    echo "0x802" > /proc/sys/kernel/real-root-dev
    fi
    IS_HDDROOT=1
#    fi
}

Note : 0×901 represent /dev/md1 … the partition that contain the real-root…

$> umount INITRD
$> rmdir INITRD
$> mv initrd.buffalo initrd.stock [backup just in case]
$> gzip initrd
$> mkimage -A arm -O linux -T ramdisk -C gzip -a 0x0 -e 0x0 -n initrd -d initrd.gz initrd.buffalo

Package the Debian Installer for an easy use

Now, we want to launch the debian-installer but … we have booted in EM mode which mean that we have booted with Buffalo’s initrd. Fortunately, Debian always do things the right way. Let’s get the Debian-Installer package, extract it and put in in a tar.gz file that we will be able to extract once booted in EM mode.

$> wget http://ftp.debian.org/dists/lenny/main/installer-armel/current/images/versatile/netboot/initrd.gz
$> gunzip initrd.gz
$> mkdir deb_init
$> cd deb_init
$> cpio -i < ../initrd
$> tar cf ../deb_init.tar *

Now we can upload that new archive file on the NAS.

$> scp <someone>@<somewhere>:/sompath/deb_init.tar /boot

Screwup your nas to make it start in EM mode

u-boot will fall back into booting the EM mode in case  of three unsucessful boot of the normal mode. Let’s now make sure that the NAS will never boot again

$> rm /sbin/init

now it’s time to REBOOT !

Gaining access to your NAS (in EM mode)

After three failed reboots, the NAS will enter the EM mode.

Same procedure :

java -jar acp_commander.jar -t <ip_of_your_nas> -o

Preparing the chroot environment and launching the debian installer

To be able to install Debian, we have to make a bit of preparation

$> miconapl -a system_set_watchdog 0
$> killall daemonwatch
$> killall miconmon clientUtil_server kernelmon errormon cat

# if /boot is not mounted yet
$> mdadm -A /dev/md0 /dev/sda1 /dev/sdb1
$> mount /dev/md0 /boot
$> mkdir /debian
$> mount -t tmpfs tmpfs /debian
$> cd /debian
$> cp /boot/uImage.buffalo /boot/new.initrd.buffalo /debian
$> mv /debian/new.initrd.buffalo /debian/initrd.buffalo
$> tar xf /boot/deb_init.tar
$> mount -t proc proc proc/
$> mount -t sysfs sysfs sys/
$> cp /boot/uImage.buffalo initrd.buffalo /debian
$> umount /boot
$> mdadm -S /dev/md0
$> chroot .

$> /lib/debian-installer/start-udev
$> sh /lib/debian-installer-startup.d/S01mount
$> sh /lib/debian-installer-startup.d/S10syslog
$> sh /lib/debian-installer-startup.d/S15lowmem
$> sh /lib/debian-installer-startup.d/S20templates

a dirty Hack !

Here is an awful hack. If you attend to kill dhcpcd to make sure that the debian installer will not get confused, then it will shutdown your interface and you will lose your telnet session. If you kill -9 dhcpcd, everything is fine until the debian-installer try to setup your iface again (with dhcp or manually).

So I opened another telnet session and wrote this dirty little hack that will do the job:

while true; do ifconfig ethX <ip> netmask <netmask>; done

Yes, this is an active loop
Let this script run, go back to your previous telnet session and

$> killall dhcpcd

Yeah !

Installing DEBIAN (YEAH !)

$> debian-installer

Let’s launch the debian installer and follow the instructions. It will complain that it can’t find a suitable kernel, can’t find a suitable bootloader neither, just ignore everything. When it comes to the Partition manager, proceed as follow :

Delete ALL partitions of the two disks.

• Create a new partition (of ~ 512M/1GB) and choose use as physical volume for RAID
• Create another partition of (5GB for exemple) and choose use as physical volume for RAID
• Finally do the same for the rest of the disk (except the last GB)
• Create a swap partition using the last GB of available free space on the disk

Do EXACTLY the same for the second disk.

Once this is done, you can see that on top of the disk#1, you know have a menu called “Configure RAID”. Go into it, accept the warning message (by selecting YES)

The Disk Partionner restarts again and now we have the RAID devices.

• Select the first one and assign it to /boot using ext3
• Select the second one ad assign it to / using ext3
• Select the last one using it for /mnt/array1 using XFS for example.

Write the changes to disks. The debian-installer may complain about not being able to re-read the partition table. DO NOT REBOOT. Just press continue to re try reading the partition table. After some tries, it should be ok.

Make sure that you don’t reboot the NAS at the end of the installation. Instead, open a new telnet session.

restoring the kernel and initrd

$> cp /debian/uImage.buffalo /debian/initrd.buffalo /debian/target/boot

installing the WatchDog monitor

A watchdog is running on the NAS to reboot it in case of a Hanged system. Buffalo’s firmware was running a small piece of code to manage it. Fortunately, the people from nas-central.org have made it available for ourt debian installation.

Download the tar file and extract it in the new environement.

$> cd /debian/target
$> chroot .
$> cd /tmp
$> wget http://buffalo.nas-central.org/download/Users/gnyf/micro_evtd_TSP.tar.gz
$> cd /
$> tar zxvf micro_evtd_TSP.tar.gz

Install SSH server on the NAS

While we are here, we want to install SSH server to make sure that we can connect back to the NAS.

$> apt-get install openssh-server.
$> exit

rebooting (and praying !)

You can now reboot and … pray !

Leave me any comments on improvement of this method that you can find.

As a new freelancer, I decided to create my own business cards using moo services. This website allow you to create collectors business cards. The principle is simple, you can upload one image per card so the Verso of the card will be different each time.

My problem : How to create a business card that  match my website layout and make it uniq at the same time ?

This is when Python and Inkscape came to rescue me. Inkscape is a well know (GPL’ed) SVG graphic editor. If you have never tried it, consider doing it. It is amazing what this soft can produce within a couple of minutes. Beside Inkscape, the website commandlinfu.com is a (cool) website providing Unix Commands and explanations of what they do (be careful some commands may be dangerous or invalid though).

So I had an idea. Why not using the website commandlinefu, extract commands from the RSS feed and generate images for my Collector Business cards ?

How ?

Inkscape support plugins and offer a nice python module to help you to create SVG objects.

Let’s go !

Inkscape expect a couple of things from the module structure.

#!/usr/bin/env python

# These two lines are only needed if you don't put the script directly into
# the installation directory
import sys
from xml.dom import minidom
import urllib
import re

# This import is for MAc os X only. In GNU systems it should
# be somewhere in /usr/share/inkscape/extensions

sys.path.append('/Applications/Inkscape.app/Contents/Resources/extensions')

# We will use the inkex module with the predefined Effect base class.
import inkex
# The simplestyle module provides functions for style parsing.
from simplestyle import *

class BusinessCard(inkex.Effect)
    """
    Example Inkscape effect extension. It reads an RSS feed and create objects according to the content.
    """
    def __init__(self):
        """
        Constructor.
        Defines the "--what" option of a script.
        """
        # Call the base class constructor.
        inkex.Effect.__init__(self)

        # Define string option "--what" with "-w" shortcut and default value "World".
        self.OptionParser.add_option('-w', '--what', action = 'store',
        type = 'integer', dest = 'cards_number', default = '10',
        help = 'How many images do you want to create?')

The optionparser is required by Inkscape as it will pass some arguments to the script. We could, for example use this argument to know how many images we want to generate. In our case, the argument will be stored in the variable call cards_number. I let you have a closer look to this Wiki Page for any further explanation.

Now that we have the basis for creating an Inkscape plugin, we should define the main actions that this plugin is gonna do:

1. Read the RSS feed
2. Extract the usefull information (and filter)
3. Create the SVG objects
4. Add them to the SVG Layer
5. Loop to 1

Let’s use Python wonderful XML parser to read our RSS feed

    # Open the XML ressource and read it
    socket = urllib.urlopen("http://feeds2.feedburner.com/Command-line-fu?format=xml");
    # Create an object representing the XML structure
    self.xmldoc = minidom.parse(socket).documentElement
    socket.close();

Create the function that will do the loop

    def effect(self):
        """
        Effect behaviour.
        Overrides base class' method and inserts "Hello World" text into SVG document.
        """
        # Get script's "--what" option value.
        cards_number = self.options.cards_number

        # Get access to main SVG document element and get its dimensions.
        svg = self.document.getroot()

        # Create a new layer.
        layer = inkex.etree.SubElement(svg, 'g')
        layer.set(inkex.addNS('label', 'inkscape'), 'Hello %s Layer' % (what))
        layer.set(inkex.addNS('groupmode', 'inkscape'), 'layer')

        # Create text element from the RSS feed
        itemlist = self.xmldoc.getElementsByTagName('item')

        #we will loop so better initialize variables
        item_x = 0
        item_y = 0

        # in the RSS feed, the iformation we want in contained in between
        # the <code></code> markup. Let's use a regexp to get it.
        regexp = re.compile('<code>.*</code>');

        # Note that here, we should use the cards_number instead of reading
        # the complete rss feed.
        for node in itemlist:
            title = node.getElementsByTagName('title')[0].firstChild.data
            command = regexp.search(node.getElementsByTagName('description')[0].firstChild.data)

            # Get ride of the markup
            command = command.group()
            command = command.replace("<code>", "");
            command = command.replace("</code>", "");

            # filter in case the comman is too long...
            if len(command) > 40:
                continue

Ok so now we have to start creating the objects. For this, Inkscape offer us a nice way to do it. Use the inkex extension. the function inkex.addNS is usefull to create everything you need in SVG.

        #Design the background grey business card
        background = inkex.etree.Element(inkex.addNS('rect', 'svg'))
        background.set('x', str(item_x))
        background.set('y', str(item_y))
        background.set('width', str(520))
        background.set('height', str(348))
        background.set('fill', 'rgb(32, 32, 32)')

        #Our lovely ornge square will fit here
        square = inkex.etree.Element(inkex.addNS('rect', 'svg'))
        square.set('x', str(item_x + 30))
        square.set('y', str(item_y + 30))
        square.set('width', str(84))
        square.set('height', str(84))
        square.set('rx', str(20))
        square.set('ry', str(20))
        square.set('fill', 'rgb(224, 121, 26)')

        #Insert the "K" letter. K stands for Kolios
        K_logo = inkex.etree.Element(inkex.addNS('text','svg'))
        K_logo.text = ("K")
        # Set text position to center of document.
        K_logo.set('x', str(item_x + 61))
        K_logo.set('y', str(item_y + 95))
        K_logo.set('fill', "white")

        # Center text horizontally with CSS style.
        style = {'text-align' : 'left',
            'font-family': 'MammaGamma',
            'font-size': '56'
        }
        K_logo.set('style', formatStyle(style))

        #Insert the Unix Tip
        tip = inkex.etree.Element(inkex.addNS('text','svg'))
        tip.text = (title)
        # Set text position to center of document.
        tip.set('x', str(item_x + 40))
        tip.set('y', str(item_y + 200))
        tip.set('fill', 'rgb(170, 170, 170)')

        # Center text horizontally with CSS style.
        style = {'text-align' : 'left',
            'font-family': 'terminal',
            'font-style': 'italic'
        }
        tip.set('style', formatStyle(style))

        #Insert the Unix Command
        unix = inkex.etree.Element(inkex.addNS('text','svg'))
        unix.text = (command)
        # Set text position to center of document.
        unix.set('x', str(item_x + 30))
        unix.set('y', str(item_y + 180))
        unix.set('fill', 'rgb(224, 121, 26)')

        # Center text horizontally with CSS style.
        style = {'text-align' : 'left',
            'font-family': 'Monaco',
            'font-size': '20'
        }
        unix.set('style', formatStyle(style))

        # Connect elements together.
        layer.append(background)
        layer.append(square)
        layer.append(K_logo)
        layer.append(kolios)
        layer.append(slogan)
        layer.append(unix)
        layer.append(tip)
        item_y = item_y + 360

    # Create effect instance and apply it.
    effect = BusinessCard()
    effect.affect()

You can notice that we use css-style for the text. This is possible with the use of the module simplestyle.

Basically, you create an object and THEN add it to the layer. Pay attention that the order you add objects MATTERS for the rendering depth. In this case the background will be rendered first, then the square… and so on. All type of objects can be created and the entire list is available at the W3c webpage.

But how do I add my plugin to Inkscape ?

Well, last thing but not the least. You python script should be placed in .inkscape/extensions with a description file

<inkscape-extension>
    <_name>Business Card</_name>
    <id>org.ekips.filter.business_card</id>
    <dependency type="executable" location="extensions">card.py</dependency>
    <dependency type="executable" location="extensions">inkex.py</dependency>
    <param name="what" type="integer" _gui-text="How many business cards ?">10</param>
    <effect>
    <object-type>all</object-type>
    <effects-menu>
        <submenu _name="Examples"/>
    </effects-menu>
    </effect>
    <script>
        <command reldir="extensions" interpreter="python">card.py</command>
    </script>
</inkscape-extension>

The file should be named with a .inx extension. I won’t explain this as this is pretty obvious.

At last, you can take a llok at the final output. The first picture is NOT generated but … it gives a good example.

A long time ago, I downloaded a .bin/.cue file on my Mac and Suprize ! the famous (un)popular format is not handled by Mac os X (10.5 at least … ) so I couldn’t mount it properly.

As this format is not really a standard, I understand Apple policy to not include any filesystem that support it but it bugs me everytime I want to play around with this kind of file. Of course, the Licensed Software addicts would jump on Toast because it has such feature.

Instead I propose you a (GPL’ed) softwaree that will convert your .bin/.cue file to an .iso image. This format is a supported nearly everywhere and you just have to open the file in Mac os X to mount it and browse the content. This magic software is called bchunk and a version compiled for Mac os X is available here.

Just type the following in your favorite terminal application :

$> bchunk myfile.bin myfile.cue mydestination.iso

$> open mydestination.iso

And voila ! This should do the work.

Refer to James blog for a proper installation of this tool.

Eric A. Meyer explain the line-height CSS property. And it does it well. Feel free to check the w3c documentation for further (usefull) information.