<?xml version="1.0" ?>
<zAppointments reminder="15">
    <appointment>
        <begin>1181251680</begin>        
        <uid>040000008200E000</uid>
        <alarmTime>1181572063</alarmTime>
        <state></state>
        <location></location>
        <duration>1800</duration>
        <subject>Bring pizza home</subject>
    </appointment>
</zAppointments>

Now let’s dig into the Python!

How to Create XML with ElementTree

Creating XML with ElementTree is very simple. In this section, we will attempt to create the XML above with Python. Here’s the code:

import xml.etree.ElementTree as xml
 
#----------------------------------------------------------------------
def createXML(filename):
    """
    Create an example XML file
    """
    root = xml.Element("zAppointments")
    appt = xml.Element("appointment")
    root.append(appt)
 
    # add appointment children
    begin = xml.SubElement(appt, "begin")
    begin.text = "1181251680"
 
    uid = xml.SubElement(appt, "uid")
    uid.text = "040000008200E000"
 
    alarmTime = xml.SubElement(appt, "alarmTime")
    alarmTime.text = "1181572063"
 
    state = xml.SubElement(appt, "state")
 
    location = xml.SubElement(appt, "location")
 
    duration = xml.SubElement(appt, "duration")
    duration.text = "1800"
 
    subject = xml.SubElement(appt, "subject")
 
    tree = xml.ElementTree(root)
    with open(filename, "w") as fh:
        tree.write(fh)
 
#----------------------------------------------------------------------
if __name__ == "__main__":
    createXML("appt.xml")

If you run this code, you should get something like the following (probably all on one line):

<zAppointments>
	<appointment>
		<begin>1181251680</begin>
		<uid>040000008200E000</uid>
		<alarmTime>1181572063</alarmTime>
		<state />
		<location />
		<duration>1800</duration>
		<subject />
	</appointment>
</zAppointments>

This is pretty close to the original and is certainly valid XML, but it’s not quite the same. However, it’s close enough. Let’s take a moment to review the code and make sure we understand it. First we create the root element by using ElementTree’s Element function. Then we create an appointment element and append it to the root. Next we create SubElements by passing the appointment Element object (appt) to SubElement along with a name, like “begin”. Then for each SubElement, we set its text property to give it a value. At the end of the script, we create an ElementTree and use it to write the XML out to a file.

What’s annoying is that it write out the XML all on one line instead of in a nice readable format (i.e. “pretty print”). There’s a recipe on Effbot, but there doesn’t appear to be a way to do it internally. You may also want to take a look at some of the other solutions on StackOverflow. It should be noted that lxml supports “pretty print” out of the box.

Now we’re ready to learn how to edit the file!

How to Edit XML with ElementTree

Editing XML with ElementTree is also easy. To make things a little more interesting though, we’ll add another appointment block to the XML:

<?xml version="1.0" ?>
<zAppointments reminder="15">
    <appointment>
        <begin>1181251680</begin>        
        <uid>040000008200E000</uid>
        <alarmTime>1181572063</alarmTime>
        <state></state>
        <location></location>
        <duration>1800</duration>
        <subject>Bring pizza home</subject>
    </appointment>
        <appointment>
        <begin>1181253977</begin>        
        <uid>sdlkjlkadhdakhdfd</uid>
        <alarmTime>1181588888</alarmTime>
        <state>TX</state>
        <location>Dallas</location>
        <duration>1800</duration>
        <subject>Bring pizza home</subject>
    </appointment>
</zAppointments>

Now let’s write some code to change each of the begin tag’s values from seconds since the epoch to something a little more readable. We’ll use Python’s time module to facilitate this:

import time
import xml.etree.cElementTree as ET
 
#----------------------------------------------------------------------
def editXML(filename):
    """
    Edit an example XML file
    """
    tree = ET.ElementTree(file=filename)
    root = tree.getroot()
 
    for begin_time in root.iter("begin"):
        begin_time.text = time.ctime(int(begin_time.text))
 
    tree = ET.ElementTree(root)
    with open("updated.xml", "w") as f:
        tree.write(f)
 
#----------------------------------------------------------------------
if __name__ == "__main__":
    editXML("original_appt.xml")

Here we create an ElementTree object (tree) and we extract the root from it. Then we use ElementTree’s iter() method to find all the tags that are labeled “begin”. Note that the iter() method was added in Python 2.7. In our for loop, we set each item’s text property to a more human readable time format via time.ctime(). You’ll note that we had to convert the string to an integer when passing it to ctime. The output should look something like the following:

<zAppointments reminder="15">
    <appointment>
        <begin>Thu Jun 07 16:28:00 2007</begin>        
        <uid>040000008200E000</uid>
        <alarmTime>1181572063</alarmTime>
        <state />
        <location />
        <duration>1800</duration>
        <subject>Bring pizza home</subject>
    </appointment>
	<appointment>
        <begin>Thu Jun 07 17:06:17 2007</begin>        
        <uid>sdlkjlkadhdakhdfd</uid>
        <alarmTime>1181588888</alarmTime>
        <state>TX</state>
        <location>Dallas</location>
        <duration>1800</duration>
        <subject>Bring pizza home</subject>
    </appointment>
</zAppointments>

You can also use ElementTree’s find() or findall() methods to get search for specific tags in your XML. The find() method will just find the first instance whereas the findall() will find all the tags with the specified label. These are helpful for editing purposes or for parsing, which is our next topic!

How to Parse XML with ElementTree

Now we get to learn how to do some basic parsing with ElementTree. First we’ll read through the code and then we’ll go through bit by bit so we can understand it. Note that this code is based around the original example, but it should work on the second one as well.

import xml.etree.cElementTree as ET
 
#----------------------------------------------------------------------
def parseXML(xml_file):
    """
    Parse XML with ElementTree
    """
    tree = ET.ElementTree(file=xml_file)
    print tree.getroot()
    root = tree.getroot()
    print "tag=%s, attrib=%s" % (root.tag, root.attrib)
 
    for child in root:
        print child.tag, child.attrib
        if child.tag == "appointment":
            for step_child in child:
                print step_child.tag
 
    # iterate over the entire tree
    print "-" * 40
    print "Iterating using a tree iterator"
    print "-" * 40
    iter_ = tree.getiterator()
    for elem in iter_:
        print elem.tag
 
    # get the information via the children!
    print "-" * 40
    print "Iterating using getchildren()"
    print "-" * 40
    appointments = root.getchildren()
    for appointment in appointments:
        appt_children = appointment.getchildren()
        for appt_child in appt_children:
            print "%s=%s" % (appt_child.tag, appt_child.text)
 
#----------------------------------------------------------------------
if __name__ == "__main__":
    parseXML("appt.xml")

You may have already noticed this, but in this example and the last one, we’ve been importing cElementTree instead of the normal ElementTree. The main difference between the two is that cElementTree is C-based instead of Python-based, so it’s much faster. Anyway, once again we create an ElementTree object and extract the root from it. You’ll note that e print out the root and the root’s tag and attributes. Next we show several ways of iterating over the tags. The first loop just iterates over the XML child by child. This would only print out the top level child (appointment) though, so we added an if statement to check for that child and iterate over its children too.

Next we grab an iterator from the tree object itself and iterate over it that way. You get the same information, but without the extra steps in the first example. The third method uses the root’s getchildren() function. Here again we need an inner loop to grab all the children inside each appointment tag. The last example uses the root’s iter() method to just loop over any tags that match the string “begin”.

As mentioned in the last section, you could also use find() or findall() to help you find specific tags or sets of tags respectively. Also note that each Element object has a tag and a text property that you can use to acquire that exact information.

Wrapping Up

Now you know how to use ElementTree to create, edit and parse XML. You can add that information to your XML parsing toolkit and use it for fun or profit. You will find links to previous articles on some of the other XML parsing tools below as well as additional information about ElementTree itself.

Related Articles from Mouse Vs Python

• Parsing XML with minidom
• Python: Parsing XML with lxml
• Parsing XML with Python using lxml.objectify

Additional Reading

• Official Python documentation for ElementTree
• Effbot’s ElementTree Overview
• Processing XML in Python with elementree
• Dr Chuck’s Simple ElementTree Example

Download the Source

• ETXMLParsing.zip

Anyway, I decided to create a silly cipher program with wxPython where I could input a string and have it convert it to something else. I also wanted my program to decode it too. Now you can’t really make a program that can use a Cryptograph Wheel or a code stick, but for number codes or slide scales, that’s extremely easy.

Creating an Encoding GUI

Creating the actual GUI is a piece of cake. It takes a little more work to code up the back end where you have to actually parse the string and change it into something else. For this exercise, I created 4 encoders and 3 decoders. The 5 encoders encode strings into numbers, ASCII (which is a different set of numbers), L33t (just for fun), and Hex. For the decoders, I decode everything except for L33t. Let’s take a moment to study the code for the GUI:

import controller
import wx
 
########################################################################
class CipherPanel(wx.Panel):
    """"""
 
    #----------------------------------------------------------------------
    def __init__(self, parent):
        """Constructor"""
        wx.Panel.__init__(self, parent=parent)
        choices = ["", "Alpha2Num", "ASCII", "L33t", "Hex"]
        decode_choices = ["", "ASCII", "Hex", "Num2Alpha"]
        self.mainSizer = wx.BoxSizer(wx.VERTICAL)
 
        toLbl = wx.StaticText(self, label="Translate into:")
        self.toCbo = wx.ComboBox(self, value=choices[1], choices=choices)
        self.add2HSizer([toLbl, self.toCbo])
 
        fromLbl = wx.StaticText(self, label="Translate from:")
        self.fromCbo = wx.ComboBox(self, value="", choices=decode_choices)
        self.add2HSizer([fromLbl, self.fromCbo])
 
        txtLbl = wx.StaticText(self, label="Enter text to encode or decode:")
        self.originalTxt = wx.TextCtrl(self, style=wx.TE_MULTILINE)
 
        self.translatedTxt = wx.TextCtrl(self, style=wx.TE_MULTILINE)
 
        encodeBtn = wx.Button(self, label="Encode")
        encodeBtn.Bind(wx.EVT_BUTTON, self.onEncode)
        decodeBtn = wx.Button(self, label="Decode")
        decodeBtn.Bind(wx.EVT_BUTTON, self.onDecode)
 
        # layout widgets
        self.mainSizer.Add(txtLbl, 0, wx.ALL, 5)
        self.mainSizer.Add(self.originalTxt, 1, wx.EXPAND|wx.ALL, 5)
        self.mainSizer.Add(self.translatedTxt, 1, wx.EXPAND|wx.ALL, 5)
        self.add2HSizer([encodeBtn, decodeBtn])
 
        self.SetSizer(self.mainSizer)
 
    #----------------------------------------------------------------------
    def add2HSizer(self, widgets):
        """
        Add widgets to a horizontal sizer
        """
        sizer = wx.BoxSizer(wx.HORIZONTAL)
        for widget in widgets:
            sizer.Add(widget, 0, wx.ALL|wx.CENTER, 5)
 
        if isinstance(widgets[0], wx.Button):
            self.mainSizer.Add(sizer, 0, wx.CENTER)
        else:
            self.mainSizer.Add(sizer)
 
    #----------------------------------------------------------------------
    def onDecode(self, event):
        """
        Decodes what's in the original text box to the encoding 
        specified and puts the result in the bottom text box
        """
        from_value = self.fromCbo.GetValue()
        value_to_decode = self.originalTxt.GetValue()
        if from_value == "Hex":
            new_value = value_to_decode.decode("hex")
        elif from_value == "ASCII":
            value_to_decode = [int(i) for i in value_to_decode.split()]
            new_value = controller.convertFromASCII(value_to_decode)
        elif from_value == "Num2Alpha":
            value_to_decode = value_to_decode.split()
            new_value = controller.convertFromNumbers(value_to_decode)
        else:
            return
 
        self.translatedTxt.SetValue(new_value)
 
    #----------------------------------------------------------------------
    def onEncode(self, event):
        """
        Encodes what's in the original text box to the encoding 
        specified and puts the result in the bottom text box
        """
        to_value = self.toCbo.GetValue()
        value_to_encode = self.originalTxt.GetValue()
        if to_value == "Hex":
            new_value = value_to_encode.encode("hex")
        elif to_value == "ASCII":
            new_value = controller.convertToASCII(value_to_encode)
        elif to_value == "L33t":
            new_value = controller.convertToLeet(value_to_encode)
        elif to_value == "Alpha2Num":
            new_value = controller.convertToNumbers(value_to_encode)
 
        self.translatedTxt.SetValue(new_value)
 
########################################################################
class CipherFrame(wx.Frame):
    """"""
 
    #----------------------------------------------------------------------
    def __init__(self):
        """Constructor"""
        title = "Cipher Creator / Translator"
        size = (800,600)
        wx.Frame.__init__(self, None, title=title, size=size)
        panel = CipherPanel(self)
        self.Show()
 
#----------------------------------------------------------------------
if __name__ == "__main__":
    app = wx.App(False)
    frame = CipherFrame()
    app.MainLoop()

We should probably take a couple moments and break this down. As you probably noticed in the screenshot earlier, this GUI has a couple of ComboBoxes, a couple multiline TextCtrls and two buttons. The ComboBoxes control what we’re encoding or decoding to. We have imported a mysterious module called “controller” which houses all the code that does the encoding. We’ll look at that in a minute. First, we need to look at a couple of the functions in this piece. In the onEncode method, we should how to grab the value we’re going to encode and pass it to the appropriate controller function. For the onDecode method, we sometimes have to do a little pre-processing before we pass the data on to the controller. You can see an example in the ASCII portion of the conditional where we have to create a list of integers or in the Num2Alpha section where we need to create a list of numbers. Once you understand what’s going on here, feel free to continue to the next piece of code below.

#----------------------------------------------------------------------
def convertToASCII(string):
    """"""
    output = []
    for letter in string:
        output.append( ord(letter) )
 
    return " ".join([str(i) for i in output])
 
#----------------------------------------------------------------------
def convertToCaesar(string):
    """

http://www.wikihow.com/Create-Secret-Codes-and-Ciphers

    Shifts the alphabet 3 places such that A becomes X,
    B becomes Y, etc
    """
    caesar_dict = {"a": "x", 
                   "b": "y",
                   "c": "z",
                   "d": "a",
                   "e": "b",
                   "f": "c",
                   "g": "d",
                   "h": "e",
                   "i": "f",
                   "j": "g",
                   "k": "h",
                   "l": "i",
                   "m": "j",
                   "n": "k",
                   "o": "l",
                   "p": "m",
                   "q": "n",
                   "r": "o",
                   "s": "p",
                   "t": "q",
                   "u": "r",
                   "v": "s",
                   "w": "t",
                   "x": "u",
                   "y": "v",
                   "z": "w"}
    new_string = ""
    for char in string:
        if char == ' ':
            new_string += ' '
        else:
            new_string += caesar_dict[char.lower()]
    return new_string
 
#----------------------------------------------------------------------
def convertToLeet(string):
    """"""
    leet_dict = {"a":"4", "b":"8", "e":"3", "l":"1",
                 "o":"0", "s":"5", "t":"7"}
    new_string = ""
    for letter in string:
        if letter.lower() in leet_dict:
            letter = leet_dict[letter.lower()]
        new_string += letter
    return new_string
 
#----------------------------------------------------------------------
def convertToNumbers(string):
    """
    Convert a string to numbers where a=1, b=2, c=3, etc
    """
    keys = "abcdefghijklmnopqrstuvwxyz"
    values = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11',
              '12', '13', '14', '15', '16', '17', '18', '19', '20', 
              '21', '22', '23', '24', '25', '26']
    num_dict = dict(zip(keys,values))
    new_string = ""
    for letter in string:
        if letter.lower() in num_dict:
            new_string += num_dict[letter.lower()] + " "
    return new_string
 
#----------------------------------------------------------------------
def convertFromASCII(data):
    """
    Convert from ASCII
    """
    s = ""
    if isinstance(data, str):
        for item in data.split():
            s += chr(int(item))
    else:
        # can also convert a list of integers
        for item in data:
            s += chr(item)
    return s
 
#----------------------------------------------------------------------
def convertFromCaesar(string):
    """
    Converts string from Caesar to normal
    """
    uncaesar_dict = {"x": "a",
                     "y": "b",
                     "z": "c",
                     "a": "d",
                     "b": "e",
                     "c": "f",
                     "d": "g",
                     "e": "h",
                     "f": "i",
                     "g": "j",
                     "h": "k",
                     "i": "l",
                     "j": "m",
                     "k": "n",
                     "l": "o",
                     "m": "p",
                     "n": "q",
                     "o": "r",
                     "p": "s",
                     "q": "t",
                     "r": "u",
                     "s": "v",
                     "t": "w",
                     "u": "x",
                     "v": "y",
                     "w": "z"}
    new_string = ""
    for char in string:
        if char == ' ':
            new_string += ' '
        else:
            new_string += uncaesar_dict[char.lower()]
    return new_string
 
#----------------------------------------------------------------------
def convertFromNumbers(data):
    """
    Convert a list of numbers to letters where 1=a, 2=b, 3=c, etc
    """
    keys = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11',
            '12', '13', '14', '15', '16', '17', '18', '19', '20', 
            '21', '22', '23', '24', '25', '26']
    values = "abcdefghijklmnopqrstuvwxyz"
    num_dict = dict(zip(keys,values))
 
    new_string = ""
    for char in data:
        val = num_dict[char]
        new_string += val
    return new_string
 
#----------------------------------------------------------------------
if __name__ == "__main__":
    x = convertToASCII("I love you")
    y = convertToLeet("I love you")
    print x
    new_x = [int(i) for i in x.split()]
    print convertFromASCII(new_x)
    print convertFromASCII(x)
 
    x = convertToCaesar("Meeting tomorrow at station")
    print "Meeting tomorrow at station =>", x
    print "%s =>" % x, convertFromCaesar(x)
 
    t = convertToNumbers("Python rules")
    print "Python rules => " + t
    print "%s => " % t, convertFromNumbers(t.split())

You may notice that I have included other examples in the controller that aren’t currently hooked into the GUI. For example, I have a converter function in there to convert strings to Caesar, which is a popular cipher where the alphabet is shifted 3 places in one direction or the other. Anyway, one of the nicest bits about this code is that we didn’t need to import anything. It all works with just normal Python! To convert to ASCII, we use Python’s builtin ord. For most of the others, we use dictionaries to map the values. At the bottom of the script, we have a few test cases to check and make sure it is converting the strings as we expect it to. These should probably be made into real unit tests, but for a quick and dirty check, these work great!

Wrapping Up

There are several other codes I’d like to add to this at some point, such as Morse code. I also like the codes where the message is hidden in the text, such as every first letter (or last) in a poem spells our something or where every letter at the beginning of a sentence spells something. Those were always fun. I’ve included a few links at the end of this article so you can read about other fun codes and ciphers. Have fun coding!

Additional Reading

• Secret Codes for Cubs and Scouts
• Cryptology for Kids
• The Pig Pen cipher – this one is fun!
• WikiHow – How to Create Secret Codes and Ciphers

Download the Source!

• cipherGUI.zip
• cipherGUI.tar

Quick Review

• Why I picked it up: I got this book as part of the perks received from its sequel’s Kickstarter campaign.
• Why I finished it: The book had an engaging writing style
• I’d give it to: Programmers new to the Python language

If that intro interested you at all, feel free to join me after the jump to read the full review!

Book Formats

This book is available as a PDF, MOBI (i.e. for Kindles) and EPUB. I don’t believe there is a dead tree version at the time of this review.

Full Review

Mr. Heisler does a good job introducing us to Python. At first, it sounds like you’ll be learning Python by writing lots of code (which made me think of Zed Shaw’s website), but the author ends up doing what most Python authors do and goes through a bunch of the basics. Anyway, he book is split up into 13 chapters (14 if you count chapter 0!) with some “interlude” sections thrown in here and there. Here’s a breakdown of what’s covered:

Chapter zero is just an introduction. Chapter one covers downloading Python and the basics of using IDLE. Then we hit an interlude that covers comments in the code. Chapters two and three covers strings and string methods (finding strings, slices, etc). Chapter 4 goes into functions and loops. Then there’s another interlude, this time covering the Python debugger: pdb. Chapter 5 does conditionals (i.e. if/elif/else) and also talks about how to break and continue in a loop. Chapter 6 is all about lists and dictionaries. In seven, we learn file I/O and how to read and write CSV files. Then we hit another interlude where the author talks about how to install 3rd party Python modules. For some reason, he recommends easy_install, which I thought had fallen out of favor in the Python community. But there’s no mention of the alternatives, such as pip. Anyway, in chapter 8, we learn how to read, write and manipulate PDFs with pyPDF. There’s a mention of reportlab and PDFMiner, but no examples. Chapter 9 goes into SQL with Python, mostly focusing on SQLite, although it mentions pyodbc, pyscopg and MySQLdb.

Chapter 10 goes into web scraping with Python regular expressions, beautifulsoup and mechanize. Chapter 11 is about scientific programming with Python and graphing. It covers a little NumPy and a little matplotlib. Chapter 12 dabbles in Python GUI work with EasyGUI and Tkinter. I thought EasyGUI was an odd choice as it’s basically just a dialog generator, but anyway. The final chapter covers web applications using the Google App Engine.

Each chapter has multiple sections and the sections usually end with an exercise or two for the reader to try out. The text is written in a very informal way with some fun examples, like writing a L33T translator script. Since this was a KickStarter book, the last few pages list all the supporters who helped get the book published. I thought the book covered an adequate amount of the language to get a new programmer started. It’s not an in-depth Python book, but it’s not supposed to be. It’s there to get the reader started on their Python journey and it does a good job doing just that!

Real Python Fletcher Heisler RealPython.com

• Color Dialog
• File Dialog
• Font Dialog
• Input Dialog
• Print & Print Preview Dialogs

We will also cover PySide’s Message Boxes. All code in this article was tested on Windows 7 Professional with PySide 1.2.2 and Python 2.6.6. Now let’s get to it!

Getting Information with Standard Dialogs

We’ll start off with some code that will show each of the first four dialogs listed above. The other two are more complicated and get their own special demo code. After the code, we’ll take a look at each dialog’s code individually to help understand it.

# stdDialogDemo_pyside.py
 
from PySide import QtCore, QtGui
 
########################################################################
class DialogDemo(QtGui.QWidget):
    """"""
 
    #----------------------------------------------------------------------
    def __init__(self):
        """Constructor"""
        # super(DialogDemo, self).__init__()
        QtGui.QWidget.__init__(self)
 
        self.label = QtGui.QLabel("Python rules!")
 
        # create the buttons
        colorDialogBtn = QtGui.QPushButton("Open Color Dialog")
        fileDialogBtn =  QtGui.QPushButton("Open File Dialog")
        self.fontDialogBtn = QtGui.QPushButton("Open Font Dialog")
        inputDlgBtn = QtGui.QPushButton("Open Input Dialog")
 
        # connect the buttons to the functions (signals to slots)
        colorDialogBtn.clicked.connect(self.openColorDialog)
        fileDialogBtn.clicked.connect(self.openFileDialog)
        self.fontDialogBtn.clicked.connect(self.openFontDialog)
        self.connect(inputDlgBtn, QtCore.SIGNAL("clicked()"), self.openInputDialog)
 
        # layout widgets
        layout = QtGui.QVBoxLayout()
        layout.addWidget(self.label)
        layout.addWidget(colorDialogBtn)
        layout.addWidget(fileDialogBtn)
        layout.addWidget(self.fontDialogBtn)
        layout.addWidget(inputDlgBtn)
        self.setLayout(layout)
 
        # set the position and size of the window
        self.setGeometry(100, 100, 400, 100)
 
        self.setWindowTitle("Dialog Demo")
 
    #----------------------------------------------------------------------
    def openColorDialog(self):
        """
        Opens the color dialog
        """
        color = QtGui.QColorDialog.getColor()
 
        if color.isValid():
            print color.name()
            btn = self.sender()
            pal = btn.palette()
            pal.setColor(QtGui.QPalette.Button, color)
            btn.setPalette(pal)
            btn.setAutoFillBackground(True)
 
            #btn.setStyleSheet("QPushButton {background-color: %s}" % color)
 
    #----------------------------------------------------------------------
    def openFileDialog(self):
        """
        Opens a file dialog and sets the label to the chosen path
        """
        import os
        path, _ = QtGui.QFileDialog.getOpenFileName(self, "Open File", os.getcwd())
        self.label.setText(path)
 
 
    #----------------------------------------------------------------------
    def openDirectoryDialog(self):
        """
        Opens a dialog to allow user to choose a directory
        """
        flags = QtGui.QFileDialog.DontResolveSymlinks | QtGui.QFileDialog.ShowDirsOnly
        d = directory = QtGui.QFileDialog.getExistingDirectory(self,
                                                               "Open Directory",
                                                               os.getcwd(),
                                                               flags)
        self.label.setText(d)
 
    #----------------------------------------------------------------------
    def openFontDialog(self):
        """
        Open the QFontDialog and set the label's font
        """
        font, ok = QtGui.QFontDialog.getFont()
        if ok:
            self.label.setFont(font)
 
    #----------------------------------------------------------------------
    def openInputDialog(self):
        """
        Opens the text version of the input dialog
        """
        text, result = QtGui.QInputDialog.getText(self, "I'm a text Input Dialog!",
                                            "What is your favorite programming language?")
        if result:
            print "You love %s!" % text
 
#----------------------------------------------------------------------
if __name__ == "__main__":
    app = QtGui.QApplication([])
    form = DialogDemo()
    form.show()
    app.exec_()

Well that looks pretty clean and straight-forward. Let’s break it down a bit. You can see at the beginning of the __init__ method that I have commented out an alternate way of initializing the QWidget using Python’s super. You can do it either way and your program will work fine. I just wanted to show you both ways of doing it. You’ll also notice that all this code does is display a QLabel and four QPushButton widgets. We connect the signals (i.e. events) from the buttons to the slots (i.e. event handlers) using two different methods. The first is more “Pythonic” in that it uses dot-notation:

colorDialogBtn.clicked.connect(self.openColorDialog)

The second way (which we use once) is probably the most common way you’ll see it done, but it’s a little harder to understand if you’re just used to Python code:

self.connect(inputDlgBtn, QtCore.SIGNAL("clicked()"), self.openInputDialog)

Both ways of connecting the signals to the slots works. Note that we’re binding the clicked event. This means that when the user clicks the button, it calls the connected method. Now we’ll take a look at each of the dialogs in turn.

The PySide Color Dialog

The PySide Color Dialog is a pretty standard color dialog that you’ll see in most simple drawing programs, such as Windows Paint. To create it, we do the following:

#----------------------------------------------------------------------
def openColorDialog(self):
    """
    Opens the color dialog
    """
    color = QtGui.QColorDialog.getColor()
 
    if color.isValid():
        print color.name()
        btn = self.sender()
        pal = btn.palette()
        pal.setColor(QtGui.QPalette.Button, color)
        btn.setPalette(pal)
        btn.setAutoFillBackground(True)
 
        #btn.setStyleSheet("QPushButton {background-color: %s}" % color)

Here we call QtGui.QColorDialog.getColor() to return the color chosen by the user and to also instantiate the dialog. If the color chosen is valid, we apply it to our QPushButton. You’ll note that there’s a line commented out at the end of this method. I was told that you can use a type of PySide CSS to change the background color of the button, but I couldn’t figure out the correct way to do it. Some people on the PySide IRC channel said the commented line should work. Others said that it should be just background instead of background-color, but that didn’t work for me either. Even with the Palette method shown here, the background color still doesn’t change. Instead, you’ll only notice a subtle change of color to the outline of the button.

The PySide File Dialog

The PySide File Dialog should be familiar to most people as it matches the native file dialog very closely (on Windows at least). Here’s the code to instantiate it:

#----------------------------------------------------------------------
def openFileDialog(self):
    """
    Opens a file dialog and sets the label to the chosen path
    """
    import os
    path, _ = QtGui.QFileDialog.getOpenFileName(self, "Open File", os.getcwd())
    self.label.setText(path)

We use getOpenFileName to return the file path in a tuple that also includes the file type, which in this case is All Files (*.*). We also set our QLabel to the path that was returned. There’s also a method in our main code called openDirectoryDialog that uses the same call signature but instead of getOpenFileName, we use getExistingDirectory. See the example below:

#----------------------------------------------------------------------
def openDirectoryDialog(self):
    """
    Opens a dialog to allow user to choose a directory
    """
    flags = QtGui.QFileDialog.DontResolveSymlinks | QtGui.QFileDialog.ShowDirsOnly
    d = directory = QtGui.QFileDialog.getExistingDirectory(self,
                                                           "Open Directory",
                                                           os.getcwd(),
                                                           flags)
    self.label.setText(d)

As you can see, we had to pass a couple of flags to this dialog to tell it not to resolve symlinks and to only show directories. Finally, there is also a getOpenFileNames method to the QFileDialog that allows the user to choose multiple files from the dialog and return all the selected files. This one is not shown, but operates similarly.

The PySide Font Dialog

The PySide Font dialog is very similar to the one you’ll see in older versions of Microsoft Office products. Creating the dialog is pretty simple:

#----------------------------------------------------------------------
def openFontDialog(self):
    """
    Open the QFontDialog and set the label's font
    """
    font, ok = QtGui.QFontDialog.getFont()
    if ok:
        self.label.setFont(font)

As you can see, you just create the dialog and call its getFont() method. This returns the chosen font and also whether or not the OK button was pushed. If it was, we reset our QLabel widget with the new font.

The PySide Input Dialog

The PySide Input dialog is also pretty simple. However, there are four varieties: Text, Integer, Double and Item. As is fairly obvious, these return text, integers, doubles (i.e. float) and items, which allows the user to choose from a list of items from a combobox. Here we show how to create the text version:

#----------------------------------------------------------------------
def openInputDialog(self):
    """
    Opens the text version of the input dialog
    """
    text, result = QtGui.QInputDialog.getText(self, "I'm a text Input Dialog!",
                                        "What is your favorite programming language?")
    if result:
        print "You love %s!" % text

If you’d like to see examples of the other types of input dialogs, I recommend you see the pyside-examples folder on git, specifically the standarddialogs.py script. You can also see screenshots of all four of these widgets here.

At this point, we’re ready to learn about the two types of print dialogs.

PySide’s Print Dialogs

For this demo, we create a simple little window with a QTextEdit to hold some example text and two buttons. We’ll copy and paste the code example from the previous section into this demo app and then press the Print button. Here’s the demo code:

# printDlgDemo.py
 
from PySide import QtGui, QtCore
 
########################################################################
class PrinterWindow(QtGui.QWidget):
    """"""
 
    #----------------------------------------------------------------------
    def __init__(self):
        """Constructor"""
        QtGui.QWidget.__init__(self)
        self.setWindowTitle("Printing Demo")
        self.text_editor = QtGui.QTextEdit(self)
 
        printButton = QtGui.QPushButton('Print')
        printButton.clicked.connect(self.onPrint)
        printPreviewButton = QtGui.QPushButton('Print Preview')
        printPreviewButton.clicked.connect(self.onPrintPreview)
 
        btnLayout = QtGui.QHBoxLayout()
        mainLayout = QtGui.QVBoxLayout()
 
        btnLayout.addWidget(printButton)
        btnLayout.addWidget(printPreviewButton)
        mainLayout.addWidget(self.text_editor)
        mainLayout.addLayout(btnLayout)
 
        self.setLayout(mainLayout)
 
    #----------------------------------------------------------------------
    def onPrint(self):
        """
        Create and show the print dialog
        """
        dialog = QtGui.QPrintDialog()
        if dialog.exec_() == QtGui.QDialog.Accepted:
            doc = self.text_editor.document()
            doc.print_(dialog.printer())
 
    #----------------------------------------------------------------------
    def onPrintPreview(self):
        """
        Create and show a print preview window
        """
        dialog = QtGui.QPrintPreviewDialog()
        dialog.paintRequested.connect(self.text_editor.print_)
        dialog.exec_()
 
#----------------------------------------------------------------------
if __name__ == "__main__":
    app = QtGui.QApplication([])
    form = PrinterWindow()
    form.show()
    app.exec_()

If you hit the Print button, you should see a dialog similar to the one below (if you’re on Windows 7):

Let’s take a look at the code behind this dialog:

#----------------------------------------------------------------------
def onPrint(self):
    """
    Create and show the print dialog
    """
    dialog = QtGui.QPrintDialog()
    if dialog.exec_() == QtGui.QDialog.Accepted:
        doc = self.text_editor.document()
        doc.print_(dialog.printer())

Here we instantiate the QPrintDialog and we show it by calling its exec_() method. If the user actually hits the Print button, we’ll extract a QTextDocument from the QTextEdit control and then call its print_() method by passing it the printer dialog.

Now let’s do the print preview dialog! Here’s the code from the demo mentioned earlier:

#----------------------------------------------------------------------
def onPrintPreview(self):
    """
    Create and show a print preview window
    """
    dialog = QtGui.QPrintPreviewDialog()
    dialog.paintRequested.connect(self.text_editor.print_)
    dialog.exec_()

This code is a little simpler than creating the QPrintDialog. Here we just instantiate an instance of QPrintPreviewDialog, tell it we want to connect paintRequested signal to the print_ method of text control. Finally we show the dialog. PySide does the rest and ends up creating a dialog that looks something like this:

You now know how to create both types of PySide’s print dialogs! At this point, we’re ready to move on to message boxes!

PySide’s Message Boxes

PySide has four Message Boxes based on the QMessageBox widget: critical, information, question and warning. We’re going to take a look at all four. We’ll start out with a full code example that is a demo that can launch any of the 4 message boxes and then we’ll look at each piece as we did in the previous section. Here’s the main program’s source:

from PySide import QtCore, QtGui
 
########################################################################
class MessageBoxDemo(QtGui.QWidget):
    """"""
 
    #----------------------------------------------------------------------
    def __init__(self):
        """Constructor"""
        # super(DialogDemo, self).__init__()
        QtGui.QWidget.__init__(self)
        self.setWindowTitle("MessageBox Demo")
 
        # create buttons
        criticalMsgBtn = QtGui.QPushButton("Show Critical Message")
        criticalMsgBtn.clicked.connect(self.onShowCriticalMessage)
 
        infoMsgBtn = QtGui.QPushButton("Show Informational Message")
        infoMsgBtn.clicked.connect(self.onShowInformation)
 
        questionMsgBtn = QtGui.QPushButton("Show Question Message")
        questionMsgBtn.clicked.connect(self.onShowQuestion)
 
        warningMsgBtn = QtGui.QPushButton("Show Warning Message")
        warningMsgBtn.clicked.connect(self.onShowWarning)
 
        # layout widgets
        layout = QtGui.QVBoxLayout()
        layout.addWidget(criticalMsgBtn)
        layout.addWidget(infoMsgBtn)
        layout.addWidget(questionMsgBtn)
        layout.addWidget(warningMsgBtn)
        self.setLayout(layout)
 
        self.setGeometry(100,100,300,100)
 
    #----------------------------------------------------------------------
    def onShowCriticalMessage(self):
        """
        Show the critical message
        """
        flags = QtGui.QMessageBox.Abort
        flags |= QtGui.QMessageBox.StandardButton.Retry
        flags |= QtGui.QMessageBox.StandardButton.Ignore
 
        result = QtGui.QMessageBox.critical(self, "CRITICAL ERROR",
                                            "You're trying Perl aren't you?",
                                            flags)
        if result == QtGui.QMessageBox.Abort:
            print "Aborted!"
        elif result == QtGui.QMessageBox.Retry:
            print "Retrying!"
        elif result == QtGui.QMessageBox.Ignore:
            print "Ignoring!"
 
    #----------------------------------------------------------------------
    def onShowInformation(self):
        """
        Show the information message
        """
        QtGui.QMessageBox.information(self, "Information", "Python rocks!")
 
    #----------------------------------------------------------------------
    def onShowQuestion(self):
        """
        Show the question message
        """
        flags = QtGui.QMessageBox.StandardButton.Yes 
        flags |= QtGui.QMessageBox.StandardButton.No
        question = "Do you really want to work right now?"
        response = QtGui.QMessageBox.question(self, "Question",
                                              question,
                                              flags)
        if response == QtGui.QMessageBox.Yes:
            print "You're very dedicated!"
        elif QtGui.QMessageBox.No:
            print "You're fired!"
        else:
            print "You chose wisely!"
 
    #----------------------------------------------------------------------
    def onShowWarning(self):
        """
        Show a warning message
        """
        flags = QtGui.QMessageBox.StandardButton.Ok
        flags |= QtGui.QMessageBox.StandardButton.Discard
        msg = "This message will self-destruct in 30 seconds!"
        response = QtGui.QMessageBox.warning(self, "Warning!",
                                             msg, flags)
        if response == 0:
            print "BOOM!"
        else:
            print "MessageBox disarmed!"
 
#----------------------------------------------------------------------
if __name__ == "__main__":
    app = QtGui.QApplication([])
    form = MessageBoxDemo()
    form.show()
    app.exec_()

Now let’s take a look at each message box in turn. The first one we’ll look at is the critical message box.

The Critical Message Box

The critical message box is launched from our demo program using the following method:

#----------------------------------------------------------------------
def onShowCriticalMessage(self):
    """
    Show the critical message
    """
    flags = QtGui.QMessageBox.Abort
    flags |= QtGui.QMessageBox.StandardButton.Retry
    flags |= QtGui.QMessageBox.StandardButton.Ignore
 
    result = QtGui.QMessageBox.critical(self, "CRITICAL ERROR",
                                        "You're trying Perl aren't you?",
                                        flags)
    if result == QtGui.QMessageBox.Abort:
        print "Aborted!"
    elif result == QtGui.QMessageBox.Retry:
        print "Retrying!"
    elif result == QtGui.QMessageBox.Ignore:
        print "Ignoring!"

All message boxes follow the same basic formula. They have a caption (“CRITICAL ERROR”), a message (“You’re trying Perl aren’t you?”) and some flags that control what buttons are shown. In this case, we show an Abort, a Retry and an Ignore button. We print out a special message to stdout that depends on which button is pressed.

The Information Message Box

The information message box is probably the simplest of any of the message boxes:

#----------------------------------------------------------------------
def onShowInformation(self):
    """
    Show the information message
    """
    QtGui.QMessageBox.information(self, "Information", "Python rocks!")

As you can see, we didn’t even need to specify any buttons for this one. It added an OK button all by itself.

The Question Message Box

The question message box is pretty simple too. Here’s the code:

#----------------------------------------------------------------------
def onShowQuestion(self):
    """
    Show the question message
    """
    flags = QtGui.QMessageBox.StandardButton.Yes 
    flags |= QtGui.QMessageBox.StandardButton.No
    question = "Do you really want to work right now?"
    response = QtGui.QMessageBox.question(self, "Question",
                                          question,
                                          flags)
    if response == QtGui.QMessageBox.Yes:
        print "You're very dedicated!"
    elif QtGui.QMessageBox.No:
        print "You're fired!"
    else:
        print "You chose wisely!"

For this message box, we needed two buttons: yes and no. We also check which button the user pressed and print out special messages based on their choice. You’ll note that there is no way to get the last print statement to execute.

The Warning Message Box

The warning message box is also quite simple and very similar to the question box.

#----------------------------------------------------------------------
def onShowWarning(self):
    """
    Show a warning message
    """
    flags = QtGui.QMessageBox.StandardButton.Ok
    flags |= QtGui.QMessageBox.StandardButton.Discard
    msg = "This message will self-destruct in 30 seconds!"
    response = QtGui.QMessageBox.warning(self, "Warning!",
                                         msg, flags)
    if response == 0:
        print "BOOM!"
    else:
        print "MessageBox disarmed!"

Here we have two buttons: an OK button and a discard button. Again we check to see which button is pressed and act accordingly.

Wrapping Up

Now you know how to create the various standard dialogs and message boxes that PySide provides. These are quite handy when you need to alert the user to something that is amiss in your program or to acquire small bits of information. Now go forth and start using your new-found knowledge wisely!

References

• Zetcode’s PySide tutorial on dialogs
• A PySide repo on git that shows standard dialog and message box examples
• StackOverflow – Print a text through a printer using PyQt4

Download the Source

• pyside_dialogs.zip

You can download it from their website and take a look. I thought it was pretty slick. You can even submit your own case studies to be included or help sponsor the brochure. Go check it out and spread the word!

Getting Started

If you don’t have PySide yet, go out and get it. If you want to try this with PyQt, make sure your version of PyQt is 4.3 or greater as the first example of partial in the following sample application won’t work in previous versions of PyQt. You can get PySide here. Once you’re all set up and ready to rock, go ahead and read the following code:

from functools import partial
from PySide.QtCore import SIGNAL
from PySide.QtGui import QApplication, QLabel, QWidget
from PySide.QtGui import QPushButton, QVBoxLayout
 
########################################################################
class MultiButtonDemo(QWidget):
    """"""
 
    #----------------------------------------------------------------------
    def __init__(self):
        """Constructor"""
        super(MultiButtonDemo, self).__init__()
 
        layout = QVBoxLayout()
 
        self.label = QLabel("You haven't pressed a button!")
 
        # use a normal signal / slot mechanic
        button1 = QPushButton("One")
        self.connect(button1, SIGNAL("clicked()"), self.one)
 
        # now let's use partial functions
        button2 = QPushButton("Two")
        self.connect(button2, SIGNAL("clicked()"),
                     partial(self.onButton, "Two"))
 
        button3 = QPushButton("Three")
        self.btn3Callback = partial(self.onButton, "Three")
        button3.clicked.connect(self.btn3Callback)
 
        # now let's try using a lambda function
        button4 = QPushButton("Four")
        button4.clicked.connect(lambda name="Four": self.onButton(name))
 
        layout.addWidget(self.label)
        layout.addWidget(button1)
        layout.addWidget(button2)
        layout.addWidget(button3)
        layout.addWidget(button4)
        self.setLayout(layout)
 
        self.setWindowTitle("PySide Demo")
 
    #----------------------------------------------------------------------
    def one(self):
        """"""
        self.label.setText("You pressed One!")
 
    #----------------------------------------------------------------------
    def onButton(self, lbl):
        """Change the label to the text (lbl) passed in"""
        self.label.setText("You pressed %s!" % lbl)
 
#----------------------------------------------------------------------
if __name__ == "__main__":
    app = QApplication([])
    form = MultiButtonDemo()
    form.show()
    app.exec_()

Let’s spend a little time breaking this down. We subclass QWidget to create our window. Then we use a QVBoxLayout to layout our widgets in a vertical row. Next we create a label and four buttons. The first button we hook up to an event handler is done in the normal way. In the one handler, it just updates the label to say that “You Pressed One!”. You could do this for the other 3 buttons, but that’s not the point of this article. Instead, we use Python’s functools library which has a very handy partial class. The partial class allows the developer to create a callable that you can give to your PySide signal. The first example creates a partial callable that is inaccessible to anything else. The 2nd example (button 3) of partial is assigned to a class variable, self.btn3Callback which you can then give to your signal. The last example (button 4) shows you how to do the same thing as partial, but by using Python’s lambda instead. This last method is especially popular with the Tkinter GUI toolkit.

Now we’re ready to find out how to make PySide itself tell us which button signaled the slot.

How to Make PySide Tell All

We’re actually going to refactor the code a bit to make the code shorter and to show you another way to layout your widgets. This time around, we’re also going to have all the buttons connect to just one slot (i.e. event handler / callable). Here’s the code:

from PySide.QtCore import SIGNAL
from PySide.QtGui import QApplication, QLabel, QWidget
from PySide.QtGui import QPushButton, QVBoxLayout
 
########################################################################
class MultiButtonDemo(QWidget):
    """"""
 
    #----------------------------------------------------------------------
    def __init__(self):
        """Constructor"""
        super(MultiButtonDemo, self).__init__()
 
        layout = QVBoxLayout()
 
        self.label = QLabel("You haven't pressed a button!")
        layout.addWidget(self.label)
        labels = ["One", "Two", "Three", "Four"]
        for label in labels:
            btn = QPushButton(label)
            btn.clicked.connect(self.clicked)
            layout.addWidget(btn)
 
        self.setLayout(layout)
 
        self.setWindowTitle("PySide Signals / Slots Demo")
 
    #----------------------------------------------------------------------
    def clicked(self):
        """
        Change label based on what button was pressed
        """
        button = self.sender()
        if isinstance(button, QPushButton):
            self.label.setText("You pressed %s!" % button.text())
 
#----------------------------------------------------------------------
if __name__ == "__main__":
    app = QApplication([])
    form = MultiButtonDemo()
    form.show()
    app.exec_()

Okay, the imports are a little shorter now as we no longer need functools. Down in the __init__ we create a list of button labels and then loop over them to create the four buttons. In the loop, we also connect the button to the callable (or the signal to the slot) and add the widget to the layout manager. According to Mark Summerfield, author of Rapid GUI Programming with Python and PyQt says in his book that the callable (slot) should be named the same as the signal as that is the convention of PyQt. My guess is that is the convention in PySide too, so we’re sticking with it.

In our clicked method/signal/callable/whatever we use self.sender() to grab the button object from whatever calls the method. Then, just to be safe, we make sure that the sender is an instance of QPushButton and if it is, then we grab the label of the button via its text() call and set the label appropriately. That’s it! Short and sweet!

Wrapping Up

Now you know several ways to pass arguments to a slot/handler. You have also learned how to ask PySide which widget called the callable. Now you can get out there and code up some cool stuff on your own.

Additional Reading

• Python’s documentation on functools.partial
• The Python Lambda
• wxPython: Binding Multiple Widgets to the Same Handler
• wxPython wiki – Passing Arguments to Callbacks

Download the Source

• pyside_passingArgstoSlots.zip

Here’s the mostly original code:

import sys
import urllib2
from PyQt4.QtCore import SIGNAL
from PyQt4.QtGui import QComboBox, QDialog, QDoubleSpinBox, QLabel
from PyQt4.QtGui import QApplication, QGridLayout
 
########################################################################
class CurrencyDlg(QDialog):
    """"""
 
    #----------------------------------------------------------------------
    def __init__(self, parent=None):
        """Constructor"""
        super(CurrencyDlg, self).__init__(parent)
 
        date = self.getdata()
        rates = sorted(self.rates.keys())
 
        dateLabel = QLabel(date)
        self.fromComboBox = QComboBox()
        self.fromComboBox.addItems(rates)
 
        self.fromSpinBox = QDoubleSpinBox()
        self.fromSpinBox.setRange(0.01, 10000000.00)
        self.fromSpinBox.setValue(1.00)
 
        self.toComboBox = QComboBox()
        self.toComboBox.addItems(rates)
        self.toLabel = QLabel("1.00")
 
        # layout the controls
        grid = QGridLayout()
        grid.addWidget(dateLabel, 0, 0)
        grid.addWidget(self.fromComboBox, 1, 0)
        grid.addWidget(self.fromSpinBox, 1, 1)
        grid.addWidget(self.toComboBox, 2, 0)
        grid.addWidget(self.toLabel, 2, 1)
        self.setLayout(grid)
 
        # set up the event handlers
        self.connect(self.fromComboBox, SIGNAL("currentIndexChanged(int)"),
                     self.updateUi)
        self.connect(self.toComboBox, SIGNAL("currentIndexChanged(int)"),
                     self.updateUi)
        self.connect(self.fromSpinBox, SIGNAL("valueChanged(double)"),
                     self.updateUi)
 
        self.setWindowTitle("Currency")
 
    #----------------------------------------------------------------------
    def getdata(self):
        """
        """
        self.rates = {}
        url = "http://www.bankofcanada.ca/en/markets/csv/exchange_eng.csv"
        try:
            date = None
            fh = urllib2.urlopen(url)
            for line in fh:
                line = line.rstrip()
                if not line or line.startswith(("#", "Closing ")):
                    continue
                fields = line.split(",")
                if line.startswith("Date "):
                    date = fields[-1]
                else:
                    try:
                        value = float(fields[-1])
                        self.rates[unicode(fields[0])] = value
                    except ValueError:
                        pass
            return "Exchange Rates Date: " + date
        except Exception, e:
            return "Failed to download: \n%s" % e
 
    #----------------------------------------------------------------------
    def updateUi(self):
        """
        Update the user interface
        """
        to = unicode(self.toComboBox.currentText())
        frum = unicode(self.fromComboBox.currentText())
        amount = ( self.rates[frum] / self.rates[to] ) 
        amount *= self.fromSpinBox.value()
        self.toLabel.setText("%0.2f" % amount)
 
#----------------------------------------------------------------------
if __name__ == "__main__":
    app = QApplication(sys.argv)
    form = CurrencyDlg()
    form.show()
    app.exec_()

If you really want to know how this code works, I recommend getting the aforementioned book or by studying the code. It is Python after all.

Porting to PySide

Now we need to “port” this to PySide, the LGPL version of the QT bindings for Python. Fortunately, in this example it is beyond easy. All you have to do is change the following imports

from PyQt4.QtCore import SIGNAL
from PyQt4.QtGui import QComboBox, QDialog, QDoubleSpinBox, QLabel
from PyQt4.QtGui import QApplication, QGridLayout

to

from PySide.QtCore import SIGNAL
from PySide.QtGui import QComboBox, QDialog, QDoubleSpinBox
from PySide.QtGui import QApplication, QGridLayout, QLabel

If you do that and save it, you’ll be done porting and the code will now work in PySide land. However, I think we need to go a bit further and make this code a little smarter. You’ll notice in the original that every time you run it, the application will go online and download the exchange rate data. That seems to be a little bit of overkill, so let’s add a check to see if it’s already downloaded and less than a day old. Only if it’s older than a day will we want to download a new copy. And instead of using urllib2, let’s use the new-fangled requests library instead.

Here’s the new code:

import datetime
import os
import PySide
import requests
import sys
 
from PySide.QtCore import SIGNAL
from PySide.QtGui import QComboBox, QDialog, QDoubleSpinBox
from PySide.QtGui import QApplication, QGridLayout, QLabel
 
########################################################################
class CurrencyDlg(QDialog):
    """"""
 
    #----------------------------------------------------------------------
    def __init__(self, parent=None):
        """Constructor"""
        super(CurrencyDlg, self).__init__(parent)
 
        date = self.getdata()
        rates = sorted(self.rates.keys())
 
        dateLabel = QLabel(date)
        self.fromComboBox = QComboBox()
        self.fromComboBox.addItems(rates)
 
        self.fromSpinBox = QDoubleSpinBox()
        self.fromSpinBox.setRange(0.01, 10000000.00)
        self.fromSpinBox.setValue(1.00)
 
        self.toComboBox = QComboBox()
        self.toComboBox.addItems(rates)
        self.toLabel = QLabel("1.00")
 
        # layout the controls
        grid = QGridLayout()
        grid.addWidget(dateLabel, 0, 0)
        grid.addWidget(self.fromComboBox, 1, 0)
        grid.addWidget(self.fromSpinBox, 1, 1)
        grid.addWidget(self.toComboBox, 2, 0)
        grid.addWidget(self.toLabel, 2, 1)
        self.setLayout(grid)
 
        # set up the event handlers
        self.connect(self.fromComboBox, SIGNAL("currentIndexChanged(int)"),
                     self.updateUi)
        self.connect(self.toComboBox, SIGNAL("currentIndexChanged(int)"),
                     self.updateUi)
        self.connect(self.fromSpinBox, SIGNAL("valueChanged(double)"),
                     self.updateUi)
 
        self.setWindowTitle("Currency - by PySide %s" % PySide.__version__)
 
    #----------------------------------------------------------------------
    def downloadFile(self, rate_file):
        """
        Download the file
        """
        url = "http://www.bankofcanada.ca/en/markets/csv/exchange_eng.csv"
        r = requests.get(url)
        try:
            with open(rate_file, "wb") as f_handler:
                f_handler.write(r.content)
        except IOError:
            print "ERROR: Unable to download file to %s" % rate_file
 
    #----------------------------------------------------------------------
    def getdata(self):
        """
        """
        base_path = os.path.dirname(os.path.abspath(__file__))
        rate_file = os.path.join(base_path, "exchange_eng.csv")
        today = datetime.datetime.today()
        self.rates = {}
 
        if not os.path.exists(rate_file):
            self.downloadFile(rate_file)
        else:
            # get last modified date:
            ts = os.path.getmtime(rate_file)
            last_modified = datetime.datetime.fromtimestamp(ts)
            if today.day != last_modified.day:
                self.downloadFile(rate_file)
 
        try:
            date = None
            with open(rate_file) as fh:
                for line in fh:
                    result = self.processLine(line)
                    if result != None:
                        date = result
 
            return "Exchange Rates Date: " + date
        except Exception, e:
            return "Failed to download: \n%s" % e
 
    #----------------------------------------------------------------------
    def processLine(self, line):
        """
        Processes each line and updates the "rates" dictionary
        """
        line = line.rstrip()
        if not line or line.startswith(("#", "Closing ")):
            return
        fields = line.split(",")
        if line.startswith("Date "):
            date = fields[-1]
            return date
        else:
            try:
                value = float(fields[-1])
                self.rates[unicode(fields[0])] = value
            except ValueError:
                pass
        return None
 
    #----------------------------------------------------------------------
    def updateUi(self):
        """
        Update the user interface
        """
        to = unicode(self.toComboBox.currentText())
        frum = unicode(self.fromComboBox.currentText())
        amount = ( self.rates[frum] / self.rates[to] ) 
        amount *= self.fromSpinBox.value()
        self.toLabel.setText("%0.2f" % amount)
 
#----------------------------------------------------------------------
if __name__ == "__main__":
    app = QApplication(sys.argv)
    form = CurrencyDlg()
    form.show()
    app.exec_()

Okay, let’s spend a little time looking at the code. We won’t explain everything, but we’ll go over what was changed. First off, we imported some more modules: datetime, os, requests and sys. We also imported PySide itself so we could easily add its version information to the dialog’s title bar. Next we added a couple of new methods: downloadFile and processLine. But first we need to look at what was changed in getdata. Here we grab the path that the script is running in and use that to create a fully qualified path to the rates file. Then we check if it already exists. If it doesn’t exist, we call the downloadFile method which uses the requests library to download the file. We’re also using Python’s with context manager construct which will automatically close the file when we’re done writing to it.

If the file DOES exist, then we fall to the else part of the statement in which we check if the file’s last modified date is older than today’s date. If it is, then we download the file and overwrite the original. Then we move on to processing the file. To do the processing, we move most of the code into a separate method called processLine. The primary reason for doing so is that if we don’t, we end up with a very complicated nested structure that can be hard to follow. We also add a check to see if the date has been returned from processLine and if it has, we set the date variable. The rest of the code stayed the same.

Wrapping Up

At this point, you should know how to create a very simple PySide application that can actually do something useful. Not only that, but you also have a very general idea of how to port your PyQt code to PySide. You have also been exposed to two different ways of downloading files from off the web. I hope this has opened your eyes to the power of Python and the fun of programming.

Note: The code in this article was tested on Windows 7 Professional with Python 2.6.6, PySide 1.2.2 and PyQt4

Related Links

• Python 101: How to Download a File
• The Official PySide website
• The Official PyQt website
• The requests package
• UPDATE (04/10/2013) – I noticed someone else decided to do this same tutorial as a video tutorial

Download the Source

• pyqt-side-currency.zip

Quick Review

• Why I picked it up: As I mentioned, the fact that it was an intermediate level book made this a must-read for me.
• Why I finished it: Because the book proved to be very interesting.
• I’d give it to: Python programmers who have a good understanding of the basics but are looking to grow in their Python skills.

Now if you have a few more minutes, you can read my full review after the jump!

Book Formats

This book is available on Amazon as a Kindle book only at the time of writing as far as I can tell. The copy I received was in epub format though, so there may be another version available somewhere…

Full Review

Matt Harrison’s latest book is his best yet. I found the writing to be almost error free with only a smattering of typos here and there, mostly in the 2nd half of the book. The book is split up into 3 sections (not including the Introduction). Harrison doesn’t spend time introducing us to Python; instead he assumes you already know it and dives off into the deep end with functional constructs. Thus begins the first section in which he covers lambda, map, reduce, filter, recursion, list, set and dict comprehensions, and finally, the operator module. He used a lot of the topics that followed the lambda to illustrate advanced uses of the lambda construct. I thought it was intriguing and ended up learning some new tricks that I hope to implement in my own code soon.

The 2nd section is devoted to Iteration and Generators. In it, you will learn the difference between iterables and iterators, how to construct a normal generator and an object generator and the author also gives tips about when to use a generator versus a list. He also shows some real life examples of generators and iterators in the Python core. He does this a little in the first section as well.

The 3rd section is all about Functions, Closures and Decorators with a heavy emphasis on the latter. I think this section is a shorter, updated version of his book on Decorators actually as some of the examples looked kind of familiar. Regardless, it was very illuminating. I will admit that the “Alternate Decorator Implementations” section at the end of the book was rather confusing though.

In the end, I think this book is well worth the cost of owning it. You’ll almost certainly pick up something new just in the first section. If you don’t know much about generators, iterators or decorators in Python, then this book will help you figure it out and hopefully give you ideas of how you could use them in your code. I know I learned a few things (and probably re-learned a few others!).

Treading on Python Volume 2: Intermediate Python Matt Harrison Amazon

Quick Review

• Why I picked it up: I picked this one up because first I was intrigued that someone wanted to use one of my articles in their book and secondly, I got a sneak peak of a couple of the chapters and enjoyed the author’s writing style. Also, picking it up for free helped!
• Why I finished it: Because I wanted to review the book. I only read the main text though and only skimmed the rather extensive glossary / appendices.
• I’d give it to: New programmers, especially if they already had a little programming already, like a 101 class.

You can read my full review after the jump!

Book Formats

This book is available on Amazon as a Kindle book only at the time of writing.

Full Review

Learn Python Quickly teaches Python 3. It covers all the topics that you would expect and a couple that you wouldn’t. I didn’t expect it to just cover installing Python, especially only on Windows. I was also surprised that a book as short as this one would attempt to jump into GUI programming with Tkinter for the last 3 chapters, but it did. The normal stuff is covered too of course (not necessarily in this order): numbers, strings, loops and if statements, lists and dictionaries (although not much on tuples), functions and classes, file I/O, exception handling, date manipulation and a chapter on spreadsheets and databases.

The spreadsheet and database chapter (number 8) focuses on the csv module for spreadsheets with a mention of the xlwt package but not xlrd. I thought this chapter might talk about PyWin32 and how to access Microsoft Excel using PyWin32′s COM modules, but it does not. The database section is a quick show-and-tell of pyodbc. He doesn’t teach SQL, which is fine, but should be noted.

The book covers the development of several applications at the end of the book. Mr. Rowland has the reader create several variations of a simple Banking application in the class chapter. Then he goes on to having the reader create a couple little Tkinter applications.

The most unique part about this book is that it uses TONS of hyperlinks. In fact, without the glossary and appendixes, the book would be only half as long. The author links to all kinds of terms in his glossary and to some outside sources as well. The writing style is engaging and sometimes entertaining, especially when the author drops some British terminology. I found the text to be straight-forward and easy to follow. I do have to point out a couple of cons though. There aren’t many code examples and he frequently refers to code on the book’s accompanying website: http://www.learnpythonquickly.com. Most of the time, this works quite well, but when I copy the code for the Tkinter stuff into my Python IDE, my line numbers don’t match up with the author’s very well. Also, if you try to read the book using the Amazon Cloud Reader, then the code is not indented properly most of the time, although if you open the book in Kindle software, it seems to be indenting the code appropriately.

Otherwise, the book was quite good and I would recommend it for people who are new to the language and want to just get up and running quickly. Of course, if you’re new, then you’ll be spending a lot of time with the Python documentation as well as this book just can’t cover the entire breadth of the entire Python language. Regardless, I think this book will allow readers to pick up the basics of Python quickly and the links will help them know what to search for later when they need to learn more.

Learn Python Quickly John Rowland Amazon

Reportlab’s Barcode Library

Reportlab provides for several different types of bar codes: code39 (i.e. code 3 of 9), code93, code 128, EANBC, QR, and USPS. I saw one called “fourstate” as well, but I couldn’t figure out how to get it to work. Underneath some of these types, there are sub-types such as Standard, Extended or MultiWidth. I didn’t have much luck getting the MultiWidth one to work for the code128 bar code as it kept giving me an attribute error, so we’ll just ignore that one. If you know how to do it, ping me in the comments or via my contact form and let me know. I’ll update the article if anyone can show me how to add that or the fourstate barcode.

Anyway, the best way to learn is to just write some code. Here’s a pretty straight-forward example:

from reportlab.graphics.barcode import code39, code128, code93
from reportlab.graphics.barcode import eanbc, qr, usps
from reportlab.graphics.shapes import Drawing 
from reportlab.lib.pagesizes import letter
from reportlab.lib.units import mm
from reportlab.pdfgen import canvas
from reportlab.graphics import renderPDF
 
#----------------------------------------------------------------------
def createBarCodes():
    """
    Create barcode examples and embed in a PDF
    """
    c = canvas.Canvas("barcodes.pdf", pagesize=letter)
 
    barcode_value = "1234567890"
 
    barcode39 = code39.Extended39(barcode_value)
    barcode39Std = code39.Standard39(barcode_value, barHeight=20, stop=1)
 
    # code93 also has an Extended and MultiWidth version
    barcode93 = code93.Standard93(barcode_value)
 
    barcode128 = code128.Code128(barcode_value)
    # the multiwidth barcode appears to be broken 
    #barcode128Multi = code128.MultiWidthBarcode(barcode_value)
 
    barcode_usps = usps.POSTNET("50158-9999")
 
    codes = [barcode39, barcode39Std, barcode93, barcode128, barcode_usps]
 
    x = 1 * mm
    y = 285 * mm
    x1 = 6.4 * mm
 
    for code in codes:
        code.drawOn(c, x, y)
        y = y - 15 * mm
 
    # draw the eanbc8 code
    barcode_eanbc8 = eanbc.Ean8BarcodeWidget(barcode_value)
    bounds = barcode_eanbc8.getBounds()
    width = bounds[2] - bounds[0]
    height = bounds[3] - bounds[1]
    d = Drawing(50, 10)
    d.add(barcode_eanbc8)
    renderPDF.draw(d, c, 15, 555)
 
    # draw the eanbc13 code
    barcode_eanbc13 = eanbc.Ean13BarcodeWidget(barcode_value)
    bounds = barcode_eanbc13.getBounds()
    width = bounds[2] - bounds[0]
    height = bounds[3] - bounds[1]
    d = Drawing(50, 10)
    d.add(barcode_eanbc13)
    renderPDF.draw(d, c, 15, 465)
 
    # draw a QR code
    qr_code = qr.QrCodeWidget('www.mousevspython.com')
    bounds = qr_code.getBounds()
    width = bounds[2] - bounds[0]
    height = bounds[3] - bounds[1]
    d = Drawing(45, 45, transform=[45./width,0,0,45./height,0,0])
    d.add(qr_code)
    renderPDF.draw(d, c, 15, 405)
 
    c.save()
 
if __name__ == "__main__":
    createBarCodes()

Let’s break this down a bit. The code39.Extended39 doesn’t really accept much beyond the value itself. On the other hand, code39.Standard39, code93.Standard93 and code128.Code128 all have basically the same API. You can change the barWidth, barHeight, turn on the start/stop symbols and add “quiet” zones. The usps bar code module provides two types of bar code: FIM and POSTNET. FIM or Facing ID Marks only encodes one letter (A-D) which I personally didn’t find it very interesting. So I just show the POSTNET version which should be pretty familiar to people in the United States as it appears on the bottom of most envelopes. POSTNET encodes the zip code!

The next three bar codes use a different API to draw them on the PDF that I discovered via StackOverflow. Basically you create a Drawing object of a certain size and then add the bar code to the drawing. Finally you use the renderPDF module to place the drawing on the PDF. It’s pretty convoluted, but it works pretty well. The EANBC codes are ones you’ll see on some manufactured products, such as tissue boxes.

If you’d like to see the result of the code above, you can download the PDF here.

Wrapping Up

At this point you should be able to go forth and create your own bar codes in your PDFs. Reportlab is pretty handy and I hope you’ll find this additional tool helpful in your endeavors.

Additional Reading

• A step by step Reportlab tutoral
• Reportlab: Mixing Fixed Content and Flowables
• Reportlab Tables – Creating Tables in PDFs with Python
• Creating QR Codes with Python
• StackOverflow question on Python barcode generation
• StackOverflow question on reportlab, QR codes and django

Get the Source!

• barcodes.tar