Index

A

• accidental complexity
  • about / Dealing with namespaces
• addNameChangedCallback function / Using OpenMaya for callbacks
• add_influences function / Refactoring for performance
• advanced decorator concepts
  • about / Advanced decorator topics
  • decorators, defining with arguments / Defining decorators with arguments
  • PyMEL attributes, decorating / Decorating PyMEL attributes and methods
  • PyMEL methods, decorating / Decorating PyMEL attributes and methods
  • decorators, stacking / Stacking decorators
  • Python's decorator library, using / Using Python's decorator library
• alternatives, hierarchy converter GUI
  • functions versus classes / Considering alternative implementations
  • specific versus general controller / Considering alternative implementations
  • complete test setup / Considering alternative implementations
• Amazon Web Services (AWS) / Designing Maya Python code for open source
• application
  • hooking up, to be effected by hierarchy converter GUI / Hooking up the application to be effected by the GUI
• application events
  • simulating / Simulating application events
• application level
  • exceptions, handling at / Handling exceptions at the application level
• args parameter / The args and kwargs parameters
• arguments
  • decorators, defining with / Defining decorators with arguments
• assignUVs method / Building a mesh
• asterisk/star character / The args and kwargs parameters
• attribute
  • about / Explaining types
• at_time context manager
  • building / Building the at_time context manager
• Autodesk
  • about / Understanding plugin type IDs
• Autodesk 3ds Max
  • about / Introducing context managers
• automated tests
  • running, in Maya / Running automated tests in Maya
• automation system
  • practical uses / Practical uses and improvements
  • improvements / Practical uses and improvements
  • batch processing, with Maya / Batch processing using Maya
  • support, adding for logging / Adding support for logging
  • multiple applications, supporting / Supporting multiple languages and applications
  • multiple languages, supporting / Supporting multiple languages and applications
  • control, supporting from remote computer / Supporting control from a remote computer
  • object-oriented system, designing / Designing an object-oriented system
  • RPC frameworks, evaluating / Evaluating other RPC frameworks
• automation system, designing
  • about / Designing the automation system
  • client and server, pairing / Pairing one client and one server
  • server, bootstrapping from client / Bootstrapping the server from the client
  • client-server handshake / The client-server handshake
  • server loop, defining / Defining the server loop
  • requests, serializing / Serializing requests and responses
  • responses, serializing / Serializing requests and responses
  • working of server, selecting / Choosing what the server does
  • exceptions, handling between client and server / Handling exceptions between client and server

B

• background thread
  • used, to send email / Using a background thread to send the e-mail
• batch mode
  • about / Using batch mode versus GUI mode
• batch processing, Maya / Batch processing using Maya
• benefits, node factory
  • less code and duplication / Designing the node factory
  • intuitive and consistent / Designing the node factory
  • lightweight / Designing the node factory
  • extensible / Designing the node factory
• best practices, Python
  • args parameter / The args and kwargs parameters
  • kwargs parameter / The args and kwargs parameters
  • string formatting / String formatting
  • string concatenation / String concatenation
  • raw strings / Raw strings and string literals
  • string literals / Raw strings and string literals
  • path, building / Path building and manipulation
  • path, manipulating / Path building and manipulation
  • Unicode strings / Unicode strings
  • doctest module, using / Using the doctest module
  • TDD, adopting / Adopting Test-Driven Development
  • GitHub repository, using / Using the GitHub repository for this book
• binary distribution
  • about / Adding an egg or wheel to Maya
• binary distributions
  • using, on Windows / Using binary distributions on Windows
• binding
  • about / Explaining connection strings, ports, bind, and connect
• bindings
  • about / Introducing Qt, PyQt, and PySide
• Bitbucket
  • URL / Starting an open source project
• boilerplate
  • about / Getting the first item in a sequence
• Boolean flags
  • avoiding / Avoiding the use of Boolean flags
• bootstrapping
  • about / Bootstrapping the server from the client
• bound methods / Adding support for methods
• built-in exceptions
  • URL / Introducing exception types

C

• callable method / Explaining decorators
• callback
  • about / Introducing Qt signals
• callbacks
  • OpenMaya, used for / Using OpenMaya for callbacks
• caller
  • about / Contrasting decorators and context managers
• cargo culting
  • about / Understanding Dependency Graph plugins
• cargo cult programming
  • about / Understanding Dependency Graph plugins
• catch keyword / Leveraging Python, which is better than MEL
• character creator
  • writing / Writing a character creator
  • stubbing out / Stubbing out the character creator
  • convert_hierarchies_main function, implementing / Implementing convert_hierarchies_main
  • convert_hierarchies function, implementing / Implementing convert_hierarchies
  • decomposing, into composable functions / Decomposing into composable functions
  • convert_hierarchy function, implementing / Implementing convert_hierarchy
  • inevitable modification, supporting / Supporting inevitable modifications
• child class
  • about / Understanding Python and MEL types
• child process / Launching Maya from Python
• circle node
  • about / Building a simple node plugin
  • scale attribute / Building a simple node plugin
  • frames attribute / Building a simple node plugin
  • input attribute / Building a simple node plugin
• class methods / Adding support for methods
• client-server handshake
  • about / The client-server handshake
• closures
  • using / Learning how to use closures
  • about / Learning how to use closures
• code
  • simplifying, custom types used / Using custom types to simplify code
• code objects
  • inspecting / Inspecting Python code objects
• code smell
  • about / Avoiding the use of Boolean flags
• code smells
  • about / Defining inputs, outputs, and the initializer
• command flag
  • adding / Adding a command flag
• command line options / Choosing a startup configuration mechanism
• community
  • engaging with / Engaging with the wider community
• composable code
  • defining / Defining composability
  • anti-patterns, identifying / Identifying anti-patterns of composability
  • Boolean flags, avoiding / Avoiding the use of Boolean flags
  • legacy code, evolving into / Evolving legacy code into composable code
  • rewriting / Rewriting code for composability
  • first item, obtaining in sequence / Getting the first item in a sequence
  • tail function, writing / Writing head and tail functions
  • head function, writing / Writing head and tail functions
• compute method
  • creating / Creating the compute method
  • abstraction, creating for / Slaying the compute method
• connecting
  • about / Explaining connection strings, ports, bind, and connect
• connection strings
  • about / Explaining connection strings, ports, bind, and connect
• container widget
  • defining / Defining control, container, and window widgets
• contextlib module / Introducing context managers
• context managers
  • about / Introducing context managers
  • creating / Introducing context managers
  • undo_chunk context manager, writing / Writing the undo_chunk context manager
  • undo_on_error context manager, writing / Writing the undo_on_error context manager
  • versus decorators / Contrasting decorators and context managers
• context managers, for scene state
  • about / Context managers for changing scene state
  • set_file_prompt context manager, building / Building the set_file_prompt context manager
  • at_time context manager, building / Building the at_time context manager
  • with_unit context manager, building / Building the with_unit context manager
  • set_renderlayer_active context manager, building / Building the set_renderlayer_active context manager
  • set_namespace_active context manager, building / Building the set_namespace_active context manager
• contibution, to open source community
  • about / Contributing to the open source community
  • Maya Python code, designing for open source / Designing Maya Python code for open source
  • open source project, starting / Starting an open source project
  • project, distributing / Distributing your project
• contract
  • about / Understanding interface contracts
• control widget
  • defining / Defining control, container, and window widgets
• convert_hierarchies function
  • implementing / Implementing convert_hierarchies
• convert_hierarchies_main function
  • implementing / Implementing convert_hierarchies_main
• convert_hierarchy function
  • implementing / Implementing convert_hierarchy
• CPython
  • about / Introducing context managers
• CPython source code repository
  • URL / Differentiating OSS from script download sites
• create_plugin function
  • about / Creating the plugin file
• create_syntax function
  • about / Adding a command flag
• critical path
  • about / Focus on the critical path
• custom types
  • used, to simplify code / Using custom types to simplify code

D

• data types, PyMEL / Understanding PyMEL data and math types
• debugging
  • about / Golden rules of error handling
• declarative code / The importance of being declarative
• decorator library
  • using / Using Python's decorator library
• decorators
  • about / Introducing decorators
  • URL, for blog / Introducing decorators
  • explaining / Explaining decorators
  • exporter, wrapping with / Wrapping an exporter with a decorator
  • versus context managers / Contrasting decorators and context managers
  • creating, for recording metrics / Creating a decorator to record metrics
  • defining, with arguments / Defining decorators with arguments
  • stacking / Stacking decorators
  • doing / Doing decorators the right way
  • URL, for information / Doing decorators the right way
  • URL, for blog posts / Doing decorators the right way
• decorators, for metrics recording
  • unique key, obtaining / Getting a unique key
  • duration, recording / Recording duration
  • duration, reporting / Reporting duration
  • errors, handling / Handling errors
• denormalized_skin context manager
  • creating / Creating the denormalized_skin context manager
  • vertex influences, swapping / Safely swapping vertex influences
  • performance concerns, addressing / Addressing performance concerns
• dependency graph plugins
  • about / Understanding Dependency Graph plugins
• development root
  • selecting, for library / Choosing a development root
• docstring / Building the pmhelp function
  • writing, for skeleton converter library / Writing the docstring and pseudocode
  • about / Understanding docstrings and reStructured Text
• doctest module
  • using / Using the doctest module
• draw method
  • about / Introducing inheritance by drawing shapes
• dunder methods
  • about / Creating more tests

E

• EAFP
  • about / Designing with EAFP versus LBYL
• ehook function / Understanding sys.excepthook
• email
  • sending, background thread used / Using a background thread to send the e-mail
• emit_selchanged function / Emitting a signal from Maya
• enumerate function / Setting mesh normals
• environment variables / Choosing a startup configuration mechanism
• error e-mail
  • sending / Sending the error e-mail
• error email contents
  • assembling / Assembling the contents of an error e-mail
• error handler
  • creating / Creating an error handler
  • improving / Improving the error handler, Improving the error handler
  • installing / Installing the error handler
  • What If Two Programs Did This rule / Obeying the What If Two Programs Did This rule
  • user interface, adding / Adding a user interface
  • background thread used, to send email / Using a background thread to send the e-mail
  • other mechanisms / Moving beyond e-mail
  • locals, capturing / Capturing locals
  • log files, attaching / Attaching log files
• error handling, Maya
  • about / Practical error handling in Maya
  • expensive state, dealing with / Dealing with expensive and mutable state
  • mutable state, dealing with / Dealing with expensive and mutable state
  • undo blocks, leveraging / Leveraging undo blocks
  • exception design, dealing with / Dealing with Maya's poor exception design
  • Maya application, leveraging / Leveraging the Maya application
  • Maya application, dealing with / Dealing with the Maya application
  • Python, leveraging / Leveraging Python, which is better than MEL
• essential complexity
  • about / Dealing with namespaces
• eval
  • Python, controlling through / Controlling Python through exec and eval
• event loop
  • about / Understanding the event loop, Running a server in a Maya GUI session
• exception design
  • dealing with / Dealing with Maya's poor exception design
• exceptions
  • about / Understanding exceptions
  • try/catch/finally flow control / Explaining try/catch/finally flow control
  • traceback objects / Explaining traceback objects
  • exc_info tuple / Explaining the exc_info tuple
  • handling, at application level / Handling exceptions at the application level
• exception types
  • about / Introducing exception types
• except keyword
  • about / Explaining try/catch/finally flow control
• exc_info tuple / Explaining the exc_info tuple
• exec
  • Python, controlling through / Controlling Python through exec and eval
• execution scope / Understanding eval and exec
• exec_ method
  • about / Understanding the event loop
• exit handler / Automatically killing the server
• expensive state
  • dealing with / Dealing with expensive and mutable state
• exporter
  • wrapping, with decorators / Wrapping an exporter with a decorator
• expression / Understanding eval and exec

F

• failing fast
  • about / Living with unhandled exceptions
• filtering based
  • adding, on filename / Adding filtering based on filename
• filtering behavior
  • about / Identifying anti-patterns of composability
• finally keyword
  • about / Explaining try/catch/finally flow control
• function
  • creating, in IDE / Creating a function in your IDE
  • precondition / Understanding interface contracts
  • postcondition / Understanding interface contracts
• function sets, Maya API / Understanding MObjects and function sets

G

• garbage collected
  • about / Introducing context managers
• generational garbage collector
  • about / Introducing context managers
• get_next_message function
  • about / Understanding the event loop
• get_type_hierarchy function / Refactoring for performance
• GitHub
  • URL / Starting an open source project
• GitHub repository
  • using / Using the GitHub repository for this book
  • URL / Using the GitHub repository for this book
• GUI
  • crafting, rules / Establishing rules for crafting a GUI
• GUI, crafting rules
  • pure PySide GUIs preference / Prefer pure PySide GUIs where possible
  • command-style UI, using / Use command-style UI building where necessary
  • .ui files usage, avoiding / Avoid the use of .ui files
• GUI mode
  • about / Using batch mode versus GUI mode

H

• handshake
  • about / The client-server handshake
• handshake port
  • about / The client-server handshake
• hash value
  • obtaining, of node / Getting the hash of a node
• head function
  • writing, for composable code / Writing head and tail functions
• hierarchy converter GUI
  • creating / Creating the hierarchy converter GUI
  • window, creating / Creating the window
  • Python file, running as script / Running a Python file as a script
  • QApplication class / Introducing the QApplication class
  • event loop / Understanding the event loop
  • executing / Running your GUI
  • designing / Designing and building your GUI
  • building / Designing and building your GUI
  • control widget, defining / Defining control, container, and window widgets
  • container widget, defining / Defining control, container, and window widgets
  • window widget, defining / Defining control, container, and window widgets
  • widgets, adding / Adding the rest of the widgets
  • application, hooking up / Hooking up the application to be effected by the GUI
  • hooking up, to be effected by application / Hooking up the GUI to be effected by the application
  • application events, simulating / Simulating application events
  • alternatives / Considering alternative implementations
  • integrating, with Maya / Integrating the tool GUI with Maya
  • opening, from Maya / Opening the tool GUI from Maya
  • main Maya window, getting as QMainWindow / Getting the main Maya window as a QMainWindow
  • Python reload function, using / Using Python's reload function with GUIs
  • signal, emitting from Maya / Emitting a signal from Maya
  • Maya, connecting to signal / Connecting Maya to a signal
  • verifying / Verifying the hierarchy converter works
• high-level error handler
  • building / Building a high-level error handler
  • sys.excepthook / Understanding sys.excepthook
  • sys.excepthook, used in Maya / Using sys.excepthook in Maya
  • error handler, creating / Creating an error handler
  • error handler, improving / Improving the error handler
  • code objects, inspecting / Inspecting Python code objects
  • filter based, adding on filename / Adding filtering based on filename
  • error email contents, assembling / Assembling the contents of an error e-mail
  • error e-mail, sending / Sending the error e-mail
• Hitchhiker's Guide to Packaging
  • URL / Starting an open source project

I

• IDE
  • function, creating in / Creating a function in your IDE
• imperative style programming / The importance of being declarative
• implementation detail, of function / Wrapping an exporter with a decorator
• info function / Leveraging the REPL
• inheritance
  • creating, by drawing shapes / Introducing inheritance by drawing shapes
• inherited
  • about / Introducing inheritance by drawing shapes
• initializePlugin function
  • about / The life of a Python plugin
• input/output (IO) / Adding support for logging
• installation, PySide / Installing PySide
• installation, ZeroMQ / Installing ZeroMQ
• interactive mode
  • about / Using the interpreter
• introspection function
  • creating / Creating an introspection function
• IPC
  • problems, handling with / Handling problems with IPC
• IronPython
  • about / Introducing context managers
• is_exact_type function
  • implementing / Implementing is_exact_type

J

• JavaScript Object Notation file format / Adding a persistence registry
• JIRA
  • URL / Moving beyond e-mail

K

• kwargs parameter / The args and kwargs parameters

L

• LBYL
  • about / Designing with EAFP versus LBYL
• library
  • creating / Creating your library
  • creating, mayapy interpreter used / Using the interpreter
  • path, finding for / Finding a place for our library
  • development root, selecting / Choosing a development root
  • function, creating in IDE / Creating a function in your IDE
  • code changes, reloading / Reloading code changes
• Liskov substitution principle
  • about / PyNodes all the way down
• Liskov Substitution Principle
  • about / Introducing inheritance by drawing shapes
• list comprehensions
  • about / Exploring Maya and PyMEL
  • using / Learning to use list comprehensions
  • URL / Learning to use list comprehensions
  • is_exact_type function, implementing / Implementing is_exact_type
  • versus, map and filter / Saying goodbye to map and filter
• locals
  • capturing / Capturing locals
• locals() function / String formatting
• log files
  • attaching / Attaching log files

M

• magic methods
  • about / Creating more tests
• MakeTrue function / Using MScriptUtil to call a method
• map and filter
  • versus, list comprehensions / Saying goodbye to map and filter
• math types, PyMEL / Understanding PyMEL data and math types
• Maya
  • exploring / Exploring Maya and PyMEL
  • sys.excepthook, using / Using sys.excepthook in Maya
  • future versions, improving / Improving on future versions of Maya
  • hierarchy converter GUI, integrating with / Integrating the tool GUI with Maya
  • hierarchy converter GUI, opening from / Opening the tool GUI from Maya
  • signal, emitting from / Emitting a signal from Maya
  • connecting, to signal / Connecting Maya to a signal
  • controlling, through request-reply / Controlling Maya through request-reply
  • launching, from Python / Launching Maya from Python
  • automated tests, running in / Running automated tests in Maya
  • architecture / Introducing Maya's API and architecture
  • site directory, creating for / Creating a new site directory for Maya
  • working with Python distributions / Working with Python distributions in Maya
  • source distribution, adding to / Adding a source distribution to Maya
• Maya's Script Editor
  • using / Using sys.excepthook in Maya
• Maya, controlling through request-reply
  • about / Controlling Maya through request-reply
  • Python client, using / Using a Python client and Maya server
  • Maya server, using / Using a Python client and Maya server
  • Python, controlling through exec / Controlling Python through exec and eval
  • Python, controlling through eval / Controlling Python through exec and eval
  • problems, handling with IPC / Handling problems with IPC
  • ZeroMQ, installing / Installing ZeroMQ
  • request-reply, demonstrating with ZeroMQ / Demonstrating request-reply with ZeroMQ
• maya.cmds.file command / Dealing with Maya's poor exception design
• maya.OpenMayaMPx.MPxNode Maya API class
  • about / Understanding Dependency Graph plugins
• Maya 2013 English PyMEL
  • URL / Creating a query string for a PyMEL object
• Maya API
  • about / Introducing Maya's API and architecture
  • OpenMaya bindings / Understanding the OpenMaya bindings
  • Reference, navigating / Navigating the Maya API Reference
  • MObjects / Understanding MObjects and function sets
  • function sets / Understanding MObjects and function sets
• Maya API Reference
  • navigating / Navigating the Maya API Reference
• Maya application
  • leveraging / Leveraging the Maya application
  • dealing with / Dealing with the Maya application
• Maya GUI session
  • server, running in / Running a server in a Maya GUI session
• Maya path
  • Qt object, getting from / Getting the Qt object from a Maya path
• mayapy interpreter
  • about / Creating your library
  • used, for creating library / Using the interpreter
• Maya Python API
  • about / Learning the Maya Python API by example
  • node name conversion, to MObject node / Converting a name to an MObject node
  • name, obtaining of MObject / Getting the name of an MObject
  • hash value, obtaining of node / Getting the hash of a node
  • mesh, building / Building a mesh
  • mesh normals, setting / Setting mesh normals
  • MScriptUtil, used to call method / Using MScriptUtil to call a method
  • OpenMaya, used for callbacks / Using OpenMaya for callbacks
  • and PyMEL, comparing / Comparing Maya Python API and PyMEL
• Maya Python code
  • designing, for open source / Designing Maya Python code for open source
• Maya Python plugin
  • creating / Creating a Maya Python plugin
  • sound player library, creating / Creating the sound player library
  • plugin file, creating / Creating the plugin file
  • plugins, reloading / Reloading plugins
  • command flag, adding / Adding a command flag
  • OpenMaya and scripting solutions, comparing / Comparing the OpenMaya and scripting solutions
• Maya server
  • using / Using a Python client and Maya server
• Maya shelves
  • working with / Working with Maya shelves
• Maya startup routine
  • about / Understanding the Maya startup routine
  • batch mode, versus GUI mode / Using batch mode versus GUI mode
  • startup configuration mechanism, selecting / Choosing a startup configuration mechanism
  • command line options, using / Using command line options
  • environment variables, using / Using environment variables
• Maya window
  • getting, as QMainWindow / Getting the main Maya window as a QMainWindow
• MEL
  • types / Understanding Python and MEL types
• menus
  • working with / Working with menus
  • top level menu, creating / Creating a top-level menu
  • Qt object, getting from Maya path / Getting the Qt object from a Maya path
  • widget font, changing / Changing the font of a widget
  • marking, as new / Marking menus as new
  • test case, creating / Creating a test case
  • persistence registry, adding / Adding a persistence registry
  • marker, verifying / Verifying the new menu marker works
  • widgets styling, alternative methods / Using alternative methods to style widgets
• Mercurial
  • URL / Starting an open source project
• mesh
  • building / Building a mesh
• mesh normals
  • setting / Setting mesh normals
• method
  • calling, MScriptUtil used / Using MScriptUtil to call a method
• method types, class definition
  • class methods / Adding support for methods
  • static methods / Adding support for methods
  • bound methods / Adding support for methods
  • unbound method / Adding support for methods
• metrics recording
  • decorator, creating for / Creating a decorator to record metrics
• MFnDependencyNode function / Getting the name of an MObject
• MFnIkJoint.setDegreesOfFreedom method / Using MScriptUtil to call a method
• MFnMesh.assignUVs method / Building a mesh
• MFnMesh.create method / Building a mesh
• MFnMesh.setUVs method / Building a mesh
• MFnMesh.updateSurface method / Building a mesh
• MFnMesh function / Building a mesh
• MObject
  • name, obtaining / Getting the name of an MObject
• MObject node
  • name node, converting to / Converting a name to an MObject node
• MObjects, Maya API / Understanding MObjects and function sets
• model-view-controller (MVC)
  • about / Hooking up the GUI to be effected by the application
• module type
  • about / Adding support for modules
• MPxNode methods
  • overriding / Overriding MPxNode methods
• MRO
  • using / Using the method resolution order
• MScriptUtil
  • used, to call method / Using MScriptUtil to call a method
• MSelectionList.add method / Converting a name to an MObject node
• MultiplyDivide node
  • about / Defining composability
• mutable state
  • dealing with / Dealing with expensive and mutable state
• MySet.__dict__ attribute
  • about / Dicts all the way down
• MySet type
  • about / Dicts all the way down

N

• name
  • obtaining, of MObject / Getting the name of an MObject
• namespaces
  • about / Dealing with namespaces
• nested function / Explaining decorators
• node
  • hash value, obtaining / Getting the hash of a node
• node connections
  • about / Dealing with node connections
• node factory
  • designing / Designing the node factory
  • benefits / Designing the node factory
  • building / Building the node factory
  • extending / Extending the node factory
• node factory, building
  • attributes, specifying / Specifying attributes
  • attributes, creating / Creating attributes
  • node, specifying / Specifying a node
  • partial application, used for creating attributes / Using partial application to create attributes
  • node, creating / Creating a node
  • abstraction, creating for compute method / Slaying the compute method
• node factory, designing
  • plugin nodes, designing / Designing plugin nodes
  • attribute specification, designing / Designing the attribute specification
  • node type specification, designing / Designing the node type specification
• node factory, extending
  • string attribute, supporting / Supporting string and color attributes
  • color attribute, supporting / Supporting string and color attributes
  • enum attributes, supporting / Supporting enum attributes
  • transform nodes, supporting / Supporting transform nodes
  • MPxNode methods, overriding / Overriding MPxNode methods
• node name
  • converting, to MObject node / Converting a name to an MObject node
• node plugins
  • about / Understanding Dependency Graph plugins
  • building / Building a simple node plugin
  • plugin type IDs / Understanding plugin type IDs
  • inputs, defining / Defining inputs, outputs, and the initializer
  • outputs, defining / Defining inputs, outputs, and the initializer
  • initializer, defining / Defining inputs, outputs, and the initializer
  • compute method, creating / Creating the compute method
  • non-Pythonic Maya API, taming / Taming the non-Pythonic Maya API
• node to joint conversion
  • simplifying / Simplifying the node to joint conversion
• non-operation program (no-op) / Addressing performance concerns
• non-Pythonic Maya API
  • taming / Taming the non-Pythonic Maya API
• nose library
  • URL / Designing Maya Python code for open source

O

• object oriented programming
  • about / Introducing context managers
• OpenMaya
  • used, for callbacks / Using OpenMaya for callbacks
  • and scripting solutions, comparing / Comparing the OpenMaya and scripting solutions
• OpenMaya bindings / Understanding the OpenMaya bindings
• open source
  • Maya Python code, designing for / Designing Maya Python code for open source
• open source licenses
  • URL / Understanding Open Source Software
• open source project
  • starting / Starting an open source project
• OSI
  • about / Understanding Open Source Software
  • URL / Understanding Open Source Software
• OSS
  • about / Understanding Open Source Software
  • differentiating, from script download sites / Differentiating OSS from script download sites

P

• .py suffix
  • about / The life of a Python plugin
• parent class
  • about / Understanding Python and MEL types
• parent process / Launching Maya from Python
• partial application
  • used, for creating attributes / Using partial application to create attributes
• path
  • finding, for library / Finding a place for our library
• PEP8
  • about / Creating an introspection function
  • URL / Creating an introspection function
• PEP 343
  • URL / Introducing context managers
• per-vertex per-face normals / Setting mesh normals
• per-vertex per-polygon normals / Setting mesh normals
• persistence registry
  • adding, in menus / Adding a persistence registry
• Pillow
  • URL / Starting an open source project
• pip
  • used, for installing third-party modules / Using pip to install third-party modules
• plugin
  • about / The life of a Python plugin
  • PyMEL, using / Using PyMEL in a plugin that loads during startup
• plugin file
  • creating / Creating the plugin file
• plugin module
  • about / The life of a Python plugin
• plugin nodes
  • designing / Designing plugin nodes
• plugins
  • reloading / Reloading plugins
• plugin type IDs
  • about / Understanding plugin type IDs
• plugin types
  • about / The life of a Python plugin
• pmhelp function
  • building / Building the pmhelp function
• pmhelp function, building
  • about / Building the pmhelp function
  • query string, creating for PyMEL object / Creating a query string for a PyMEL object
  • test cases, writing / Creating more tests
  • support, adding for modules / Adding support for modules
  • support, adding for types / Adding support for types
  • support, adding for methods / Adding support for methods
  • support, adding for functions / Adding support for functions
  • support, adding for non-PyMEL objects / Adding support for non-PyMEL objects
  • EAFP versus LBYL / Designing with EAFP versus LBYL
  • code issues / Code is never complete
  • help, opening in web browser / Opening help in a web browser
• ports
  • about / Explaining connection strings, ports, bind, and connect
• postcondition, function
  • about / Understanding interface contracts
• precondition, function
  • about / Understanding interface contracts
• predicate
  • about / Rewriting code for composability
• problems, handling with IPC
  • monogamy / Handling problems with IPC
  • pairing / Handling problems with IPC
  • availability / Handling problems with IPC
  • timeout mechanism / Handling problems with IPC
  • process lifetime / Handling problems with IPC
• process_message function
  • about / Understanding the event loop
• ProxyUnicode class
  • about / PyNodes all the way down
• pseudocode
  • about / Building the pmhelp function
  • writing, for skeleton converter library / Writing the docstring and pseudocode
• PyMEL
  • exploring / Exploring Maya and PyMEL
  • data types / Understanding PyMEL data and math types
  • math types / Understanding PyMEL data and math types
  • and Maya Python API, comparing / Comparing Maya Python API and PyMEL
  • used, in plugin / Using PyMEL in a plugin that loads during startup
  • about / Defining what a third-party module is
• pymel.core.unloadPlugin function
  • about / The life of a Python plugin
• PyMEL attributes
  • decorating / Decorating PyMEL attributes and methods
• PyMEL methods
  • decorating / Decorating PyMEL attributes and methods
• PyMEL object
  • query string, creating for / Creating a query string for a PyMEL object
• PyMEL performance
  • improving / Improving the performance of PyMEL
  • defining / Defining performance
  • refactoring / Refactoring for performance
  • inner loops, rewriting to use maya.cmds / Rewriting inner loops to use maya.cmds
• PyNodes
  • about / PyNodes all the way down
• PyQt
  • about / Introducing Qt, PyQt, and PySide
  • and PySide, supporting / Supporting PySide and PyQt
• PySide
  • about / Introducing Qt, PyQt, and PySide
  • installing / Installing PySide
  • URL / Installing PySide
  • and PyQt, supporting / Supporting PySide and PyQt
• Python
  • types / Understanding Python and MEL types
  • about / PyNodes all the way down
  • leveraging / Leveraging Python, which is better than MEL
  • Maya, launching from / Launching Maya from Python
  • URL / Engaging with the wider community
  • best practices / The args and kwargs parameters, String formatting, String concatenation, Raw strings and string literals, Unicode strings, Using the doctest module, Using the GitHub repository for this book
• Python client
  • using / Using a Python client and Maya server
• Python Decorator Library
  • URL / Using Python's decorator library
• Python Developer's Guide
  • URL / Differentiating OSS from script download sites
• Python distributions
  • working with / Working with Python distributions in Maya
  • source distribution, adding to Maya / Adding a source distribution to Maya
  • egg, adding to Maya / Adding an egg or wheel to Maya
  • wheel, adding to Maya / Adding an egg or wheel to Maya
  • binary distributions, using on Windows / Using binary distributions on Windows
  • pip, used for installing third-party modules / Using pip to install third-party modules
• Python Enhancement Proposal (PEP)
  • about / Learning to use list comprehensions
• Python file
  • running, as script / Running a Python file as a script
• Python library
  • benefits / Comparing the OpenMaya and scripting solutions
• Python metaprogramming
  • demystifying / Demystifying Python metaprogramming
  • type creation / Rethinking type creation
  • type function, exploring / Exploring the type function
  • declarative code / The importance of being declarative
• Python Package Index
  • about / Using Python's decorator library
• Python Package Index (PyPI)
  • using / Using the Python Package Index
  • URL / Using the Python Package Index
  • URL, for mock library / Adding a source distribution to Maya
• Python plugin
  • defining / The life of a Python plugin
• PyZMQ
  • about / Installing ZeroMQ
  • URL / Installing ZeroMQ

Q

• QApplication class
  • about / Introducing the QApplication class
• Qt
  • about / Introducing Qt, PyQt, and PySide
• Qt Designer
  • using / Avoid the use of .ui files
• Qt layouts
  • about / Introducing Qt layouts
• Qt main windows
  • about / Understanding Qt main windows and sorting
• Qt object
  • getting, from Maya path / Getting the Qt object from a Maya path
• qtshim.py module
  • QtCore namespace / Supporting PySide and PyQt
  • QtGui namespace / Supporting PySide and PyQt
  • Signal class / Supporting PySide and PyQt
  • wrapinstance function / Supporting PySide and PyQt
• Qt signals
  • about / Introducing Qt signals
• Qt sorting
  • about / Understanding Qt main windows and sorting
• Qt widgets
  • about / Introducing Qt widgets
• Qt window
  • making, child of Maya window / Making a Qt window the child of Maya's window
• query string
  • creating, for PyMEL object / Creating a query string for a PyMEL object

R

• %r sequence / String formatting
• race condition
  • about / The client-server handshake
• raise statement
  • about / Explaining try/catch/finally flow control
• Raven client
  • URL / Capturing locals
• raw strings
  • about / Raw strings and string literals
• read-copy-update
  • about / Dealing with expensive and mutable state
• refactor
  • about / Code is never complete
• refactoring
  • about / Learning how to refactor
• reference counting
  • about / Introducing context managers
• reload function
  • about / Using sys.excepthook in Maya
  • using / Using Python's reload function with GUIs
• remote procedure call (RPC)
  • about / Choosing what the server does
• remove_selected function / Refactoring for performance
• REPL
  • leveraging / Leveraging the REPL
  • about / Leveraging the REPL
• request-reply
  • Maya, controlling through / Controlling Maya through request-reply
  • demonstrating, with ZeroMQ / Demonstrating request-reply with ZeroMQ
• request-reply automation system, building
  • about / Building the request-reply automation system
  • Python package, creating / Creating a Python package
  • Maya, launching from Python / Launching Maya from Python
  • server, killing automatically / Automatically killing the server
  • basic Maya server, creating / Creating a basic Maya server
  • code, running at Maya startup / Running code at Maya startup
  • eval statement / Understanding eval and exec
  • exec statement / Understanding eval and exec
  • support, adding for eval / Adding support for eval and exec
  • support, adding for exec / Adding support for eval and exec
  • support, adding for exception handling / Adding support for exception handling
  • support, adding for timeouts / Adding support for timeouts
  • support, adding for client-server handshake / Adding support for the client-server handshake
• request-response
  • about / Controlling Maya through request-reply
• reStructured Text
  • about / Understanding docstrings and reStructured Text
• rules, error handling
  • about / Golden rules of error handling
  • critical path, focusing / Focus on the critical path
  • tool distribution, avoiding / Keep the end user in mind
  • errors, catching / Only catch errors you can handle
  • partial mutations, avoiding / Avoid partial mutations

S

• %s sequence / String formatting
• s.__dict__ attribute
  • about / Dicts all the way down
• safe_setparent utility function
  • extracting / Extracting the safe_setparent utility function
• script download sites
  • OSS, differentiating from / Differentiating OSS from script download sites
• scripting solutions
  • and OpenMaya, comparing / Comparing the OpenMaya and scripting solutions
• selection behavior
  • about / Identifying anti-patterns of composability
• Sentry server
  • URL / Capturing locals
• serializer
  • about / Serializing requests and responses
• server
  • about / Using a Python client and Maya server
  • running, in Maya GUI session / Running a server in a Maya GUI session
• set_file_prompt context manager
  • building / Building the set_file_prompt context manager
• set_namespace_active context manager
  • building / Building the set_namespace_active context manager
• set_renderlayer_active context manager
  • building / Building the set_renderlayer_active context manager
• shapes
  • drawing, through inheritance creation / Introducing inheritance by drawing shapes
• shared normals / Setting mesh normals
• Simplified Wrapper and Interface Generator (SWIG)
  • about / Understanding the OpenMaya bindings
  • URL / Understanding the OpenMaya bindings
• site directory
  • creating, for third party modules / Creating a site directory for third-party modules
  • explaining / Explaining the site directory
  • creating, for Maya / Creating a new site directory for Maya
  • establishing, at startup / Establishing the site directory at startup
• skeleton converter library
  • coding / Writing a skeleton converter library
  • docstring, writing / Writing the docstring and pseudocode
  • pseudocode, writing / Writing the docstring and pseudocode
  • docstring, using / Understanding docstrings and reStructured Text
  • reStructured Text, using / Understanding docstrings and reStructured Text
  • implementation, writing / Writing the first implementation
  • implementation, breaking / Breaking the first implementation
  • contract / Understanding interface contracts
  • safe_setparent utility function, extracting / Extracting the safe_setparent utility function
  • refactoring / Learning how to refactor
  • node to joint conversion, simplifying / Simplifying the node to joint conversion
  • closures, using / Learning how to use closures
  • node connections, dealing with / Dealing with node connections
  • namespaces, dealing with / Dealing with namespaces
  • wrapping up / Wrapping up the skeleton converter
• sound player library
  • creating / Creating the sound player library
• source code management (SCM) / Starting an open source project
• source distribution
  • adding, to Maya / Adding a source distribution to Maya
• Sphinx project
  • URL / Designing Maya Python code for open source
• SQL Alchemy
  • URL / The importance of being declarative
• startup
  • site directory, establishing at / Establishing the site directory at startup
• statement / Understanding eval and exec
• static methods / Adding support for methods
• status codes
  • about / Handling exceptions between client and server
• string concatenation
  • about / String concatenation
• string formatting
  • about / Creating an introspection function, String formatting
• string literals
  • about / Raw strings and string literals
• subroutine
  • inverting / Inverting the subroutine
• superclass
  • about / Understanding Python and MEL types
• sys.excepthook
  • about / Understanding sys.excepthook
  • using, in Maya / Using sys.excepthook in Maya
• sys.excepthook function / Understanding sys.excepthook
• sys.exc_info() function
  • about / Explaining the exc_info tuple

T

• tail function
  • writing, for composable code / Writing head and tail functions
• TDD
  • adopting / Adopting Test-Driven Development
• Test Driven Development (TDD)
  • about / Creating a query string for a PyMEL object
• third-party modules
  • about / Defining what a third-party module is
• third-party modules, putting in thirdparty folder
  • drawbacks / Adding a source distribution to Maya
• third party modules
  • site directory, creating for / Creating a site directory for third-party modules
• top level menu
  • creating / Creating a top-level menu
• traceback
  • about / Explaining traceback objects
• traceback2 module
  • URL / Capturing locals
• traceback objects / Explaining traceback objects
• Trello
  • URL / Moving beyond e-mail
• try/catch/finally flow control / Explaining try/catch/finally flow control
• tuple_to_mpoint function / Building a mesh
• type
  • about / Exploring Maya and PyMEL, Explaining types
  • creating / Dicts all the way down
  • custom types used, to simplify code / Using custom types to simplify code
  • inheritance creation, by drawing shapes / Introducing inheritance by drawing shapes
• type function
  • about / Understanding Python and MEL types
  • exploring / Exploring the type function
• type hierarchies
  • about / Introducing Qt widgets
• types, MEL / Understanding Python and MEL types
• types, Python / Understanding Python and MEL types

U

• unbound method / Adding support for methods
• undo blocks
  • leveraging / Leveraging undo blocks
• undoInfo
  • drawbacks / Leveraging undo blocks
• undo_chunk context manager
  • writing / Writing the undo_chunk context manager
• undo_on_error context manager
  • writing / Writing the undo_on_error context manager
• unhandled exceptions
  • about / Living with unhandled exceptions
• Unicode strings
  • about / Unicode strings
• unit
  • about / Defining composability
• user-defined scripts / Choosing a startup configuration mechanism
• user interface
  • adding / Adding a user interface
• utility functions
  • about / Extracting the safe_setparent utility function

V

• vertexArray parameter / Navigating the Maya API Reference

W

• What-You-See-Is-What-You-Get (WYSIWYG) / Avoid the use of .ui files
• What If Two Programs Did This rule
  • about / Obeying the What If Two Programs Did This rule
• widget font, menu
  • changing / Changing the font of a widget
• widgets
  • styling, alternative methods / Using alternative methods to style widgets
• Windows
  • binary distributions, using on / Using binary distributions on Windows
• Windows Presentation Foundation / Avoid the use of .ui files
• window widget
  • defining / Defining control, container, and window widgets
• WinForms / Avoid the use of .ui files
• with_unit context manager
  • building / Building the with_unit context manager

Z

• ZeroMQ
  • installing / Installing ZeroMQ
  • request-reply, demonstrating with / Demonstrating request-reply with ZeroMQ
• ZMQ- The Guide
  • URL / Demonstrating request-reply with ZeroMQ