def importSkinByRef(ref, file, skip=[], **kwargs):
    """Import skin for every dag node in reference."""

    if not os.path.exists(file):
        rigUtils.log('Skin file not found - skipping: %s' % file)
        return

    rigUtils.log('Reading file: %s' % file)

    f = open(file, 'r')
    j = json.loads(f.read())
    f.close()

    cmds.namespace(set=ref)
    dagnodes = cmds.namespaceInfo(lod=True)
    cmds.namespace(set=':')

    skinned = []

    for dagnode in dagnodes:
        if skip:
            if dagnode in skip:
                continue
        if dagnode in j:
            dict = j[dagnode]
            try: skindict = dict['skinCluster']
            except: continue
            importSkin(skindict, dagnode, **kwargs)
            skinned.append(dagnode)

    return skinned

	def resolveNamespaceClashes(self, tempNamespace):
		returnNames = []
		
		cmds.namespace(setNamespace=tempNamespace)
		namespaces = cmds.namespaceInfo(listOnlyNamespaces=True)
		cmds.namespace(setNamespace=':')
		existingNamespaces = cmds.namespaceInfo(listOnlyNamespaces=True)
		
		for i in range(len(namespaces)):
			namespaces[i] = namespaces[i].partition(tempNamespace+ ':')[2]
			
		for name in namespaces:
			newName = str(name)
			oldName = tempNamespace + ':' + name
			
			if name in existingNamespaces:
				highestSuffix = utils.findHighestTrailingNumber(existingNamespaces, name+'_')
				highestSuffix += 1
			
				newName = str(name) + '_' + str(highestSuffix)
			
			returnNames.append([oldName,newName])
			
		self.resolveNameChangeMirrorLinks(returnNames,tempNamespace)
		
		self.renameNamespaces(returnNames)
		
		return returnNames

def searchCharsName():
    """检索当前场景中的所有角色名

    Description:
        根据绑定文件的命名规范与reference原则，从命名空间中就可获得角色名称

    Arguments:
        无

    Returns:
        allCharsNameList：所有角色名列表(无重复)
    """
    cmds.namespace(set = ":")
    allNamespace = cmds.namespaceInfo(listOnlyNamespaces = True)  #拿到所有根目录下的命名空间名称
    allCharsName = []
    
    for eachNamespace in allNamespace:
        #拿到带有_Char_的命名空间名称，从中拿到角色名
        
        if eachNamespace.find("_chr_") < 0:
            print "This Is Not A Char!"            
        else:
            namesapceWithChar = eachNamespace
            charName = namesapceWithChar.split("_")[2]  #charName存放角色名
            allCharsName.append(charName)

    allCharsNameList = cT.delDupFromList(allCharsName)  #调用函数去除list中的重复元素
    
    return allCharsNameList

	def installModule(self, module, *arg):
		basename = 'instance_'
	
		cmds.namespace(setNamespace=":")
		namespaces = cmds.namespaceInfo(listOnlyNamespaces=True)
		
		for i in range(len(namespaces)):
			if namespaces[i].find('__') != -1:
				namespaces[i] = namespaces[i].partition('__')[2]

		newSuffix = utils.findHighestTrailingNumber(namespaces, basename) + 1
		
		userSpecName = basename + str(newSuffix)
		
		hookObj = self.findHookObjectFromSelection()
	
		mod = __import__('Blueprint.'+ module,{},{},[module])
		reload(mod)
		
		moduleClass = getattr(mod, mod.CLASS_NAME)
		moduleInstance = moduleClass(userSpecName, hookObj)
		moduleInstance.install()
		
		#this is to make sure move tool is selected by default
		moduleTransform = mod.CLASS_NAME + '__' + userSpecName + ':module_transform'
		cmds.select(moduleTransform, replace=True)
		cmds.setToolTo('moveSuperContext')

 def deleteModule(self, *args):
     """ Delete the Guide, ModuleLayout and Namespace.
     """
     # delete mirror preview:
     try:
         cmds.delete(self.moduleGrp[:self.moduleGrp.find(":")]+"_MirrorGrp")
     except:
         pass
     # delete the guide module:
     utils.clearNodeGrp(nodeGrpName=self.moduleGrp, attrFind='guideBase', unparent=True)
     # clear default 'dpAR_GuideMirror_Grp':
     utils.clearNodeGrp()
     # remove the namespaces:
     allNamespaceList = cmds.namespaceInfo(listOnlyNamespaces=True)
     if self.guideNamespace in allNamespaceList:
         cmds.namespace(moveNamespace=(self.guideNamespace, ':'), force=True)
         cmds.namespace(removeNamespace=self.guideNamespace, force=True)
     try:
         # delete the moduleFrameLayout from window UI:
         cmds.deleteUI(self.moduleFrameLayout)
         self.clearSelectedModuleLayout()
         # edit the footer A text:
         self.currentText = cmds.text("footerAText", query=True, label=True)
         cmds.text("footerAText", edit=True, label=str(int(self.currentText[:self.currentText.find(" ")]) - 1) +" "+ self.langDic[self.langName]['i005_footerA'])
     except:
         pass
     # clear module from instance list (clean dpUI list):
     delIndex = self.dpUIinst.moduleInstancesList.index(self)
     self.dpUIinst.moduleInstancesList.pop(delIndex)

 def __init__(self, dpUIinst, langDic, langName, userGuideName, rigType, CLASS_NAME, TITLE, DESCRIPTION, ICON):
     """ Initialize the module class creating a button in createGuidesLayout in order to be used to start the guide module.
     """
     # defining variables:
     self.dpUIinst = dpUIinst
     self.langDic = langDic
     self.langName = langName
     self.guideModuleName = CLASS_NAME
     self.title = TITLE
     self.description = DESCRIPTION
     self.icon = ICON
     self.userGuideName = userGuideName
     self.rigType = rigType
     # defining namespace:
     self.guideNamespace = self.guideModuleName + "__" + self.userGuideName
     # defining guideNamespace:
     cmds.namespace(setNamespace=":")
     self.namespaceExists = cmds.namespace(exists=self.guideNamespace)
     self.guideName = self.guideNamespace + ":Guide"
     self.moduleGrp = self.guideName+"_Base"
     self.radiusCtrl = self.moduleGrp+"_RadiusCtrl"
     self.annotation = self.moduleGrp+"_Ant"
     if not self.namespaceExists:
         cmds.namespace(add=self.guideNamespace)
         # create GUIDE for this module:
         self.createGuide()
     # create the Module layout in the mainUI - modulesLayoutA:        
     self.createModuleLayout()
     # update module instance info:
     self.updateModuleInstanceInfo()

	def _fixTheFuckingCores(self):
		"""
		This is used to clean sweep the static scenes and remove the duplicate Namespaces and reconnect the bases to the duplicates
		"""

		removedNameSpaces = []
		## Remove duplicate root core namespaces
		getAllNameSpaces = cmds.namespaceInfo(listOnlyNamespaces = True)
		for eachNS in getAllNameSpaces:
			if eachNS.endswith('1'):
				print 'Removing %s' % eachNS
				cmds.namespace(removeNamespace = eachNS, mergeNamespaceWithRoot = True)
				removedNameSpaces.append(eachNS.replace('1', '').replace('_CORE', ''))

		## Remove duplicate base cores
		for each in cmds.ls(type = 'core_archive'):
			if '1'in each:
				print 'Cleaned rootCore %s from scene...' % each
				cmds.delete(each)

		## Now find all geo with the core name in it and proceess it for reconnection
		for eachCore in removedNameSpaces:
			#print eachCore
			## Check child _hrc grps for processing
			getAllGeo = [eachGeo for eachGeo in cmds.ls('*%s*' % eachCore) if cmds.nodeType(eachGeo) == 'transform']
			for eachGeo in getAllGeo:
				self._reconnectDuplicates(eachGeo, '%s_CORE_Geoshader' % eachCore)

		coreLib.cleanupDeadCoreArchives()

def namespaceList(current= None):
	"""
	"""
	if not current:
		cmds.namespace(set = ':')

	return cmds.namespaceInfo(lon= 1, r= 1, an= 1)

    def buildScene(self):
        MayaCmds.file(new=True, force=True)

        MayaCmds.namespace(addNamespace='foo')
        MayaCmds.namespace(addNamespace='bar')
        MayaCmds.createNode('transform', name='foo:a')
        MayaCmds.createNode('transform', name='bar:a')
        MayaCmds.createNode('transform', name='a')
        MayaCmds.polyPlane(sx=1, sy=1, w=1, h=1, ch=0, n='foo:b')
        MayaCmds.polyPlane(sx=1, sy=1, w=1, h=1, ch=0, n='bar:b')
        MayaCmds.polyPlane(sx=1, sy=1, w=1, h=1, ch=0, n='b')
        MayaCmds.parent('foo:b', 'foo:a')
        MayaCmds.parent('bar:b', 'bar:a')
        MayaCmds.parent('b', 'a')

        MayaCmds.select('foo:b.vtx[0:8]')
        MayaCmds.setKeyframe(t=[1, 4])
        MayaCmds.scale(0.1, 0.1, 0.1, r=True)
        MayaCmds.setKeyframe(t=2)

        MayaCmds.select('bar:b.vtx[0:8]')
        MayaCmds.setKeyframe(t=[1, 4])
        MayaCmds.scale(2, 2, 2, r=True)
        MayaCmds.setKeyframe(t=2)

        MayaCmds.select('b.vtx[0:8]')
        MayaCmds.setKeyframe(t=[1, 4])
        MayaCmds.scale(5, 5, 5, r=True)
        MayaCmds.setKeyframe(t=2)

def deleteNS():
    sel_namespace = cmds.ls(sl=True)[0]
    NS = sel_namespace.rsplit(':',1)[0]
    if not cmds.namespace(ex=NS):
        raise Exception('Namespace "'+NS+'" does not exist!')
    cmds.namespace(mv=[NS,':'],f=True)
    cmds.namespace(rm=NS)

def renameAllNodeInNamespace( ns='' ) :

	# Remove every nodes that belong to the given namespace.
	# Input		: Namespace
	# Output	: Empty namespace
	
	nodes = mc.ls( '%s:*' % ns , l=True )
	mc.namespace( set=':' )

	if nodes :
		# If current namespace contains nodes,
		# delete them.
		for node in nodes :

			if mc.objExists( node ) :

				lockState = mc.lockNode( node , q=True )[0]

				if lockState :
					mc.lockNode( node , l=False )
				newName = addElementToName( node.split( ':' )[-1] , ns )
				print newName
				try :
					mc.rename( node , newName )
				except :
					pass

def getCharacterInfo():
    cmds.namespace(set=":")
    namespaces = cmds.namespaceInfo(lon=True)
    characterName = []
    for name in namespaces: 
        """ TODO: """
        """ I need a global check for valid characters in the scene """
        characterContainer = (name + ":character_container")
        setupContainer = name.replace("Character__", "Export__")
        setupContainer = (setupContainer + ":Setup")

        if cmds.objExists (characterContainer):
            fullCharName = name
            tmpCharName = name.split("__")[1]
            tmpCharName = tmpCharName[:tmpCharName.rfind("_")]
            characterName = tmpCharName
            return (characterName, characterContainer, fullCharName, setupContainer)  
                  
        else:
            characterContainer = 'Character__tmp_1:character_container'
            fullCharName = name
            tmpCharName = name.split("__")[1]
            tmpCharName = tmpCharName[:tmpCharName.rfind("_")]
            characterName = tmpCharName

            return (characterName, characterContainer, fullCharName, setupContainer)
            # Warn no character in the scene
            #charConfirm = ("No character exists in this scene")
            #cmds.confirmDialog(messageAlign="center", title="Create Directory", message= charConfirm)
            characterName = 'Character__tmp'
            return characterName

def process( call, *args):
	# Selection
	intialSelection = cmds.ls(selection=True, flatten=True)
	selections = intialSelection[:]
	# Input Values from UI
	inputName = ['placeholder'] # needs to be a list fed into it to work
	inputName[0] = cmds.textField("inputField", q=True, text = True)
	old = cmds.textField("replaceField", q=True, text = True)
	new = cmds.textField("withField", q=True, text = True)
	# Assign the Rename Class 
	D = Rename(selections, inputName )
	if old: # if there is data in the replaceField txt box, then run the replacement code
		for i in range( len (selections) ):
			findTxt = D.reFunction(D.getAfterNamespace(i), old)
			replacementName = D.getAfterNamespace(i)[ : findTxt [0][0] ] + new + D.getAfterNamespace(i)[ findTxt [0][1] : ]
			cmds.rename(selections[i], D.getNamespace(i) + replacementName)
	else:
		for i in range( len (selections) ):
			X = D.processNamespace(i)
			if X == ':': X = '::' # This prevents the root namespace from getting lost in the cutoff [:-1] use X[:-1] instead of D.processNamespace(i) [:-1]
			if cmds.namespace(exists = X [:-1] ) != True: # creates new namespace if doesn't already exist
				print ' creating new namespace'
				cmds.namespace(addNamespace = X [:-1] ) # create namespace if doesn't already exist
			cmds.rename( D.selection[i] , ':' + D.processNamespace(i) + D.processRename(i) )
			cmds.namespace(set = ':') # set namespace back to root so any new object created is under the root
	if call == 'NA':
		cmds.warning('no exit call, window stays open')
	elif call == 'exit':
		cmds.warning('exit called, closing rename window')
		cmds.evalDeferred('cmds.deleteUI("renameUI")')
		#cmds.deleteUI(window)

    def deleteNsContents(self, nameSpace):
        mc.namespace(set=":")
        mc.namespace(set=":"+nameSpace)
        if self.debug: print"current ns: ", mc.namespaceInfo(currentNamespace=True)
        nsContent = mc.namespaceInfo(ls=True, listOnlyDependencyNodes=True)

        if not nsContent:
            return

        for i in mc.namespaceInfo(ls=True, listOnlyDependencyNodes=True):
            
            delStr = i.split(":")[-1]
            
            try:
                print "deleting:", delStr
                #print mc.nodeType(i)
                mc.delete(i)
                self.count += 1

            except:
                if self.debug:print "can not delete: ", i
                pass

        if self.debug: print "renaming namespace: ", nameSpace
        self.setNsCleaned(nameSpace)

def instanceAsset(namespace=""):
    """Find new namespace"""
    ns = namespace
    name = "%s:root" % ns

    i = 1
    while cmds.objExists(name):
        ns = "%s%d" % (namespace, i)
        name = "%s:root" % ns
        i += 1

    """Make instance"""
    cmds.namespace(add=ns)
    root = cmds.instance("%s:root" % namespace, name=name)[0]

    """Get model_grp path"""
    model_grp = "%s:root|%s:master_trs|%s:shot_trs|%s:aux_trs|%s:model_grp" % (
        ns,
        namespace,
        namespace,
        namespace,
        namespace,
    )

    """Lock attributes"""
    cmds.setAttr("%s.%s" % (root, "asset"), lock=True)
    cmds.setAttr("%s.%s" % (root, "texturever"), lock=True)
    cmds.setAttr("%s.inheritsTransform" % model_grp, 0)

	def _removeNativeModels(self, models):
		""" Deletes provided native models.
			:param models: list of native models
			:return: <bool> success
		"""
		ret = True
		for model in models:
			nameInfo = cross3d.SceneWrapper._namespace(model)
			fullName = cross3d.SceneWrapper._mObjName(model)
			if cmds.referenceQuery(fullName, isNodeReferenced=True):
				# The model is referenced and we need to unload it.
				refNode = cmds.referenceQuery(fullName, referenceNode=True)
				filename = cmds.referenceQuery(refNode, filename=True)
				# If all nodes in the namespace are referenced, the namespace will be removed, otherwise
				# the namespace will still exist and contain all of those unreferenced nodes.
				cmds.file(filename, removeReference=True)
				# Remove nodes that were parented to referneced nodes
				leftovers = self.objects(wildcard='{refNode}fosterParent*'.format(refNode=refNode))
				if leftovers:
					self.removeObjects(leftovers)
			# Local node processing: check for unreferenced items in the namespace and remove them.
			namespace = nameInfo['namespace']
			if cmds.namespace(exists=namespace):
				cmds.namespace(removeNamespace=namespace, deleteNamespaceContent=True)
			if cmds.namespace(exists=namespace):
				print 'The namespace {ns} still exists the model {model} was not entirely removed.'.format(namespace, model=fullName)
				ret = False
		return ret

    def import_file(self):
        """Import component file"""

        log.info("Importing file: %s" % self.file)

        temp_namespace = "temp"
        cmds.file(self.file, i=True, namespace=temp_namespace)

        # Collect component nodes
        nodes = self._collect_imported_nodes()
        for node in nodes:

            # Check for duplicates
            if node.count("|"):
                e = "Duplicate node detected %s in component %s" % (node, self.__class__.__name__)
                log.error(e)
                raise RuntimeError(e)

            # Rename
            clean_node = ":".join(node.split(":")[1:])
            try:
                cmds.rename(node, clean_node)
                self.nodes.append(clean_node)
            except:
                pass

        cmds.namespace(removeNamespace=temp_namespace, mergeNamespaceWithRoot=True, force=True)

    def testExportWithStripAndMerge(self):
        mayaFilePath = os.path.abspath('UsdExportStripNamespaces.ma')
        cmds.file(mayaFilePath, new=True, force=True)

        cmds.namespace(add=":foo")
        cmds.namespace(add=":bar")

        node1 = cmds.polyCube( sx=5, sy=5, sz=5, name="cube1" )
        cmds.namespace(set=":foo");
        node2 = cmds.polyCube( sx=5, sy=5, sz=5, name="cube2" )
        cmds.namespace(set=":bar");
        node3 = cmds.polyCube( sx=5, sy=5, sz=5, name="cube3" )
        cmds.namespace(set=":");

        usdFilePath = os.path.abspath('UsdExportStripNamespaces_EXPORTED.usda')

        cmds.usdExport(mergeTransformAndShape=True,
                       selection=False,
                       stripNamespaces=True,
                       file=usdFilePath,
                       shadingMode='none')

        stage = Usd.Stage.Open(usdFilePath)
        self.assertTrue(stage)

        expectedPrims = ("/cube1", "/cube2", "/cube3")

        for primPath in expectedPrims:
            prim = stage.GetPrimAtPath(primPath)
            self.assertTrue(prim.IsValid(), "Expect " + primPath)

	def _createNativeModel(self, name='Model', nativeObjects=[], referenced=False):
		name = 'Model' if not name else name
		# Create a "model" namespace and add the locator to it
		# TODO: Make this a context
		currentNamespace = cmds.namespaceInfo(currentNamespace=True)
		namespace = cmds.namespace(addNamespace=name)
		cmds.namespace(setNamespace=namespace)
		# Create the transform node then the shape node so the transform is properly named
		parent = cmds.createNode('transform', name='Model')
		#name = cmds.createNode('locator', name='{}Shape'.format(name), parent=parent)
		output = cross3d.SceneWrapper._asMOBject(parent)
		userProps = cross3d.UserProps(output)
		userProps['model'] = True
		if referenced:
			userProps['referenced'] = referenced
			# Create the Active_Resolution enum if it doesn't exist
#			cmds.addAttr(name, longName="Active_Resolution", attributeType="enum", enumName="Offloaded:")
#			userProps['Resolutions'] = OrderedDict(Offloaded='')
		cmds.namespace(setNamespace=currentNamespace)

		# Add each of nativeObjects to the model namespace
		if nativeObjects:
			for nativeObject in nativeObjects:
				nativeObject = cross3d.SceneWrapper._getTransformNode(nativeObject)
				objName = cross3d.SceneWrapper._mObjName(nativeObject)
#				cmds.parent(objName, cross3d.SceneWrapper._mObjName(nativeParent))
				nameInfo = cross3d.SceneWrapper._namespace(nativeObject)
				newName = '{namespace}:{name}'.format(namespace=namespace, name=nameInfo['name'])
				cmds.rename(objName, newName)
		nativeObjects.append(output)
		return output

 def refreshAnimationModuleList(self, index=1):
     cmds.textScrollList(self.UIElements["animationModule_textScroll"], edit=True, removeAll=True)
     
     cmds.symbolButton(self.UIElements["deleteModuleButton"], edit=True, enable=False)
     cmds.symbolButton(self.UIElements["duplicateModuleButton"], edit=True, enable=False)
     
     selectedBlprnModule = cmds.textScrollList(self.UIElements["blueprintModule_textScroll"], q=True, selectItem=True)
     self.selectedBlueprintModule = self.blueprintModules[selectedBlprnModule[0]]
     
     self.setupActiveModuleControls()
     
     cmds.namespace(setNamespace=self.selectedBlueprintModule)
     controlModuleNamespaces = cmds.namespaceInfo(listOnlyNamespaces=True)
     cmds.namespace(setNamespace=":")
     
     if controlModuleNamespaces != None:
         for module in controlModuleNamespaces:
             moduleName = utils.stripAllNamespaces(module)[1]
             cmds.textScrollList(self.UIElements["animationModule_textScroll"], edit=True, append=moduleName)
             
         cmds.textScrollList(self.UIElements["animationModule_textScroll"], edit=True, selectIndexedItem = index)
         
         cmds.symbolButton(self.UIElements["deleteModuleButton"], edit=True, enable=True)
         cmds.symbolButton(self.UIElements["duplicateModuleButton"], edit=True, enable=True)
         cmds.symbolButton(self.UIElements["zeroModulesButton"], edit=True, enable=True)
      
     self.setupModuleSpecificControls()    
     self.previousBlueprintListEntry = selectedBlprnModule