Create a new group from an optional sequence of parm templates. If none are passed in, the new group will be empty.

Because groups and folder parm templates can both be constructed using a sequence of contained parm templates, it is possible to construct a parm template group with parameters inside folders using a single expression. The following example creates a group with two folders and with parameters inside each of those folders:

>>> group = hou.ParmTemplateGroup((
... hou.FolderParmTemplate("folder", "Physical", (
...     hou.FloatParmTemplate("mass", "Mass", 1),
...     hou.FloatParmTemplate("density", "Density", 1),
... )),
... hou.FolderParmTemplate("folder", "Divisions", (
...     hou.FloatParmTemplate("divisions", "Divisions", 3),
...     hou.ToggleParmTemplate("laser", "Laser Scan", default_value=True),
... )),
... ))
>>> group.entries()
(<hou.FolderParmTemplate name='folder' label='Physical' folder_style=Tabs>,
<hou.FolderParmTemplate name= 'folder' label='Divisions' folder_style=Tabs>)
>>> group.entries()[0].parmTemplates()[0]
<hou.FloatParmTemplate name='mass' label='Mass' length=1 naming_scheme=XYZW look=Regular default_value=(0,)>
>>> group.entriesWithoutFolders()
(<hou.FloatParmTemplate name='mass' label='Mass' length=1 naming_scheme=XYZW look=Regular default_value=(0,)>,
 <hou.FloatParmTemplate name='density' label='Density' length=1 naming_scheme=XYZW look=Regular default_value=(0,)>,
  <hou.FloatParmTemplate name='divisions' label='Divisions' length=3 naming_scheme=XYZW look=Regular default_value=(0,0,0)>,
   <hou.ToggleParmTemplate name='laser' label='Laser Scan' default_value=True>)

Raises hou.OperationFailed if any of the parm templates in the sequence are hou.FolderSetParmTemplate objects.

Search in this group for a parm template whose name matches the specified one. Return a copy of the parm template or None if no match was found.

Note that this function returns a copy of the parm template stored in this group. Modifying the copy will not affect the parameters in this group. The following example shows how to use the find and replace methods to modify the "pos" parm template in the group:

>>> parm_template = group.find("pos")
>>> parm_template.setLabel("Position")
>>> parm_template.replace("pos", parm_template)

If you created the group from existing parameters, folder parm templates in the same folder set will share the same name, so searching for a folder using this method may return the first folder in the folder set. To instead search for a folder by its folder label, use findFolder.

Note that, in general, the group does not prevent you from adding two parameters with the same name. In this case, searching for a parameter with this name will return the first one. Note, though, that when when setting this group to a node or asset definition’s parms, either the duplicate parameters will be renamed on an exception will be raised. See the rename_conflicting_parms parameter to hou.HDADefinition.setParmTemplateGroup() for more information.

Search in this group for a parm template and return a tuple of integers corresponding to the indices of the parm in the group. Return an empty tuple if no match was found.

If the parm template was found and it is not inside any folders, the result tuple will contain a single integer with the index of the parm template. Otherwise, the first entry will be the index of a folder inside the group, the next will be an index of a folder inside that folder, and so on until the last index is an index of a parm template inside a folder.

See also findIndicesForFolder.

Search in this group for a folder parm template with the given label. Return a copy of the hou.FolderParmTemplate or None if the folder wasn’t found.

Note that a folder parm template’s label is what appears in the interface in the parameter dialog. The folder parm template’s name is used to determine the name of the parm tuple for the folder set, if the folder is the first in the folder set. See the documentation for this class for more information.

Search in this group for a folder parm template with the given label. Return an empty tuple if no match was found.

See findFolder for a description of the parameter and findIndices for a description of the return value.

Note that this method does not accept a parm template. However, if you have a folder parm template and want to find its indices, simply call findIndices on the folder parm template.

Given a sequence of integer indices return a copy of the hou.ParmTemplate object at that location. The indices are of the format returned by findIndices.

Like the hou.ParmTemplate.find and hou.ParmTemplate.entries methods, this method returns a copy of the parm template stored inside this group. Modifying the copied parm template will not affect the contents of this group. Use replace to change a parm template.

Raises hou.OperationFailed if the indices are invalid, including when the indices sequence is empty.

This method could be implemented as follows:

def entryAtIndices(self, indices):
    if len(indices) == 0:
        raise hou.OperationFailed("Invalid indices")
    parm_template = self.entries()[indices[0]]

    # If there are multiple indices then we should have just looked up
    # a folder parm template.
    for index in indices[1:]:
        parm_template = parm_template.parmTemplates()[index]
    return parm_template

Return a copy of the hou.FolderParmTemplate in this group containing a parm template.

Raises hou.OperationFailed if the parameter is not inside the group or is not inside a folder.

Return the indices of the folder in this group containing a given parm template. Return an empty tuple if no match was found.

See replace for a description of the parameter and findIndices for a description of the return value.

Raises hou.OperationFailed if the parameter is not inside the group or is not inside a folder.

Return a tuple containing copies of the parm templates inside this group.

Note that folders are returned as hou.FolderParmTemplate objects, and each folder parm template contains the parm templates inside it. Use hou.FolderParmTemplate.parmTemplates() to access the elements in a folder.

The following example creates a function named allParmTemplates that returns a single sequence of parm templates, including folders, for all parm templates in the group:

def allParmTemplates(group_or_folder):
    for parm_template in group_or_folder.parmTemplates():
        yield parm_template

    # Note that we don't want to return parm templates inside multiparm
    # blocks, so we verify that the folder parm template is actually
    # for a folder.
        if (parm_template.type() == hou.parmTemplateType.Folder and
        parm_template.isActualFolder()):
            for sub_parm_template in allParmTemplates(parm_template):
                yield sub_parm_template

See also the parmTemplates method.

This method is simply an alias for the entries method.

It makes it easier to search down through a parm template group for items nested in folders, since the hou.FolderParmTemplate class also has a method named parmTemplates. The following example shows how to look up the labels for a folder parameter given its indices:

def folderLabels(parm_template_group, indices):
    container = parm_template_group
    result = []
    for index in indices:
        container = container.parmTemplates()[index]
        result.append(container.label())
    return result

Return a tuple containing all the non-folder parm templates inside this group. The output is the flattened set of parm templates in the group, and includes the non-folder parms inside folders.

Like entries, this method returns a copy of the parm templates inside this group.

Note that this function does not return parm templates for entries inside multiparm blocks.

Also see the entries method for the example function allParmTemplates.

Replace a parm template inside this group with another parm template.

This method changes the contents of this group. Note that it stores a copy of the parm template in the group, so future changes to the parm template passed in will not affect the group.

See the find method for a simple example of how to use this method.

Note that parm templates for reserved parameters (for example, the transform parameters in object-level digital assets) can be replaced in the parm template group, but all aspects of reserved parameters except for their visibility and join settings will be restored to their defaults when you save this group to a node or asset definition.

Raises hou.OperationFailed if the parm template doesn’t exist.

Insert a parm template inside this group before an existing one. The new parm template will be in the same folder as the existing one.

See replace for a description of the name/parm template/indices parameter.

Use appendToFolder to add an entry to a empty folder. Use append to add an entry to an empty parm template group.

Insert a parm template inside this group after an existing one. The new parm template will be in the same folder as the existing one.

See replace for a description of the name/ parm template/indices parameter.

Use appendToFolder to add an entry to a empty folder. Use append to add an entry to an empty parm template group.

Add a parm template after all existing parm templates, outside of any folder.

See also appendToFolder.

This method is simply an alias for the append method.

It makes it easier to treat parm template groups and hou.FolderParmTemplate objects uniformly, since hou.FolderParmTemplate has an addParmTemplate method.

Add a parm template to the bottom of an existing folder.

Note that you cannot add to a folder by simply looking up the folder parm template and calling hou.FolderParmTemplate.addParmTemplate() on it, because asking for a folder will return a deep copy. The parm templates inside the copied folder will be separate from those inside this group, and modifying the folder will not affect the group. Consider the following example:

>>> folder = group.findFolder("Transform")
# "folder" now has its own copy of the parms inside it.
>>> folder.addParmTemplate(new_parm_template)
# "folder"'s parm templates are updated, but the group's parm templates are
# unchanged.

>>> group.appendToFolder(folder, new_parm_template)
# The group is modified.  "folder"'s contents are unchanged.

Remove a parm template from the group. Note that if you remove a folder, all of the parm templates in the folder are also removed.

See replace for a description of the name/parm template/indices parameter.

Raises hou.OperationFailed if the parm template could not be found.

Hide a parameter by making it invisible. The parameter still exists in the group, but parameter dialogs will not display it.

See replace for a description of the name/parm template/indices parameter.

This method could be implemented as follows:

def hide(self, name_or_parm_template_or_indices, on):
    parm_template = self.find(name_or_parm_template_or_indices)
    parm_template.hide(on)
    self.replace(name_or_parm_template_or_indices, parm_template)

See also hideFolder and hou.ParmTemplate.hide().

Hide a folder and all the parameters in it.

You may pass in either a string containing a single folder name or a sequence of strings to indentify a nested folder. For example, the sequence ("Render", "Dicing") identifies the Dicing folder inside the Render folder. The folder is hidden if on is True and unhidden if it is False.

The following example hides the Transform parameter in a geometry object:

>>> group = geo_node.parmTemplateGroup()
>>> group.hideFolder("Transform", True)
>>> geo_node.setParmTemplateGroup(group)

The following example hides the Dicing folder inside the Render folder on a geometry object:

>>> group = geo_node.parmTemplateGroup()
>>> group.hideFolder(("Render", "Dicing"), True)
>>> geo_node.setParmTemplateGroup(group)

This method could be implemented as follows:

def hideFolder(self, label_or_labels, on):
    self.hide(self.findFolder(label_or_labels), on)

See also hide.

Return whether the given parameter is itself hidden or lies inside a hidden folder.

See replace for a description of the name/parm template/indices parameter.

Note that if the parameter is inside a hidden folder but the parameter is not marked as hidden, calling hou.ParmTemplate.isHidden() on the parm template will return False, while this method will return True.

Return whether a folder or one of its containing folders is hidden.

Note that if a folder is inside a hidden folder but this folder is not marked as hidden, calling hou.ParmTemplate.isHidden() on the folder parm template will return False, while this method will return True.

You may pass in either a string containing a single folder name or a sequence of strings to indentify a nested folder. For example, the sequence ("Render", "Dicing") identifies the Dicing folder inside the Render folder. The folder is hidden if on is True and unhidden if it is False.

Remove all parm templates from this group.

Return a string containing the dialog script file contents corresponding to this parm template group.

Houdini saves parameter definitions in this format when saving digital asset definitions (in the DialogScript section of the digital asset) and when saving parameter layouts of nodes.

The default behaviour for reserved parameters is to output baseparm tokens for reserved parameters so that it is resistant to changes in their definition. To change this, use full_info=True.

Set the contents of this group to match the parameters defined by the given dialog script string.

Raises hou.OperationFailed if there is an error in the dialog script contents.

Return Python code that will recreate this group.

Return the node that the parameter template group was generated from. If the group was not generated from a node, then return None.

Raises hou.ObjectWasDeleted if the source node has been destroyed.

Return the node type that the parameter template group was generated from. If the group was not generated from a node type, then return None.

Raises hou.ObjectWasDeleted if the source node type has been destroyed.