Next time, we’ll be booking it at the Ames Public Library in (you guessed it!) Ames, IA on Thursday, October 7th. If you think you got the chops for talking about Python, drop me a line and I’ll hook you up.

Getting Started with GUI2Exe

Quite some time ago, I wrote another article on this cool tool. However, the look-and-feel of the application has changed quite a bit, so I felt I should re-write that article in the context of this series. To follow along with this article, you’ll need to hit Google Code for the source. Let’s begin, shall we? Here are some step-by-step directions for making the console script using py2exe via GUI2Exe:

1. Download the source and unzip them in a convenient location
2. Run the “GUI2Exe.py” file (you can use your favorite editor, open it via the command line or whatever)
3. Go to File, New Project. A dialog will appear asking you to name the project. Give it a good name! Then hit OK.
4. Click in the “Exe Kind” column and change it to “Console”
5. Click in the “Python Main Script” column and you’ll see a button appear.
6. Press the button and use the file dialog to find your main script
7. Fill out the other optional fields however you like
8. Hit the compile button on the lower right
9. Try the result to see if it worked!

If you followed the directions above, you should now have an executable file (and a few dependencies) in a “dist” folder at the location of the main script. As you can see in the screenshot above, there are all the typical options that you would set in your setup.py file. You can set your excludes list, the includes, the optimize and compressed settings, whether or not to include a zip, packages and much more! You can tweak to your hearts content and hit the “Compile” button whenever you’re ready to see the result. If I’m experimenting, I usually change the output directory’s name so I can compare the results to see which is the most compact.

If you want to use bbfreeze, cx_freeze, PyInstaller or py2app, just click the respective name in the column on the right. This will cause the middle part of the screen to change according to your choice and show the corresponding options for said choice. Let’s take a quick visual tour!

GUI2Exe in Pictures!

The following is a snapshot of the py2app options:

Next is a shot of the cx_Freeze options:

And here is PyInstaller’s settings:

Finally, we have bbfreeze’s options:

There’s also a VendorId screen, but I don’t know much about that one, so we’ll be skipping it.

GUI2Exe’s Menu Options

As you might guess, all these options work the same way as they do when you do it all yourself in code. If you ever need to check out the setup.py file that GUI2Exe is making for you, just go to the Builds menu and choose View Setup Script. If you want to see a handy listing of the files it output and where it output the files, go to Build, Explorer and you should see something like the screenshot below:

Other handy option in the Builds menu include the Mission Modules and the Binary Dependencies menu items. These show you what may be missing from the dist folder that you may need to include should you distribute your masterpiece.

The Options menu controls options for GUI2Exe itself and a few custom items for the build process, like setting the Python version, deleting the build and/or dist folders, set the PyInstaller Path and more. The other menus are pretty self-explanatory and I leave them for the adventurous readers.

Wrapping Up

If you’ve read my other tutorials in the “Build a Binary Series” then you should be able to take that knowledge and use it productively with GUI2Exe. I find GUI2Exe to be very helpful when it comes time for me to build an executable and I used it to help me figure out the options for some of the other binary builders in this series. I hope you enjoyed this series and found it helpful. See you next time!

Further Reading

• GUI2Exe Official website
• Andrea Gavana’s website and blog
• Build a Binary Series
• The other GUI2Exe tutorial

Python 3 Object Oriented Programming

By Dusty Phillips

Amazon

Packt

A few months ago, I wrote a preview of this book. A little over a week ago, I received my copy of the book. Before we get to the review though, I want to give full disclosure: Packt contacted me to be a “Reviewer” (read: technical editor) for this book last December. The payment? They gave me a copy of the book, one copy of any other book from their catalog that I wanted and my name appears in the book. If you think that remuneration will cause me to biased, so be it. Everyone is biased in some way or another. I tend to be harsher on things that I’m involved in though.

Well, enough of the baring of my soul. Let’s take a look at the book. The author of this book really likes Unified Modeling Language (UML) class diagrams, so if you find those helpful in learning, then you’ll like this book. The entire first chapter is made up of text and UML diagrams, after all and it gives a brief introduction to the Object Oriented philosophy. Chapter 2 jumps into Python Objects, modules and packages. Chapter 3 digs into inheritance (basic and multiple) and polymorphism. Chapter 4 is all about exceptions in Python. Chapter 5 attempts to explain when to use object oriented programming. I thought that was an interesting chapter because it seems to me that colleges browbeat their students into thinking they should use OOP for everything. Chapters 6 and 7 dig into the Python standard library by covering tuples, lists, dicts, sets, various comprehensions, generators and functions. I learned a lot about comprehensions from these chapters that made me wish I used Python 3 more. Chapters 8 and 9 cover Python Design Patterns. I found these chapters to be the highlight of the book and very interesting. He covers the following patterns: decorator, observer, strategy, state, singleton, template, adapter, facade, flyweight, command, abstract factory and composite.

Chapter 10 covers the basics of files and strings; chapter 11 goes overs testing with unit tests and py.test. Last, chapter 12 does a quick overview of common Python 3 libraries, like SqlAlchemy, Tkinter, PyQt, lxml and CherryPy.

When I was reviewing the book, Chapters 5 and 8 had some Python Imaging Library examples. The author had noted that PIL hadn’t been ported to Python 3 at the time, but he thought it would be by publishing. Alas, the people behind PIL still do not have a Python 3 port. So I was curious how the author handled this conundrum. It turns out that he ended up replacing PIL with pygame. An interesting choice that appears to work all right for the examples. I didn’t re-read the book (although I plan to at some point). Instead, I just did a spot check to see if the author followed any of my suggestions or fixed errors. It appears that he did.

This book was good before he fixed the problems with it. There’s more theory here than you normally find in Python textbooks, but I found the examples intriguing and he has unusual exercises at the end of the chapters that should keep you thinking. I’m pretty sure I would have been quite happy if I had purchased this book. If you’re new to Python 3 and specifically object oriented programming or you want to learn about programming patterns, I recommend this book. If you want a sneak peak, Packt has Chapter 7 available on their website here.

Getting Started with bbfreeze

You can use easy_install to download and install bbfreeze or you can just download its source or the egg file directly from the Python Package Index (PyPI). In this article, we’ll try using it on a simple configuration file generator script and we’ll also try it against a lame wxPython program. My test machine was a Windows 7 Home Edition 32-bit laptop with bbfreeze 0.96.5, and Python 2.6.4. Let’s start with the configuration script:

# config_1.py
import configobj
 
#----------------------------------------------------------------------
def createConfig(configFile):
    """
    Create the configuration file
    """
    config = configobj.ConfigObj()
    inifile = configFile
    config.filename = inifile
    config['server'] = "http://www.google.com"
    config['username'] = "mike"
    config['password'] = "dingbat"
    config['update interval'] = 2
    config.write()
 
#----------------------------------------------------------------------
def getConfig(configFile):
    """
    Open the config file and return a configobj
    """
    return configobj.ConfigObj(configFile)
 
def createConfig2(path):
    """
    Create a config file
    """
    config = configobj.ConfigObj()
    config.filename = path
    config["Sony"] = {}
    config["Sony"]["product"] = "Sony PS3"
    config["Sony"]["accessories"] = ['controller', 'eye', 'memory stick']
    config["Sony"]["retail price"] = "$400"
    config.write()
 
if __name__ == "__main__":
    createConfig2("sampleConfig2.ini")

This script has a couple of functions that are pointless, but we’ll leave them in for illustrative purposes. According to the bbfreeze documentation, we should be able to create a binary with the following string typed into the command line:


bb-freeze config_1.py


This assumes that you have “C:\Python26\Scripts” on your path. If you don’t, you’ll need to type the complete path out (i.e. “C:\Python26\Scripts\bb-freeze config_1.py”). When I ran this, I got an error. Here it is:

Traceback (most recent call last):
  File "C:\Python26\Scripts\bb-freeze-script.py", line 8, in <module>
    load_entry_point('bbfreeze==0.96.5', 'console_scripts', 'bb-freeze')()
  File "C:\Python26\lib\site-packages\bbfreeze-0.96.5-py2.6-win32.egg\bbfreeze\__init__.py", line 18, in main
    f()
  File "C:\Python26\lib\site-packages\bbfreeze-0.96.5-py2.6-win32.egg\bbfreeze\freezer.py", line 474, in __call__
    self.addModule("encodings.*")
  File "C:\Python26\lib\site-packages\bbfreeze-0.96.5-py2.6-win32.egg\bbfreeze\freezer.py", line 411, in addModule
    self.mf.import_hook(name[:-2], fromlist="*")
  File "C:\Python26\lib\site-packages\bbfreeze-0.96.5-py2.6-win32.egg\bbfreeze\modulegraph\modulegraph.py", line 256, in import_hook
    modules.update(self.ensure_fromlist(m, fromlist))
  File "C:\Python26\lib\site-packages\bbfreeze-0.96.5-py2.6-win32.egg\bbfreeze\modulegraph\modulegraph.py", line 345, in ensure_fromlist
    fromlist.update(self.find_all_submodules(m))
  File "C:\Python26\lib\site-packages\bbfreeze-0.96.5-py2.6-win32.egg\bbfreeze\modulegraph\modulegraph.py", line 369, in find_all_submodules
    for (path, mode, typ) in ifilter(None, imap(moduleInfoForPath, names)):
NameError: global name 'ifilter' is not defined

It would seem that the “modulegraph.py” file is missing an import from the itertools library, which is included with Python. I edited my copy of “modulegraph.py” to include the following line at the top of the file: “from itertools import ifilter”. This got rid of that traceback, but it raised another because “imap” wasn’t defined either. To fix the second error, I changed my import to “from itertools import ifilter,imap” and then it ran with no problems and produced a binary in a “dist” folder along with nine other files (see screenshot below).

Using bbfreeze’s Advanced Configuration

The PyPI page for bbfreeze (which is also its home page) has very little documentation. However, the page does say that the preferred way to use bbfreeze is with little scripts. We’re going to try using creating a binary with the lame wxPython, mentioned earlier. Here’s the wx code:

import wx
 
########################################################################
class DemoPanel(wx.Panel):
    """"""
 
    #----------------------------------------------------------------------
    def __init__(self, parent):
        """Constructor"""
        wx.Panel.__init__(self, parent)
 
        labels = ["Name", "Address", "City", "State", "Zip",
                  "Phone", "Email", "Notes"]
 
        mainSizer = wx.BoxSizer(wx.VERTICAL)
        lbl = wx.StaticText(self, label="Please enter your information here:")
        lbl.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))
        mainSizer.Add(lbl, 0, wx.ALL, 5)
        for lbl in labels:
            sizer = self.buildControls(lbl)
            mainSizer.Add(sizer, 1, wx.EXPAND)
        self.SetSizer(mainSizer)
        mainSizer.Layout()
 
    #----------------------------------------------------------------------
    def buildControls(self, label):
        """"""
        sizer = wx.BoxSizer(wx.HORIZONTAL)
        size = (80,40)
        font = wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD)
 
        lbl = wx.StaticText(self, label=label, size=size)
        lbl.SetFont(font)
        sizer.Add(lbl, 0, wx.ALL|wx.CENTER, 5)
        if label != "Notes":
            txt = wx.TextCtrl(self, name=label)
        else:
            txt = wx.TextCtrl(self, style=wx.TE_MULTILINE, name=label)
        sizer.Add(txt, 1, wx.ALL, 5)
        return sizer
 
 
 
########################################################################
class DemoFrame(wx.Frame):
    """
    Frame that holds all other widgets
    """
 
    #----------------------------------------------------------------------
    def __init__(self):
        """Constructor"""
        wx.Frame.__init__(self, None, wx.ID_ANY,
                          "cxFreeze Tutorial",
                          size=(600,400)
                          )
        panel = DemoPanel(self)
        self.Show()
 
#----------------------------------------------------------------------
if __name__ == "__main__":
    app = wx.App(False)
    frame = DemoFrame()
    app.MainLoop()

Now let’s create a simple freezing script!

# bb_setup.py
from bbfreeze import Freezer
 
f = Freezer(distdir="bb-binary")
f.addScript("sampleApp.py")
f()

First off, we import the Freezer class from the bbfreeze package. Freezer accepts three arguments: a destination folder, an includes iterable and an excludes iterable (i.e. a tuple or list). Just to see how well bbfreeze works with only its defaults, we leave out the includes and excludes tuples/lists. Once you have a Freezer object, you can add your script(s) by calling the Freezer object name’s addScript method. Then you just need to call the object (i.e. f() ). If you do all that, you should end up with a 14.5 MB folder holding 18 files. When I ran the sampleApp.exe file, it ran just fine and was properly themed, however it also had a console screen. To figure out the correct syntax, I used GUI2Exe. Here’s the new code:

# bb_setup2.py
from bbfreeze import Freezer
 
includes = []
excludes = ['_gtkagg', '_tkagg', 'bsddb', 'curses', 'email', 'pywin.debugger',
            'pywin.debugger.dbgcon', 'pywin.dialogs', 'tcl',
            'Tkconstants', 'Tkinter']
 
bbFreeze_Class = Freezer('dist', includes=includes, excludes=excludes)
 
bbFreeze_Class.addScript("sampleApp.py", gui_only=True)
 
bbFreeze_Class.use_compression = 0
bbFreeze_Class.include_py = True
bbFreeze_Class()

If you run this, you should end up with a “dist” folder that contains 18 files and is 16.6 MB in size. Notice that we added a second argument to the addScript method: gui_only=True. This makes that annoying console go away. We also set compression to zero (no compression, I think) and include the Python interpreter. Turning on compression only reduced the result down to 14.3 MB though.

The bbfreeze package also handles “recipes” and includes several examples, however they are not documented well either and I couldn’t figure out how to include them with my current examples. Feel free to figure them out on your own!

Wrapping Up

Well, now you should know the basics of using bbfreeze to create binaries from your programs. I hope you found this helpful. The last article in this series will be on GUI2Exe. Look for it soon!

Practical Programming: An Introduction to Computer Science Using Python

By Jennifer Campbell, Paul Gries, Jason Montojo and Greg Wilson

Amazon

I received the book, Practical Programming: An Introduction to Computer Science Using Python as a gift last month from a family member. This book is by four authors: Jennifer Campbell, Paul Gries, Jason Montojo and Greg Wilson. I’d been interested in reading another Python-related textbook for a while, and this happens to be one of the few out there. The only other Python textbook I’ve read is Python Programming: An Introduction to Computer Science by John Zelle. I’m aware of one or two others, but those books are beyond what I’m willing to pay.

Normally when I see something that required multiple authors, the results are less than stellar. However, this book does a pretty good job of introducing students to computer science using Python. Of course, when I was taking classes in computer science, we spent multiple classes on just theory. Most of this book is on learning the basics of Python, such as how to use strings, lists, dicts, tuples, etc. So if you were hoping to learn algorithms and data structures using Python, you won’t be finding much of that here. There is one chapter on algorithms that covers sorts and search algorithms though, and I thought that was one of the highlights of the book.

On the other hand, you will get a nice introduction to one of the easiest and most fun to use programming languages ever created. Not only do you get a nice introduction, but each chapter ends with a series of exercises based on the text of the chapter. I like having review questions or problems to solve that make what I learned stick in my brain. I mostly skimmed the exercises though because the chapters were designed for college Freshmen with no programming experience.

This book covers basic testing in two places. It’s not thorough, but it does give the reader a taste and I think it conveys the reasoning behind testing fairly well. At the end of the book, they get a little more topical on us. The book gives an overview of the following topics: debugging, the object-oriented philosophy (classes, inheritance, polymorphism), graphical user interfaces using Tkinter, and databases (sqlite).

After reading Dusty Phillips’ book on Object Oriented Programming with Python, I found the one chapter in this book lacking. However, it is typical of an introduction, so I can’t knock it too much. The Tkinter chapter was fun as I have been planning on brushing up on that for other articles on this blog. The authors even spend some time on the Model-Viewer-Controller paradigm. I didn’t really like how they laid out the code though since it was hard to tell which code fit where in the whole MVC schema. The database section was almost straight-up SQL code using Python 2.5′s sqlite module. While there’s nothing particularly bad with that approach, I know I would have been a little confused by it because of all the new syntax that doesn’t match anything I had learned previously in the book.

There are some instances of weird or poor grammar, but I didn’t find any obvious coding errors that weren’t there on purpose. The book is priced reasonably, especially considering that it’s supposed to be a college textbook. If you are new to computer science or to Python, I think you’ll find this book helpful. If you’re an experienced programmer or you’ve already had several courses in computer science, than you’ll probably want to skip this book (unless you’re looking to learn Python).

Getting Started with cx_Freeze

As mentioned on the cx_Freeze website, there are three ways to use this script. The first is to just use the included cxfreeze script; the second is to create a distutils setup script (think py2exe) which you can save for future use; and the third is to work with the internals of cxfreeze. We will focus on the first two ways of using cx_Freeze. We’ll begin with the console script:

import configobj
 
#----------------------------------------------------------------------
def createConfig(configFile):
    """
    Create the configuration file
    """
    config = configobj.ConfigObj()
    inifile = configFile
    config.filename = inifile
    config['server'] = "http://www.google.com"
    config['username'] = "mike"
    config['password'] = "dingbat"
    config['update interval'] = 2
    config.write()
 
#----------------------------------------------------------------------
def getConfig(configFile):
    """
    Open the config file and return a configobj
    """
    return configobj.ConfigObj(configFile)
 
def createConfig2(path):
    """
    Create a config file
    """
    config = configobj.ConfigObj()
    config.filename = path
    config["Sony"] = {}
    config["Sony"]["product"] = "Sony PS3"
    config["Sony"]["accessories"] = ['controller', 'eye', 'memory stick']
    config["Sony"]["retail price"] = "$400"
    config.write()
 
if __name__ == "__main__":
    createConfig2("sampleConfig2.ini")

All this script does is create a really simple configuration file using Michael Foord’s configobj module. You can set it up to read the config too, but for this example, we’ll skip that. Let’s find out how to build a binary with cx_Freeze! According to the documentation, all it should take is the following string on the command line (assuming you are in the correct directory):


cxfreeze config_1.py --target-dir dirName


This assumes that you have “C:\PythonXX\Scripts” on your path. If not, you’ll either have to fix that or type out the fully qualified path. Anyway, if the cxfreeze script run correctly, you should have a folder with the following contents:

As you can see, the total file size should be 4.81 MB or almost 5 megabytes. That was pretty easy. It even picked up the configobj module without our having to tell it to, something that PyInstaller failed to do. There are 18 command line arguments you can pass to cx_Freeze to control how it does things. These range from what modules to include or exclude, optimization, compression, include a zip file, path manipulation and more. Now let’s try something a little more advanced.

“Advanced” cx_Freeze – Using a setup.py File

First off we need a script to use. For this one, we’ll use that simple wxPython script from the PyInstaller article:

import wx
 
########################################################################
class DemoPanel(wx.Panel):
    """"""
 
    #----------------------------------------------------------------------
    def __init__(self, parent):
        """Constructor"""
        wx.Panel.__init__(self, parent)
 
        labels = ["Name", "Address", "City", "State", "Zip",
                  "Phone", "Email", "Notes"]
 
        mainSizer = wx.BoxSizer(wx.VERTICAL)
        lbl = wx.StaticText(self, label="Please enter your information here:")
        lbl.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))
        mainSizer.Add(lbl, 0, wx.ALL, 5)
        for lbl in labels:
            sizer = self.buildControls(lbl)
            mainSizer.Add(sizer, 1, wx.EXPAND)
        self.SetSizer(mainSizer)
        mainSizer.Layout()
 
    #----------------------------------------------------------------------
    def buildControls(self, label):
        """"""
        sizer = wx.BoxSizer(wx.HORIZONTAL)
        size = (80,40)
        font = wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD)
 
        lbl = wx.StaticText(self, label=label, size=size)
        lbl.SetFont(font)
        sizer.Add(lbl, 0, wx.ALL|wx.CENTER, 5)
        if label != "Notes":
            txt = wx.TextCtrl(self, name=label)
        else:
            txt = wx.TextCtrl(self, style=wx.TE_MULTILINE, name=label)
        sizer.Add(txt, 1, wx.ALL, 5)
        return sizer
 
 
 
########################################################################
class DemoFrame(wx.Frame):
    """
    Frame that holds all other widgets
    """
 
    #----------------------------------------------------------------------
    def __init__(self):
        """Constructor"""
        wx.Frame.__init__(self, None, wx.ID_ANY,
                          "cxFreeze Tutorial",
                          size=(600,400)
                          )
        panel = DemoPanel(self)
        self.Show()
 
#----------------------------------------------------------------------
if __name__ == "__main__":
    app = wx.App(False)
    frame = DemoFrame()
    app.MainLoop()

Now let’s create a setup.py file in the cx_Freeze style:

from cx_Freeze import setup, Executable
 
setup(
    name = "wxSampleApp",
    version = "0.1",
    description = "An example wxPython script",
    executables = [Executable("sampleApp.pyw")]
    )

As you can see, this is a pretty simple one. We import a couple classes from cx_Freeze and pass some parameters into them. In this case, we give the setup class a name, version, description and and Executable class. The Executable class also gets one parameter, the script name that it will use to create the binary from. To get this to build the binary, you need to do the following on the command line:


python setup.py build


After running this, you should end up with the following folders: “build\exe.win32-2.6″. Inside that last folder are 17 files that total 15.3 MB. When you run the sampleApp.exe file, you will notice that we’ve screwed something up. There’s a console window loading in addition to our GUI!!! To rectify this, we’ll need to change our setup file slightly. Take a look at our new one:

from cx_Freeze import setup, Executable
 
exe = Executable(
    script="sampleApp.pyw",
    base="Win32GUI",
    )
 
setup(
    name = "wxSampleApp",
    version = "0.1",
    description = "An example wxPython script",
    executables = [exe]
    )

First off, we separated the Executable class from the setup class and assigned the Executable class to a variable. We also added a second parameter to the Executable class that is key. That parameter is called “base”. By setting base=”Win32GUI”, we are able to suppress the console window. A good way to learn the many other options that we can use with cx_Freeze is to use GUI2Exe to generate the setup.py files for us. The documentation on the cx_Freeze website shows the many other options that the Executable class takes. Oddly enough, I couldn’t find any information about what the setup class takes for arguments other than just the source itself, which has very little comments. Good luck figuring that bit out.

Wrapping Up

Now you should know how to create binaries with cx_Freeze. It’s pretty easy to do and it’s nice that they’ve created a method to create binaries in a cross-platform way. Have fun!

Further Reading

• Stackoverflow
• cx_Freeze official site, mailing list
• GUI2Exe website

Getting Started with PyInstaller

Note on Python 2.6 on Windows: If you read the PyInstaller website closely, you will see a warning about Python 2.6+ not being fully supported. The note says that you will currently need to have the Microsoft CRT installed for your executable to work. What this is probably referring to is the side-by-side assemblies / manifest issues that were introduced with Python 2.6 vis-a-vis Microsoft Visual Studio 2008. We already mentioned this problem in the first article. If you don’t know anything about it, please check out the py2exe website, the wxPython wiki or Google for the issue.

Anyway, let’s get on with the show. After you download PyInstaller, you just unzip the archive somewhere convenient. The follow these three simple steps:

1. Run Configure.py to save some basic configuration data to a “.dat” file. This saves some time since PyInstaller won’t have to recalculate the configuration on the fly.
2. Run the following command on the command line: python Makespec.py [opts] where scriptname is the name of the main Python file you use to run your program.
3. Finally, run the following command via the command line: python Build.py specfile to build your executable.

Let’s run through this with a real script now. We’ll start with a simple console script that creates a faux configuration file. Here’s the code:

import configobj
 
#----------------------------------------------------------------------
def createConfig(configFile):
    """
    Create the configuration file
    """
    config = configobj.ConfigObj()
    inifile = configFile
    config.filename = inifile
    config['server'] = "http://www.google.com"
    config['username'] = "mike"
    config['password'] = "dingbat"
    config['update interval'] = 2
    config.write()
 
#----------------------------------------------------------------------
def getConfig(configFile):
    """
    Open the config file and return a configobj
    """
    return configobj.ConfigObj(configFile)
 
def createConfig2(path):
    """
    Create a config file
    """
    config = configobj.ConfigObj()
    config.filename = path
    config["Sony"] = {}
    config["Sony"]["product"] = "Sony PS3"
    config["Sony"]["accessories"] = ['controller', 'eye', 'memory stick']
    config["Sony"]["retail price"] = "$400"
    config.write()
 
if __name__ == "__main__":
    createConfig2("sampleConfig.ini")

Now let’s make a spec file:


c:\Python25\python c:\Users\Mike\Desktop\pyinstaller-1.4\Makespec.py config_1.py


On my test machine, I have 3 different Python versions installed, so I had to specify the Python 2.5 path explicitly (or set Python 2.5 as the default). Anyway, this should create a file similar to the following (which was named “config_1.spec”):

# -*- mode: python -*-
a = Analysis([os.path.join(HOMEPATH,'support\\_mountzlib.py'), os.path.join(HOMEPATH,'support\\useUnicode.py'), 'config_1.py'],
             pathex=['C:\\Users\\Mike\\Desktop\\py2exe_ex', r'C:\Python26\Lib\site-packages'])
pyz = PYZ(a.pure)
exe = EXE(pyz,
          a.scripts,
          exclude_binaries=1,
          name=os.path.join('build\\pyi.win32\\config_1', 'config_1.exe'),
          debug=False,
          strip=False,
          upx=True,
          console=True )
coll = COLLECT( exe,
               a.binaries,
               a.zipfiles,
               a.datas,
               strip=False,
               upx=True,
               name=os.path.join('pyInstDist2', 'config_1'))

For the Python script we’re using, we need to add an explicit path to the location of configobj.py in the Analysis section of the spec file in the pathex parameter. If you do not do this, when you run the resulting executable, it will open and close a console window really fast and you won’t be able to tell what it says unless you run the exe from the command line. I did the latter to find out what was wrong and discovered it could not find the configobj module. You can also specify the output path for your exe in the COLLECT function’s name parameter. In this case, we put PyInstaller’s output in the “config_1″ subfolder of “pyInstDist2″, which should be a folder alongside your original script. There are a ton of options when configuring your spec file, which you can read about here.

To build the executable based on the spec file, do the following on the command line:


c:\Python25\python c:\Users\Mike\Desktop\pyinstaller-1.4\Build.py config_1.spec


On my machine, I ended up with a folder that had 25 files in it that totaled 6.7 MB. You should be able to reduce the size using the Analysis section’s excludes parameter and/or compression.

PyInstaller and wxPython

Now let’s try creating a binary from a simple wxPython script. Here’s the Python script:

import wx
 
########################################################################
class DemoPanel(wx.Panel):
    """"""
 
    #----------------------------------------------------------------------
    def __init__(self, parent):
        """Constructor"""
        wx.Panel.__init__(self, parent)
 
        labels = ["Name", "Address", "City", "State", "Zip",
                  "Phone", "Email", "Notes"]
 
        mainSizer = wx.BoxSizer(wx.VERTICAL)
        lbl = wx.StaticText(self, label="Please enter your information here:")
        lbl.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))
        mainSizer.Add(lbl, 0, wx.ALL, 5)
        for lbl in labels:
            sizer = self.buildControls(lbl)
            mainSizer.Add(sizer, 1, wx.EXPAND)
        self.SetSizer(mainSizer)
        mainSizer.Layout()
 
    #----------------------------------------------------------------------
    def buildControls(self, label):
        """"""
        sizer = wx.BoxSizer(wx.HORIZONTAL)
        size = (80,40)
        font = wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD)
 
        lbl = wx.StaticText(self, label=label, size=size)
        lbl.SetFont(font)
        sizer.Add(lbl, 0, wx.ALL|wx.CENTER, 5)
        if label != "Notes":
            txt = wx.TextCtrl(self, name=label)
        else:
            txt = wx.TextCtrl(self, style=wx.TE_MULTILINE, name=label)
        sizer.Add(txt, 1, wx.ALL, 5)
        return sizer
 
 
 
########################################################################
class DemoFrame(wx.Frame):
    """
    Frame that holds all other widgets
    """
 
    #----------------------------------------------------------------------
    def __init__(self):
        """Constructor"""
        wx.Frame.__init__(self, None, wx.ID_ANY,
                          "PyInstaller Tutorial",
                          size=(600,400)
                          )
        panel = DemoPanel(self)
        self.Show()
 
#----------------------------------------------------------------------
if __name__ == "__main__":
    app = wx.App(False)
    frame = DemoFrame()
    app.MainLoop()

Since this is a GUI, we’ll create our spec file slightly differently:


c:\Python25\python c:\Users\Mike\Desktop\pyinstaller-1.4\Makespec.py -F -w sampleApp.py


Note the -F and -w parameters. The -F command tells PyInstaller to create just one executable whereas the -w tells PyInstaller to hide the console window. Here’s the resulting spec file:

# -*- mode: python -*-
a = Analysis([os.path.join(HOMEPATH,'support\\_mountzlib.py'), os.path.join(HOMEPATH,'support\\useUnicode.py'), 'sampleApp.py'],
             pathex=['C:\\Users\\Mike\\Desktop\\py2exe_ex'])
pyz = PYZ(a.pure)
exe = EXE( pyz,
          a.scripts,
          a.binaries,
          a.zipfiles,
          a.datas,
          name=os.path.join('pyInstDist', 'sampleApp.exe'),
          debug=False,
          strip=False,
          upx=True,
          console=False )

Note that the last line has the “console” parameter set to “False”. If you build this like you did with the console script you should end up with one file in the “pyInstDist” folder that is approximately 7.1 MB in size.

Wrapping Up

This ends our quick tour of PyInstaller. I hope you found this helpful in your Python binary-making endeavors. There is much more information on the PyInstaller website and it’s pretty well documented, although the website is pretty plain. Be sure to give it a try and see just how much easy PyInstaller is to use!

Note: I tested all this using PyInstaller 1.4 and Python 2.5 on Windows 7 Home Premium (32-bit).

Further Reading

• PyInstaller Official Website, Manual, Mailing List
• First article in the “Build a Binary Series”

Our next meeting will be in Des Moines at the IMT Group building. We are currently getting all the details nailed down for that, so be sure to check out the Pyowa website for updates or join our mailing list!

Let’s Get Started

For this tutorial, we’re going to use a wxPython script that doesn’t do anything. This is a contrived example, but we’re using wx to make it more visually interesting than just doing a console “Hello World” program. Note also that I am using py2exe 0.6.9, wxPython 2.8.11.0 and Python 2.6. Here’s what the end product should look like when run:

Now that we know what it looks like, here’s a look at the code:

import wx
 
########################################################################
class DemoPanel(wx.Panel):
    """"""
 
    #----------------------------------------------------------------------
    def __init__(self, parent):
        """Constructor"""
        wx.Panel.__init__(self, parent)
 
        labels = ["Name", "Address", "City", "State", "Zip",
                  "Phone", "Email", "Notes"]
 
        mainSizer = wx.BoxSizer(wx.VERTICAL)
        lbl = wx.StaticText(self, label="Please enter your information here:")
        lbl.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))
        mainSizer.Add(lbl, 0, wx.ALL, 5)
        for lbl in labels:
            sizer = self.buildControls(lbl)
            mainSizer.Add(sizer, 1, wx.EXPAND)
        self.SetSizer(mainSizer)
        mainSizer.Layout()
 
    #----------------------------------------------------------------------
    def buildControls(self, label):
        """"""
        sizer = wx.BoxSizer(wx.HORIZONTAL)
        size = (80,40)
        font = wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD)
 
        lbl = wx.StaticText(self, label=label, size=size)
        lbl.SetFont(font)
        sizer.Add(lbl, 0, wx.ALL|wx.CENTER, 5)
        if label != "Notes":
            txt = wx.TextCtrl(self, name=label)
        else:
            txt = wx.TextCtrl(self, style=wx.TE_MULTILINE, name=label)
        sizer.Add(txt, 1, wx.ALL, 5)
        return sizer
 
 
 
########################################################################
class DemoFrame(wx.Frame):
    """
    Frame that holds all other widgets
    """
 
    #----------------------------------------------------------------------
    def __init__(self):
        """Constructor"""
        wx.Frame.__init__(self, None, wx.ID_ANY,
                          "Py2Exe Tutorial",
                          size=(600,400)
                          )
        panel = DemoPanel(self)
        self.Show()
 
#----------------------------------------------------------------------
if __name__ == "__main__":
    app = wx.App(False)
    frame = DemoFrame()
    app.MainLoop()

This is fairly straightforward, so I’ll leave it the reader to figure out. This article is about py2exe after all.

The py2exe setup.py file

The key to any py2exe script is the setup.py file. This file controls what gets included or excluded, how much we compress and bundle, and much more! Here is the simplest setup that we can use with the wx script above:

from distutils.core import setup
import py2exe
 
setup(windows=['sampleApp.py'])

As you can see, we import the setup method from distutils.core and then we import py2exe. Next we call setup with a windows keyword parameter and pass it the name of the main file inside a python list object. If you were creating a non-GUI project, than you would use the console key instead of windows. To run this, open up a command prompt and navigate to the appropriate location. Then type “python setup.py py2exe” to run it. This is what I got when I first ran it:

It looks like wxPython requires the “MSVCP90.dll” and Windows can’t find it. A quick Google search yielded the consensus that I needed the “Microsoft Visual C++ 2008 Redistributable Package”, found here. I downloaded it, installed it and tried py2exe again. Same error. This would have probably worked had I been using Visual Studio to create an exe of a C# program. Anyway, the trick was to search the hard drive for the file and then copy it to Python’s DLL folder, which on my machine was found at the following location: C:\Python26\DLLs (adjust as necessary on your machine). Once the DLL was in the proper place, the setup.py file ran just fine. The result was put into a “dist” folder which contains 17 files and weighs in at 15.3 MB. I double-clicked the “sampleApp.exe” file to see if my shiny new binary would work and it did! In older versions of wxPython, you would have needed to include a manifest file to get the right look and feel (i.e the themes), but that was taken care of in 2.8.10 (I think) as was the side-by-side (SxS) assembly manifest file that used to be required.

Note that for non-wxPython scripts, you will probably still need to mess with the SxS manifests and all the hoops that includes. You can read more about that in the py2exe tutorial.

Creating an Advanced setup.py File

Let’s see what other options py2exe gives us for creating binaries by creating a more complex setup.py file.

from distutils.core import setup
import py2exe
 
includes = []
excludes = ['_gtkagg', '_tkagg', 'bsddb', 'curses', 'email', 'pywin.debugger',
            'pywin.debugger.dbgcon', 'pywin.dialogs', 'tcl',
            'Tkconstants', 'Tkinter']
packages = []
dll_excludes = ['libgdk-win32-2.0-0.dll', 'libgobject-2.0-0.dll', 'tcl84.dll',
                'tk84.dll']
 
setup(
    options = {"py2exe": {"compressed": 2,
                          "optimize": 2,
                          "includes": includes,
                          "excludes": excludes,
                          "packages": packages,
                          "dll_excludes": dll_excludes,
                          "bundle_files": 3,
                          "dist_dir": "dist",
                          "xref": False,
                          "skip_archive": False,
                          "ascii": False,
                          "custom_boot_script": '',
                         }
              },
    windows=['sampleApp.py']
)

This is pretty self-explanatory, but let’s unpack it anyway. First we set up a few lists that we pass to the options parameter of the setup function.

• The includes list is for special modules that you need to specifically include. Sometimes py2exe can’t find certain modules, so you get to manually specify them here.
• The excludes list is a list of which modules to exclude from your program. In this case, we don’t need Tkinter since we’re using wxPython. This list of excludes is what GUI2Exe will exclude by default.
• The packages list is a list of specific packages to include. Again, sometimes py2exe just can’t find something. I’ve had to include email, PyCrypto, or lxml here before. Note that if the excludes list contains something you’re trying to include in the packages or includes lists, py2exe may continue to exclude them.
• dll_excludes – excludes dlls that we don’t need in our project.

In the options dictionary, we have a few other options to look at. The compressed key tells py2exe whether or not to compress the zipfile, if it’s set. The optimize key sets the optimization level. Zero is no optimization and 2 is the highest. The bundle_files key bundles dlls in the zipfile or the exe. Valid values for bundle_files are: 3 = don’t bundle (default) 2 = bundle everything but the Python interpreter 1 = bundle everything, including the Python interpreter. A couple of years ago, when I was first learning py2exe, I asked on their mailing list what the best option was because I was having issues with bundle option 1. I was told that 3 was probably the most stable. I went with that and stopped having random problems, so that’s what I currently recommend. If you don’t like distributing more than one file, zip them up or create an installer. The only other option I use in this list is the dist_dir one. I use it to experiment with different built options or to create custom builds when I don’t want to overwrite my main good build. You can read about all the other options (including ones not even listed here) on the py2exe website. By setting optimize to 2, we can reduce the size of folder by about one megabyte.

Reducing a wxPython Script’s Binary Size

There’s a thread on the wxPython mailing list about reducing the size of the binary. I contacted Steven Sproat, one of the people in the thread, about what he did and here’s the trick: Set the “bundle_files” option to 1 and the the zipfile to None. The result will be three files in your dist folder: MSVCR71.dll, sampleApp.exe and w9xpopen.exe. The size of the folder is 5.94 MB on my machine (Tested on a Windows XP machine). As I mentioned earlier, setting bundle_files to 1 can cause some users to experience issues when running your application, but this may have been fixed with the newer versions of py2exe. Here’s what the setup.py file looks like with the new options set:

from distutils.core import setup
import py2exe
 
includes = []
excludes = ['_gtkagg', '_tkagg', 'bsddb', 'curses', 'email', 'pywin.debugger',
            'pywin.debugger.dbgcon', 'pywin.dialogs', 'tcl',
            'Tkconstants', 'Tkinter']
packages = []
dll_excludes = ['libgdk-win32-2.0-0.dll', 'libgobject-2.0-0.dll', 'tcl84.dll',
                'tk84.dll']
 
setup(
    options = {"py2exe": {"compressed": 2,
                          "optimize": 2,
                          "includes": includes,
                          "excludes": excludes,
                          "packages": packages,
                          "dll_excludes": dll_excludes,
                          "bundle_files": 1,
                          "dist_dir": "dist",
                          "xref": False,
                          "skip_archive": False,
                          "ascii": False,
                          "custom_boot_script": '',
                         }
              },
    zipfile = None,
    windows=['sampleApp.py']
)

Another way to reduce the size of the folder is to use compression programs as one of my readers, ProgMan, pointed out. Here are his results:

Wrapping Up

You now know the basics for creating binaries with py2exe. I hope you have found this helpful for your current or future projects. If so, let me know in the comments!

Further Reading

• The py2exe Tutorial
• Packaging wxPyMail for Distribution
• GUI2Exe

It’s probably easiest to just jump right into the code. Note that the only thing other than Python that you will need is the PyWin32 package. Once you’ve got that, then you can follow along:

import codecs
import os
import sys
import time
import traceback
import win32con
import win32evtlog
import win32evtlogutil
import winerror
 
#----------------------------------------------------------------------
def getAllEvents(server, logtypes, basePath):
    """
    """
    if not server:
        serverName = "localhost"
    else:
        serverName = server
    for logtype in logtypes:
        path = os.path.join(basePath, "%s_%s_log.log" % (serverName, logtype))
        getEventLogs(server, logtype, path)
 
#----------------------------------------------------------------------
def getEventLogs(server, logtype, logPath):
    """
    Get the event logs from the specified machine according to the
    logtype (Example: Application) and save it to the appropriately
    named log file
    """
    print "Logging %s events" % logtype
    log = codecs.open(logPath, encoding='utf-8', mode='w')
    line_break = '-' * 80
 
    log.write("\n%s Log of %s Events\n" % (server, logtype))
    log.write("Created: %s\n\n" % time.ctime())
    log.write("\n" + line_break + "\n")
    hand = win32evtlog.OpenEventLog(server,logtype)
    total = win32evtlog.GetNumberOfEventLogRecords(hand)
    print "Total events in %s = %s" % (logtype, total)
    flags = win32evtlog.EVENTLOG_BACKWARDS_READ|win32evtlog.EVENTLOG_SEQUENTIAL_READ
    events = win32evtlog.ReadEventLog(hand,flags,0)
    evt_dict={win32con.EVENTLOG_AUDIT_FAILURE:'EVENTLOG_AUDIT_FAILURE',
              win32con.EVENTLOG_AUDIT_SUCCESS:'EVENTLOG_AUDIT_SUCCESS',
              win32con.EVENTLOG_INFORMATION_TYPE:'EVENTLOG_INFORMATION_TYPE',
              win32con.EVENTLOG_WARNING_TYPE:'EVENTLOG_WARNING_TYPE',
              win32con.EVENTLOG_ERROR_TYPE:'EVENTLOG_ERROR_TYPE'}
 
    try:
        events=1
        while events:
            events=win32evtlog.ReadEventLog(hand,flags,0)
 
            for ev_obj in events:
                the_time = ev_obj.TimeGenerated.Format() #'12/23/99 15:54:09'
                evt_id = str(winerror.HRESULT_CODE(ev_obj.EventID))
                computer = str(ev_obj.ComputerName)
                cat = ev_obj.EventCategory
        ##        seconds=date2sec(the_time)
                record = ev_obj.RecordNumber
                msg = win32evtlogutil.SafeFormatMessage(ev_obj, logtype)
 
                source = str(ev_obj.SourceName)
                if not ev_obj.EventType in evt_dict.keys():
                    evt_type = "unknown"
                else:
                    evt_type = str(evt_dict[ev_obj.EventType])
                log.write("Event Date/Time: %s\n" % the_time)
                log.write("Event ID / Type: %s / %s\n" % (evt_id, evt_type))
                log.write("Record #%s\n" % record)
                log.write("Source: %s\n\n" % source)
                log.write(msg)
                log.write("\n\n")
                log.write(line_break)
                log.write("\n\n")
    except:
        print traceback.print_exc(sys.exc_info())
 
    print "Log creation finished. Location of log is %s" % logPath
 
 
if __name__ == "__main__":
    server = None  # None = local machine
    logTypes = ["System", "Application", "Security"]
    getAllEvents(server, logTypes, "C:\downloads")

There are a couple potential caveats to this type of scripting. I tested this code as an Administrator on my PCs and as a Domain Administrator at work. I did not test it as any other type of user. So if you have problems getting this code to run, check your permissions. I tested this from Windows XP and Windows 7. The UAC doesn’t appear to block this activity on Windows 7, so that made it just as easy to use as XP did. However, Windows 7′s events had some unicode in the message portion of the code whereas XP did not. Watch out for that and handle it accordingly.

Anyway, let’s unpack this script and see how it works. First we have a number of imports. We use the codecs modules to encode the log file in utf-8 just in case there’s some sneaky unicode in the message. We use PyWin32′s win32evtlog module to open the event log and pull information out of it. According to the article I mentioned at the beginning, to get all the events from the log, you need to call win32evtlog.ReadEventLog repeatedly until it stops returning events. Thus, we use while loop. Inside the while loop, we use a for loop to iterate over the events and extract the event ID, record number, event message, event source and a few other tidbits. We log it and then we exit the for loop and the while loop calls the win32evtlog.ReadEventLog again.

We use the traceback module to print out any errors that occur during the script’s run. And that’s all there is to it!

Wrapping Up

As you can see, using the PyWin32 package is easy. If you get stuck, it has some great documentation. If that documentation isn’t good enough though, you can fall back on MSDN instead. PyWin32 is a light wrapper around Windows’ API, so using MSDN’s instructions is fairly simple. Anyway, I hope you learned a lot and will find it helpful.

Further Reading

• Python and Unicode
• PyWin32
• PyWin32 Documentation from ActiveState