Return the node type defined by this digital asset. Raises hou.OperationFailed if the digital asset is not installed.

Return the node type category (e.g. Objects, SOPs, DOPs, etc.) for the node type defined by this digital asset. See hou.NodeTypeCategory for more information.

It is safe to call this method if the digital asset is not installed. If the digital asset is installed, this method is equivalent to self.nodeType().category().

Return the name of the node type defined by this digital asset. Raises hou.OperationFailed if the digital asset is not installed.

If the digital asset is installed, this method is a shortcut for self.nodeType().name().

Return the path to the hda file containing the digital asset’s definition.

Note that it is possible to save an asset with a hip file, without storing it in an hda file. In this case, this method returns "Embedded".

Return whether this definition is installed in Houdini.

It is possible to access HDADefinition objects in hda files that are not installed with hou.hda.definitionsInFile().

See also hou.hda.installFile().

Update and save the definition to match the contents of a given unlocked instance of the asset. Calling this method is the same as selecting Save Operator Type on the node’s menu.

def saveUnlockedNodes():
    '''Look through all the nodes in the file for unlocked digital asset
       instances and save and lock them.'''
    for node in hou.node("/").allSubChildren():
        if node.type().definition() is None or node.matchesCurrentDefinition():
            continue

        node.type().definition().updateFromNode(node)
        node.matchCurrentDefinition()

Save the definition into an hda file.

See also hou.HDADefinition.updateFromNode() for a way to save an unlocked node’s definition to the current hda file. See also hou.HDADefinition.copyToHDAFile().

Copy this definition into an hda file.

Return the user-defined version string. By default, the version is an empty string. It is up to you how you use this version information; it is passed to the Sync Node Version event handler script for performing parameter upgrades.

Set the user-defined version string. See hou.HDADefinition.version() for more information.

Return the user-defined comment string. It is up to you how you use the comment; it is not used by Houdini.

Set the user-defined comment. See hou.HDADefinition.comment() for more information.

Return the description for this definition’s node type. Houdini uses this description for user interface elements such as the TAB menu. This description is also called the operator label in Houdini.

See also hou.NodeType.description().

Set the description for this definition’s node type. Houdini uses this description for user interface elements such as the TAB menu. This description is also called the operator label in Houdini.

See also hou.HDADefinition.description() and hou.NodeType.description().

Return the name or path of the icon for this definition’s node type. Note that Houdini uses its search path to locate icons, so you do not need to pass in a full path.

See also hou.NodeType.icon().

Set the icon for this definition’s node type. See hou.HDADefinition.icon() for more information.

Return the time when the definition was last modified. This time is returned as a POSIX timestamp, such as is returned by time.time().

>>> import time
>>> time.ctime(hou.nodeType(hou.objNodeTypeCategory(), "toon_character").
...     definition().modificationTime())
'Thu Nov  6 18:22:38 2008'

Set the modification time for the definition to the given POSIX timestamp. If the time parameter is negative, uses the current time.

See also hou.HDADefinition.modificationTime().

Return whether this definition is the one currently in use by Houdini.

This example shows how you can access other definitions for the same node type:

def otherDefinitions(definition):
    '''Given an HDADefinition object, return the other loaded definitions
       for the same node type.'''
    # Look through all the loaded hda files for definitions providing
    # the same node type.
    result = []
    for hda_file in hou.hda.loadedFiles():
        # Skip the hda file containing the definition that was passed in.
        if hda_file == definition.libraryFilePath():
            continue

        for other_definition in hou.hda.definitionsInFile(hda_file):
            if other_definition.nodeType() == definition.nodeType():
                result.append(other_definition)
    return result

# Print the paths to hda files providing other definitions for a digital asset instance.
>>> for other_definition in otherDefinitions(hou.node("/obj/my_hda1").type().definition()):
...     print other_definition.libraryFilePath()
/path/to/file1.hda
/path/to/file2.hda

Return whether this definition is preferred.

After loading hda files, Houdini uses a set of rules to resolve conflicts when it encounters multiple definitions for the same node type (e.g. preferring the most recent hda file, preferring definitions embedded in the hip file, etc.). When these rules do not use the definition you want, you can override them by explicitly marking a definition as preferred. Houdini saves this list of preferred definitions with the hip file. Marking a definition as not preferred will remove it from this list, and the normal rules will apply again.

Set whether this definition is preferred. See hou.HDADefinition.isPreferred() for more information.

Return the help text embedded in the digital asset. Return an empty string if no embedded help exists.

Embedded help typically comes from the Help tab of the operator type properties window, but it may also come from a dialog script.

Return a string containing user specified information about the asset definition.

Set user information about the asset definition. This info isn’t used by Houdini so it can contain any text.

Return a hou.HDAOptions object for the options stored in this digital asset. See hou.HDAOptions for more information.

Set this digital asset definition’s options to the data in a hou.HDAOptions object. See hou.HDAOptions for more information.

Return a string storing extra information about the asset definition that isn’t stored elsewhere, like the representative node, guide geometry, whether default parameters are hidden, etc.

See also hou.HDADefinition.representativeNodePath() and hou.HDADefinition.hideDefaultParameters() to more easily retrieve some portions of the extra info.

Set extra information about the asset definition that isn’t stored elsewhere, like the representative node, guide geometry, etc. This string is encoded in a specific format, so it is recommended that you only call this method with values returned from hou.HDADefinition.extraInfo().

Return the contents of the Representative Node field on the Basic tab of the Type Properties dialog.

For object-level digital assets that contain other object nodes, it is possible to make Houdini treat your digital asset like a camera or light by choosing a node inside the asset to represent it. For example, if you choose a camera inside the asset as the representative node, instances of the digital asset will appear in the viewport’s list of camera objects.

Note that this value is also stored in the string returned by hou.HDADefinition.extraInfo().

Uninstall this definition and delete it from the hda file. Any node instances of this asset will warn that they are using an incomplete asset definition.

See also hou.hda.uninstallFile().

Return a dictionary mapping section names to hou.HDASection objects. See hou.HDASection for more information on sections.

Return True if the HDA definition contains a section with the specified name and False otherwise.

See hou.HDASection for more information on sections.

Create a new section with the specified contents. If a section already exists with this name, changes the existing contents to the new contents. Note that the contents may contain binary data. Also note that section names may contain '/'.

You can optionally specify a compression type, hou.compressionType, to compress the contents. Note that you must specify the same compression type when reading the contents back to decompress them.

See hou.HDASection for more information on sections. To remove a section, use hou.HDASection.destroy().

Sections can have associated properties stored in the hou.HDADefinition.extraFileOptions().

def addSectionFromFile(hda_definition, section_name, file_name):
    '''Add a section whose contents come from a file.  If the section
       already exists, replace its contents.'''
    section_file = open(file_name, "r")
    hda_definition.addSection(section_name, section_file.read())
    section_file.close()

Remove an existing section. Only remove sections that you explicitly added. Do not remove the special sections that Houdini uses to store the contents of the digital asset definition, or Houdini will generate errors or strange side effects.

See hou.HDASection for more information on sections. Note that hou.HDASection.destroy() will also remove a section.

Raises hou.OperationFailed if no such section exists in the definition.

Return a dictionary containing the extra options attached to sections in the asset’s definition. For example, event handler scripts such as OnCreated are stored as sections inside the asset, and extra metadata in this dictionary determines whether Houdini runs these scripts as Python as as Hscript.

These is one dictionary for the entire asset, and keys in this dictionary are usually of the form section_name/option_name. For example, if the OnCreated section is marked as containing Python code, this dictionary will contain "OnCreated/IsPython" set to True.

Note that the contents of this dictionary are saved in the ExtraFileOptions section and are encoded in a binary format.

See also hou.HDADefinition.setExtraFileOption() and hou.HDADefinition.removeExtraFileOption().

Set an entry in the dictionary of extra file options. See hou.HDADefinition.extraFileOptions() for more information.

The following example function marks an section, such as OnCreated, as containing Python code:

def markSectionAsPython(definition, section_name):
    definition.setExtraFileOption(section_name + "/IsPython", True)

Remove an entry in the dictionary of extra file options. See hou.HDADefinition.extraFileOptions() for more information.

Raises hou.OperationFailed if there is no entry in the dictionary with this name.

Return a string containing the data of the uncompressed Contents section.

The Contents section consists of data in the CPIO format representing the child nodes used to create a node instance of the HDA.

See also hou.HDADefinition.parsedContents().

Return a list of (name, value) pairs of the parsed from the Contents section.

The Contents section consists of the child nodes used to create a node instance of the HDA.

See also hou.HDADefinition.uncompressedContents().

Return the minimum number of connected inputs that node instances of this digital asset can have. If these inputs are not connected, the node will generate an error.

See also hou.NodeType.minNumInputs().

Set the minimum number of connected inputs that node instances of this digital asset must have. min_num_inputs must be between 0 and 4, inclusive. If a node does not have the minimum number of inputs, it will generate an error.

Return the maximum number of inputs that node instances of this digital asset can have. Return a number greater than 4 if this node type can accept an unlimited number of inputs.

See also hou.NodeType.maxNumInputs().

Set the maximum number of inputs that node instances of this digital asset may have. This number must be greater than or equal to the minimum number of inputs. If it is 5 or greater, Houdini will use a merge SOP-style input connector that allows an unlimited number of inputs. Otherwise, the node will have between 0 and 4 input connectors, each of which may or may not be connected, that correspond to the subnet indirect inputs inside the digital asset.

See hou.Node.inputConnectors() and hou.SubnetIndirectInput for more information on input connectors and subnet indirect inputs.

Return whether the parameters that are common to nodes types in this node type category are hidden or not. For example, nearly all objects have common translation, rotation, scale, etc. parameters, and object level digital assets have these parameters by default. If hidden, though, these parameters are still there but are not displayed to the user.

Note that this value is also stored in the string returned by hou.HDADefinition.extraInfo().

Return the group of parm templates corresponding to this asset definition’s parameter interface.

You can edit the parameter layout for this asset by getting the current parameter group, modifying it, and calling setParmTemplateGroup with it.

See hou.ParmTemplateGroup for more information.

Change the parameters for this digital asset.

parm_template_group: A hou.ParmTemplateGroup object containing the new parameter layout.

This method is preferred over the other parameter-related methods in this class (addParmTuple, removeParmTuple, replaceParmTuple, addParmFolder, removeParmFolder) because it lets you more easily make manipulate parameters. It is also faster when making many parameter changes because the other methods resave the hda file after each change.

See hou.Node.setParmTemplateGroup() to change the parameter interface of an individual node.

Adds a folder to this node type’s parameters.

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 removeParmFolder and addParmTuple methods.

This method is deprecated in favor of setParmTemplateGroup.

Remove an empty folder from this node type’s parameters.

Raises hou.OperationFailed if the folder does not exist or it is not empty. Use hou.HDADefinition.removeParmTuple() to remove all the parameters inside the folder before calling this method.

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

This method is deprecated in favor of hou.HDADefinition.setParmTemplateGroup().

Add a parameter tuple to this node type’s parameters. Houdini places the new parameter at the bottom 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 hou.HDADefinition.replaceParmTuple().

This method is deprecated in favor of hou.HDADefinition.setParmTemplateGroup().

Remove a parameter tuple from this node type’s parameters.

See also hou.HDADefinition.addParmTuple() and hou.HDADefinition.removeParmFolder().

This method is deprecated in favor of hou.HDADefinition.setParmTemplateGroup().

Replace an existing 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 parameter tuple. The following example function changes the definition of the asset to make a parameter tuple visible or invisible in all nodes of that type.

To show or hide a parameter in just one instance of a node, use hou.ParmTuple.hide().

To change a spare parameter on a node, use hou.Node.replaceSpareParmTuple() or hou.Node.setParmTemplateGroup().

This method is deprecated in favor of hou.HDADefinition.setParmTemplateGroup().

This function is deprecated. Compiled VEX code should no longer be stored inside of an HDA.