Return an enum value indicating what type of network item is represented by this object. This value is equivalent to using the isinstance built in Python function with the matching class (for example hou.networkItemType.Connection is equivalent to hou.NodeConnection).

Return this node’s name. See also hou.NetworkMovableItem.path.

Set the name of this node. Raises hou.OperationFailed if the new name contains characters other than letters, numbers, periods, dashes, or underscores. Raises hou.OperationFailed if the node could not be renamed (for example, another node already exists with the name, the node is the root node or top-level manager (e.g. /obj), or the node is inside a locked asset). If the unique_name parameter is set to True, the supplied name may be changed to ensure that it doesn’t match the name of any existing node.

Return the value of the last set of digits inside the node’s name, or 0 if there are no digits.

For example, the result is 102 for a node named geo102, and 34 for a node named light12to34.

Return the full path (i.e. starting with /) of this node in the network.

Return a relative path to another node object from this node.

>>> box1 = hou.node("/obj/box_object1/box1")
>>> sphere1 = hou.node("/obj/sphere_object1/sphere1")
>>> box1.relativePathTo(sphere1)
'../../sphere_object1/sphere1'
>>> hou.node("/obj").relativePathTo(box1)
'box_object1/box1'
>>> box1.relativePathTo(box1)
'.'

Return the node that contains this item.

Note that this method returns None if the item is the root node (i.e. /).

>>> hou.node("/obj/box_object1").parent()
<hou.Node at /obj>
>>> print hou.node("/").parent()
None

Returns the parent network box which contains this item, or None if it is not inside a network box.

Return whether this item is selected.

See also hou.selectedNodes().

Equivalent to calling hou.NetworkMovableItem.isSelected.

Select or deselect this item, optionally deselecting all other selected items in this network. If show_asset_if_selected is True, and this item is a Node, then the panes will show the top-level asset of the selected item instead.

Equivalent to calling hou.NetworkMovableItem.setSelected with default values for all optional parameters.

Return the color of this item’s tile in the network editor.

Sets the color of this item’s tile in the network editor to the given hou.Color.

Returns an integer value that uniquely identifies this item in a given Houdini session. This id is only guaranteed to be unique in a single Houdini process. It is useful as a quick and easy way to save a restore a reference to an item. It is also only unique for a specific item subclass. So there may be a Node with the same session id as a NetworkBox.

See hou.nodeBySessionId() to turn a session id back into a node, or hou.networkBoxBySessionId() to turn a session id back into a network box, or more generally, hou.itemBySessionId() to turn a session id combined with an enum value indicating the item subclass into an item of that type.

Return the position of this item’s tile in the network editor graph as a Vector2. See also move() and setPosition().

Sets the position of this item’s tile in the network editor graph. Raises hou.InvalidInput if the item cannot have the given position.

Moves this item’s tile in the network editor graph by the increments in the given hou.Vector2.

To position a item absolutely, use setPosition().

To get the item’s current graph position, use position().

Raises hou.InvalidInput if the item cannot move to the position specified.

Equivalent to calling hou.NetworkMovableItem.move.

Return the size of this item’s tile in the network editor graph as a Vector2.

Return the node at the given path, or None if no such node exists. If you pass in a relative path (i.e. the path does not start with /), searches are performed relative to this node.

For example, to get the parent node of a node in the variable n, use n.node(".."). To get a child node named geo5, use n.node("geo5"). To get a sibling node named light3, use n.node("../light3").

Note that the return value may be an instance of a subclass of Node. For example, if the node being found is an object node, the return value will be a hou.ObjNode instance.

If the path is an absolute path (i.e. it starts with /), this method is a shortcut for hou.node(node_path). Otherwise, it is a shortcut for hou.node(self.path() + "/" + node_path). See also hou.node().

This is like node() but takes multiple paths and returns multiple Node objects. This is the equivalent of:

nodes = [self.node(path) for path in paths]

Return the network item at the given path, or None if no such item exists. If you pass in a relative path (i.e. the path does not start with /), searches are performed relative to this node.

If the path is an absolute path (i.e. it starts with /), this method is a shortcut for hou.item(node_path). Otherwise, it is a shortcut for hou.item(self.path() + "/" + item_path). See also hou.item().

Note that the return value may be an instance of a subclass of NetworkMovableItem. For example, if the item being found is an object node, the return value will be a hou.ObjNode instance. If the item is a network box, the return value will be a hou.NetworkBox instance.

This is like item() but takes multiple paths and returns multiple NetworkMovableItem objects. This is the equivalent of:

items = [self.item(path) for path in paths]

Return True if this node is a network, in other words a node that may contain child nodes. Otherwise return False which indicates that several other methods such as hou.Node.createNode will raise hou.OperationFailed if they are called.

If this node is not an HDA and not inside an HDA, this method returns True.

If this node is an HDA node, returns True if the node is unlocked, False if it is locked (this is equivalent to not node.matchesCurrentDefinition()).

If this node is inside a locked HDA node, this method returns True if this node is or is inside an editable subnet within the locked HDA. Otherwise it returns False.

This method reflects the ability of certain types of modifications to be made to the children of this node. These modifications, such as wiring nodes together, or setting flags are edits to the child nodes which also affect the behavior of the parent or surrounding nodes. For example, to determine if a node can have its display flag turned on, you would test node.parent().isEditable(). For modifications to a node that are purely internal to the node itself, such as modifying a parameter value, you should test if node.isEditableInsideLockedHDA().

Return a list of nodes that are children of this node. Using the file system analogy, a node’s children are like the contents of a folder/directory.

To find the number of children nodes, use len(node.children()).

The order of the children in the result is the same as the user defined ordering in Houdini. To see this order, switch the network view pane into list mode, and ensure that the list order is set to user defined. To reorder nodes, drag and drop them in the list.

def pc(node):
    '''Print the names of the children of a particular node.  This function
       can be handy when working interactively in the Python shell.'''
    for child in node.children():
        print child.name()

def ls():
    '''Print the names of the nodes under the current node.'''
    pc(hou.pwd())

The following expression evaluates to a list of children of a particular node type:

[c for c in node.children() if c.type() == node_type]

Return a tuple containing all the children of this node. Unlike children, this method will also return hou.NetworkBox, hou.SubnetIndirectInput, hou.StickyNote, and hou.NetworkDot objects.

Recursively return all sub children of this node. For example, hou.node("/").allSubChildren() will return all the nodes in the hip file.

Note that a tuple is returned, not a generator. This means that it is safe to delete or create nodes while looping through the return value.

The following function deletes all children of a particular type that appear anywhere inside a given node:

def removeSubChildrenOfType(node, node_type):
    '''Recursively delete all children of a particular type.'''
    for child in node.allSubChildren():
        if child.type() == node_type:
            child.destroy()

This code, for example, removes all the visibility SOPs anywhere under /obj:

>>> removeSubChildrenOfType(hou.node("/obj"), hou.sopNodeTypeCategory().nodeTypes()['visibility'])

Recursively return all sub items (nodes, network boxes, sticky notes, etc.) in this node. For example, hou.node("/").allSubItems() will return all the node network items in the hip file.

Refer to hou.Node.allSubChildren for more information on the method parameters.

Recursively return a sequence of all nodes contained in this node including this node. This method differs from hou.Node.allSubChildren in the following ways:

• It includes this node in the returned sequence.

• It does not guarantee a top-down or bottom-up traversal order.

• The method is a generator and does not return a tuple so it is not safe to create or delete nodes while looping through the return value.

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

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

Return a tuple of children nodes name matches 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 nodes 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 names. It does not apply when matching group, network box or bundle names.

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

>>> obj = hou.node("/obj")
>>> obj.createNode("geo", "geo1")
<hou.ObjNode of type geo at /obj/geo1>
>>> obj.createNode("geo", "geo2")
<hou.ObjNode of type geo at /obj/geo2>
>>> obj.createNode("geo", "grid")
<hou.ObjNode of type geo at /obj/grid>
>>> obj.createNode("geo", "garbage")
<hou.ObjNode of type geo at /obj/garbage>
>>> obj.createNode("geo", "box")
<hou.ObjNode of type geo at /obj/box>

>>> def names(nodes):
... return [node.name() for node in nodes]

>>> names(obj.glob("g*"))
['geo1', 'geo2', 'grid', 'garbage']
>>> names(obj.glob("ge* ga*"))
['geo1', 'geo2', 'garbage']
>>> names(obj.glob("g* ^ga*"))
['geo1', 'geo2', 'grid']

See also hou.Node.recursiveGlob.

Like hou.Node.glob, return a tuple of children nodes whose name matches the pattern. However, any matching child will have all its children added, recursively. As well, the result may be filtered by node type.

Houdini first matches children nodes against the pattern, then recursively adds the subchildren of matching children, and then applies the filter.

The pattern and filter behavior is very similar to that used by node bundles in Houdini. See hou.NodeBundle for more information.

Raises hou.OperationFailed if the pattern is invalid.

Create a new node of type node_type_name as a child of this node.

Raises hou.OperationFailed if the given node name is invalid and force_valid_node_name is False. Raises hou.OperationFailed if this node cannot contain children. Raises hou.PermissionError if this node is inside a locked asset.

>>> obj = hou.node("/obj")

# Let Houdini choose a name based on the node type name.
>>> obj.createNode("geo")
<hou.ObjNode of type geo at /obj/geo1>

# Let Houdini choose a unique name.
>>> obj.createNode("geo")
<hou.ObjNode of type geo at /obj/geo2>

# Give the node a specific name.
>>> obj.createNode("geo", "foo")
<hou.ObjNode of type geo at /obj/foo>

# Let Houdini create a unique name from our suggested name.  Also, don't
# run the geometry object init scripts so the contents are empty.
>>> obj.createNode("geo", "geo1", run_init_scripts=False)
<hou.ObjNode of type geo at /obj/geo3>
>>> obj.node("geo1").children()
(<hou.SopNode of type file at /obj/geo1/file1>,)
>>> obj.node("geo3").children()
()

Delete this node.

If you call methods on a Node instance after it has been destroyed, Houdini will raise hou.ObjectWasDeleted.

Raises hou.OperationFailed if you try to delete a node inside a locked asset.

When disable_safety_checks is True, this disables safety checks that might otherwise crash Houdini when this method is called while nodes are cooking.

Create copies of all specified items in this network. The items do not need to be children of this network, but all items must be contained in the same parent network.

If channel_reference_originals is True, the parameters of all new nodes are set to channel reference the original nodes. If a copied node is a sub-network, only the top level node establishes channel references to the original. Child nodes inside the sub-network will be simple copies of the original child nodes. The relative_references parameter controls whether the channel references use relative or absolute paths to the source nodes.

If connect_outputs_to_multi_inputs is True, and any items being copied have outputs connected to a multi-input node (like a Merge), then the new item copies will also be connected to the multi-input node. Normally copied nodes do not have any outputs to nodes outside the copied set.

Returns a tuple of all the new network items.

Raises hou.OperationFailed if this node cannot contain children. Raises hou.PermissionError if this node is inside a locked asset.

Destroys all the items in the provided tuple of hou.NetworkMovableItem objects. This is significantly more efficient than looping over the items and calling destroy() on each one. It also safely handles cases where one object may not be allowed to be deleted unless another object is also deleted.

Raises hou.OperationFailed if one or more of the provided items is not a child of this node. Raises hou.PermissionError if this node is or is inside a locked digital asset.

When disable_safety_checks is True, this disables safety checks that might otherwise crash Houdini when this method is called while nodes are cooking.

Return True if hou.Node.createDigitalAsset can succeed.

Return a boolean to indicate of the node is the last selected node in its network.

Each network (i.e. node containing children) stores its own list of selected nodes, and the last selected node has special meaning. For example, it is the node displayed in unpinned parameter panes.

See also hou.selectedNodes() to get a tuple of all the selected nodes in all networks in Houdini. The last node in this list also has special meaning in Houdini, and corresponds to the global current node.

Set or unset this node as the last selected one.

Each network (i.e. node containing children) stores its own list of selected nodes, and the last selected node has special meaning. For example, it is the node displayed in unpinned parameter panes.

If on is True, this node will become the last selected node. If it is False and this node was the last selected one, it will be unselected and the second-last selected node will become the last selected node.

If clear_all_selected is true, Houdini will unselect every node in this network before performing the operation.

See also hou.Node.setSelected and hou.selectedNodes().

Return a tuple containing the children of this node that are selected. Note that the last selected node has special meaning, and can also be retrieved with hou.Node.isCurrent.

The following example will print the names of all selected objects in /obj:

for n in hou.node("/obj").selectedChildren():
    print n.name()

To find the total number of selected children nodes, use len(node.selectedChildren()).

Return a tuple containing the children of this node that are selected. Unlike selectedChildren, this method will also return any selected hou.NetworkBox, hou.SubnetIndirectInput, hou.StickyNote, and hou.NetworkDot objects.

The following example will print the positions of all selected items in /obj:

for n in hou.node("/obj").selectedItems():
    print n.position()

Return the number of children of this node that are selected and are of the type specified by item_type.

Return the hou.NodeType object for this node.

For example, all camera node instances share the same node type.

Return the hou.NodeTypeCategory corresponding to the children of this node. For example, if this node is a geometry object, the children are SOPs. If it is an object subnet, the children are objects.

Return a tuple of the nodes connected to this node’s inputs. If an input is connected to a hou.SubnetIndirectInput, the node connected to the corresponding input on the parent subnet is returned. In other words the presence of the indirect input is hidden. This means the resulting nodes may not all be siblings of the calling node.

If a particular input is not connected (or is connected to an indirect input and the corresponding subnet parent input is not connected), a None value is placed in the tuple at that location.

Return the node connected to specified input of this node. If an input is connected to a hou.SubnetIndirectInput, the node connected to the corresponding input on the parent subnet is returned. In other words the presence of the indirect input is hidden. This means the resulting nodes may not all be siblings of the calling node.

If the input is not connected (or is connected to an indirect input and the corresponding subnet parent input is not connected), a None value is returned.

Return the node connected to specified input of this node. If an input is connected to a hou.SubnetIndirectInput, the node connected to the corresponding input on the parent subnet is returned. In other words the presence of the indirect input is hidden. This means the resulting nodes may not all be siblings of the calling node.

In addition, if the input is connected to a non-primary output in SOPs, the returned node will be the node inside of the SOP network rather than the subnet itself. This can be used for code that doesn’t understand multiple outputs as it will attempt to resolve the node whose first output matches the input of this node.

If the input is not connected (or is connected to an indirect input and the corresponding subnet parent input is not connected), a None value is returned.

Return a tuple of the nodes connected to this node’s outputs.

This method is a shortcut for [connection.outputNode() for connection in self.outputConnections()].

Returns a tuple of hou.NodeConnection objects for the connections coming into the top of this node. The tuple will have a length equal to the number of connections coming into the node. Returns an empty tuple if nothing is connected to this node.

To get a list of the connected nodes themselves, use hou.Node.inputs. To get a list of all possible connection sites (whether or not anything is connected to them), use hou.Node.inputConnectors.

>>> cookie = hou.node("/obj").createNode("geo").createNode("cookie")
>>> cookie.setInput(1, cookie.parent().createNode("box"))
>>> cookie.inputConnections()
(<hou.NodeConnection from grid1 output 0 to cookie input 1>,)
>>> cookie.inputConnectors()
((), (<hou.NodeConnection from grid1 output 0 to cookie input 1>,))

See also hou.Node.inputConnectors.

Return a tuple of NodeConnection objects for the connections going out of the bottom of this node. If nothing is wired into the output of this node, return an empty tuple.

To get a list of the connected nodes themselves, use hou.Node.outputs.

Note that this method is a shortcut for: reduce(lambda a, b: a+b, self.outputConnectors(), ()). Since most nodes have only one output connector, though, this method is usually equivalent to self.outputConnectors()[0].

>>> box = hou.node("/obj").createNode("geo").createNode("box")
>>> box.parent().createNode("xform").setFirstInput(box)
>>> box.parent().createNode("subdivide").setFirstInput(box)
>>> box.outputConnections()
(<hou.NodeConnection from box1 output 0 to xform1 output 0>, <hou.NodeConnection from box1 output 0 to subdivide1 input 0>)

See also hou.node.outputConnectors.

Return a tuple of tuples of hou.NodeConnection objects. The length of the result tuple is equal to the maximum number of inputs that can be connected to this node. Each subtuple contains exactly one node connection if something is wired into the connector; otherwise it is the empty tuple.

See also hou.NodeConnection and hou.Node.inputConnections.

Return a tuple of tuples of hou.NodeConnection objects. The length of the result tuple is equal to the number of output connectors on this node. Each subtuple contains all the connections going out of that connector, and is empty if nothing is wired to that connector.

>>> split = hou.node("/obj").createNode("dopnet").createNode("split")
>>> split.parent().createNode("rbdsolver").setFirstInput(split)
>>> split.parent().createNode("gravity").setFirstInput(split, 1)
>>> split.parent().createNode("merge").setFirstInput(split, 1)
>>> split.outputConnectors()
((<hou.NodeConnection from split1 output 0 to rbdsolver1 input 0>,), (<hou.NodeConnection from split1 output 1 to gravity2 input 0>, <hou.NodeConnection from split1 output 1 to merge1 input 0>), (), ())

See also hou.NodeConnection and hou.Node.outputConnections.

Return the hou.SubnetIndirectInput objects of a subnet.

Raises hou.InvalidNodeType if this node is not a subnetwork.

Return the child output nodes of a subnetwork.

Certain networks, such as SOPs, have special Output nodes to override the canonical Display or Render nodes and allow multiple outputs. If any output nodes are present, this returns a list of those nodes. If no output nodes are present, either the display or render node is returned depending on if the target of cooking is the display or an output driver. If the node has no children, an empty list is returned.

Return a tuple of all input ancestors of this node. If include_ref_inputs is False, then reference inputs are not traversed. If follow_subnets is True, then instead of treating subnetwork nodes as a single node, we also traverse its children starting with its display node. If only_used_inputs is True, we only traverse nodes that were involved in the last cook.

See also the inputs() method.

Obtains an index of a node input that has the given name.

For the node categories that use input names, it returns the index of the input with the given name. For VOP nodes, the name may also be a node parameter name that has a corresponding input.

Obtains an index of a node output that has the given name.

For the node categories that use input names, it returns the index of the output with the given name.

If item_to_become_input is not None, connect the output connector of another node to an input connector of this node. Otherwise, disconnect anything connected to the input connector.

Raises hou.InvalidInput if output_index is invalid. Raises hou.OperationFailed if item_to_become_input is not in the same network as this node. Raises hou.PermissionError if the node is inside a locked asset.

Connects an input on this node, specified by input_name, to an output on the item_to_become_input, specified by either an output name or an an output index.

A shortcut for self.setInput(0, item_to_become_input). See hou.Node.setInput for more information.

Connect the output connector from another node into the first unconnected input connector or a multi-input connector of this node. If a node has some ordered inputs followed by a multi-input connector, the unordered_only parameter can be used to force the input to connect to the unordered multi-input connection instead of any of the ordered input which may not be connected.

This method is roughly equivalent to:

for input_index, connectors in enumerate(self.inputConnectors()):
    if len(connectors) == 0:
        self.setInput(input_index, item_to_become_input, output_index)
    raise hou.InvalidInput("All inputs are connected")

Raises hou.InvalidInput if all inputs are connected. See hou.Node.setInput for more information.

Insert an input wire. In other words, for each input connector after input_index, shift the contents of that input connector to the next one, and then call hou.Node.setInput. See hou.Node.setInput for the meanings of the parameters.

Some nodes can have a small number of dedicated inputs with specific meanings, followed by an arbitrary number of additional inputs, where gaps are not permitted between the inputs (these are referred to as unordered inputs). This is common in DOP nodes such as the Multiple Solver DOP. This function returns the number of dedicated (or ordered) inputs that occur before the unordered inputs begin. This function will only return non-zero values if the hou.NodeType.hasUnorderedInputs function for this node’s hou.Node.type object returns True.

Create a new node and connect it to one of this node’s inputs. Return the new node.

See also the createOutputNode method.

Create a new node and connect its first input to this node’s (first) output. Return the new node.

See the createNode method for more information on the parameters.

See also the createInputNode method.

Returns a tuple of all input names for this node. Names for input connectors that are hidden are also included.

Returns a tuple of all input labels for this node. Labels for input connectors that are hidden are also included.

Returns a tuple of all output names for this node.

Returns a tuple of all output labels for this node.

Return a dictionary of the string key/value pairs associated with the specified input index. The purpose of these strings may vary from one node type to another.

This method will raise an exception if the node type does not use this feature. Use hasEditableInputData to determine if a node type supports editable input data.

Return the string associated with the specified input index and key. The purpose of this string may vary from one node type to another.

This method will raise an exception if the node type does not use this feature. Use hasEditableInputData to determine if a node type supports editable input data.

Sets a string value associated with the specified input index and key. The purpose of this string may vary from one node type to another.

This method will raise an exception if the node type does not use this feature. Use hasEditableInputData to determine if a node type supports editable input data.

Return True if the node is a sub-network and False otherwise.

Given a sequence of children nodes of this node, collapse them into a subnetwork. In other words, create a subnet inside this node’s network and move the specified children of this network inside that subnet.

Raises hou.OperationFailed if a node inside child_nodes is not a child of this network, or if child_nodes is an empty sequence.

This example function takes a single node and replaces it with a subnet, moving the node into the subnet..

def collapseSingleNodeIntoSubnet(node, subnet_name=None):
    node.parent().collapseIntoSubnet((node,), subnet_name=None)

Move the children of this subnet node to become siblings of this node, and then delete this node. The method is the opposite of collapseIntoSubnet(). Returns a tuple containing all extracted items.

Raises hou.InvalidNodeType if this node is not a subnetwork.

Return the node’s comment string.

Sets the comment associated with this node. See also appendComment().

Appends the given text to the comment associated with this node.

Return a boolean to indicate of the node should display its descriptive name in the network editor.

Set or unset whether this node should display its descriptive name in the network editor.

Returns the first parent of different type from this node. For simple networks this will be the same as parent(), but if the parent is the same node type, eg, both are SOPs, the process is repeated until a different type is found. This is useful for finding the container node, for example, the Object that a SOP is in, without having to worry about nested SOP networks. Note that SOPs do not always have Objects as parents, however!

Moves a node to a well-spaced position near its inputs or outputs and returns the new position of the node.

Automatically position all or some children of this node in the network editor.

Return whether the node is hidden in the network editor. Note that Houdini also uses the term “exposed” to refer to nodes that are not hidden.

If a visible node is connected to a hidden node, the network editor will display dashed lines for the wire going from the visible node to the hidden node.

See also hou.Node.hide.

Hide or show a node in the network editor. See hou.Node.isHidden for more information about hidden nodes.

Return the text of any errors from the last cook of this node, or an empty tuple if there were no errors.

Return the text of any warnings from the last cook of this node, or an empty tuple if there were no warnings.

Return the text of any messages from the last cook of this node, or an empty tuple if there were no messages.

Return a list of the network boxes inside this node.

Return a generator that iterates through all the network boxes inside this node.

Return a network box with the given name inside this node, or None if no network box with the given name exists.

Return a list of network boxes inside this node whose names match a pattern.

Creates a network box inside this network. Raises hou.OperationFailed if this node is not a network.

If you don’t specify a name, Houdini gives the box a default name.

Network box names are not displayed in the network editor pane. Instead, a “comment” can be specified with the hou.NetworkBox.setComment method, and this comment will appear in the title bar of the network box.

Copies a network box and returns the copy.

If new_name is given, the network box will be copied to a new network box named new_name (a different name will be generated if there is already a network box with that name).

If channel_reference_original is True, all operators created by the copy will have their animatable parameters set to reference the original operators.

Raises hou.OperationFailed if this node is not a network or if the node child type does not match the network box’s node type.

Return a list of the sticky notes inside this node.

Return a generator that iterates through all the sticky notes inside this node.

Return a sticky note with the given name inside this node, or None if no sticky note with the given name exists.

Return a list of sticky notes inside this node whose names match a pattern.

Creates a sticky note inside this network. Raises hou.OperationFailed if this node is not a network.

If you don’t specify a name, Houdini gives the note a default name.

Copies a sticky note and returns the copy.

If new_name is given, the sticky note will be copied to a new sticky note named new_name (a different name will be generated if there is already a sticky note with that name).

Raises hou.OperationFailed if this node is not a network or if the node child type does not match the sticky note’s node type.

Creates a network dot inside this network. Raises hou.OperationFailed if this node is not a network.

Returns a tuple of all dots in this network.

Given a sequence of child items (nodes, network boxes, sticky notes, etc), save them to the clipboard so they can be pasted into this or another network.

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

Load the contents of a file saved with hou.Node.copyItemsToClipboard into the contents of this node. If the position parameter is given as a tuple of two float values (or equivalent, like a hou.Vector2), the pasted items are moved such that they are centered around the provided position.

Raises hou.OperationFailed if this node is not a network, or if there are errors loading the items from the clipboard. Raises hou.PermissionError if this node is a locked instance of a digital asset.

Implements == between Node objects.

For example, hou.root() == hou.node(“/”) will return True.

There can be multiple Python Node objects for the same Houdini node. Two identical calls to hou.node() will return different Python Node objects, with each representing the same Houdini node. Comparing these nodes using == (which calls __eq__) will return True, while comparing them using is (the object identity test) will return False.

Implements != between Node objects. See __eq__().

Add/set a named string on this node instance.

This name/value pair is stored with the hip file and is included in the output from opscript and hou.Node.asCode.

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

>>> n = hou.node("/obj").createNode("geo")
>>> n.setUserData("my data", "my data value")
>>> n.userData("my data")
'my data value'
>>> n.userDataDict()
{'my data': 'my data value'}
>>> n.destroyUserData("my data")
>>> n.userDataDict()
{}
>>> print n.userData("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.setUserData for more information.

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

See hou.Node.setUserData for more information.

This method can be implemented as follows:

def userData(self, name):
    return self.userDataDict().get(name)

Remove the user-defined data with this name.

See hou.Node.setUserData for more information.

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

Remove all user-defined data.

See hou.Node.setUserData for more information.

Return True if the specified flag is readable and False otherwise.

flag must be a hou.nodeFlag value.

Return True if the specified flag is writable and False otherwise.

flag must be a hou.nodeFlag value.

Returns the value of the specific flag.

flag must be a hou.nodeFlag value.

Sets the value of the specified flag based on the bool value argument.

flag must be a hou.nodeFlag value.

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.

Returns the duration of the node’s last cook in milliseconds.

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.

Returns a dictionary of context options that were set during the most recent cook of this node. Setting only_used_options to True restricts the returned context option values to those that were actually used while cooking the node (or its inputs).

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

Add an info message badge to the node

Add a warning badge to the node

Add an error badge to the node

Returns a sequence of tuples representing each connected input of this node, where each tuple has three items:

• A hou.OpNode instance representing the node connected to this input.

• An int representing the index (or a string representing the internal name, depending on the use_names argument) of the upstream node’s output that is connected to this input.

• An int representing the index (or a string representing the internal name, depending on the use_names argument) of this input.

Returns a sequence of tuples representing each connected output of this node, where each tuple has three items:

• A hou.OpNode instance representing the node connected to this output.

• An int representing the index (or a string representing the internal name, depending on the use_names argument) of the output.

• An int representing the index (or a string representing the internal name, depending on the use_names argument) of the downstream node’s input that is connected to this input.

Returns a JSON-like data structure representing this node.

Updates the parameters, options, and contents of this node from data, as returned by OpNode.asData().

Returns a JSON-like data strcture representing this node’s parameters.

Updates the parameters on this node from data, as returned by OpNode.parmsAsData().

Returns a JSON-like data strcture representing the contents of this node.

Replaces or updates the content of this node using data, as returned by OpNode.childrenAsData().

Returns a JSON-like data structure representing the contents of any editable dive targets inside this node.

Replaces or updates the content of any editable dive targets inside this node using data, as returned by OpNode.childrenAsData().

Create the network items represented by data as “decorations” with this node as the target. See decoration recipes for more information.

Returns a JSON-like data structure representing the parameter template group of this node.

Creates spare parameters from the data (as returned by OpNode.parmTemplatesAsData()), and adds them to this node’s parameter template group, after existing parameters.

Creates spare parameters from the data (as returned by OpNode.parmTemplatesAsData()), and replaces any existing parameters with the same names on this node.

Creates spare parameters from the data (as returned by OpNode.parmTemplatesAsData()), and inserts them before the parameter named ‹parm_name›.

Creates spare parameters from the data (as returned by OpNode.parmTemplatesAsData()), and inserts them after the parameter named ‹parm_name›.

Creates spare parameters from the data (as returned by OpNode.parmTemplatesAsData()), and inserts at the start of the folder named ‹parm_name›.

Creates spare parameters from the data (as returned by OpNode.parmTemplatesAsData()), and inserts at the start of the folder named ‹parm_name›.

Returns a JSON-like data structure representing this node’s input connections.

Creates input wires on this node from data, as returned by OpNode.inputsAsData().

Returns a JSON-like data structure representing this node’s output connections.

Creates output wires on this node from data, as returned by OpNode.inputsAsData().