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

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 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 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()
()

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.

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.

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.

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.

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.

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.

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

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})

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.

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()

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.

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 a tuple of the nodes connected to this node’s outputs.

This method is a shortcut for [connection.inputNode() 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 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 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.

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 output on this node (specified by either an output name or an output index) to the input on the item_to_become_input specified by input_name.

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, conectors 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 unordere 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 valus 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 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.

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 True if hou.Node.createDigitalAsset() can succeed.

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

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 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 True if the node is an editable node contained inside a locked HDA node and False otherwise. In particular this function will return False for a node that is not inside a locked HDA.

Return True if the node is editable. This is similar to the hou.Node.isEditableInsideLockedHDA() method except that it will return True for nodes that are not inside a locked HDA. This function is the simplest way to determine if most node modifications (changing inputs, changing parameters, changing flags) will be allowed on the node.

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

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

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.

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.

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.

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.

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.

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.

Setting verbose to True will cause some additional information to be generated. In particular data that is expensive to calculate, or which will generate a large amount of information tends to be generated only if this option is turned on.

Setting debug to True will, in a few cases, cause additional information to be displayed which generally will be most useful when debugging the internal opreation of Houdini. For example, geometry attributes will display their "data ids", which can be helpful when tracking down errors in SOPs written with the HDK.

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.

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")

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.

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

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.

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.

Prints the Python code necessary to recreate a node.

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__().

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.

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

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.

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.

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.