Return the Parm object for the specified component of this parameter tuple. Negative indices will index from the end.

This method makes instances of this class appear like a tuple, and lets you iterate over the parms in a ParmTuple.

Raises IndexError if the index is not valid.

>>> parm_tuple = hou.node("/obj").createNode("geo").parmTuple("t")
>>> for parm in parm_tuple:
...     print parm.name(),
tx ty tz
>>> tuple(parm_tuple)
(<hou.Parm tx in /obj/geo1>, <hou.Parm ty in /obj/geo1>, <hou.Parm tz in /obj/geo1>)

Return the number of hou.Parms in this parameter tuple.

Return the name of this parameter tuple. Note that the parameter tuple’s name and its naming scheme determine the names of the parameters inside it.

>>> node = hou.node("/obj").createNode("geo")
>>> node.parmTuple("t").parmTemplate().namingScheme()
parmNamingScheme.XYZW
>>> [parm.name() for parm in node.parmTuple("t")]
['tx', 'ty', 'tz']

>>> parm_tuple = node.parent().createNode("cam").parmTuple("dcolor")
>>> parm_tuple.parmTemplate().namingScheme()
parmNamingScheme.RGBA
>>> [parm.name() for parm in parm_tuple]
['dcolorr', 'dcolorg', 'dcolorb']

Return this parameter tuple’s label that is displayed in the parameter dialog.

Return the node containing this parameter tuple.

Return this parameter tuple’s template.

Note that a folder parameter will have a hou.FolderSetParmTemplate template and a multiparm parameter will have a hou.FolderParmTemplate template.

Returns whether the parameter is a “spare” (user-defined) parameter.

Returns whether any of the parameters in the tuple are time dependent, that is, a parameter’s value changes depending on the point on the timeline at which it’s evaluated. For example the parameter has an expression containing the $F (current frame number) variable.

Lock or unlock all the parameters in this tuple. Houdini displays locked parameters as disabled and does not let you change their values.

For example, the parameter tuple for “translation” contains Parm objects for translation along each of the axes, “tx”, “ty” and “tz”. If lock is called with the following tuple of boolean values, (True, True, False), then the parameter “tx” and “ty” will be locked and made non-editable, while “tz” will be unlocked and made editable.

Raises hou.InvalidSize if bool_values has a different length than this parameter tuple. Raises hou.PermissionError if any of the parameters in this parameter tuple are not writable.

Sets the UI disable state of this parameter tuple in its node. This is not the same as locking a parameter, as the underlying value can still be modified. It’s closer to what a disable-when conditional does, when a parameter is disabled automatically by it.

Returns the disable state of the parameter tuple, ignoring the lock state. This can be used to read the result of a disable-when conditional.

It is recommended that hou.OpNode.updateParmStates is called before executing this method either in non-graphical Houdini or when the owner node has not yet been loaded into the Parameter Pane.

Sets the UI hidden state of this parameter tuple in its node. Calling this method is equivalent to changing the Invisible checkbox on the Edit Parameter Interface dialog, or hiding the parameter with a hide-when conditional.

To hide a folder, use hou.OpNode.setParmTemplateGroup. This method cannot be used to hide a folder because a parm tuple corresponds to a set of folders, not an individual folder.

To change the visibility of all new instances of the node type defined by a digital asset, use hou.HDADefinition.setParmTemplateGroup as in the following example:

def showParmTupleInDefinition(parm_tuple, visible):
    '''parm_tuple is a hou.ParmTuple on an instance of the digital asset.'''
    definition = parm_tuple.node().type().definition()
    parm_template_group = definition.parmTemplateGroup()
    parm_template = parm_template_group.find(parm_tuple.name())
    parm_template.hide(not visible)
    parm_template_group.replace(parm_tuple.name(), parm_template)
    definition.setParmTemplateGroup(parm_template_group)

Returns the hidden state of the parameter tuple. This can be used to read the result of a hide-when conditional.

It is recommended that hou.OpNode.updateParmStates is called before executing this method either in non-graphical Houdini or when the owner node has not yet been loaded into the Parameter Pane.

Returns True if the Parm’s parent node is an OBJ that is cooked and has constraints.

Evalute this parameter tuple at the current frame and returns the result as a tuple of integers, floats or strings, or a hou.Ramp object, depending on the type of the parameter.

See also the evalAtFrame and evalAtTime methods.

Evalute the parameter tuple at a given time and return the result as a tuple of integers, floats, strings, or a Ramp object, depending on the type of the parameter.

See also evalAtFrame.

Evalute the parameter tuple at a given frame and return the result as a tuple of integers, floats, strings, or a Ramp object, depending on the type of the parameter.

See also evalAtTime.

Evaluates this parameter tuple at the current frame and returns the result as a tuple of floats.

Raises TypeError if a value cannot be converted to a float.

Evaluates this parameter tuple at a certain frame and returns the result as a tuple of floats.

Raises TypeError if a value cannot be converted to a float.

Evaluates this parameter tuple at the current frame and returns the result as a tuple of integers.

Raises TypeError if a value cannot be converted to an integer.

Evaluates this parameter tuple at a certain frame and returns the result as a tuple of integers.

Raises TypeError if a value cannot be converted to an integer.

Evaluates this parameter tuple at the current frame and returns the result as a tuple containing a hou.Ramp object.

Raises TypeError if this is not a ramp parameter.

Evaluates this parameter tuple at a certain frame and returns the result as a tuple containing a hou.Ramp object.

Raises TypeError if this is not a ramp parameter.

Evaluates this parameter tuple at the current frame and returns the result as a tuple of strings.

Raises TypeError if a value cannot be converted to a string.

Evaluates the parameter tuple at a frame and returns the result as a tuple of strings.

Raises TypeError if a value cannot be converted to a string.

Evaluates this parameter tuple at the current frame and returns the result as a tuple containing a hou.Geometry object.

Raises TypeError if a value cannot be converted to a hou.Geometry.

Evaluates this parameter tuple at a certain frame and returns the result as a tuple containing a hou.Geometry object.

Raises TypeError if a value cannot be converted to a hou.Geometry.

Evaluates this parameter tuple at the current frame and returns the result as a tuple containing JSON map structures (i.e. Python dictionary).

Raises TypeError or hou.OperationFailed if the parameter tuple is not a JSON map data parameter tuple.

Evaluates this parameter tuple at a certain frame and returns the result as a a tuple containing JSON map structures (i.e. Python dictionary).

Raises TypeError or hou.OperationFailed if the parameter tuple is not a JSON map data parameter tuple.

Sets the values of the parameters in the tuple at the current frame.

If this parameter tuple currently contains channel references to another parameter tuple, then this method will follow channel references and change the value of the referenced parameter tuple. If this is not the desired behavior, then first delete the channel reference with hou.Parm.deleteAllKeyframes or hou.Parm.revertToDefaults for string parameters that don’t have the channel reference embedded in their string value.

Raises hou.InvalidSize if values has a different length than this parameter tuple. Raises hou.PermissionError if any of the parameters in this parameter tuple are not writable.

Saves the animation associated with the parameters of this tuple to the clip file specified by ‹file_name›. The extension of ‹file_name› determines the format of the saved file.

You can use one of the following extensions:

• .clip: save animation as plain text (ASCII) clip file.

• .bclip: save animation as a bclip (binary clip) file.

• .bclip.sc: save animation as a bclip file using Blosc compression.

Set ‹sample_rate› to a non-zero, non-negative value to specify the sample_rate to be used for the clip file. For example, if the current frame rate is 24 (hou.fps()), and ‹sample_rate› is set to 12, the animation will be sampled every second frame since ‹sample_rate› is half of the current frame rate.

If ‹start› is not None, start saving the animation from the specified frame (inclusive). Otherwise, the animation will be saved from the global start frame (inclusive).

Similarly, if ‹end› is not None, stop saving the animation at the specified frame (inclusive). Otherwise, the animation will be saved until the global end frame (inclusive).

The global start and end frame are specified in the Global Animation Options window.

Raises a hou.OperationFailed exception if none of the parameters of this tuple have animation.

Raises a hou.OperationFailed exception if there is an error saving the animation to file.

Raises a hou.InvalidInput exception if start >= end. If specifying only ‹start›, ensure that the specified value is less than the global end frame. Likewise, if specifying only ‹end›, ensure it is larger than the global start frame.

Load animation for the parameters in this tuple from the clip file specified by ‹file_name›. See hou.ParmTuple.saveClip for the list of supported clip file formats.

Any tracks in the clip file that do not match the name of the parameters of this tuple will be ignored.

If ‹sample_rate› is set to a non-zero, non-negative value, the specified value will be used when loading the animation. For example, if the current frame rate is 24 (hou.fps()) and ‹sample_rate› is set to 12, the animation will be loaded with a keyframe at every second frame since ‹sample_rate› is half of the current frame rate.

‹start› specifies the frame the loaded animation should start from. By default the animation starts at the frame specified in the clip file.

This function will raise a hou.OperationFailed exception if there is an error reading animation data from the file.

Returns the clip data for the parameters of this tuple. This method is similar to hou.ParmTuple.saveClip, except that it returns the clip data (file contents) instead of saving the animation to a clip file.

‹start›, ‹end›, and ‹sample_rate› behave the same as in hou.ParmTuple.saveClip.

If ‹binary› is True, return binary clip data otherwise, return plain text (ASCII) clip data.

If ‹use_blosc_compression› is True, blosc compress the binary clip data. This cannot be used for plain text (ASCII) clip data.

The returned clip data is a bytes object in Python 3 and a str object in Python 2. See HOM binary data for more information.

Raises a hou.OperationFailed exception if none of the parameters of this tuple have animation.

Raises a hou.InvalidInput exception if start >= end. If specifying only ‹start›, ensure that the specified value is less than the global end frame. Likewise, if specifying only ‹end›, ensure it is larger than the global start frame.

Raises a hou.InvalidInput exception if binary = False and use_blosc_compression = True.

Load animation for the parameters of this tuple from the given clip ‹data›. This method is similar to hou.ParmTuple.loadClip, except that it loads animation from the given clip data instead of a clip file.

‹sample_rate› and ‹start› behave the same as in hou.ParmTuple.loadClip.

‹binary› and ‹blosc_compressed› specify the type of input data.

If ‹binary› is True, the given data is binary clip data otherwise, it is plain text (ASCII) clip data.

If ‹blosc_compressed› is True, the given data is blosc compressed binary data. This cannot be used for plain text (ASCII) clip data.

The data must be a bytes object in Python 3 and a str object in Python 2. See HOM binary data for more information.

Raises a hou.OperationFailed exception if the given data is invalid.

Raises a hou.InvalidInput exception if binary = False and blosc_compressed = True.

Sets the value of a parameter in the tuple at the current frame and marks it as pending if the parameter is keyed.

For example, the parameter tuple for “translation” contains Parm objects for translation along each of the axes, “tx”, “ty” and “tz”. If set is called with following tuple of floats, (2.5, 4.0, 5.5), then the parameter “tx” with be set to 2.5, “ty” will be set to 4.0 and “tz” will be set to 5.5.

Raises hou.InvalidSize if values has a different length than this parameter tuple. Raises hou.PermissionError if any of the parameters in this parameter tuple are not writable.

Remove all the keyframes from this parameter tuple.

This method be approximately implemented as follows:

def deleteAllKeyframes(self):
for parm in self:
    parm.deleteAllKeyframes()

See also hou.Parm.deleteAllKeyframes.

Removes a keyframe from this parameter tuple at the given frame.

This function will raise a hou.ObjectWasDeleted exception if it is invoked on a parameter that does not exist in Houdini.

This function will raise a hou.PermissionError exception if writing to the specified parameter is impossible.

This function will raise a hou.OperationFailed exception the parameter doesn’t have a keyframe at the given frame.

See also hou.ParmTuple.deleteAllKeyframes.

Changes the autoscope property of components of this parameter tuple.

For example, the parameter tuple for “translation” contains Parm objects for translation along each of the axes, “tx”, “ty” and “tz”. If setAutoscope is called with the following tuple of boolean values, (True, True, False), then the parameter “tx” and “ty” will be automatically scoped, while “tz” will not.

Raises hou.InvalidSize if values has a different length than this parameter tuple. Raises hou.PermissionError if any of the parameters in this parameter tuple are not writable.

Sets a keyframe on this parameter.

Raises TypeError if keyframe is not of type hou.BaseKeyframe. Raises hou.PermissionError if this parameter is not writable. Raises hou.InvalidSize if keyframe_vector has a different length than this parameter tuple.

Return whether this parameter is shown as an expression or as the

See also the showExpression() method.

Sets the UI for the parm to show the expression instead of the value. See also the isShowingExpression() method.

Overwrite the default values with the current parameter tuple values.

Changes the value back to the defaults that ship with Houdini, and restore those defaults.

See also the revertToDefaults() method.

Changes the value back to the default(s). See also the revertToAndRestoreFactoryDefaults() method.

Returns whether the parameter tuple is currently at its defaults.

compare_temporary_defaults: When ‹compare_temporary_defaults› is True, isDefault also checks

compare_expressions: When ‹compare_Expressions› is True, isDefault compares the actual

See also the revertToDefaults() and revertToAndRestorePermanentDefaults()methods.

Returns whether the ramp parameter is currently at its default.

This tests all of the multiparm parameters associated with the ramp by comparing to the special ramp default spare paramater data. Ramps with no default spare data will never be at default.

Return whether this parameter is an instance of a multi parm. For example, the pt0, pt1, pt2, etc. parameter tuples in an add SOP are instances of a multiparm.

Return whether this parameter is a parent multi parm, the number of instances parameter or returns None otherwise

Return the parent multi-parameter if this parameter is a multi-parameter instance and None otherwise.

If this parameter is a multi-parameter instance, then return a tuple of indices of where the parameter appears in the multi-parameter block and any nested blocks. Indices for outer multi-parameter blocks are listed first.

For example if this parameter appears as the fourth instance in the multi-parameter block then (3,) is returned.

As another example if this parameter appears as the third instance in the multi-parameter block and the block itself appears as the first instance of an outer multi-parameter block then (0, 2) is returned.

If this parameter corresponds to the number of instances for a multiparm, return all the parameter tuples corresponding to all instances of this multiparm.

Returns an empty tuple if this parameter is not for a multiparm.

If this parameter corresponds to the number of instances for a multiparm, return number of parameters per instance.

Returns 0 if this parameter is not for a multiparm.

If this parameter corresponds to the number of instances for a multiparm, return number of parameters per instance.

Returns 0 if this parameter is not for a multiparm.

If this parameter corresponds to the number of instances for a multiparm, return the starting index used when building multi parameter names. The default value is 1.

Returns 0 if this parameter is not for a multiparm.

Creates a Channel CHOP representing this parameter. The Channel CHOP is created with the given name as a child of the given parent node. The parent_node is typically created via hou.OpNode.findOrCreateMotionEffectsNetwork.

create_new: Always create a new Channel CHOP. If set to False, then if a Channel CHOP already exists with the same name, it will be re-used. If the parameter already exists on the Channel CHOP, the older parameter will be removed first.

apply_immediately: If set to True, then the export flag on the Channel CHOP will be set.

current_value_only: If set to True, then only the current value of the parameter will be stored.

create_locked: If set to True, then the parameters are locked on creation.

set_value_to_default: If set to True, then the parameters are reverted to their default values on creation

See also hou.OpNode.findOrCreateMotionEffectsNetwork.

Appends this parameter to the specified Channel CHOP.

apply_immediately: If set to True, then the export flag on the Channel CHOP will be set.

current_value_only: If set to True, then only the current value of the parameter will be stored.

create_locked: If set to True, then the parameters are locked on creation.

set_value_to_default: If set to True, then the parameters are reverted to their default values on creation

Returns a tuple of strings corresponding to the names of the folders containing this parameter.

For example, if this parameter is in the Shading folder and the Shading folder is inside the Render folder, this method will return (“Render”, “Shading”). Note that by folder name, we mean the label used in the parameter dialog, not the internal parameter name.

Returns an empty tuple if this parameter is not inside a folder.

Note that calling this method on many parameters may be slow. For a faster alternative, see hou.OpNode.parmsInFolder.

See also the containingFolderSetParmTuples method, and hou.OpNode.parmTuplesInFolder.

Return a tuple of ParmTuples corresponding to the folders containing this parameter.

For example, if this parameter is in the Shading folder and the Shading folder is inside the Render folder, this method will return a tuple containing the Render parm tuple and the Shading parm tuple. Any parm tuples returned will be folder sets.

If this parameter is not inside a folder, an empty tuple is returned.

See also the containingFolders() method, and hou.OpNode.parmsInFolder and hou.OpNode.parmTuplesInFolder.

Return a tuple of indices corresponding to the folders containing this parameter. Each index refers to a folder in the corresponding folder set parameter.

This method can be implemented as follows:

def containingFolderIndices(self):
return tuple(
    list(folder_set_parm_tuple.parmTemplate().folderNames()).index(
    folder_name)
    for folder_set_parm_tuple, folder_name in zip(
    parm.containingFolderSetParmTuples(), parm.containingFolders()))

This example makes a parameter visible in the parameter pane by opening all the folders containing it.

def makeParmVisible(parm):
for folder_set_parm_tuple, folder_index in zip(
    parm.containingFolderSetParmTuples(),
    parm.containingFolderIndices()):
    folder_set_parm_tuple[0].set(folder_index)

Copies this to the parameter clipboard. See also hou.parmClipboardContents().

Returns a script of Python statements that can be executed to set the parameter tuple’s values, flags and other properties. To run the script, use either Python’s exec or execfile functions.

The wrapper function takes in a single argument which must be a reference to an existing node parameter tuple. For symmetry, the function also returns the parameter tuple reference.

Here is an example of saving the output to a file and then loading it back into Houdini:

# Get a reference to the target parameter tuple.
pt = hou.parmTuple("/obj/geo1/t")

# Execute asCode and write the output script to file.
script = pt.asCode()
f = open("set_parm_tuple_properties.py", "w")
f.write(script)
f.close()

# Execute the script.  This will set the values, flag values
# and other properties on /obj/geo1's t parameter tuple.  It will
# also store a reference to the t parameter tuple into a variable
# named 'hou_parm_tuple'.
execfile("set_parm_tuple_properties.py")

Here is an example of saving the output into a function and then calling it in Houdini:

# Get a reference to the target parameter tuple.
node = hou.parmTuple("/obj/geo1/t")

# Execute asCode and write the function definition to file.
func = p.asCode(function_name="setParmTupleProperties")
f = open("parmtuplelib.py", "w")
f.write(func)
f.close()

# Call the function definition to set the properties on another
# parameter tuple.
import parmtuplelib
hou_parm_tuple = parmtuplelib.setParmTupleProperties(node.parm("t"))

Emulates clicking a script action button on a parameter to trigger its script. Raises hou.OperationFailed if the action script could not be run. An optional dictionary of arguments can be passed to the action script. Returns the result of the execution of the script.

Returns a JSON-like structure representing this parameter.

Updates the settings and value of this parameter from the given data (as returned by ParmTuple.asData()).

Returns a JSON-like value representing the value of this parameter.

Updates the value of this parameter from the given data (as returned by ParmTuple.valueAsData()).

Returns a JSON-like structure representating any child instances of this multiparm.

Sets the child instances of this multiparm from the given data (as returned by ParmTuple.multiParmInstancesAsData()).

Returns a JSON-like structure representing the points of this ramp parameter.

Sets the points of this ramp parameter from the given data (as returned by ParmTuple.rampPointsAsData()).

Returns a JSON-like structure representing this tuple’s template.

Returns a JSON-like structure representing the children of this tuple’s template.

Inserts spare parameters relative to this parameter, from the given data.