def getCGMNameTags(self):
"""
Get the cgm name tags of an object.
"""
self.cgm = {}
for tag in NameFactory.cgmNameTags:
self.cgm[tag] = search.findRawTagInfo(self.nameLong,tag)
def returnObjectGeneratedNameDict(obj, ignore=[False]):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns a generated dictionary of name info
ARGUMENTS:
obj(string) - object
ignore(string) - default is 'none', only culls out cgmtags that are
generated via returnCGMOrder() function
RETURNS:
namesDict(string)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
typesDictionary = dictionary.initializeDictionary(typesDictionaryFile)
namesDictionary = dictionary.initializeDictionary(namesDictionaryFile)
settingsDictionary = dictionary.initializeDictionary(
settingsDictionaryFile)
namesDict = {}
divider = returnCGMDivider()
order = returnCGMOrder()
nameBuilder = []
#>>> Get our cgmVar_iables
userAttrs = attributes.returnUserAttributes(obj)
cgmAttrs = lists.returnMatchList(userAttrs, order)
#>>> Tag ignoring
if ignore:
for i in ignore:
if i in order:
order.remove(i)
#>>> Geting our data
for tag in order:
tagInfo = search.findRawTagInfo(obj, tag)
if tagInfo is not False:
namesDict[tag] = (tagInfo)
""" remove tags up stream that we don't want if they don't exist on the actual object"""
if mc.objExists(obj + '.cgmTypeModifier') != True:
if namesDict.get('cgmTypeModifier') != None:
namesDict.pop('cgmTypeModifier')
#>>> checks if the names exist as objects or it's a shape node
ChildNameObj = False
nameObj = search.returnTagInfo(obj, 'cgmName')
typeTag = search.returnTagInfo(obj, 'cgmType')
isType = search.returnObjectType(obj)
childrenObjects = search.returnChildrenObjects(obj)
"""first see if it's a group """
if childrenObjects > 0 and isType == 'transform' and typeTag == False:
""" if it's a transform group """
groupNamesDict = {}
if not nameObj:
groupNamesDict['cgmName'] = childrenObjects[0]
else:
groupNamesDict['cgmName'] = nameObj
groupNamesDict['cgmType'] = typesDictionary.get('transform')
if namesDict.get('cgmDirection') != None:
groupNamesDict['cgmDirection'] = namesDict.get('cgmDirection')
if namesDict.get('cgmDirectionModifier') != None:
groupNamesDict['cgmDirectionModifier'] = namesDict.get(
'cgmDirectionModifier')
if namesDict.get('cgmTypeModifier') != None:
groupNamesDict['cgmTypeModifier'] = namesDict.get(
'cgmTypeModifier')
return groupNamesDict
""" see if there's a name tag"""
elif nameObj != None or isType == 'shape':
"""if there is, does it exist """
if mc.objExists(nameObj) == True:
"""basic child object with cgmName tag """
childNamesDict = {}
childNamesDict['cgmName'] = namesDict.get('cgmName')
childNamesDict['cgmType'] = namesDict.get('cgmType')
if namesDict.get('cgmDirection') != None:
childNamesDict['cgmDirection'] = namesDict.get('cgmDirection')
if namesDict.get('cgmNameModifier') != None:
childNamesDict['cgmNameModifier'] = namesDict.get(
'cgmNameModifier')
if namesDict.get('cgmDirectionModifier') != None:
childNamesDict['cgmDirectionModifier'] = namesDict.get(
'cgmDirectionModifier')
if namesDict.get('cgmTypeModifier') != None:
childNamesDict['cgmTypeModifier'] = namesDict.get(
'cgmTypeModifier')
return childNamesDict
elif isType == 'shape' or 'Constraint' in isType:
"""if so, it's a child name object"""
childNamesDict = {}
childNamesDict['cgmName'] = search.returnParentObject(obj, False)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
elif typeTag == 'infoNull':
"""if so, it's a special case"""
moduleObj = search.returnMatchedTagObjectUp(
obj, 'cgmType', 'module')
masterObj = search.returnMatchedTagObjectUp(
obj, 'cgmType', 'master')
if moduleObj != False:
moduleName = returnUniqueGeneratedName(moduleObj,
ignore='cgmType')
childNamesDict = {}
childNamesDict['cgmName'] = (moduleName + '_' + nameObj)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
elif masterObj != False:
masterName = returnUniqueGeneratedName(masterObj,
ignore='cgmType')
childNamesDict = {}
childNamesDict['cgmName'] = (masterName + '_' + nameObj)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
else:
return namesDict
else:
return namesDict
else:
return namesDict
def __init__(self, characterName='', *a, **kw):
"""
Intializes an optionVar class handler
Keyword arguments:
varName(string) -- name for the optionVar
ObjectFactories:
self.PuppetNull - main null
self.NoTransformGroup
>>> self.GeoGroup - group where geo is stored to
self.PuppetInfoNull - master puppet info null under which the other nulls live
>>> self.GeoInfoNull
>>> self.ModuleInfoNull
>>> self.ModulesGroup
BufferFactories:
self.ModulesBuffer - buffer for modules. Instanced from self.ModuleInfoNull
"""
#>>>Keyword args
characterType = kw.pop('characterType', '')
initializeOnly = kw.pop('initializeOnly', False)
#Default to creation of a var as an int value of 0
### input check
self.masterNulls = modules.returnPuppetObjects()
self.nameBase = characterName
for l in initLists:
self.__dict__[l] = []
for d in initDicts:
self.__dict__[d] = {}
for o in initStores:
self.__dict__[o] = False
guiFactory.doPrintReportStart()
if mc.objExists(characterName):
#Make a name dict to check
if search.findRawTagInfo(characterName,
'cgmModuleType') == 'master':
self.nameBase = characterName
self.PuppetNull = ObjectFactory(characterName)
self.refState = self.PuppetNull.refState
guiFactory.report("'%s' exists. Checking..." % characterName)
else:
guiFactory.warning(
"'%s' isn't a puppet module. Can't initialize" %
characterName)
return
else:
if self.nameBase == '':
randomOptions = [
'ReallyNameMe', 'SolarSystem_isADumbName', 'David', 'Josh',
'Ryan', 'NameMe', 'Homer', 'Georgie', 'PleaseNameMe',
'NAMEThis', 'PleaseNameThisPuppet'
]
buffer = random.choice(randomOptions)
cnt = 0
while mc.objExists(buffer) and cnt < 10:
cnt += 1
buffer = random.choice(randomOptions)
self.nameBase = buffer
if self.refState or initializeOnly:
guiFactory.report("'%s' Initializing..." % characterName)
if not self.initialize():
guiFactory.warning(
"'%s' failed to initialize. Please go back to the non referenced file to repair!"
% moduleName)
return
else:
if not self.verify():
guiFactory.warning("'%s' failed to verify!" % characterName)
return
self.checkGeo()
self.verifyTemplateSizeObject(False)
self.getModules(initializeOnly=initializeOnly, *a, **kw)
guiFactory.report("'%s' checks out" % self.nameBase)
guiFactory.doPrintReportEnd()
def returnObjectGeneratedNameDict(obj,ignore='none'):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns a generated dictionary of name info
ARGUMENTS:
obj(string) - object
ignore(string) - default is 'none', only culls out cgmtags that are
generated via returnCGMOrder() function
RETURNS:
namesDict(string)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
typesDictionary = dictionary.initializeDictionary(typesDictionaryFile)
namesDictionary = dictionary.initializeDictionary(namesDictionaryFile)
settingsDictionary = dictionary.initializeDictionary(settingsDictionaryFile)
namesDict={}
divider = returnCGMDivider()
order = returnCGMOrder()
nameBuilder = []
#>>> Get our cgmVar_iables
userAttrs = attributes.returnUserAttributes(obj)
cgmAttrs = lists.returnMatchList(userAttrs,order)
#>>> Tag ignoring
if ignore != 'none':
if ignore in order:
order.remove(ignore)
#>>> Geting our data
for tag in order:
tagInfo = search.findRawTagInfo(obj,tag)
if tagInfo is not False:
namesDict[tag] = (tagInfo)
""" remove tags up stream that we don't want if they don't exist on the actual object"""
if mc.objExists(obj+'.cgmTypeModifier') != True:
if namesDict.get('cgmTypeModifier') != None:
namesDict.pop('cgmTypeModifier')
#>>> checks if the names exist as objects or it's a shape node
ChildNameObj = False
nameObj = search.returnTagInfo(obj,'cgmName')
typeTag = search.returnTagInfo(obj,'cgmType')
isType = search.returnObjectType(obj)
childrenObjects = search.returnChildrenObjects(obj)
"""first see if it's a group """
if childrenObjects > 0 and isType == 'transform' and typeTag == False:
""" if it's a transform group """
groupNamesDict = {}
if not nameObj:
groupNamesDict['cgmName'] = childrenObjects[0]
else:
groupNamesDict['cgmName'] = nameObj
groupNamesDict['cgmType'] = typesDictionary.get('transform')
if namesDict.get('cgmDirection') != None:
groupNamesDict['cgmDirection'] = namesDict.get('cgmDirection')
if namesDict.get('cgmDirectionModifier') != None:
groupNamesDict['cgmDirectionModifier'] = namesDict.get('cgmDirectionModifier')
if namesDict.get('cgmTypeModifier') != None:
groupNamesDict['cgmTypeModifier'] = namesDict.get('cgmTypeModifier')
return groupNamesDict
""" see if there's a name tag"""
elif nameObj != None or isType == 'shape':
"""if there is, does it exist """
if mc.objExists(nameObj) == True:
"""basic child object with cgmName tag """
childNamesDict = {}
childNamesDict['cgmName'] = namesDict.get('cgmName')
childNamesDict['cgmType'] = namesDict.get('cgmType')
if namesDict.get('cgmDirection') != None:
childNamesDict['cgmDirection'] = namesDict.get('cgmDirection')
if namesDict.get('cgmNameModifier') != None:
childNamesDict['cgmNameModifier'] = namesDict.get('cgmNameModifier')
if namesDict.get('cgmDirectionModifier') != None:
childNamesDict['cgmDirectionModifier'] = namesDict.get('cgmDirectionModifier')
if namesDict.get('cgmTypeModifier') != None:
childNamesDict['cgmTypeModifier'] = namesDict.get('cgmTypeModifier')
return childNamesDict
elif isType == 'shape' or 'Constraint' in isType:
"""if so, it's a child name object"""
childNamesDict = {}
childNamesDict['cgmName'] = search.returnParentObject(obj,False)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
elif typeTag == 'infoNull':
"""if so, it's a special case"""
moduleObj = search.returnMatchedTagObjectUp(obj,'cgmType','module')
masterObj = search.returnMatchedTagObjectUp(obj,'cgmType','master')
if moduleObj != False:
moduleName = returnUniqueGeneratedName(moduleObj,ignore='cgmType')
childNamesDict = {}
childNamesDict['cgmName'] = (moduleName+'_'+nameObj)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
elif masterObj != False:
masterName = returnUniqueGeneratedName(masterObj,ignore='cgmType')
childNamesDict = {}
childNamesDict['cgmName'] = (masterName+'_'+nameObj)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
else:
return namesDict
else:
return namesDict
else:
return namesDict
def returnObjectGeneratedNameDict(obj,ignore=[False]):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns a generated dictionary of name info
ARGUMENTS:
obj(string) - object
ignore(string) - default is 'none', only culls out cgmtags that are
generated via returnCGMOrder() function
RETURNS:
namesDict(string)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
_str_funcName = "returnObjectGeneratedNameDict"
log.debug(">>> %s >>> "%(_str_funcName) + "="*75)
#_str_funcName = "returnObjectGeneratedNameDict(%s,ignore = %s)"%(obj,ignore)
if type(ignore) is not list:ignore = [ignore]
typesDictionary = dictionary.initializeDictionary(typesDictionaryFile)
namesDictionary = dictionary.initializeDictionary(namesDictionaryFile)
settingsDictionary = dictionary.initializeDictionary(settingsDictionaryFile)
namesDict={}
divider = returnCGMDivider()
order = returnCGMOrder()
nameBuilder = []
#>>> Get our cgmVar_iables
userAttrs = attributes.returnUserAttributes(obj)
cgmAttrs = lists.returnMatchList(userAttrs,order)
#>>> Tag ignoring
if ignore:
for i in ignore:
if i in order:
order.remove(i)
#>>> Geting our data
for tag in order:
tagInfo = search.findRawTagInfo(obj,tag)
if tagInfo is not False:
namesDict[tag] = (tagInfo)
_iterator = search.findRawTagInfo(obj,'cgmIterator')
if _iterator is not False:
log.debug("Iterator found")
namesDict['cgmIterator'] = (_iterator)
# remove tags up stream that we don't want if they don't exist on the actual object"""
if not mc.objExists(obj+'.cgmTypeModifier'):
if namesDict.get('cgmTypeModifier') != None:
namesDict.pop('cgmTypeModifier')
log.debug("%s >>> initial nameDict: %s "%(_str_funcName,namesDict))
#>>> checks if the names exist as objects or it's a shape node
ChildNameObj = False
nameObj = search.returnTagInfo(obj,'cgmName')
typeTag = search.returnTagInfo(obj,'cgmType')
isType = search.returnObjectType(obj)
childrenObjects = search.returnChildrenObjects(obj)
"""first see if it's a group """
if isType == 'group' and typeTag == False:
log.debug("%s >>> group and no typeTag..."%(_str_funcName))
""" if it's a transform group """
groupNamesDict = {}
if not nameObj:
groupNamesDict['cgmName'] = childrenObjects[0]
else:
groupNamesDict['cgmName'] = nameObj
groupNamesDict['cgmType'] = typesDictionary.get('transform')
if namesDict.get('cgmTypeModifier') != None:
groupNamesDict['cgmTypeModifier'] = namesDict.get('cgmTypeModifier')
return groupNamesDict
""" see if there's a name tag"""
elif nameObj != None or isType == 'shape':
#If we have a name object or shape
log.debug("%s >>> nameObj not None or isType is 'shape'..."%(_str_funcName))
if mc.objExists(nameObj) and mc.attributeQuery ('cgmName',node=obj,msg=True):
log.debug("%s >>> nameObj exists: '%s'..."%(_str_funcName,nameObj))
#Basic child object with cgmName tag
childNamesDict = {}
childNamesDict['cgmName'] = namesDict.get('cgmName')
childNamesDict['cgmType'] = namesDict.get('cgmType')
if namesDict.get('cgmTypeModifier') != None:
childNamesDict['cgmTypeModifier'] = namesDict.get('cgmTypeModifier')
if namesDict.get('cgmIterator') != None:
childNamesDict['cgmIterator'] = namesDict.get('cgmIterator')
return childNamesDict
elif isType == 'shape' or 'Constraint' in isType:
"""if so, it's a child name object"""
log.debug("%s >>> child name object..."%(_str_funcName))
childNamesDict = {}
childNamesDict['cgmName'] = search.returnParentObject(obj,False)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
elif typeTag == 'infoNull':
log.debug("%s >>> special case..."%(_str_funcName))
moduleObj = search.returnMatchedTagObjectUp(obj,'cgmType','module')
masterObj = search.returnMatchedTagObjectUp(obj,'cgmType','master')
if moduleObj != False:
moduleName = returnUniqueGeneratedName(moduleObj,ignore='cgmType')
childNamesDict = {}
childNamesDict['cgmName'] = (moduleName+'_'+nameObj)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
elif masterObj != False:
masterName = returnUniqueGeneratedName(masterObj,ignore='cgmType')
childNamesDict = {}
childNamesDict['cgmName'] = (masterName+'_'+nameObj)
childNamesDict['cgmType'] = namesDict.get('cgmType')
return childNamesDict
else:
return namesDict
else:
log.debug("%s >>> No special case found. %s"%(_str_funcName,namesDict))
return namesDict
else:
return namesDict