Returns the parameter’s channel alias name. Returns an empty string if no such name exists.

Gives the parameter another name by which it can be referenced in channels. You can pass in an empty string to remove an existing alias name.

Returns whether this parameter’s autoscope property is on.

Removes all keyframes from this parameter.

This has no effect if there are no keyframes to delete. The value of the parameter after all keyframes are removed will be the one it evaluated to at the current 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.

See also hou.Parm.deleteKeyframeAtFrame() and hou.ParmTuple.deleteAllKeyframes().

Removes a keyframe from this parameter 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.Parm.deleteAllKeyframes().

Returns the keyframes on this parameter.

Returns a tuple of keyframes on this paramter that occur at or after frame. If no keyframes are found an empty tuple is returned.

Returns a tuple of keyframes on this paramter that occur at or before frame. If no keyframes are found an empty tuple is returned.

Returns extrapolation on this parameter for time before the first keyframe or after the last keyframe. Extrapolation defines how a parm value is evaluated outside the keyframe range.

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.OperationFailed exception the parameter doesn’t have a valid animation channel.

Returns a tuple of keyframes on this parameter that fall in the range start_frame to end_frame, inclusive. If no keyframes are found an empty tuple is returned.

Performs a refitting operation with resampling and range controls.

Returns whether this parameter’s channel is scoped. If it is scoped, then it is loaded in the animation editor.

Changes the scope property of this parameter’s channel, which affects whether it is loaded in the animation editor.

Changes the autoscope property of the parameter. If this property is on, this parameter is automatically scoped when the object is selected.

Sets a keyframe on this parameter.

Raises hou.TypeError if keyframe is not of type hou.BaseKeyframe. Raises hou.PermissionError if this parameter is not writable.

Sets multiple keyframe on this parameter. Calling this method is more efficient than calling hou.Parm.setKeyframe() several times because it sends out only one update event to Houdini for the entire batch of keyframes that are set.

keyframes must be a tuple or list of hou.BaseKeyframe objects.

Raises hou.PermissionError if this parameter is not writable.

Sets a extrapolation on this parameter for time before the first keyframe or after the last keyframe. Extrapolation defines how a parm value is evaluated outside the keyframe range.

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 valid animation channel.

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

Raises hou.TypeError if the type of value does not match this parameter’s type. Raises hou.PermissionError if this parameter is not writable.

Returns the contents of the parameter before dollar sign and back-tick expansion.

Examples of unexpanded strings would be "image$F.pic", "$HIP/split.hda", or "chs('../font1/text')". If you were to call eval() on them, Houdini would perform variable expansion and back-tick expression evaluation, so you would get back something like "image1.pic" instead of "image$F.pic".

Because only string parameters will attempt to do dollar sign and string expansion, this method will raise hou.OperationFailed if called from a non-string parameter.

Suppose a string parameter contains keyframes. In this situation, Houdini will not attempt to do string expansion on the parameter’s value, so calling this method will raise hou.OperationFailed. Instead of calling this method, you can call expression() to access the first Keyframe’s expression. If there are multiple keyframes, you can call keyframes() to get a list of hou.StringKeyframe objects and call expression() on those objects to retrieve the expression.

Evaluates this parameter at the current frame and returns the result. See also the evalAtFrame and evalAtTime methods.

Evaluates this parameter at the current frame and returns the result as a float.

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

Evaluates this parameter at a certain frame and returns the result as a float.

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

Evaluates this parameter at the current frame and returns the result as an integer.

Raises hou.TypeError if the value cannot be converted to an integer.

Evaluates this parameter at a certain frame and returns the result as an integer.

Raises hou.TypeError if the value cannot be converted to an integer.

Evaluates this parameter at the current frame and returns the result as a hou.Node.

Raises hou.TypeError if the value cannot be converted to a hou.Node.

Evaluates this parameter at a certain frame and returns the result as a hou.Node.

Raises hou.TypeError if the value cannot be converted to a hou.Node.

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

Raises hou.TypeError if the value cannot be converted to a hou.Node.

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

Raises hou.TypeError if the value cannot be converted to a hou.Node.

Evaluates this parameter at the current frame and returns the result as a string.

If you want the string contents of the parameter before variable expansion and expression evaluation then call hou.Parm.unexpandedString().

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

Evaluates this parameter at a certain frame and returns the result as a string.

If you want the string contents of the parameter before variable expansion and expression evaluation then call hou.Parm.unexpandedString().

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

Evalute this parameter at a given time and return the result as an integer, float or string.

See also evalAtFrame.

Evalute this parameter at a given frame and return the result as an integer, float or string.

See also evalAtTime.

Evaluates this parameter at the current frame and returns the result as a ramp.

Raises hou.TypeError if the parameter is not a ramp.

Evaluates this parameter at a certain frame and returns the result as a ramp.

Raises hou.TypeError if the parameter is not a ramp.

Evaluates this parameter at the current frame and returns the result as a geometry.

Raises hou.TypeError if the parameter is not a geometry.

Evaluates this parameter at a certain frame and returns the result as a geometry.

Raises hou.TypeError if the parameter is not a geometry.

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

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

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

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

Returns the parameter’s raw text value without evaluation or expansion. If the parameter has an expression then the expression is returned otherwise the parameter’s plain text value is returned.

Sets the parameter value at the current frame.

If this parameter currently contains a channel reference to another parameter, then this method will follow channel references and change the value of the referenced parameter. If this is not the desired behavior, then first delete the channel reference with hou.Parm.deleteAllKeyframes(). Alternatively if you are setting the value to another parameter and do not want to follow existing channel references then set the optional follow_parm_reference argument to False.

Raises hou.TypeError if the type of value does not match the type of this parameter. Raises hou.PermissionError if this parameter is not writable.

See also hou.Node.setParms().

Copies the value of an entire parameter, including channels, from the provided src parameter.

Returns this parameter’s expression.

For example, a parameter might contain the Python expression frame() * 2. In this case hou.Parm.eval() at frame 2 would return the value 4, while calling expression() would return the string frame() * 2.

If the parameter does not contain an expression, this method will raise hou.OperationFailed. Also, if the parameter contains more than one keyframe then it could contain multiple different expressions, so it also raises hou.OperationFailed in that case.

This method is roughly equivalent to…

parm.keyframes()[0].expression()

See also the setExpression(), expressionLanguage(), keyframes(), and eval() methods.

Sets this parameter’s expression.

expression: A string containing the expression that will go inside the parameter.

language: Either a hou.exprLanguage enumeration value or None.

If language is None and the parameter does not already contain an expression, the language will be the node’s expression language. (See hou.Node.expressionLanguage().) Otherwise, if language is None and the parameter already has an expression, the expression language will not change.

replace_expression: This parameter only has effect if the parameter already contains keyframes. If it is True, Houdini will replace the keyframe before the current time with one containing the new expression. Otherwise, it will always add a keyframe at the current time. Note that this behavior matches what happens when you edit an expression from Houdini’s parameter dialog.

Unlike hou.Parm.set(), this method does not follow channel references. That is, if this parameter is referencing another parameter and you call setExpression(), it change the channel reference expression into the specified expression.

If the parameter does not already contain any keyframes, this method is roughly equivalent to setting a keyframe at frame 1, where the keyframe’s expression and language are the ones specified.

This method can be approximately implemented as follows:

def setExpression(self, expression, language=None, replace_expression=None)
if self.template().type() == hou.parmTemplateType.String:
    k = hou.StringKeyframe()
else:
    k = hou.Keyframe()

k.setExpression(expression, language)

if len(self.keyframes()):
    if replace_expression:
    k.setTime(self.effectiveKeyframeAtFrame(hou.frame()).time())
    else:
    k.setTime(hou.time())
else
    k.setTime(0.0)

self.setKeyframe(k)

See also the expression, expressionLanguage, and setKeyframe methods, hou.Node.expressionLanguage(), and hou.Node.setExpressions.

Returns the parameter’s expression’s language.

If the parameter does not contain an expression, this method will raise hou.OperationFailed. Also, if the parameter contains more than one keyframe then it could contain multiple different expressions, so it also raises hou.OperationFailed in that case.

To change the expression language, use hou.Parm.setExpression() and explicitly specify the language: parm.setExpression(parm.expression(), language).

This method is roughly equivalent to…

parm.keyframes()[0].expressionLanguage()

See also the expression(), setExpression(), keyframes(), and setExpressionLanguage() methods.

Returns the referenced parameter. If no parameter is referenced, returns this parameter.

Return a tuple of all the parameters in the scene that have channel references to this parameter.

Returns whether a default has been explicitly set on the parameter.

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

Returns whether the parameter is currently at its default.

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.

Changes the value back to the default that ships with Houdini, and restores that default.

See also the revertToDefaults() method, and hou.ParmTuple.revertToAndRestorePermanentDefaults()

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

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.Node.parmsInFolder().

See also the containingFolderSetParmTuples method, and hou.Node.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.Node.parmsInFolder() and hou.Node.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 this parameter’s name.

Returns the hou.ParmTuple associated with this parameter.

For example, calling this method on the Parm object for the translation parameter "tx", would return a ParmTuple that contains Parm objects for the three translation parameters "tx", "ty" and "tz". If no tuple is associated with the parameter, then the parameter itself is returned in a tuple of size 1.

Returns the full path to this parameter.

Returns this parameter’s label.

Returns the node on which this parameter exists.

Returns the template for this parameter.

Returns the component index of this parameter.

For example, the translation parameter along the x-axis, "tx", would return a component index of 0, while the translation parameter along the y-axis, "ty" would return a component index of 1.

Returns whether this parameter is locked (uneditable).

Returns whether this parameter is a "spare" (user-defined) parameter.

Returns whether this parameter is time dependent, that is, its 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.

Sets the UI disable state of this parameter 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, ignoring the lock state. This can be used to read the result of a disable-when conditional.

It is recommended that hou.Node.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 in its node. Calling this method has the same effect as changing the Invisible checkbox on the Edit Parameter Interface dialog, or hiding the parameter with a hide-when conditional.

However, changing the UI state with this function is transient and does not affect node parameter templates, which means that the new state is not saved to .hip file and can be restored when refreshing the node to its spare parameter templates.

To permanently change the UI state of a parameter on a node, please use hou.ParmTemplate.hide() instead:

parms = hou.node('/obj/node').parmTemplateGroup()
p = parms.find('lookatpath')
p.hide(True)
parms.replace('lookatpath', p)
hou.node('/obj/node').setParmTemplateGroup(parms) 

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

It is recommended that hou.Node.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 whether or not this parameter would be visible in the parameter dialog for this node. It checks both the parameter’s template, and the hidden state of the parameter. This is equivalent to the following code (but runs faster because it avoids creating the hou.ParmTemplate):

>>> p = hou.parm('/obj/geo1/tx')
>>> not p.isHidden() and not p.parmTemplate().isHidden()
True

Locks (lock(True)) or unlocks (lock(False)) this parameter (this is, makes the value uneditable).

Raises hou.PermissionError if this parameter is part of a locked digital asset.

Returns the CHOP track overriding this parameter, if any.

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.Node.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.

See also hou.Node.findOrCreateMotionEffectsNetwork().

Emulates clicking a button parameter to trigger its callback script. Raises hou.OperationFailed if the callback script could not be run.

Insert a new multi parm instance before the given index. To append a new multi parm instance, set the index to be the current number of instances. The current number can be queried by calling evalAsInt on the this parameter.

Removes the multi parm instance at the given index.

Return whether this parameter is an instance of a multi parm. For example, the pt0x, pt1x, pt2x, etc. parameters in an add SOP are instances of a multiparm.

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 parameters corresponding to all instances of this multiparm.

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

Returns a list of labels for all possible menu items (for a menu parameter). Raises hou.OperationFailed if this parameter is not a menu.

Returns a list of all possible menu items (for a menu parameter). Raises hou.OperationFailed if this parameter is not a menu.

Returns a script of Python statements that can be executed to set the parameter’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. For symmetry, the function also returns the parameter 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.
p = hou.parm("/obj/geo1/tx")

# Execute asCode and write the output script to file.
script = p.asCode()
f = open("set_parm_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 tx parameter.  It will
# also store a reference to the tx parameter into a variable
# named 'hou_parm'.
execfile("set_parm_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.
node = hou.parm("/obj/geo1/tx")

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

# Call the function definition to set the properties on another
# parameter.
import parmlib
hou_parm = parmlib.setParmProperties(node.parm("ty"))