• I suggested that idiomatic Python is not simply a matter of using OOP (hence, using pymel, although awesome, is not sufficient to make your code “Pythonic”). I stressed that the Python community is made up of a variety of programming cultures that each have their own particular design patterns and paradigms (be it procedural, functional, object-oriented, or some half-baked convention of web programmers), and that the few existing unifying factors are centered more around readability and testability of code.
• I talked a bit about code organization and Python’s data model in contrast to MEL (stressing again that MEL and the cmds module are equal citizens with respect to the Command Engine). I used function pointer arguments for Maya commands as one example where the differences between Python and MEL become clearer when organizing code. Namely, I would argue that there is almost never a good reason to pass a command string rather than a function pointer to e.g., GUI commands, scriptJob, etc. Passing command strings a) is more prone to error since you won’t get code completion in a string literal, b) will execute statements in __main__ rather than in the calling context, and c) therefore throws exceptions when the callback is issued and without a stack trace, rather than when the command is executed and with a stack trace.
• I also related points about Python’s data model to the rationale for MScriptUtil, and pointed out simple ways to subclass parts of the API that make use of it in order to create more “Pythonic” APIs, as in the following snippet.

import collections
import maya.OpenMaya as om
UV = collections.namedtuple('UV', ('u','v'))
class MFnNurbsSurfaceX(om.MFnNurbsSurface):
    def __init__(self, *args):
        om.MFnNurbsSurface.__init__(self, *args)
    def closestPoint(self, *args):
        uutil = om.MScriptUtil()
        uutil.createFromDouble(0)
        uptr = uutil.asDoublePtr()
        vutil = om.MScriptUtil()
        vutil.createFromDouble(0)
        vptr = vutil.asDoublePtr()
        pt = om.MFnNurbsSurface.closestPoint(self, args[0], uptr, vptr)
        return pt, UV(uutil.getDouble(uptr), vutil.getDouble(vptr))

• One final novel point I mentioned was a technique for plug-in deployment within a package in order to streamline tool distribution and access plug-in classes from corresponding GUI tools (and enable users to simply import a single plug-in module rather than calling the loadPlugin command for several files if so desired). A brief example follows.

import os
import maya.cmds as cmds
import maya.OpenMaya as om
## the Maya plug-in path environment variable
kPluginPathEnvVar = 'MAYA_PLUG_IN_PATH'
def appendToPluginPath():
    """
    Modify the Maya plug-in path for this session to include this module.
    """
    path = os.environ[kPluginPathEnvVar]
    folder = os.path.dirname(__file__)
    if not folder in path:
        path = os.pathsep.join([path, folder])
    os.environ[kPluginPathEnvVar] = path
def getPluginFileName():
    """
    Get the plug-in file name for use with the loadPlugin command.
    """
    return '%s.py'%os.path.splitext(os.path.basename(__file__))[0]
# import classes from modules
import classes.pluginOne
import classes.pluginTwo
# etc.
def initializePlugin(mobject):
  # create fn, register plugins
  return
def uninitializePlugin(mobject):
  # create fn, deregister plugins
  return
# following lines enable ability to "import" plug-ins via this module
try:
    appendToPluginPath()
    cmds.loadPlugin(getPluginFileName())
# __file__ doesn't exist in context where loadPlugin evaluates
except NameError: pass

Last but not least, Ryan recently completed a MasterClass for Autodesk on vector math for artists, where he provides some examples using Python. You can check it out on Autodesk’s Area web site.

Although we (as authors) have little ability to do anything about it ourselves, we have passed this info up the food chain in hopes that it can be resolved. In the meantime, if you have the option, we’d recommend avoiding the Kindle version of the book until or unless it can be resolved. Thanks to those of you who let us know! We’ll be sure to post an update if we find out anything different.

import maya.cmds as cmds
def make_nodes(node_type_name, amount):
    """
    Make the specified amount of the specified node.
    @param node_type_name: The name of the node type to create.
    @param amount: The number of nodes to make.
    """
    current_selection = cmds.ls(sl=True)
    try:
        for i in range(amount):
            cmds.createNode(node_type_name)
    except:
        raise
    try:
        cmds.select(current_selection)
    except:
        pass

The first problem here concerns the first try-except clause. Namely: why does it exist? If anything in the try block fails (either the loop or the createNode call), it will raise an exception. Wrapping this code in a try clause is useless in this case, because we don’t actually change any behavior if an exception happens to be raised. The exception is just tossed out to the calling context.

The second problem is that both of these try-except clauses use what I have grown to call Pokémon Exception Handling: they gotta catch ‘em all! Unlike the first try-except clause, the second one at least has a point here. (For example, if the selection list is empty when this function is called, resetting the selection would ordinarily raise a TypeError.) However, the PEP style guide recommends against this type of bare except clause (and suggests minimally specifying Exception). Why?

Imagine this function did something more substantial to edit the scene. Suppose it possibly deletes some nodes as well as creates them. If you simply throw in a bare except clause, you may catch errors you do not actually want to, which can lead to sloppy programming. For example, while selecting an empty list throws a TypeError, trying to select an object that does not exist throws a ValueError. In this case, we want to silently trap and ignore the TypeError, but NOT the ValueError, as we anticipate the former, but not the latter. If we built a set of tests for this function, we might totally miss scenarios in which a ValueError is raised. In short, do not put in an except clause unless you anticipate a specific exception of some kind and plan to actually do something about it.

Finally, you should strive to try the minimum amount of code possible at any one time. It is possible some errors can be raised in multiple ways. Since the PEP discusses this point, I won’t go into detail, but you can imagine there may be some cases where you want to catch one TypeError, but not another, in which case they should not be wrapped in the same try clause.

I want to end this post by talking about the API command examples in the book. The book notes that when parsing the command’s arguments by constructing an MArgDatabase, simply raising the exception throws out a really non-descriptive RuntimeError. The book errantly advises that this just be passed over instead of raised, because the command engine would display information about the problem (at least when the command is invoked from MEL). But what about when the command is invoked from Python? Obviously we want it to throw some kind of exception, and probably not just a really low-level RuntimeError. The trouble here of course is that, because you cannot initialize an MArgDatabase or an MArgParser, you can’t really tell what exactly is wrong. In this case, the safest thing to do, in my view, is to raise a TypeError, which can occur with either an invalid flag, or with a flag argument of the wrong type. While you can’t tell the user exactly what is wrong, it is still better than raising the bult-in RuntimeError, and of course infinitely preferable to raising no exception at all!

• Seth Gibson: You Got Art In My Test Suite!
• Adam Mechtley: The Odd Couple: Maya and Python
• Kristine Middlemiss: Top 10 Autodesk Maya Python API Gotchas When Getting Started

Hope to see you there!

Overview and Download Links

If you have previously built the PyQt libraries for Maya 2011 and older, Autodesk has made some changes in the delivery of Qt in Maya 2012 and newer. There is now an Autodesk-customized version of the open source Qt framework, which is required for C++ or PyQt GUIs. Consequently, you do not need the complete Qt SDK for Maya 2012 and newer (because they use the Autodesk-modified version), but you can download the source packages of the Qt framework if you need access Qt Designer or anything else that comes with the framework.

Note that 32-bit and 64-bit versions of Qt cannot coexist in the same directory tree. If you want both versions installed on the same system then you will have to configure, build, and install Qt twice, using different installation directories each time.

The items you are going to need to download to prepare for building and installing PyQt are:

1. An appropriate version of the Qt SDK for Maya 2011 and older, or Autodesk’s modified Qt source for Maya 2012 (under the heading QT4.7.1 modified for Maya)
2. SIP, a C++ wrapper tool
3. PyQt* (for Windows, use Python version 2.6, which is the version used in Maya 2012)
4. Microsoft Visual Studio 2008, SP 1 (Windows only)**

*PyQt does not have the same licensing as Autodesk Maya, Qt, or Python. Please consult the PyQt website for information about licensing.
**These instructions should also work with Microsoft Visual Studio Express.

You do not need a specific version of SIP and PyQt—any recent version is good. PyQt keeps up with Qt, so anything after the compatible Qt version that is documented in the Maya API documentation is suitable. Once you have built and installed the first three components, you end up with PyQt binaries, which you put in your site-packages directory. Thereafter, you will be ready to start building custom PyQt GUIs!

Building and Installing PyQt

I am prefacing these build instructions by noting that I found I had to tinker with the settings and file locations to make it build. I have added in where I had to make adjustments, but everyone’s computer and environment is different, so what worked for me may not work for you. In spite of these few modifications, I successfully built and installed PyQt with Maya 2012, allowing me to create my PyQt custom GUIs for Maya 2012.

Jump to:

• Windows
• OS X
• Linux

Windows

Building Qt

1. Unzip the Qt package you downloaded from the Autodesk website, Qt-4.7.1-Modified_for_Maya.zip to a folder (e.g., C:\qt-adsk-4.7.1).
2. Follow the instructions inside the zip file (howToBuildQtOnWindows_m2012.txt) to configure and build the modified Maya Qt SDK.

Building SIP

1. Unzip the SIP package you downloaded from the Riverbank Computing website, sip-4.12.4.zip, to a folder (e.g., C:\sip-4.12.4).
2. Start a Microsoft Visual Studio 2008 Command Prompt (Start -> All Programs -> Microsoft Visual Studio -> Visual Studio Tools -> Visual Studio 2008 Command Prompt).
3. Change to the directory into which you extracted SIP.
   cd c:\sip-4.12.4
4. Execute the following commands in the Command Prompt. The first line is required so the build can find python26.lib.
   set LIB=%LIB%;C:\Program Files\Autodesk\Maya2012\lib
"C:\Program Files\Autodesk\Maya2012\bin\mayapy" configure.py
nmake
nmake install

SIP will now be installed in Maya’s site‐packages directory located at C:\Program Files\Autodesk\Maya2012\Python\lib\site-packages.

Building PyQt

1. Unzip the PyQt package you downloaded from the Riverbank Computing website, PyQt-win-gpl-4.8.5.zip, to a folder (e.g., C:\PyQt-win-gpl-4.8.5).
2. Start a Microsoft Visual Studio 2008 Command Prompt.
3. Change to the directory into which you extracted PyQt.
   cd c:\PyQt-win-gpl-4.8.5
4. Execute the following commands in the Command Prompt. The PyQt configure.py script searches the PATH for a Qt installation. If you have other Qt installations, make sure they aren’t in the PATH.
   set QTDIR= c:\qt-adsk-4.7.1
set PATH=c:\qt-adsk-4.7.1\bin;%PATH%
set QMAKESPEC=C:\qt-adsk-4.7.1\mkspecs\win32‐msvc2008
"C:\Program Files\Autodesk\Maya2012\bin\mayapy" configure.py ‐w LIBDIR_QT=C:\qt-adsk-4.7.1\lib INCDIR_QT=C:\qt-adsk-4.7.1\include

5. You might get errors here so it is helpful to pipe it out to a file so you can see all the output.
   "C:\Program Files\Autodesk\Maya2012\bin\mayapy" configure.py -w LIBDIR_QT=C:\qt-adsk-4.7.1\lib INCDIR_QT=C:\qt-adsk-4.7.1\include > config.txt
set INCLUDE=%INCLUDE%;C:\Program Files\Autodesk\Maya2012\include\python2.6;C:\qt-adsk-4.7.1\include
nmake
nmake install

If these commands result in errors referring to D:\qt, first search and replace all occurrences of D:\qt-adsk-4.7.1 to C:\qt-adsk-4.7.1 in all makefiles in the PyQt folder.

PyQt4 will now be installed in Maya’s site‐packages directory located at C:\Program Files\Autodesk\Maya2012\Python\lib\site-packages.

OS X

Building Qt

1. Unzip the package you downloaded from the Autodesk website, Qt-4.7.1-Modified_for_Maya.zip.
2. Follow the instructions inside the zip file (howToBuildQtOnMac_m2012.txt), to configure and build the modified Maya Qt SDK.

Building SIP

1. Open the Terminal application (Applications -> Utilities -> Terminal).
2. Change to the directory into which you saved the SIP download, such as e.g.,
   cd ~/Downloads
3. Execute the following lines to build SIP.
   tar ‐zxvf sip‐4.12.4.tar.gz
cd sip‐4.12.4
/Applications/Autodesk/maya2012/Maya.app/Contents/bin/mayapy configure.py ‐‐arch=x86_64
make
sudo make install

SIP will now be installed in Maya’s site‐packages directory located at /Applications/Autodesk/maya2012/Maya.app/Contents/Frameworks/Python.framework/Versions/Current/lib/python2.6/site‐packages.

Building PyQt

1. Open the Terminal application.
2. Change to the directory into which you saved the PyQt download, such as e.g.
   cd ~/Downloads
3. Execute the following lines to build PyQt.
   tar ‐zxvf PyQt‐mac‐gpl‐4.8.5.tar.gz
cd PyQt‐mac‐gpl‐4.8.5
export QTDIR=/usr/local/Trolltech/Qt‐4.8.5
export PATH=/usr/local/Trolltech/Qt‐4.8.5/bin:$PATH
export QMAKESPEC=/usr/local/Trolltech/Qt‐4.8.5/mkspecs/macx‐g++
export DYLD_LIBRARY_PATH=/usr/local/Trolltech/Qt‐4.8.5/lib
/Applications/Autodesk/maya2012/Maya.app/Contents/bin/mayapy configure.py
LIBDIR_QT=/usr/local/Trolltech/Qt‐4.8.5/lib INCDIR_QT=/usr/local/Trolltech/Qt‐4.8.5/include
MOC=/usr/local/Trolltech/Qt‐4.8.5/bin/moc ‐w ‐‐no‐designer‐plugin
make ‐j8
sudo make install
4. PyQt will now be installed in Maya’s site‐packages directory located at /Applications/Autodesk/maya2012/Maya.app/Contents/Frameworks/Python.framework/Versions/Current/lib/python2.6/site‐packages/PyQt4. At this point PyQt is installed, but the binaries are improperly linked for Maya, which must be corrected. Maya only includes the Qt binaries that it actually uses, so there are several installed PyQt modules which will not work because they won’t find the missing libraries. This problem can in theory be solved by copying in the missing libraries from the Qt build earlier. Execute the following lines in Terminal to do so.
   sudo find /Applications/Autodesk/maya2012/Maya.app/Contents/Frameworks/Python.framework/Versions/Current/lib/python2.6/site‐packages/PyQt4 ‐name "*so" ‐exec install_name_tool ‐change libQtCore.4.dylib @executable_path/QtCore {} \;
sudo find /Applications/Autodesk/maya2012/Maya.app/Contents/Frameworks/Python.framework/Versions/Current/lib/python2.6/site‐packages/PyQt4 ‐name "*so" ‐exec install_name_tool ‐change libQtGui.4.dylib @executable_path/QtGui {} \;
sudo find /Applications/Autodesk/maya2012/Maya.app/Contents/Frameworks/Python.framework/Versions/Current/lib/python2.6/site‐packages/PyQt4 ‐name "*so" ‐exec install_name_tool ‐change libQtSvg.4.dylib @executable_path/QtSvg {} \;
sudo find /Applications/Autodesk/maya2012/Maya.app/Contents/Frameworks/Python.framework/Versions/Current/lib/python2.6/site‐packages/PyQt4 ‐name "*so" ‐exec install_name_tool ‐change libQtOpenGL.4.dylib @executable_path/QtOpenGL {} \;
sudo find /Applications/Autodesk/maya2012/Maya.app/Contents/Frameworks/Python.framework/Versions/Current/lib/python2.6/site‐packages/PyQt4 ‐name "*so" ‐exec install_name_tool ‐change libQtXml.4.dylib @executable_path/QtXml {} \;

Linux

Building Qt

1. Unzip the package you downloaded from the Autodesk website, Qt-4.7.1-Modified_for_Maya.zip.
2. Follow the instructions inside the zip file (howToBuildQtOnLinux_m2012.txt) in order to configure and build the modified Maya Qt SDK. In the instructions file, you can skip downloading the Qt SDK from the Nokia website, as we downloaded a custom version from the Autodesk website. There is also one incorrect item in this file. It says the default gcc version is 4.10 for Maya 2012, which is not the case. The default gcc version is 4.1.2 for Maya 2012.

Building SIP

1. Open the Terminal application.
2. Unzip the package you downloaded from the Riverbank Software website, sip-4.12.4.tar.gz.
3. Execute the following commands in a command prompt:
   cd sip‐4.12.4
/usr/autodesk/maya2012‐x64/bin/mayapy configure.py
make
sudo make install

SIP will now be installed in Maya’s site‐packages directory located at /usr/autodesk/maya2012‐x64/lib/python2.6/site‐packages/.

Building PyQt

1. Unzip the package you downloaded from the Riverbank Software website, PyQt-x11-gpl-4.8.5.tar.gz.
2. Execute the following commands in a command prompt:
   cd PyQt‐x11‐gpl‐4.8.5
/usr/autodesk/maya2012‐x64/bin/mayapy configure.py ‐q /usr/local/Trolltech/Qt4.8.5/bin/qmake
make ‐j4
sudo make install

PyQt will now be installed in Maya’s site‐packages directory located at /usr/autodesk/maya2012‐x64/lib/python2.6/sitepackages/PyQt4.

That being said, writing a book is hard, and writing a book about Python is a lot more difficult than we had anticipated! As such, we want to thank our contributing authors, Seth Gibson and Kristine Middlemiss, as well as our technical editor, Dean Edmonds, without whom this project would not have been possible.

We also want to be the first to admit that our book is not perfect. We have striven to be incredibly attentive to detail, but we’re sure there are problems or inconsistencies in our text or code examples. (You can find errata for each chapter noted on the chapter pages.) We’re also sure that, with as talented and populous as the Python community is, there will be plenty of people who disagree with some of our decisions or coding style. (Please make the time to read the Introduction chapter, as our printed code samples ended up a little unconventional to fit with the restrictions of the medium.)

Have fun and good luck on your journey to master Python in Maya!