def test_unitConversion(cmds): # pylint: disable=invalid-name
"""
Test we can understand TdataNumeric attributes.
unitConversion nodes are a good case.
"""
cmds.createNode("transform")
cmds.createNode("unitConversion")
cmds.connectAttr("transform1.rotateX", "unitConversion1.input")
cmds.connectAttr("unitConversion1.output", "transform1.translateX")
create_from_nodes(["unitConversion1"], expose=True)
def test_integration(cmds):
"""
Test a complex case where:
- We expose two element attributes from the same array
"""
cmds.createNode("transform", name="inputs1")
cmds.createNode("transform", name="inputs2")
cmds.createNode("plusMinusAverage", name="util")
cmds.createNode("transform", name="outputs")
cmds.connectAttr("inputs1.translate", "util.input3D[0]")
cmds.connectAttr("inputs2.translate", "util.input3D[1]")
cmds.connectAttr("util.output3D", "outputs.translate")
create_from_nodes(["util"], expose=True)
def test_create_from_nodes_nested():
"""Validate we can create compound inside compound from a set of nodes."""
create_from_nodes({"b", "c", "d"}, namespace="namespace_a")
create_from_nodes({"namespace_a:c"}, namespace="namespace_b")
assert _ls() == {
"a",
"namespace_a:inputs",
"namespace_a:b",
"namespace_a:namespace_b:inputs",
"namespace_a:namespace_b:c",
"namespace_a:namespace_b:outputs",
"namespace_a:d",
"namespace_a:outputs",
"e",
}
def test_create_from_nodes_nested_2(scene):
create_from_nodes({"c"}, namespace="namespace_b")
create_from_nodes(
{"b", "namespace_b:c", "namespace_b:inputs", "namespace_b:outputs"},
namespace="namespace_a",
)
assert _ls() == {
"a",
"namespace_a:inputs",
"namespace_a:b",
"namespace_a:namespace_b:inputs",
"namespace_a:namespace_b:c",
"namespace_a:namespace_b:outputs",
"namespace_a:outputs",
"d",
"e",
}
def test_create_from_nodes_namespaces(scene):
cmds.namespace(addNamespace="namespace")
cmds.rename("a", "namespace:a")
cmds.rename("b", "namespace:b")
cmds.rename("c", "namespace:c")
cmds.rename("d", "namespace:d")
cmds.rename("e", "namespace:e")
create_from_nodes({"namespace:c"}, namespace="new_namespace")
assert _ls() == {
"namespace:a",
"namespace:b",
"namespace:new_namespace:inputs",
"namespace:new_namespace:c",
"namespace:new_namespace:outputs",
"namespace:d",
"namespace:e",
}
def test_create_from_nodes_namespaces():
"""Validate we can create a compound from a set of nodes and namespace them."""
cmds.namespace(addNamespace="namespace")
cmds.rename("a", "namespace:a")
cmds.rename("b", "namespace:b")
cmds.rename("c", "namespace:c")
cmds.rename("d", "namespace:d")
cmds.rename("e", "namespace:e")
create_from_nodes({"namespace:c"}, namespace="new_namespace")
assert _ls() == {
"namespace:a",
"namespace:b",
"namespace:new_namespace:inputs",
"namespace:new_namespace:c",
"namespace:new_namespace:outputs",
"namespace:d",
"namespace:e",
}
def test_map_from_nodes_expose_simple(cmds):
cmds.createNode("transform", name="a")
cmds.createNode("transform", name="b")
cmds.createNode("transform", name="c")
cmds.connectAttr("a.translateX", "b.translateX")
cmds.connectAttr("b.translateY", "c.translateY")
create_from_nodes(["b"], expose=True)
assert _ls() == {
"a", "compound1:inputs", "compound1:b", "compound1:outputs", "c"
}
for src, dst in (
("a.translateX", "compound1:inputs.translateX"),
("compound1:inputs.translateX", "compound1:b.translateX"),
("compound1:b.translateY", "compound1:outputs.translateY"),
("compound1:outputs.translateY", "c.translateY"),
):
assert cmds.isConnected(src, dst)
def test_create_from_nodes_nested_2():
"""
Validate we can create a compound from a set of nodes containing another compound.
"""
create_from_nodes({"c"}, namespace="namespace_b")
create_from_nodes(
{"b", "namespace_b:c", "namespace_b:inputs", "namespace_b:outputs"},
namespace="namespace_a",
)
assert _ls() == {
"a",
"namespace_a:inputs",
"namespace_a:b",
"namespace_a:namespace_b:inputs",
"namespace_a:namespace_b:c",
"namespace_a:namespace_b:outputs",
"namespace_a:outputs",
"d",
"e",
}
def test_map_from_nodes_expose_cyclic(cmds):
""" Validate we ignore connections pointing to nodes in the network."""
cmds.createNode("transform", name="a")
cmds.createNode("transform", name="b")
cmds.createNode("transform", name="c")
cmds.connectAttr("a.translateX", "b.translateX")
cmds.connectAttr("b.translateY", "c.translateY")
cmds.connectAttr("b.rotateX", "b.rotateY")
create_from_nodes(["b"], expose=True)
assert _ls() == {
"a", "compound1:inputs", "compound1:b", "compound1:outputs", "c"
}
for src, dst in (
("a.translateX", "compound1:inputs.translateX"),
("compound1:inputs.translateX", "compound1:b.translateX"),
("compound1:b.translateY", "compound1:outputs.translateY"),
("compound1:outputs.translateY", "c.translateY"),
):
assert cmds.isConnected(src, dst)
def test_create_from_nodes():
"""Validate we can create a compound from a set of nodes."""
compound = create_from_nodes({"b", "c"})
assert isinstance(compound, Compound)
assert _ls() == {
"a",
"compound1:inputs",
"compound1:outputs",
"compound1:b",
"compound1:c",
"d",
"e",
}
def test_create_from_nodes_expose_reused_input_attributes(cmds):
""" Ensure that we re-use an attribute if it is used twice as the network input.
"""
cmds.createNode("transform", name="input1")
cmds.createNode("transform", name="node1")
cmds.createNode("transform", name="node2")
cmds.connectAttr("input1.translateX", "node1.translateX")
cmds.connectAttr("input1.translateX", "node2.translateX")
create_from_nodes({"node1", "node2"},
namespace="test_namespace",
expose=True)
assert _ls() == {
"input1",
"test_namespace:inputs",
"test_namespace:node1",
"test_namespace:node2",
"test_namespace:outputs",
}
assert cmds.listAttr("test_namespace:inputs",
userDefined=True) == ["translateX"]
assert not cmds.listAttr("test_namespace:outputs", userDefined=True)
def test_integration_1(manager):
"""
1) Create a compound
2) Register the compound
3) Modify the compound
4) Register a new version of the compound
5) Rollback to the previous version
6) Update to latest
"""
def _test_compound_v1():
"""
Validate the namespace actually contain v1 of our test compound.
:param str namespace: The compound namespace
"""
# Validate internal connections
for src, dst in (
("foo:inputs.input1X", "foo:multiplyDivide1"),
("foo:multiplyDivide1.outputX", "foo:outputs.outputX"),
):
cmds.isConnected(src, dst)
# Validate external connections
for src, dst in (
("testInn.translateX", "foo:inputs.input1X"),
("foo:outputs.outputX", "testOut.translateX"),
):
cmds.isConnected(src, dst)
# Validate scene content
for dagpath in (
"foo:inputs",
"foo:inputs.input1X",
"foo:multiplyDivide1",
"foo:outputs",
"foo:outputs.outputX",
):
assert cmds.objExists(dagpath)
for dagpath in ("foo:outputs.outputY", ):
assert not cmds.objExists(dagpath)
def _test_compound_v2():
for dagpath in (
"foo:inputs",
"foo:inputs.input1X",
"foo:multiplyDivide1",
"foo:outputs",
"foo:outputs.outputX",
"foo:outputs.outputY",
):
assert cmds.objExists(dagpath)
# 1) Create a simple network
mult1 = pymel.createNode("multiplyDivide")
# Create a compound from the network
compound = create_from_nodes([mult1], namespace="foo")
attr = mult1.input1X
compound.expose_input_attr(attr)
compound.expose_output_attr(mult1.outputX)
# Create connections from outside the compound
cmds.createNode("transform", name="testInn")
cmds.createNode("transform", name="testOut")
cmds.connectAttr("testInn.translateX", "foo:inputs.input1X")
cmds.connectAttr("foo:outputs.outputX", "testOut.translateX")
_test_compound_v1()
# Register the compound?
compound_def_1 = CompoundDefinition(name="compound_name",
version="1.0.0",
uid="compound_uid")
compound.set_metadata(dict(compound_def_1))
manager.publish_compound(compound)
# Modify the scene content
compound.expose_output_attr(mult1.outputY)
_test_compound_v2()
# TODO: Error if the file does not end with .ma?
compound_def_2 = CompoundDefinition(name="compound_name",
version="1.0.1",
uid="compound_uid")
compound.set_metadata(dict(compound_def_2))
manager.publish_compound(compound)
cmds.connectAttr("foo:outputs.outputY", "testOut.translateY")
# Downgrade our compound
manager.update_compound(compound, "1.0.0")
_test_compound_v1()
# Upgrade our compound
manager.update_compound(compound)
_test_compound_v2()
# Verify that we can restore our in-memory registry
new_registry = Registry()
new_registry.parse_directory(manager.preferences.compound_location)
assert manager.registry == new_registry