I was reading the Python blog feed yesterday and stumbled on Tarek Ziade’s Python Meme article. I thought it sounded like a fun idea, so here’s my answers to his questions.

1. What’s the coolest Python application, framework or library you have discovered in 2011?

I can’t think of anything new that I’ve really used this year. However, this was the year that I started using the ObjectListView widget in wxPython pretty extensively. It’s a great wrapper around the wx.ListCtrl that just makes it super easy to use. This is also the year that I started working on a big TurboGears 2 project, but I haven’t decided if it’s my favorite yet.

2. What new programming technique did you learn in 2011?

Lately I’ve taken to keeping my code more organized and structured than I have in the past, splitting my components into different modules, refactoring a lot more, trying to follow the Model-View-Controller schema more, etc. I have also started using Mercurial source control and BitBucket much more this year. I’m still not an expert in using them, but I know enough to keep my source mostly safe.

3. What’s the name of the open source project you contributed the most in 2011? What did you do?

wxPython. I write a lot of documentation for it on my wiki and I help lots of people with understanding it on the wxPython mailing list and on StackOverflow.

4. What was the Python blog or website you read the most in 2011?

Umm, this is a tough one. I read Tim Golden’s a lot with a dash of Jesse Noller and Doug Hellman. I like David Beazley too, but he doesn’t write much.

5. What are the three top things you want to learn in 2012?

I need to get a better handle on Mercurial branching and merging. Learning more TurboGears and maybe another Python web framework. Testing (I know some, but not enough, especially as related to GUIs).

6. What are the top software, app or lib you wish someone would write in 2012?

I wish there was a better eBay wrapper. I’d like to write my own sniper script. Another nice one would be some kind of all-in-one script that could create my bit.ly link for my blog post and then submit it to the various major tech sites for me.

Want to do your own list? here’s how:

• copy-paste the questions and answer to them in your blog
• tweet it with the #2012pythonmeme hashtag

The Linux Journal readers have good taste. This is the 3rd year that they have voted Python as the Best Programming Language. Oddly enough, C++ is the runner-up. I personally liked C++ when I was in school, but the two languages are quite different. On the other hand, Python interfaces with C/C++ pretty well, so maybe the readers of that magazine like to do mash-ups with the two languages. You will also note that they voted Python as the Best Scripting Language too.

Congrats to the Python community and the PSF too!

Hat-tip to Steve Holden who mentioned this on Python.org’s news feed.

Another week is over and we have a new set of articles for you to check out this weekend. You can learn new things, try modules, and be productive. Or you can go party. Don’t forget about all the different PyCons going on this year around the world. There are local ones and International conferences.

• Multiple reviews for the Python Testing Cookbook” target=”_blank”>Python Testing Cookbook are out now. See Jacob Perkins or Doug Hellman’s reviews
• Learn why SqlAlchemy rocks and how it’s different from Django’s ORM in Armin Ronacher’s article
• Speaking of Django, this article is an introduction to sessions in Django
• Python Application in the Cloud
• Re-load modules or import them without import with Exocet
• A Python 4 Kids Tkinter tutorial
• PyOhio

is next weekend!

• Read-Ahead and Python Generators
• How to convert Python UTC datetime to UNIX timestamp

That’s all for this week. Let me know if you find anything cool that you think I should highlight next time.

It’s been a while since I have done any interesting Python links. I quit for a while because these things take a while to put together and few seemed interested, but I’ll give it another go. This week has a really interesting article on Python and robots. Jesse Noller has a fun article where he collects various Python stories too (I nabbed a couple of his picks for mine too because he was right: they are interesting!)

• Building a face-tracking robot (Headroid1) with Python in an afternoon
• Python Debugging; Embarrassment, Contracts and Nothing is private (Jesse Noller)
• Nothing is Private: Python Closures (and ctypes) – Michael Foord
• namedtuple and exec() by Kristján Valur
• Both PyTexas and PyCon Japan are calling for papers so if you like talking about Python, get in on the action now!
• mock 0.7.2 and PyDev 2.1.0 were both released recently.
• Quick and Easy Debugging in Python by Jeet Sukumaran
• Teaching (and learning) Python by Ned Batchelder
• Filenames with accents by Ned Batchelder

If you think I missed something awesome that happened in the Python world recently, let me know in the comments and maybe I’ll add it next time. Thanks for your support!

As PyCon approaches, the blogger community was invited to interview the speakers that are coming to the event. I chose Wesley Chun, writer of Core Python Programming and co-author of Python Web Development with Django. In this interview, I ask Wesley about his talk, Running Django Apps on Google App Engine and about PyCon in general. Let’s see what he has to say:

1) What do you want the attendees to take away from this talk?

I’d like all attendees to come away from this talk with a greater sense of optimism they can take their Django apps and run them with little or no modification on Google App Engine, taking advantage of the scalability they need and is so difficult to achieve on your own.

Part of this talk is pseudo-marketing to bring more awareness to Django-nonrel, which is the foundation of how to get Django apps to run on App Engine. For the past several years since App Engine debuted in 2008, there have been several tools, called the Helper and the Patch, to help you run Django apps on App Engine. Unfortunately, those older systems required you to modify your apps’ data models in order to get them to run on App Engine. This is not the case with Django-nonrel, which should take its place as the leading tool that users should use when desiring to run Django apps on any NoSQL or non-relational database.

Along with Django-nonrel, developers also need the corresponding NoSQL adapter code, djangoappengine (for Google App Engine’s datastore), Django-mongodb-engine (for MongoDB). they (and others) are working on adapters to other NoSQL databases, but more exciting than that is the prospect of having NoSQL JOINs!

2) What made you decide to speak on this topic?

I wanted to give this talk for many reasons… I already mentioned awareness earlier. The other thing is that people are so used to the Helper and the Patch, that they don’t realize there’s a better tool out there.

Another important reason is the concept of vendor lock-in, the phenomenon where you can’t easily migrate your apps and/or data to different platforms because you’re “locked in” by your current vendor. people complain that you can’t run App Engine apps anywhere else, but this is not true. You can choose a different backend besides Google’s original… two of these backends are AppScale and TyphoonAE. similarly, if you created a Django app and ran it via traditional hosting, Django-nonrel helps you bring it to App Engine with very little porting. Similarly, if you write a Django app and run it on App Engine using Django-nonrel, it shouldn’t take much work to move it to traditional hosting.

3) What are the pros and cons in using Django on Google App Engine?

The most obvious pro is scalability. This is something that’s both very difficult and very expensive to build. why not take advantage of all the smart people at Google that have built scalability into their core infrastructure that helps them be…, well, Google! With Django-nonrel, if Google isn’t right for you, you can take your app and run it elsewhere! no vendor lock-in here.

One con would be that App Engine’s datastore is still difficult to wrap your head around if you’re used to the traditional relational database model. you can’t do raw SQL or JOINs completely yet. Google does give you a stripped-down SQL syntax known as GQL, but it’s not the complete picture. Also, in exchange for its benefits, you do have to give up some control over your app by letting Google host it. you can’t use any C/C++ extensions, and don’t have access to your logs or other raw files.

4) What are you most looking forward to at PyCon this year?

I’m looking forward to connecting with familiar and friendly faces of those I’ve met over the past decade of attending Python and open source conferences. Because we’re all so geographically diverse, it’s the one time you can count on to see people you haven’t seen in a year and to catch up, either in the exhibit hall or part of an interesting hallway conversation.

I’m also excited to learn new things that are part of the Python universe. every year it seems to grow a bit more, so it’s a struggle to stay up-to-date with what’s been going on in the community. I’m also looking forward to reprising my Python 3 talk from last year, partly because it’s becoming more important every year, and as part of my research for the talk, I’ll be finding out which projects have moved to Python 3.

5) What were your favorite parts of PyCon in previous years?

The best part of the Python ecosphere is having a great programming language to rally behind, but the next best thing is the people… the Python community itself. And PyCon is the best place to interact with the community. the conference is phenomenal because of the talks, ability to reach to all skill levels (from beginner through advanced), superb tutorials stretching across TWO days, compelling session talks, amazing lightning talks and open space sessions, and of course, the hallway conversations, not to mention that crazy memes and hacks such as OHwar –http://pycon.ohwar.com — that come from such convos.

Just think: you could meet your favorite Python author at PyCon this year AND learn about Django and Google App Engine at the same time. And if that doesn’t float your boat, Wesley is also doing a talk on Python 3. What are you waiting for? Get on over to the PyCon website and sign yourself up!

Note: This article cross-posted to the PyCon blog

This weekly edition of Python News has quite the variety of topics. You can learn about how to create passwords, the new Enthought Python Distribution and about something called pylibftdi. Plus, I’ve added a section just for PyCon related stuff since they seem to be releasing a lot of info this month. For example, there’s an interview with Armin Ronacher (author of Flask) in that section.

• Peter Fein talks about Better Passwords in Under 200 Characters
• Sphinx and htmlhelp
• Enthought Python Distribution version 7.0 released this week.
• pylibftdi 0.7 – multiple device support
• Python’s dictionary implementation
• A simple self-upgrade build pattern
• `cute_profile`: Profile your Python code on the fly

PyCon News

• Press release: Record-Breaking Submissions to PyCon 2011
• PyCon 2011: Interview with Armin Ronacher – “Opening the Flask”

So far no one has ever given me any leads for my next article, so that either means I’m doing something right or no one’s reading these posts. Well, as always, I will take a look at any links that my kind readers give me.

It’s time for your weekly dose of Python news. What happened in the last week? Or what did I find that I thought was newsy? Lots of stuff, it turns out. This week, you can learn about the controversy of PyPI, Tablib, a “fireside” chat with Python’s founder that’s coming up next month at PyCon USA and more.

• In Defense of PyPI
• Tablib update
• Enthought’s reStructuredText editor
• A fun, short article on Sphinx documentation
• PyCon 2011: Announcing “A Fireside Chat with Guido van Rossum”
• FLOSS Weekly Interviews the Pylons Project
• Add City Coverage to MapPoint using the GeoNames Database
• Help Mike Pirnat by giving him topics for his PyCon talk
• Jenkins (FKA: Hudson) is now available

I hope you find a few of those links useful or interesting. Feel free to give me a few for next week in the comments!

It’s almost the end of January already and PyCon USA 2011 is just around the corner. In this edition, we cover a wide variety of topics, from Python 2.7 – 3.x. We’ve got sprints, new books, web-related projects and good old recursion articles. Come one, come all! Read the news of the week!

• eWeek reports that Python Skills are in demand this year
• zzzeek’s Guide to Python 3 Porting by Michael Bayer, the man behind SqlAlchemy.
• Foundations of Python Network Programming: A Last Hurrah For Python 2. Brandon Rhodes (former editor of Python Magazine) talks about a book he just finished writing.
• Python Sprints is sponsoring Software Carpentry 2011. Details are sparse and I’m not really familiar with either organization, but this sounds interesting.
• Shannon Behrens talks about Python SSL Hell on his blog
• Learn how to deploy Python WSGI apps behind nginx
• Learn New-style PyQt Signals and Slots on Mario Boikov’s blog
• Building Python with LLVM 2.8 (and why I still love the project) by Brett Cannon.
• A little discussion of tail recursion can be found in the following article: Tail Recursion in Python using Pysistence

On the PyCon front, you should take note the Early Bird pricing is now over. Why did you wait? Fortunately, they are still selling tickets, so stop stalling and just come! The PyCon blog also mentions that they’re still looking for sponsors, so if you or someone you know has that kind of cashola, point them in that direction.

And now we return you back to your regularly scheduled blog reading…

In this article, we will be looking at wxPython’s Wizard widget. No, it has nothing to do with Dumbledore or Gandalf. Instead, it is that dialog that you’ll see when you run an installer or set up a template. Sometimes you’ll even see them used for setting up mail merge. We will cover two examples in this tutorial: one that is fairly simple and another that is slightly more complex. Let’s get started!

Note: The code in this article was adapted from the wxPython Demo application

A Simple Wizard

When you need to use a wizard in wxPython, you’ll want to import it in a special way. Instead of just importing wx, you will have to do this: import wx.wizard. Also note that there are two primary types of wizard pages: WizardPageSimple and PyWizardPage. The former is the easiest, so we’ll use that in our simple example. Here’s the code:

import wx
import wx.wizard as wiz
 
########################################################################
class TitledPage(wiz.WizardPageSimple):
    """"""
 
    #----------------------------------------------------------------------
    def __init__(self, parent, title):
        """Constructor"""
        wiz.WizardPageSimple.__init__(self, parent)
 
        sizer = wx.BoxSizer(wx.VERTICAL)
        self.SetSizer(sizer)
 
        title = wx.StaticText(self, -1, title)
        title.SetFont(wx.Font(18, wx.SWISS, wx.NORMAL, wx.BOLD))
        sizer.Add(title, 0, wx.ALIGN_CENTRE|wx.ALL, 5)
        sizer.Add(wx.StaticLine(self, -1), 0, wx.EXPAND|wx.ALL, 5)
 
#----------------------------------------------------------------------
def main():
    """"""
    wizard = wx.wizard.Wizard(None, -1, "Simple Wizard")
    page1 = TitledPage(wizard, "Page 1")
    page2 = TitledPage(wizard, "Page 2")
    page3 = TitledPage(wizard, "Page 3")
    page4 = TitledPage(wizard, "Page 4")
 
    wx.wizard.WizardPageSimple.Chain(page1, page2)
    wx.wizard.WizardPageSimple.Chain(page2, page3)
    wx.wizard.WizardPageSimple.Chain(page3, page4)
    wizard.FitToPage(page1)
 
    wizard.RunWizard(page1)
 
    wizard.Destroy()
 
#----------------------------------------------------------------------
if __name__ == "__main__":
    app = wx.App(False)
    main()
    app.MainLoop()

That’s a fair bit of code. Let’s take it a part and see if we can figure it out. First off, we import wx and the wizard which we rename “wiz” to save on keystrokes. Next, we create a TitledPage class that subclasses WizardPageSimple. This class will be the basis for all the pages in our wizard. It basically just defines a page that has a centered title in 18 point font with a line underneath.

In the main function we find the real meat. Here we create the wizard using the following syntax: wx.wizard.Wizard(None, -1, “Simple Wizard”). This gives the wizard a parent of None, an id and a title. Then we create four pages which are instances of the TitledPage class that we mentioned earlier. Finally, we use wx.wizard.WizardPageSimple.Chain to chain the pages together. This allows us to use a couple of automatically generated buttons to page forwards and backwards through the pages. The last couple of lines of code will run the wizard and when the user is done, will destroy the wizard. Pretty simple, right? Now let’s move on to the more advanced example.

Using PyWizardPage

In this section, we will create a subclass of PyWizardPage. We will also have a WizardPageSimple subclass so that we can mix and match the two to create a series of different pages. Let’s just jump to the code so you can see it for yourself!

import images
import wx
import wx.wizard as wiz
 
########################################################################
class TitledPage(wiz.WizardPageSimple):
    """"""
 
    #----------------------------------------------------------------------
    def __init__(self, parent, title):
        """Constructor"""
        wiz.WizardPageSimple.__init__(self, parent)
 
        sizer = wx.BoxSizer(wx.VERTICAL)
        self.sizer = sizer
        self.SetSizer(sizer)
 
        title = wx.StaticText(self, -1, title)
        title.SetFont(wx.Font(18, wx.SWISS, wx.NORMAL, wx.BOLD))
        sizer.Add(title, 0, wx.ALIGN_CENTRE|wx.ALL, 5)
        sizer.Add(wx.StaticLine(self, -1), 0, wx.EXPAND|wx.ALL, 5)
 
########################################################################
class UseAltBitmapPage(wiz.PyWizardPage):
 
    #----------------------------------------------------------------------
    def __init__(self, parent, title):
        wiz.PyWizardPage.__init__(self, parent)
        self.next = self.prev = None
        self.sizer = wx.BoxSizer(wx.VERTICAL)
 
        title = wx.StaticText(self, label=title)
        title.SetFont(wx.Font(18, wx.SWISS, wx.NORMAL, wx.BOLD))
        self.sizer.Add(title)
 
        self.sizer.Add(wx.StaticText(self, -1, "This page uses a different bitmap"),
                       0, wx.ALL, 5)
        self.sizer.Layout()
 
    #----------------------------------------------------------------------
    def SetNext(self, next):
        self.next = next
 
    #----------------------------------------------------------------------
    def SetPrev(self, prev):
        self.prev = prev
 
    #----------------------------------------------------------------------
    def GetNext(self):
        return self.next
 
    #----------------------------------------------------------------------
    def GetPrev(self):
        return self.prev
 
    #----------------------------------------------------------------------
    def GetBitmap(self):
        # You usually wouldn't need to override this method
        # since you can set a non-default bitmap in the
        # wxWizardPageSimple constructor, but if you need to
        # dynamically change the bitmap based on the
        # contents of the wizard, or need to also change the
        # next/prev order then it can be done by overriding
        # GetBitmap.
        return images.WizTest2.GetBitmap()
 
#----------------------------------------------------------------------
def main():
    """"""
    wizard = wiz.Wizard(None, -1, "Dynamic Wizard",
                        images.WizTest1.GetBitmap())
    page1 = TitledPage(wizard, "Page 1")
    page2 = TitledPage(wizard, "Page 2")
    page3 = TitledPage(wizard, "Page 3")
    page4 = UseAltBitmapPage(wizard, "Page 4")
    page5 = TitledPage(wizard, "Page 5")
 
    wizard.FitToPage(page1)
    page5.sizer.Add(wx.StaticText(page5, -1, "\nThis is the last page."))
 
    # Set the initial order of the pages
    page1.SetNext(page2)
    page2.SetPrev(page1)
    page2.SetNext(page3)
    page3.SetPrev(page2)
    page3.SetNext(page4)
    page4.SetPrev(page3)
    page4.SetNext(page5)
    page5.SetPrev(page4)
 
    wizard.GetPageAreaSizer().Add(page1)
    wizard.RunWizard(page1)
    wizard.Destroy()
 
#----------------------------------------------------------------------
if __name__ == "__main__":
    app = wx.App(False)
    main()
    app.MainLoop()

This code starts out in much the same way as the previous code did. In this example, we also import an images module that contains a couple PyEmbeddedImage objects that we will use to demonstrate how to add bitmaps to our wizard page. Anyway, the first class is exactly the same as the previous one. Next we create a UseAltBitmapPage class that is a subclass of the PyWizardPage. We have to override a few methods to make it work correctly, but they’re pretty self-explanatory. This page will just be used to change the bitmap image of one page.

In the main function, we create a wizard in a slightly different way than we did previously:

wizard = wiz.Wizard(None, -1, "Dynamic Wizard", images.WizTest1.GetBitmap())

As you can see, this method allows us to add a bitmap that will appear along the left hand side of the wizard pages. Anyway, after that, we create five pages with four of them being instances of the TitledPage and one being an instance of a UseAltBitmapPage. We fit the wizard to page one and then we see something odd:

page5.sizer.Add(wx.StaticText(page5, -1, "\nThis is the last page."))

What does that do? Well, it’s a silly way to append a widget to a page. To let the user know that they’ve reached the last page, we add a StaticText instance to it that explicitly tells that they have reached the end. The next few lines set up the order of the pages using SetNext and SetPrev. While these methods give you more granular control over the order of the pages, they’re not as convenient as the WizardPageSimple.Chain method. The last few lines of code are the same as the previous example.

A Bonus Tip: How to Relabel the Wizard Buttons

While creating this article, someone actually asked how to change the button labels of the wizard on the official wxPython mailing list. So for completeness, we’ll take Robin Dunn’s solution and show how to change both the previous and the next button’s labels.

prev_btn = self.FindWindowById(wx.ID_BACKWARD)
prev_btn.SetLabel("Foo")
next_btn = self.FindWindowById(wx.ID_FORWARD)
next_btn.SetLabel("Bar")

Wrapping Up

Now you know how to create the two types of wizards that are included with wxPython. You also have learned a fun hack to change the labels of the buttons in the wizard. Let me know if you think I forgot something and I’ll update the post or write a follow-up.

Further Reading

• wx.wizard.Wizard official documentation
• wx.wizard.WizardPage documentation
• Andrea Gavana’s Wizard documentation

Source Code

• wxWizards.zip
• wxWizards.tar

PyChecker is a cool tool for checking Python scripts for bugs. It works with Python 2.0 – 2.7. In this article, we will write some crappy code to see what PyChecker can pick up on. Then we’ll improve the code according to what we find until the code checks out. According to PyChecker’s website, it can detect the following problems:

• No global found (e.g., using a module without importing it)
• Passing the wrong number of parameters to functions/methods/constructors
• Passing the wrong number of parameters to builtin functions & methods
• Using format strings that don’t match arguments
• Using class methods and attributes that don’t exist
• Changing signature when overriding a method
• Redefining a function/class/method in the same scope
• Using a variable before setting it
• self is not the first parameter defined for a method
• Unused globals and locals (module or variable)
• Unused function/method arguments (can ignore self)
• No doc strings in modules, classes, functions, and methods

Getting Started

We won’t test everything that it can detect, but we can make some pretty messy code for PyChecker to check. Let’s start coding!

import sys
 
########################################################################
class CarClass:
    """"""
 
    #----------------------------------------------------------------------
    def __init__(self, color, make, model, year):
        """Constructor"""
        self.color = color
        self.make = make
        self.model = model
        self.year = year
 
        if "Windows" in platform.platform():
            print "You're using Windows!"
 
        self.weight = self.getWeight(1, 2, 3)
 
    #----------------------------------------------------------------------
    def getWeight(this):
        """"""
        return "2000 lbs"

This code doesn’t really do much of anything and is only for illustration purposes. According to PyChecker, there are four problems with this code. Can you see the issues? If not, then let’s find out how to use PyChecker to expose them! Once you have installed PyChecker and put it on your path (see PyChecker’s documentation), you should be able to do the following command:


C:\Users\Mike\Documents\My Dropbox\Scripts\code analysis>pychecker bad.py


Note: The above only works if you have pychecker on your system path on Windows. Technically, on Windows you will be using pychecker.bat

If you do this, you’ll end up with something like the following:

Hopefully you can tell what that all means, but we’ll break it down just in case you don’t. There are four problems that it has identified. The first issue it found is that we import the sys module, but we don’t use it. The second issue is the opposite of the first. We refer to the platform module, but it’s not actually imported! Thirdly, we call our getWeight method and it reports that we passed it too many parameters. I think PyChecker may have a bug here as our method should accept one method, not zero. The “this” parameter must confuse PyChecker. Fortunately, the last problem it finds is that getWeight doesn’t have self as the first parameter. This kind of rectifies the bug I mentioned. While the first method doesn’t require us to name it “self”, that is the normal naming convention for the first parameter in a class method.

Other Tips

PyChecker doesn’t just work on the command line. You can also use it directly in your code! All you have to do is import PyChecker at the top of your module, like this:

import pychecker.checker

This will make PyChecker check all the following imported modules, although it won’t do the main module. What does that mean? It means that if you stick that line in the example we used, you won’t see any errors related to that code. The PyChecker documentation says that you can also set PyChecker’s option via os.environ. Here’s an example:

os.environ['PYCHECKER'] = 'command line options here'

Speaking of which, here are the common command line options:

Options	Description	Default
--only	only warn about files passed on the command line	no
-#, --limit	the maximum number of warnings to be displayed	10
--no-shadowbuiltin	check if a variable shadows a builtin	off
-q, --stdlib	ignore warnings from files under standard library	off
-T, --argsused	unused method/function arguments	on

If you’d like a full list of commands, type the following: pychecker -h

NOTE: PyChecker’s docstring checking is off by default, so if you want it you need to pass the “-m -f” commands. This only found the class module’s empty docstring. There seems to be a minor bug with “-f” in which it thinks empty doc strings are ok. I have alerted the PyChecker team to that.

Wrapping Up

I think PyChecker is pretty cool and it looks like it could be a handy tool. Give it a try and see what you think!

Additional Reading

• PyChecker official website
• PyLint - another project that’s in the same vein as PyChecker
• pyflakes – another similar project
• Doug Hellman’s review of Python Static Code Analyzers from the Python Magazine