def test_objectExistance( self ): depnode = nt.createNode( "node", "facade" ) assert nt.objExists( str( depnode ) ) # TEST DUPLICATION duplnode = depnode.duplicate( ) assert duplnode.isValid( ) copy2 = depnode.duplicate( "name2" ) assert str( copy2 ) == "name2" # NOTE: currently undo is not opetional dagnode = nt.createNode( "parent|node", "mesh" ) assert nt.objExists( str( dagnode ) ) # must clash with dg node ( in maya, dg nodes will block names of dag node leafs ! ) self.failUnlessRaises( NameError, nt.createNode, "parent|node|node", "mesh", renameOnClash=False ) # same clash occours if dag node exists first dagnode = nt.createNode( "parent|othernode", "transform" ) self.failUnlessRaises( NameError, nt.createNode, "othernode", "facade", renameOnClash=False )
def test_objectExistance(self): depnode = nt.createNode("node", "facade") assert nt.objExists(str(depnode)) # TEST DUPLICATION duplnode = depnode.duplicate() assert duplnode.isValid() copy2 = depnode.duplicate("name2") assert str(copy2) == "name2" # NOTE: currently undo is not opetional dagnode = nt.createNode("parent|node", "mesh") assert nt.objExists(str(dagnode)) # must clash with dg node (in maya, dg nodes will block names of dag node leafs !) self.failUnlessRaises(NameError, nt.createNode, "parent|node|node", "mesh", renameOnClash=False) # same clash occours if dag node exists first dagnode = nt.createNode("parent|othernode", "transform") self.failUnlessRaises(NameError, nt.createNode, "othernode", "facade", renameOnClash=False)
def test_setOperations( self ): """byroniom.maya.nt.sets: unions, intersections, difference, overloaded ops""" memberlist = self._getMemberList( ) s3 = nt.createNode( "anotherObjectSet", "objectSet" ) s = nt.ObjectSet() s.clear() s.addMembers( memberlist ) side = nt.Node( "side" ) s2 = nt.createNode( "memberSet2", "objectSet" ) s2.addMember( side ) # UNION ######## # with set sellist = s.union( s2 ) assert sellist.length() == len( memberlist ) + 1 # with sellist - will create temp set sellist = s.union( s2.members() ) assert sellist.length() == len( memberlist ) + 1 assert not nt.objExists( "set4" ) # tmp set may not exist # with multiple object sets s.union( [ s2, s3 ] ) list( s.iterUnion( s2 ) ) # INTERSECTION ############### fewmembers = memberlist[:3] s2.addMembers( fewmembers ) # add 0 members s2.addMembers( list() ) # with set sellist = s.intersection( s2 ) assert sellist.length() == len( fewmembers ) # with sellist sellist = s.intersection( fewmembers ) assert sellist.length() == len( fewmembers ) # with multi sets s3.addMembers( fewmembers ) sellist = s.intersection( [ s2, s3 ] ) assert sellist.length() == len( fewmembers ) list( s.iterIntersection( s2 ) ) # DIFFERENCE ############# # with set s2.removeMember( side ) sellist = s.difference( s2 ) assert s.members().length() - s2.members().length() == sellist.length() # with objects sellist = s.difference( list( s2.iterMembers() ) ) assert s.members().length() - s2.members().length() == sellist.length() # with sellist sellist = s.difference( s2.members() ) # with multiple sets s3.clear() s3.addMember( nt.Node( "front" ) ) sellist = s.difference( [ s2, s3 ] ) assert len( list( s.iterDifference( [ s2, s3 ] ) ) ) == s.difference( [ s2, s3 ] ).length() assert s.members().length() - s2.members().length() - s3.members().length() == sellist.length()
def test_childEditing(self): base = nt.createNode("basenode", "transform") obase = nt.createNode("otherbasenode", "transform") trans = nt.createNode("trans", "transform") otrans = nt.createNode("parent|trans", "transform") mesh = nt.createNode("meshparent|meshshape", "mesh") curve = nt.createNode("nurbsparent|ncurve", "nurbsCurve") itemlist = [trans, mesh, curve] instlist = list() # MULTIPLE ADDS #################### # Returns the same instance - its what the user wants for item in itemlist: assert item.instanceCount(0) == 1 inst = base.addInstancedChild(item) assert base.addInstancedChild(item) == inst assert item.instanceCount(0) == 2 assert item != inst and inst.isValid() and item.isValid() instlist.append(inst) # UNDO TEST # undo basemesh cmds.undo() assert not inst.isValid() and inst.isAlive() cmds.redo() assert inst.isValid() and inst.isAlive() # END for each object including undo/redo # KEEP PARENT FALSE - USE INSTANCES # TODO: this test needs a redo - the original purpose got lost when # the addChild method has been changed, additionally it needs to be # better documented as this instancing stuff is not easily understood if # one just sees the code for orig,inst in zip(itemlist, instlist): assert orig.object() == inst.object() and orig != inst ninst = obase.addChild(inst, keepExistingParent=False) # # duplicate adds are not problem, but it can't be tested as the inst is already invalid # assert obase.addChild(inst, keepExistingParent=False) == ninst assert not inst.isValid() assert ninst.isValid() and ninst.isAlive() assert orig.isValid() # original may not be influenced by that operation # undo / redo cmds.undo() assert orig.isValid() assert not ninst.isValid() assert inst.isValid() cmds.redo() assert not inst.isValid() and orig.isValid() and ninst.isValid() # END for each instance # RENAME ON CLASH = False self.failUnlessRaises(RuntimeError, obase.addChild, otrans, renameOnClash = False) # RENAME ON CLASH = True otransname = str(otrans) renamedtrans = obase.addChild(otrans, renameOnClash = True) assert renamedtrans.isValid() renamedname = str(renamedtrans) assert renamedname != otransname cmds.undo() assert nt.objExists(otransname) and not nt.objExists(renamedname) cmds.redo()
def test_plugin_handling(self): mrp = "Mayatomr" pp = 'persistence' assert not cmds.pluginInfo(mrp, q=1, loaded=1) assert not hasattr(nt, 'Transmat') cmds.loadPlugin(mrp) # loading a plugin will add the node types assert hasattr(nt, 'Transmat') assert nt.typ.nodeTypeTree.has_node('transmat') tmat = nt.Transmat() # mr dep node tmat.delete() dll = nt.MapVizShape() # mr dag node assert isinstance(dll, nt.DagNode) dll.delete() cmds.flushUndo() # make sure we get rid of the custom data # custom node types are favored and not overwritten by dummies when # loading assert nt.StorageNode is mstorage.StorageNode # custom node types will remain when unloaded cmds.unloadPlugin(pp) assert not cmds.pluginInfo(pp, q=1, loaded=1) assert hasattr(nt, 'StorageNode') # unloading a plugin will remove the nodetypes as well as the hierarchy # entries # NOTE: on OSX unloading the plugin beautifully crashes maya, probably # a memory exception as MR claims to have had a peak memory of 136 GB # As a final goal, this test should be fixed to run here, there # probably is some kind of workaround. # http://tracking.byronimo.de/view.php?id=144 mr_testobj = "contour_composite1" if sys.platform != 'darwin': cmds.unloadPlugin(mrp, force=1) assert not hasattr(nt, 'Transmat') assert not hasattr(nt, 'MapVizShape') assert not nt.typ.nodeTypeTree.has_node('transmat') assert not nt.typ.nodeTypeTree.has_node('mapVizShape') # plugins required by a scene trigger the database to update as well assert not cmds.pluginInfo(mrp, q=1, loaded=1) assert not nt.objExists('transmat1') needs_mr_scene = get_maya_file('needsMayatomr.ma') mrvmaya.Scene.open(needs_mr_scene, force=True) assert hasattr(nt, 'Transmat') assert not nt.objExists(mr_testobj), "object shouldn't exist if it works" # try it during reference and import scenarios mrvmaya.Scene.new(force=True) cmds.unloadPlugin(mrp, force=0) assert not hasattr(nt, 'Transmat') FileReference.create(needs_mr_scene) assert hasattr(nt, 'Transmat'), "Should have triggered the callback" assert not nt.objExists(mr_testobj), "object shouldn't exist if it works" # try import mrvmaya.Scene.new(force=True) cmds.unloadPlugin(mrp, force=0) assert not hasattr(nt, 'Transmat') cmds.file(needs_mr_scene, i=True) assert hasattr(nt, 'Transmat'), "Should have triggered callback by import" assert not nt.objExists(mr_testobj), "object shouldn't exist if it works" # END skip this on osx assert not nt.objExists(mr_testobj) cmds.undoInfo(st=0) mod = api.MDGModifier() mod.createNode('transmat') assert not nt.objExists(mr_testobj), "Shouldn't actually create the object even if undo is off" cmds.undoInfo(st=1) # dynamically added types (which will not trigger a plugin changed event) # can be wrapped as well customMI = get_maya_file('customshader.mi') csn = "testCustomShader" csnc = "TestCustomShader" mrvmaya.Mel.mrFactory('-load',customMI) # it doesnt exist, but can be wrapped nontheless, then it exists assert not hasattr(nt, csnc) cs = nt.Node(cmds.createNode(csn)) assert hasattr(nt, csnc)
def test_wrapDagNode(self): mesh = nt.createNode("parent|mesh", "mesh") parent = mesh.parent() # simple rename mesh.rename("fancymesh") # simple dupl test duplbase = nt.createNode("parent|this|other|duplbase", "mesh") transcopy = duplbase.transform().duplicate() copy = duplbase.duplicate("parent|this|other|duplcopy") assert copy != duplbase assert str(copy) != str(duplbase) assert str(copy) == "|parent|this|other|duplcopy" # TEST ADDITIONAL OPTIONS for i in range(1,3): ocopy = duplbase.duplicate() assert str(ocopy) == str(duplbase) + str(i) ocopy = duplbase.duplicate(newTransform=1) assert ocopy.basename() == duplbase.basename() assert str(ocopy.parent()) == str(duplbase.parent()) + str(i + 1) # undo both duplications and redo # CRASHES MAYA AFTER REDO # and if someone tries to access an object already created #cmds.undo() #cmds.undo() #assert duplbase.isValid() #cmds.redo() #cmds.redo() # END for each copy # simple reparent otherparent = nt.createNode("oparent", "transform") mesh.reparent(otherparent) # REPARENT UNDO TEST cmds.undo() assert mesh.parent() == parent cmds.redo() assert mesh.parent() == otherparent # REPARENT RENAME CLASH origmesh = nt.createNode("parent|fancymesh", "mesh") # "|parent|fancymesh" self.failUnlessRaises(RuntimeError, mesh.reparent, parent , renameOnClash = False) # RENAME CLASH DAG NODE othermesh = nt.createNode("parent|mesh", "mesh") self.failUnlessRaises(RuntimeError, origmesh.rename, "mesh", renameOnClash = False) # now it works othermesh.rename("mesh", renameOnClash = True) assert othermesh.basename() == "mesh" # shape under root self.failUnlessRaises(RuntimeError, mesh.reparent, None) # REPARENT AGAIN # should just work as the endresult is the same mesh.reparent(otherparent) # it will also trigger a new undo event, so undo will react as it should mesh.reparent(otherparent) # "|otherparent|fancymesh" # REPARENT UNDER SELF self.failUnlessRaises(RuntimeError, mesh.reparent, mesh) # reparent transform to world wtrans = nt.createNode("parent2|worldtrans", "transform") parent = nt.Node("parent2") oparent = nt.createNode("oparent2", "transform") wtrans = wtrans.reparent(None) wtransnewparent = wtrans.setParent(parent) assert wtrans == wtransnewparent assert wtransnewparent.instanceCount(1) == 1 wtransnewparent.addParent(oparent) assert wtransnewparent.instanceCount(1) == 2 wtransnewparent.removeParent(oparent) assert wtrans.instanceCount(1) == 1 # OBJECT NAVIGATION ####################### # TODO: navigate the object properly # DUPLICATE (Dag only) ######################### newmesh = mesh.duplicate("|duplparent|duplmesh") assert str(newmesh) == "|duplparent|duplmesh" self.failUnlessRaises(RuntimeError, mesh.duplicate, "|duplparent2|doesntexistns:duplmesh", autocreateNamespace = False) assert newmesh != mesh instbase = nt.createNode("|duplparent2|newnamespace:instmesh", "transform") meshinst = instbase.addInstancedChild(mesh) meshinstname = str(meshinst) # UNDO DUPLICATE ################# cmds.undo() # this object will end up pointing to the same object , as it came from, use string test assert not nt.objExists(meshinstname) cmds.redo() cmds.undo() cmds.redo() assert meshinst != mesh assert meshinst.isAlive() and meshinst.isValid() and str(meshinst) == meshinstname # Duplicate TRANSFORM (just a name given) # dag paths should be different although object is the same mesh = nt.createNode("|parent|mybeautifuluniquemeshname", "mesh") meshassert = nt.createNode("|parent|mesh", "mesh") meshself = nt.Node("|parent|mybeautifuluniquemeshname") assert mesh == meshself # connect it, to track the instance by connection persp = nt.Node("persp") perspplug = persp.t.mchildByName('tx') triplug = meshself.maxTriangles perspplug.mconnectTo(triplug) # target does exist # this is blocking the target instance name with an incorrect type nt.createNode("parent|this|mybeautifuluniquemeshname", "transform") self.failUnlessRaises(RuntimeError, mesh.duplicate, "|parent|this") # if the path is too short ... self.failUnlessRaises(NameError, mesh.duplicate, str(mesh.transform())) self.failUnlessRaises(NameError, mesh.parent().duplicate, '|') meshinstname = mesh.transform().fullChildName("newns:meshinst") assert isinstance(meshinst, nt.Mesh)
def test_createNodes(self): names = ["hello","bla|world","this|world|here","that|this|world|here"] nsnames = ["a:hello","blab|b:world","c:this|b:world","d:that|c:this|b:world|a:b:c:d:here"] types = ["facade", "nurbsCurve", "nurbsSurface", "subdiv"] # SIMPLE CREATION: Paths + nested namespaces for i in range(len(names)): ntype = types[i] newnode = nt.createNode(names[i], ntype) assert isinstance(newnode, getattr(nt, capitalize(ntype))) assert newnode.isValid() and newnode.isAlive() # test undo cmds.undo() assert not newnode.isValid() and newnode.isAlive() cmds.redo() assert newnode.isValid() and newnode.isAlive() newnsnode = nt.createNode(nsnames[i], ntype) assert isinstance(newnsnode, getattr(nt, capitalize(ntype))) assert newnsnode.isValid() and newnsnode.isAlive() # test undo cmds.undo() assert not newnsnode.isValid() and newnsnode.isAlive() cmds.redo() assert newnsnode.isValid() and newnsnode.isAlive() # END for each created object # EMPTY NAME and ROOT self.failUnlessRaises(RuntimeError, nt.createNode, '|', "facade") self.failUnlessRaises(RuntimeError, nt.createNode, '', "facade") # CHECK DIFFERENT ROOT TYPES depnode = nt.createNode("blablub", "facade") self.failUnlessRaises(NameError, nt.createNode, "|blablub|:this", "transform", renameOnClash = False) # DIFFERENT TYPES AT END OF PATH nt.createNode("this|mesh", "mesh") self.failUnlessRaises(NameError, nt.createNode, "this|mesh", "nurbsSurface", forceNewLeaf = False) # renameOnClash - it fails if the dep node exists first nt.createNode("node", "facade") self.failUnlessRaises(NameError, nt.createNode, "this|that|node", "mesh", renameOnClash = False) # obj exists should match dg nodes with dag node like path (as they occupy the same # namespace after all assert nt.objExists("|node") # it also clashes if the dg node is created after a dag node with the same name nt.createNode("that|nodename", "mesh") self.failUnlessRaises(NameError, nt.createNode, "nodename", "facade", renameOnClash = False) # it should be fine to have the same name in several dag levels though ! newmesh = nt.createNode("parent|nodename", "transform") newmesh1 = nt.createNode("parent|nodename|nodename", "mesh") newmesh2 = nt.createNode("otherparent|nodename|nodename", "mesh") assert newmesh != newmesh1 assert newmesh1 != newmesh2 # FORCE NEW ############## oset = nt.createNode("objset", "objectSet", forceNewLeaf = False) newoset = nt.createNode("objset", "objectSet", forceNewLeaf = True) assert oset != newoset # would expect same set to be returned sameoset = nt.createNode("objset", "objectSet", forceNewLeaf = False) assert sameoset == oset # force new and dag paths newmesh3 = nt.createNode("otherparent|nodename|nodename", "mesh", forceNewLeaf = True) assert newmesh3 != newmesh2
def test_childEditing( self ): base = nt.createNode( "basenode", "transform" ) obase = nt.createNode( "otherbasenode", "transform" ) trans = nt.createNode( "trans", "transform" ) otrans = nt.createNode( "parent|trans", "transform" ) mesh = nt.createNode( "meshparent|meshshape", "mesh" ) curve = nt.createNode( "nurbsparent|ncurve", "nurbsCurve" ) itemlist = [ trans, mesh, curve ] instlist = [] # MULTIPLE ADDS #################### # Returns the same instance - its what the user wants for item in itemlist: baseiteminst = base.addInstancedChild( item ) base.addInstancedChild( item ) assert item != baseiteminst and baseiteminst.isValid() and item.isValid() instlist.append( baseiteminst ) # UNDO TEST # undo basemesh cmds.undo() cmds.undo() assert not baseiteminst.isValid() and baseiteminst.isAlive() cmds.redo() assert baseiteminst.isValid() and baseiteminst.isAlive() # END for each object including undo/redo # KEEP PARENT FALSE - USE INSTANCES # TODO: this test needs a redo - the original purpose got lost when # the addChild method has been changed, additionally it needs to be # better documented as this instancing stuff is not easily understood if # one just sees the code for orig,inst in zip( itemlist, instlist ): inst = obase.addChild( inst, keepExistingParent=False ) obase.addChild( inst, keepExistingParent=False ) # duplicate adds are not problem assert inst.isValid() and inst.isAlive() assert orig.isValid() # original may not be influenced by that operation # undo / redo cmds.undo() #cmds.undo() # just one undo counts assert inst.isValid() and orig.isValid() cmds.redo() # END for each instance # RENAME ON CLASH = False self.failUnlessRaises( RuntimeError, obase.addChild, otrans, renameOnClash = False ) # RENAME ON CLASH = True otransname = str( otrans ) renamedtrans = obase.addChild( otrans, renameOnClash = True ) assert renamedtrans.isValid() renamedname = str( renamedtrans ) assert renamedname != otransname cmds.undo( ) assert nt.objExists( otransname ) and not nt.objExists( renamedname ) cmds.redo()
def test_wrapDagNode( self ): mesh = nt.createNode( "parent|mesh", "mesh" ) parent = mesh.parent( ) # simple rename mesh.rename( "fancymesh" ) # simple dupl test duplbase = nt.createNode( "parent|this|other|duplbase", "mesh" ) transcopy = duplbase.transform( ).duplicate() copy = duplbase.duplicate( "parent|this|other|duplcopy" ) assert copy != duplbase assert str( copy ) != str( duplbase ) assert str( copy ) == "|parent|this|other|duplcopy" # TEST ADDITIONAL OPTIONS for i in range( 1,3 ): ocopy = duplbase.duplicate( ) assert str( ocopy ) == str( duplbase ) + str( i ) ocopy = duplbase.duplicate( newTransform=1 ) assert ocopy.basename( ) == duplbase.basename() assert str( ocopy.parent() ) == str( duplbase.parent() ) + str( i + 1 ) # undo both duplications and redo # CRASHES MAYA AFTER REDO # and if someone tries to access an object already created #cmds.undo() #cmds.undo() #assert duplbase.isValid() #cmds.redo() #cmds.redo() # END for each copy # simple reparent otherparent = nt.createNode( "oparent", "transform" ) mesh.reparent( otherparent ) # REPARENT UNDO TEST cmds.undo() assert mesh.parent() == parent cmds.redo() assert mesh.parent() == otherparent # REPARENT RENAME CLASH origmesh = nt.createNode( "parent|fancymesh", "mesh" ) # "|parent|fancymesh" self.failUnlessRaises( RuntimeError, mesh.reparent, parent , renameOnClash = False ) # RENAME CLASH DAG NODE othermesh = nt.createNode( "parent|mesh", "mesh" ) self.failUnlessRaises( RuntimeError, origmesh.rename, "mesh", renameOnClash = False ) # now it works othermesh.rename( "mesh", renameOnClash = True ) assert othermesh.basename( ) == "mesh" # shape under root self.failUnlessRaises( RuntimeError, mesh.reparent, None ) # REPARENT AGAIN # should just work as the endresult is the same mesh.reparent( otherparent ) # it will also trigger a new undo event, so undo will react as it should mesh.reparent( otherparent ) # "|otherparent|fancymesh" # REPARENT UNDER SELF self.failUnlessRaises( RuntimeError, mesh.reparent, mesh ) # reparent transform to world wtrans = nt.createNode( "parent2|worldtrans", "transform" ) parent = nt.Node( "parent2" ) oparent = nt.createNode( "oparent2", "transform" ) wtrans = wtrans.reparent( None ) wtransnewparent = wtrans.setParent( parent ) assert wtrans == wtransnewparent assert wtransnewparent.instanceCount( 1 ) == 1 wtransnewparent.addParent( oparent ) assert wtransnewparent.instanceCount( 1 ) == 2 wtransnewparent.removeParent( oparent ) assert wtrans.instanceCount( 1 ) == 1 # OBJECT NAVIGATION ####################### # TODO: navigate the object properly # DUPLICATE ( Dag only ) ######################### newmesh = mesh.duplicate( "|duplparent|duplmesh" ) assert str( newmesh ) == "|duplparent|duplmesh" self.failUnlessRaises( RuntimeError, mesh.duplicate, "|duplparent2|doesntexistns:duplmesh", autocreateNamespace = False ) assert newmesh != mesh instbase = nt.createNode( "|duplparent2|newnamespace:instmesh", "transform" ) meshinst = instbase.addInstancedChild( mesh ) meshinstname = str( meshinst ) # UNDO DUPLICATE ################# cmds.undo() # this object will end up pointing to the same object , as it came from, use string test assert not nt.objExists( meshinstname ) cmds.redo() cmds.undo() cmds.redo() assert meshinst != mesh assert meshinst.isAlive() and meshinst.isValid() and str( meshinst ) == meshinstname # Duplicate TRANSFORM ( just a name given ) # dag paths should be different although object is the same mesh = nt.createNode( "|parent|mybeautifuluniquemeshname", "mesh" ) meshassert = nt.createNode( "|parent|mesh", "mesh" ) meshself = nt.Node( "|parent|mybeautifuluniquemeshname" ) assert mesh == meshself # connect it, to track the instance by connection persp = nt.Node( "persp" ) perspplug = persp.t.mchildByName('tx') triplug = meshself.maxTriangles perspplug.mconnectTo(triplug) # target does exist # this is blocking the target instance name with an incorrect type nt.createNode( "parent|this|mybeautifuluniquemeshname", "transform" ) self.failUnlessRaises( RuntimeError, mesh.duplicate, "|parent|this" ) # if the path is too short ... self.failUnlessRaises( NameError, mesh.duplicate, str( mesh.transform() ) ) self.failUnlessRaises( NameError, mesh.parent().duplicate, '|' ) meshinstname = mesh.transform().fullChildName( "newns:meshinst" ) assert isinstance( meshinst, nt.Mesh )
def test_createNodes( self ): names = ["hello","bla|world","this|world|here","that|this|world|here" ] nsnames = ["a:hello","blab|b:world","c:this|b:world","d:that|c:this|b:world|a:b:c:d:here"] types = [ "facade", "nurbsCurve", "nurbsSurface", "subdiv" ] # SIMPLE CREATION: Paths + nested namespaces for i in range( len( names ) ): ntype = types[i] newnode = nt.createNode( names[i], ntype ) assert isinstance( newnode, getattr( nt, capitalize( ntype ) ) ) assert newnode.isValid() and newnode.isAlive() # test undo cmds.undo() assert not newnode.isValid() and newnode.isAlive() cmds.redo() assert newnode.isValid() and newnode.isAlive() newnsnode = nt.createNode( nsnames[i], ntype ) assert isinstance( newnsnode, getattr( nt, capitalize( ntype ) ) ) assert newnsnode.isValid() and newnsnode.isAlive() # test undo cmds.undo() assert not newnsnode.isValid() and newnsnode.isAlive() cmds.redo() assert newnsnode.isValid() and newnsnode.isAlive() # END for each created object # EMPTY NAME and ROOT self.failUnlessRaises( RuntimeError, nt.createNode, '|', "facade" ) self.failUnlessRaises( RuntimeError, nt.createNode, '', "facade" ) # CHECK DIFFERENT ROOT TYPES depnode = nt.createNode( "blablub", "facade" ) self.failUnlessRaises( NameError, nt.createNode, "|blablub|:this", "transform", renameOnClash = False ) # DIFFERENT TYPES AT END OF PATH nt.createNode( "this|mesh", "mesh" ) self.failUnlessRaises( NameError, nt.createNode, "this|mesh", "nurbsSurface", forceNewLeaf = False ) # renameOnClash - it fails if the dep node exists first nt.createNode( "node", "facade" ) self.failUnlessRaises( NameError, nt.createNode, "this|that|node", "mesh", renameOnClash = False ) # obj exists should match dg nodes with dag node like path ( as they occupy the same # namespace after all assert nt.objExists( "|node" ) # it also clashes if the dg node is created after a dag node with the same name nt.createNode( "that|nodename", "mesh" ) self.failUnlessRaises( NameError, nt.createNode, "nodename", "facade", renameOnClash = False ) # it should be fine to have the same name in several dag levels though ! newmesh = nt.createNode( "parent|nodename", "transform" ) newmesh1 = nt.createNode( "parent|nodename|nodename", "mesh" ) newmesh2 = nt.createNode( "otherparent|nodename|nodename", "mesh" ) assert newmesh != newmesh1 assert newmesh1 != newmesh2 # FORCE NEW ############## oset = nt.createNode( "objset", "objectSet", forceNewLeaf = False ) newoset = nt.createNode( "objset", "objectSet", forceNewLeaf = True ) assert oset != newoset # would expect same set to be returned sameoset = nt.createNode( "objset", "objectSet", forceNewLeaf = False ) assert sameoset == oset # force new and dag paths newmesh3 = nt.createNode( "otherparent|nodename|nodename", "mesh", forceNewLeaf = True ) assert newmesh3 != newmesh2
def test_setOperations(self): """byroniom.maya.nt.sets: unions, intersections, difference, overloaded ops""" memberlist = self._getMemberList() s3 = nt.createNode("anotherObjectSet", "objectSet") s = nt.ObjectSet() s.clear() s.addMembers(memberlist) side = nt.Node("side") s2 = nt.createNode("memberSet2", "objectSet") s2.addMember(side) # UNION ######## # with set sellist = s.union(s2) assert sellist.length() == len(memberlist) + 1 # with sellist - will create temp set sellist = s.union(s2.members()) assert sellist.length() == len(memberlist) + 1 assert not nt.objExists("set4") # tmp set may not exist # with multiple object sets s.union([s2, s3]) list(s.iterUnion(s2)) # INTERSECTION ############### fewmembers = memberlist[:3] s2.addMembers(fewmembers) # add 0 members s2.addMembers(list()) # with set sellist = s.intersection(s2) assert sellist.length() == len(fewmembers) # with sellist sellist = s.intersection(fewmembers) assert sellist.length() == len(fewmembers) # with multi sets s3.addMembers(fewmembers) sellist = s.intersection([s2, s3]) assert sellist.length() == len(fewmembers) list(s.iterIntersection(s2)) # DIFFERENCE ############# # with set s2.removeMember(side) sellist = s.difference(s2) assert s.members().length() - s2.members().length() == sellist.length() # with objects sellist = s.difference(list(s2.iterMembers())) assert s.members().length() - s2.members().length() == sellist.length() # with sellist sellist = s.difference(s2.members()) # with multiple sets s3.clear() s3.addMember(nt.Node("front")) sellist = s.difference([s2, s3]) assert len(list(s.iterDifference([s2, s3]))) == s.difference([s2, s3 ]).length() assert s.members().length() - s2.members().length() - s3.members( ).length() == sellist.length()