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.