Creates a node for visualizing the data from a particular output of this node. If a visualizer node already exists in the current network, it is moved and connected to the specified output_index. This method is only implemented for SOP and VOP nodes. Other node types do nothing when this method is called.

Copy this node to a new place in the node hierarchy. The new node is placed inside the given destination node. This method returns the new node.

Raises hou.OperationFailed if the destination node cannot contain the new node. Raises hou.PermissionError if the destination node is inside a locked asset.

Return the parameter at the given path, or None if the parameter doesn’t exist.

Return a tuple of parameters matching the pattern.

The pattern may contain multiple pieces, separated by spaces. An asterisk (*) in a pattern piece will match any character. By default, Houdini will add the parameters from each pattern piece to those already matched. However, if the pattern piece begins with a caret (^), Houdini will remove the matches for that piece from the result.

By default the pattern match is case-sensitive. Set ignore_case to True for case-insensitive pattern matching. Note that case insensitivity only applies when matching node and parameter names. It does not apply when matching group, network box or bundle names.

By default, only parameters with names matching the pattern are returned. Set search_label to True to also return parameters with labels matching the pattern.

If single_pattern is True, the pattern will be treated as one pattern even if there are spaces in the pattern.

This method returns an empty tuple if you pass in an empty pattern.

Evaluates the specified parameter and returns the result.

Return a list of the parameters on this node.

Return a list of the parameters that reference this node.

Recursively return a sequence of all the parameters on all of the nodes contained in this node including this node.

This method is a generator and does not return a tuple.

Here is an example of printing out the parameter paths for all nodes under /obj:

root_node = hou.node("/obj")
for parm in root_node.allParms():
    print parm.path()

Given a dictionary mapping parm names to values, set each of the corresponding parms on this node to the given value in the dictionary.

The following example sets the tx and sy parameters at once:

>>> node = hou.node("/obj").createNode("geo")
>>> node.setParms({"tx": 1, "sy": 3})

The names are tried against both parameters and parmameter tuples, so the base name can also be used:

>>> node = hou.node("/obj").createNode("geo")
>>> node.setParms({"t": (1, 2, 3), "s": (3, 3, 3)})

Raises hou.OperationFailed if any of the parameter names are not valid.

See also the setParmExpressions method.

Given a dictionary mapping parm names to values, sets the pending value of each of the corresponding parms on this node. Supports both parameters and parameter tuples.

Raises hou.OperationFailed if any of the parameter names are not valid.

See also the setPending method.

Given a dictionary mapping parm names to expression strings, set each of the corresponding parms on this node to the given expression string in the dictionary.

See hou.Parm.setExpression for a description of the language and replace_expressions parms.

The following example expressions set the tx and sy parameters at once:

>>> node = hou.node("/obj").createNode("geo")
>>> node.setParmExpressions({"tx": 'ch("ty")', "sy": "sin($F)"})

Raises hou.OperationFailed if any of the parameter names are not valid.

See also the setParms method.

Return the parm tuple at the given path, or None if it doesn’t exist.

This method is similar to parm(), except it returns a hou.ParmTuple instead of a hou.Parm.

Evaluates the specified parameter tuple and returns the result.

Return a list of all parameter tuples on this node.

This method is similar to parms(), except it returns a list of hou.ParmTuple instead of hou.Parm.

Return a list of parameters in a folder on this node. Returns all parameters in the folder and its subfolders (if any).

Raises hou.OperationFailed if the folder specified by folder_names does not exist.

For example, suppose a node had a Render folder that contained a Shading subfolder. Then this line of code would return the parameters in the Render folder:

# Note the trailing comma after "Render" to tell Python that "Render" is
# contained in a tuple/sequence as opposed to just a single string with
# parentheses around it.
>>> node.parmsInFolder(("Render", ))

And this line of code would return the parameters in the Shading subfolder.

>>> node.parmsInFolder(("Render", "Shading"))

See also hou.Parm.containingFolders and hou.Parm.containingFolderSetParmTuples

Note that this method does not work for multi-parameters, which behave similar to folder parameters. To get a list of parameters in a multi-parameter, call hou.Parm.multiParmInstances.

Return a list of the parameter tuples in a folder on this node. This method is similar to parmsInFolder(), except it returns a list of hou.ParmTuple instead of hou.Parm. See parmsInFolder() above for information about the arguments.

See also hou.Parm.containingFolders and hou.Parm.containingFolderSetParmTuples

Return the node’s default expression language.

When you enter an expression in a parameter that does not already contain an expression, the node’s expression language is used to determine how that expression should be evaluated. You can change a node’s expression language in the parameter dialog in the GUI.

Changing the node’s expression language will not change the language in parameters already containing expressions (i.e. parameters with keyframes).

Note that if a parameter already contains an expression and you change that expression in the GUI, the expression language will not change, regardless of the value of the node’s expression language. To change the language of an existing expression in a parameter from Python, use hou.Parm.setExpression, as in parm.setExpression(parm.expression(), language).

Set the node’s default expression language. See expressionLanguage() for more information.

Return a dictionary of parameter aliases on the node’s parameters. The keys in the dictionary are the parameters that have aliases and the values are the alias names.

Removes all alias names from parameters on the node.

Return a list of the spare (user-defined) parameters on this node.

Removes all spare parameters from this node.

Return the group of parm templates corresponding to the current parameter layout for this node.

You can edit the parameter layout for this node (add or remove spare parameters, reorder or hide built-in parameters, etc.) by getting the current parameter group, modifying it, and calling hou.Node.setParmTemplateGroup with it.

The following example creates a geometry object, adds a My Parms folder to it, and adds a My Parm float parameter to it in that folder. The parameters are added only to the geometry object created; other geometry objects are unaffected.

>>> node = hou.node("/obj").createNode("geo")
>>> group = node.parmTemplateGroup()
>>> folder = hou.FolderParmTemplate("folder", "My Parms")
>>> folder.addParmTemplate(hou.FloatParmTemplate("myparm", "My Parm", 1))
>>> group.append(folder)
>>> node.setParmTemplateGroup(group)

See hou.ParmTemplateGroup and the setParmTemplateGroup method for more information and examples.

Change the spare parameters for this node.

Note that each node type has a set of parameters which must exist and must be of certain types. If your parm template group does not contain the required parameters for the node type the will be added at the bottom and will be made invisible. Similarly, if your parm template group attempts to modify the type, range, label, or other property of a required parameter, all changes to that parameter other than visibility settings will be ignored.

This method is preferred over the other parameter-related methods in this class (addSpareParmTuple, removeSpareParmTuple, replaceSpareParmTuple, addSpareParmFolder, removeSpareParmFolder) because it lets you more easily make manipulate parameters.

See hou.HDADefinition.setParmTemplateGroup to change the parameter interface of a digital asset.

Add a spare parameter tuple to the end of the parameters on the node. If in_folder is not an empty sequence, this method adds the parameters to the end of the parameters in a particular folder.

Note that this method can add a single folder by passing a hou.FolderParmTemplate for parm_template.

See also the removeSpareParmTuple() and addSpareParmFolder() methods.

This method is deprecated in favor of setParmTemplateGroup.

Removes the specified spare parameter tuple.

See also addSpareParmTuple().

This method is deprecated in favor of setParmTemplateGroup.

Adds a control parameter folder as the front-most folder at the top-level. This is used to increase visibility of customized control parameters. If a folder of the same name already exists, no new folder will be created. If folder_name is None, it will be set as 'Controls'. If parm_name is None, it will be set as 'folder'.

If there are no current folders present, the existing parameters will be grouped together and stored into a new folder named 'Parameters' and placed after the new control parameter folder.

Adds a folder to the spare parameters.

Note that all the folders in a set correspond to one parameter. If this is the first folder to go in the set, parm_name will be used as the parameter name. Otherwise, parm_name will be ignored and the parameter name of the first folder in the set is used.

If this is the first folder in the set and parm_name is None, it will default to 'sparefolder0'. If parm_name is already in use, a unique name will be automatically generated.

If create_missing_folders is True, this method will create the folders in in_folder that don’t exist. So, this method can be used to add spare folders and a spare parameter at the same time.

Note that you can add folders by passing a hou.FolderParmTemplate to the addSpareParmTuple method, so this method is deprecated. Note also that addSpareParmTuple is deprecated in favor of setParmTemplateGroup.

See also the removeSpareParmFolder and addSpareParmTuple methods.

This method is deprecated in favor of setParmTemplateGroup.

Removes an empty folder from the spare parameters.

folder is a sequence of folder names. So, to remove the Output folder, use ("Output",) instead of "Output".

See also addSpareParmFolder(), hou.ParmTemplateGroup.remove, and hou.ParmTemplateGroup.findFolder.

Replace an existing spare parameter tuple with a new one. The old parameter tuple is removed and the new one is added in its place.

The new parameter tuple may or may not have the same name as the old one. By providing a parameter tuple with the same name, you can modify an existing spare parameter tuple.

Note that you cannot replace non-spare parameter tuples. However, you can change the visibility of non-spare parameters using hou.ParmTuple.hide.

To change a parameter for all instances of digital asset, use hou.HDADefinition.replaceParmTuple.

This method is deprecated in favor of setParmTemplateGroup.

Return a list of local variables that can be referenced in parameter expressions on this node using the $ prefix.

Return a list of local variables that can be referenced in parameter expressions on this node using the @ prefix. This includes local variables defined in this node as attributes and any context options that were available to this node the last time it was cooked.

Saves the animation associated with the parameters of this node 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.

If scoped_only is True, only the animation associated with scoped parameters will be saved. If there are no scoped parameters, the animation associated with auto-scoped parameters will be saved.

If scoped_only is False, animation associated with any of the parameters of this node will be saved.

Raises a hou.OperationFailed exception if none of the parameters of this node have animation. If scoped_only is True, this exception can be raised if none of the scoped parameters have animation, or if none of the auto-scoped parameters have animation (if the node has no scoped parameters).

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 node from the clip file specified by file_name. See hou.Node.saveParmClip 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 node 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 node. This method is similar to hou.Node.saveParmClip, except that it returns the clip data (file contents) instead of saving the animation to a clip file.

start, end, sample_rate, and scoped_only behave the same as in hou.Node.saveParmClip.

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 in this node from the given clip data. This method is similar to hou.Node.loadParmClip, except that it loads animation from the given clip data instead of a clip file.

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

sample_rate and start behave the same as in hou.Node.loadParmClip.

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.

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

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

Return a tuple of nodes that are referenced by this node, either through parameter expressions, referring to the node by name, or using expressions which rely on the data generated by another node. These reflect all the other ways (besides connecting to an input) in which one node may affect another.

Note that the result can differ depending last cook of the nodes. It’s recommended that you first call cook() on the node first.

Return a tuple of nodes that are reference this node, either through parameter expressions, referring to the node by name, or using expressions which rely on the data generated by this node. These reflect all the other ways (besides connecting to an input) in which one node may affect another.

Note that the result can differ depending last cook of the nodes.

Returns a sequence of tuples representing references to external files (such as textures, geometry files, and asset libraries) from this node. Applies to all sub children of this node if recurse is set to true.

See also hou.fileReferences()

Create a digital asset from this node. You would typically call this method on subnet nodes.

Create a compiled digital asset from this node. You would typically call this method on VOP network nodes, such as Material Shader Builder SHOP, Surface Shader Builder SHOP, or VEX Surface SHOP Type VOPNET. The digital asset does not have contents section, which means it does not have VOP network inside, but instead relies on the saved VEX code sections to provide the shader code.

After the creation of a compiled HDA, if its VEX code section is ever changed manually, the corresponding vex object code section can be recompiled using hou.HDADefinition.compileCodeSection.

Changes the node to a new type (within the same context). new_node_type is the internal string name of the type you want to change to.

Keep_name, keep_parms, and keep_network_contents indicate that the node should keep the same name, parameter values, and contents, respectively, after its type has changed. force_change_on_node_type_match indicates whether to perform the change even when is already of the specified type.

Unlocks a digital asset so its contents can be edited.

To use this function, you must have permission to modify the HDA.

If this node is an unlocked digital asset, change its contents to match what is stored in the definition and lock it. The parameter values are unchanged.

If this node is locked or is not a digital asset, this method has no effect.

See also hou.Node.matchesCurrentDefinition and hou.Node.isLocked.

Return whether the contents of the node are locked to its type definition.

If this node is a digital assets whose contents are currently in a delay-sync condition, the contents will be synced. If it is already synced or not a syncable asset, no effect occurs.

If this node is a digital assets whose contents are currently in a delay-sync condition, returns true. Otherwise returns false, which will include nodes that are not syncable.

If this node is an instance of a digital asset, return whether or not it is locked. Otherwise, return False.

To differentiate between unlocked digital assets and nodes that are not instances of digital assets, check if the node’s type has a definition:

def isUnlockedAsset(node):
    return not node.isLockedHDA() and node.type().definition() is not None

See hou.HDADefinition.updateFromNode for an example of how to save and lock all unlocked digital asset instances.

Return whether this node is inside a locked digital asset. If this node is not inside a locked HDA, the node may deviate from the HDA definition.

Return False if the node is contained inside a locked HDA node and, is not marked as editable within that locked HDA, and True otherwise. In particular this function will return True for a node that is not inside a locked HDA (or not inside an HDA at all).

Returns True if the node contains materials.

This method is a shortcut for self.type().hdaModule() to reduce the length of expressions in Python parameters and button callbacks. See hou.NodeType.hdaModule for more information.

See also the hm method and hou.phm().

This method is a shortcut for self.hdaModule().

See also hou.phm().

This method creates an instance of hou.HDAViewerStateModule associated to the underlying Node.

See also hou.NodeType.hdaViewerStateModule.

This method creates an instance of hou.HDAViewerHandleModule associated to the underlying Node.

See also hou.NodeType.hdaViewerHandleModule.

Synchronize the node from the specified version to the current version of its HDA definition. See also hou.HDADefinition.version.

Return an integer to indicate which output of the node should be used for display purposes.

Sets which output should be used for display purposes on this node.

Return the date and time when the node was created.

Return the date and time when the node was last modified.

This returns the name of the viewport tool that was used to be created. This name is not set by default and is usually the empty string.

This sets the name of the tool that created this node. If you call this with a name that differs from the node type name, you should also call setBuiltExplicitly(False).

Return whether this node was built explicitly (defaults to True). Most nodes are built explicitly, but some are implicitly created by Houdini. For example, if you select geometry from multiple SOPs and then perform an operation, Houdini will put down an implicit merge SOP before performing that operation. When reselecting geometry in SOPs, Houdini will automatically delete any SOPs that were created implicitly.

Set whether this node was built explicitly (default value is True). If set to False, this node will not show up in various menus and in the Network View pane’s list mode. This flag is typically used for intermediate utility nodes that one is unlikely to want to change its parameters.

Return whether the node is time dependent. A time dependent node is re-evaluated every time the frame changes.

Asks or forces the node to re-cook.

Asks if the node needs to re-cook.

Returns the number of times this node has cooked in the current session.

Update the UI states, such as hidden and disabled, for each parameter in the node.

UI states can be expressed as conditionals (i.e. Disable When) which require evaluation. Typically in graphical Houdini the Parameter Pane performs the evaluation when the node is selected in order to determine how the node parameters should look in the pane. However in non-graphical Houdini or if the Parameter Pane has not yet loaded the node, then the evaluation does not occur and the UI states remain at their defaults causing methods such as hou.Parm.isDisabled and hou.Parm.isHidden to return incorrect values. In these cases, it is recommended that hou.Node.updateParmStates is called.

Returns a tree structure containing information about the node and its most recently cooked data. The contents of the tree vary widely depending on the node type, and the nature of its cooked data. This tree of data is used to generate the node information window contents.

Return a list of the nodes, including nodes in subnets, that were used in the last cook for the network this node belongs to.

Return True if the node can generate compiled cook code and False otherwise.

If check_parent is true, the parents in the ancestor hierarchy are tested if any of them can generate code.

If the node cannot generate cook code explicitly, it might still be able to provide such code implicitly, if it can be wrapped in auto-shader. E.g., a building-block VOPs such as Anti-Aliased Noise don’t generate a complete cook code; they provide code fragment that contributes to the full cook function. But sometimes they can be automatically wrapped in such a function, which which will act as cook code. If check_auto_shader is true, the node will be tested if it provides implicit cook code.

Return the node itself or a network node that contains this node and can generate compiled cook code. For example, the generator node for a VOP node could be the SHOP node or SOP node that contains it for example.

Return None if this node cannot generate code and is not contained in a code generating node either either.

Return the language of the generated cook code (i.e. VEX, RSL).

Raises hou.OperationFailed if this node cannot generate compiled code.

Return True if this node can generate compiled cook code for multiple contexts (i.e. surface context, displacement context, etc.) and False otherwise.

Raises hou.OperationFailed if this node cannot generate compiled code.

Saves compiled VEX code to a disk file (for nodes that support this). See hou.Node.saveCookCodeToFile for a description of the arguments.

Saves VEX/RSL source code to a disk file (on nodes that support this).

node("/shop/vopmaterial1").saveCookCodeToFile("myfile.vfl", context_name="surface")

Add a node group to the node and return the new group.

If a group of the given name already exists then this function simply returns the existing group without adding a new one. If the name of the group is None or an empty string, then a unique default name is automatically chosen.

This function can only be called on nodes that are networks. If it is called on a node that is not a network, then it raises hou.OperationFailed.

To remove a node group, use hou.NodeGroup.destroy.

Return a node group contained by the node with the given name, or None if the group does not exist.

Return the list of node groups in this node.

Runs the initialization script associated with this node’s type.

Return the script that will run when this node is deleted.

Sets the script that will run when this node is deleted.

Return a node path representing the location for storing clips. This location may or may not exist. To find or create such a network, use hou.Node.findOrCreateMotionEffectsNetwork.

Return a CHOP network node suitable for storing Motion Effects. By default, if the node doesn’t exist, it will be created.

See also hou.Parm.storeAsClip and hou.Node.motionEffectsNetworkPath.

Return a copy stamping floating point or string value. This node must be a downstream stamping operator, such as a Copy SOP, Cache SOP, LSystem SOP, or Copy CHOP.

You might put the following expression in a Python parameter:

node("../copy1").stampValue("sides", 5)

Given a sequence of child items (nodes, network boxes, sticky notes, etc), save a file containing those items. You can load this file using hou.Node.loadItemsFromFile.

Raises hou.OperationFailed if any of the nodes or network boxes are node children of this node, or if the file could not be written to. Raises hou.PermissionError if you do not have permission to read the contents of this node.

Combines separate lists of nods and network boxes into a single sequence, and calls hou.Node.saveItemsToFile. This method is provided for backward compatibility. New code should call saveItemsToFile directly.

Load the contents of a file (saved with hou.Node.saveItemsToFile) into the contents of this node.

Raises hou.OperationFailed if the file does not exist or it is not the correct type of file. Raises hou.PermissionError if this node is a locked instance of a digital asset. Raises hou.LoadWarning if the load succeeds but with warnings and ignore_load_warnings is False.

Calls hou.Node.loadItemsFromFile. Provided for backward compatibility. New code should call loadItemsFromFile directly.

Prints the Python code necessary to recreate a node.

Registers a Python callback that Houdini will call whenever a particular action, or event, occurs on this particular node instance.

Callbacks only persist for the current session. For example, they are not saved to the .hip file. If you want persistent callbacks in every session, you can add them in code in 456.py (runs when the user opens a .hip file). See where to add Python scripting for more information.

def event_callback(event_type, **kwargs):
    ...

Raises hou.OperationFailed if the event_types list argument is empty.

The following example shows to set up a function that’s called whenever a certain node’s name changes:

def name_changed(node, event_type, **kwargs):
    print("The geometry object is now named", node.name())

hou.node("/obj/geo1").addEventCallback((hou.nodeEventType.NameChanged, ), name_changed)

See also hou.Node.removeEventCallback and hou.Node.removeAllEventCallbacks.

Given a callback that was previously added on this node and a sequence of hou.nodeEventType enumerated values, remove those event types from the set of event types for the callback. If the remaining set of event types is empty, the callback will be removed entirely from this node.

Raises hou.OperationFailed if the callback had not been previously added.

See hou.Node.addEventCallback for more information.

Registers a Python callback that Houdini will call whenever a parameter in parm_names changes on this particular node instance. This is can be faster than filtering the parameter names in a callback installed with hou.Node.addEventCallback if you only care about some parameters or if the node has many parameters.

See hou.Node.addEventCallback for more information.

Remove all event callbacks for all event types from this node.

See hou.Node.addEventCallback for more information.

Return a tuple of all the Python callbacks that have been registered with this node with calls to hou.Node.addEventCallback.

Add/set a named value on this node instance. Unlike setUserData, values set using this method are not saved with the hip file.

name: A unique name (key) for the user-defined data. By using different names, you can attach multiple pieces of user-defined data to a node. value: The value to store. Unlike setUserData, this value may be any Python object.

This name/value pair is not stored with the hip file. It is useful for nodes implemented in Python that want to save temporary values between cooks, to avoid recomputing them on subsequent cooks.

The following example illustrates how to set, access, and delete cached user-defined data:

>>> n = hou.node("/obj").createNode("geo")
>>> n.setCachedUserData("my data", [1, 2, {"a": "b", "c": "d"}])
>>> n.cachedUserData("my data")
[1, 2, {'a': 'b', 'c': 'd'}]
>>> n.cachedUserDataDict()
{'my data': [1, 2, {'a': 'b', 'c': 'd'}]}
>>> n.destroyCachedUserData("my data")
>>> n.cachedUserDataDict()
{}
>>> print n.cachedUserData("my data")
None

See per-node user-defined data for more information and examples.

Return a dictionary containing all the user-defined name/string pairs for this node.

See hou.Node.setCachedUserData for more information.

Return the user-defined cached data with this name, or None if no data with this name exists.

See hou.Node.setCachedUserData for more information.

This method can be implemented as follows:

def cachedUserData(self, name):
    return self.cachedUserDataDict().get(name)

Note that None is a valid value for a key, so the most reliable way to check if a key is valid is to check if it is in the result of cachedUserDataDict:

>>> n = hou.node("/obj").createNode("geo")
>>> n.cachedUserDataDict()
{}
>>> print n.cachedUserData("foo")
None
>>> "foo" in n.cachedUserDataDict()
False
>>> n.setCachedUserData("foo", None)
>>> n.cachedUserDataDict()
{'foo': None}
>>> print n.cachedUserData("foo")
None
>>> "foo" in n.cachedUserDataDict()
True

Remove the user-defined cached data with this name.

See hou.Node.setCachedUserData for more information.

Raises hou.OperationFailed if no user data with this name exists and must_exist is True.

Remove all user-defined cached data.

See hou.Node.setCachedUserData for more information.

Return the names of all data blocks stored on this node that are of the data type specified by the blocktype parameter.

Data blocks are similar to user data in that they can contain any extra data that may be useful to attach to a specific node. They differ from user data in that data blocks are designed to more efficiently handle large blocks of data. Data blocks can also contain binary data, and have a data type associated with each block.

Return the data type of the block specified by the key parameter.

Raises hou.ValueError if the provided key is not associated with any data block on this node.

Returns the data block as a binary string stored under the given key. This method will only work if the specified data block is has a type that can be represented by a python object. Otherwise None is returned.

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

Raises hou.ValueError if the provided key is not associated with any data block on this node.

Stores the provided data block on the node under the provided key name, marking it with the provided data type.

Passing an empty string as the block value will remove any data block with the specified key. Data blocks can also be removed with the removeDataBlock() method.

The blocktype string argument requires a C++/HDK plugin to interpret data blocks and turn them into C++ objects. If you're using Python to get and set data blocks, leave the blocktype empty.

Removes any existing data block on the node with the specified key. If there is no data block with this key, this method does nothing.

Return the simulation defined by this DOP network node. This raises an exception if this is not a dop network.

Given a hou.DopObject, return a tuple of DOP nodes that processed that object. This raises an exception if this is not a dopnetwork.

If a work item is selected, selects the next visible work item

If a work item is selected, selects the previous work item

Deselects the active work item if this node is inside or contains the TOP network with the currently selected work item.

If a TOP node can’t display all work items, sets which work item subset (page) will be displayed