def test_shapeAttr(self): self.assertFalse( pm.hasAttr(self.loc, 'localPositionX', checkShape=False)) self.assertTrue(pm.hasAttr(self.loc, 'localPositionX', checkShape=True)) self.assertFalse(self.loc.hasAttr('localPositionX', checkShape=False)) self.assertTrue(self.loc.hasAttr('localPositionX', checkShape=True))
def setViewportRGB(nodes, rgb, shape=0): isList = False if isinstance(nodes, tuple) or isinstance(nodes, list): isList = True if not isList: nodes = [nodes] for node in nodes: shapes = pm.listRelatives(node, s=True) if (shape==1 ): if len(shapes) > 0: for shape in shapes: if pm.hasAttr(shape, 'overrideColorRGB'): shape.overrideEnabled.set(1) shape.overrideDisplayType.set(0) shape.overrideRGBColors.set(1) shape.overrideColor.set(rgb) shape.overrideColor.set(rgb) else: if pm.hasAttr(node, 'overrideColorRGB'): node.overrideEnabled.set(1) node.overrideDisplayType.set(0) node.overrideRGBColors.set(1) node.overrideColorRGB.set(rgb) node.overrideColor.set(1)
def add_driver(self, treewidget, children=False): """ """ userSel = pm.ls(sl=True) itemsToAdd = [] for item in userSel: # filtering out SDK and tweak ctls. if pm.hasAttr(item, "is_SDK") == False: if pm.hasAttr(item, "is_tweak") == False: if pm.nodeType(item) == "transform": if item not in itemsToAdd: itemsToAdd.append(item) AllTreeItems = self.get_tree_item_names(treewidget) if itemsToAdd: for item in itemsToAdd: if item.name() not in AllTreeItems: treeItem = self.create_item(item.name()) # -------- brush = QtGui.QBrush(QtGui.QColor(60, 60, 60)) brush.setStyle(QtCore.Qt.SolidPattern) treeItem.setBackground(0, brush) treeItem.setSizeHint(0, QtCore.QSize(0, 30)) pprint(dir(treeItem)) treewidget.addTopLevelItem(treeItem) if children: self.add_children(treeItem)
def switchLayer(layer=''): ''' This method can be used for showing or hiding objects in the stereo layers layer: near, main, far ''' layers = findStereoLayers() if not layers.has_key(layer): return for l in layers[layer]: if not pm.hasAttr(l, 'stereo_layer'): continue if not pm.hasAttr(l, 'stereo_layer_visibility'): pm.addAttr(l, ln='stereo_layer_visibility', at='bool') l.stereo_layer_visibility.set(1) objects = getObjectsFromLayer(l) if l.stereo_layer_visibility.get(): setObjectVisibilityOff(objects) l.stereo_layer_visibility.set(0) else: setObjectVisibilityOn(objects) l.stereo_layer_visibility.set(1)
def copy_channelbox_attributes(): # copy values from selected main and shape attributes main_channels = pm.channelBox('mainChannelBox', q=True, selectedMainAttributes=True) shape_channels = pm.channelBox('mainChannelBox', q=True, selectedShapeAttributes=True) # input_attr = pm.channelBox('mainChannelBox', q=True, selectedHistoryAttributes=True) # output_attr = pm.channelBox('mainChannelBox', q=True, selectedOutputAttributes=True) clipboard = collections.OrderedDict() for obj in pm.ls(orderedSelection=True): main_attr = {} shape_attr = {} if main_channels: for at in main_channels: if pm.hasAttr(obj, at): main_attr[str(at)] = pm.getAttr(obj + '.' + at) shape_node = obj.getShape() if shape_channels: for at in shape_channels: if pm.hasAttr(obj, at): shape_attr[str(at)] = pm.getAttr(shape_node + '.' + at) clipboard[str(obj.fullPath())] = { 'main_attributes': main_attr, 'shape_attributes': shape_attr } return clipboard
def isIKFKLimb(ctl): if not isController(ctl): return False if pm.hasAttr(ctl, "mp"): if pm.listConnections(ctl + ".mp"): metaNode = pm.listConnections(ctl + ".mp")[0] return pm.hasAttr(metaNode, "state") else: return False
def doSimplify( self, parentNode ): for node in parentNode: childenNode = pm.listRelatives( node, c=True, typ='joint' ) if len( childenNode ): self.doSimplify( childenNode ) print node print pm.hasAttr( node, 'inbetweenJoints') print pm.hasAttr( node, 'inbetweenJoints') #pm.setAttr( (node+'.inbetweenJoints'), 0 ) return
def _connectToTarget(node, target): # Add message attributes to the node and its target if not pmc.hasAttr(node, 'bindTarget'): pmc.addAttr(node, ln='bindTarget', at='message') if not pmc.hasAttr(target, 'bindNode'): pmc.addAttr(target, ln='bindNode', at='message') # Connect the attributes pmc.connectAttr(node.bindTarget, target.bindNode, force=True)
def test_intance_from_meta(self): new_character = components.Character.create() instance = components.Character(new_character.pynode.name()) # Assertions # Meta node attributes self.assertTrue(pm.hasAttr(instance.pynode, "rootCtl")) self.assertTrue(pm.hasAttr(instance.pynode, "characterName")) self.assertTrue(pm.hasAttr(instance.pynode, "rootCtl")) self.assertTrue(pm.hasAttr(instance.pynode, "controlRig")) self.assertTrue(pm.hasAttr(instance.pynode, "deformationRig")) self.assertTrue(pm.hasAttr(instance.pynode, "geometryGroup")) self.assertTrue(pm.hasAttr(instance.pynode, "locatorsGroup")) self.assertTrue(pm.hasAttr(instance.pynode, "worldLocator")) # Main groups self.assertEqual(str(instance.control_rig), names.Character.control_rig.value) self.assertEqual(str(instance.deformation_rig), names.Character.deformation_rig.value) self.assertEqual(str(instance.geometry_grp), names.Character.geometry.value) self.assertEqual(str(instance.locators_grp), names.Character.locators.value) self.assertTrue(pm.objExists(instance.world_locator)) # Data struct self.assertEqual(instance.side, "char") self.assertEqual(instance.name, "character") # Save test scene pm.renameFile( self.get_temp_filename( "character_component_test_instance_from_meta.ma")) pm.saveFile(f=1)
def test_create_default(self): instance = luna_rig.components.Character.create() # Assertions # Metanode attributes self.assertTrue(pm.hasAttr(instance.pynode, "rootCtl")) self.assertTrue(pm.hasAttr(instance.pynode, "characterName")) self.assertTrue(pm.hasAttr(instance.pynode, "rootCtl")) self.assertTrue(pm.hasAttr(instance.pynode, "controlRig")) self.assertTrue(pm.hasAttr(instance.pynode, "deformationRig")) self.assertTrue(pm.hasAttr(instance.pynode, "geometryGroup")) self.assertTrue(pm.hasAttr(instance.pynode, "locatorsGroup")) self.assertTrue(pm.hasAttr(instance.pynode, "worldLocator")) # Instance members self.assertEqual(instance.tag, "character") self.assertEqual(str(instance.control_rig), static.CharacterMembers.control_rig.value) self.assertEqual(str(instance.deformation_rig), static.CharacterMembers.deformation_rig.value) self.assertEqual(str(instance.geometry_grp), static.CharacterMembers.geometry.value) self.assertEqual(str(instance.locators_grp), static.CharacterMembers.locators.value) self.assertTrue(pm.objExists(instance.world_locator)) # Save test scene pm.renameFile( self.get_temp_filename( "character_component_test_create_default.ma")) pm.saveFile(f=1)
def test_instance_from_meta(self): component1 = AnimComponent.create() new_component = AnimComponent(component1.pynode.name()) # Assertions # Structs self.assertEqual(new_component.name, "anim_component") self.assertEqual(new_component.side, "c") # Metanode self.assertEqual( str(new_component.pynode), "{0}_{1}_00_meta".format(new_component.side, new_component.name)) self.assertEqual(new_component.pynode.metaRigType.get(), AnimComponent.as_str()) self.assertEqual(new_component.pynode.version.get(), 1) self.assertEqual( str(new_component.root), "{0}_{1}_00_comp".format(new_component.side, new_component.name)) self.assertEqual( str(new_component.group_ctls), "{0}_{1}_00_ctls".format(new_component.side, new_component.name)) self.assertEqual( str(new_component.group_joints), "{0}_{1}_00_jnts".format(new_component.side, new_component.name)) self.assertEqual( str(new_component.group_parts), "{0}_{1}_00_parts".format(new_component.side, new_component.name)) # Meta parent attrs on hierarchy self.assertTrue(pm.hasAttr(new_component.root, "metaParent")) self.assertTrue(pm.hasAttr(new_component.group_ctls, "metaParent")) self.assertTrue(pm.hasAttr(new_component.group_joints, "metaParent")) self.assertTrue(pm.hasAttr(new_component.group_parts, "metaParent")) # Attributes on meta node self.assertTrue(pm.hasAttr(new_component.pynode, "rootGroup")) self.assertTrue(pm.hasAttr(new_component.pynode, "ctlsGroup")) self.assertTrue(pm.hasAttr(new_component.pynode, "jointsGroup")) self.assertTrue(pm.hasAttr(new_component.pynode, "partsGroup")) # Connections to metanode self.assertTrue( pm.isConnected(new_component.root.metaParent, new_component.pynode.rootGroup)) self.assertTrue( pm.isConnected(new_component.group_ctls.metaParent, new_component.pynode.ctlsGroup)) self.assertTrue( pm.isConnected(new_component.group_joints.metaParent, new_component.pynode.jointsGroup)) self.assertTrue( pm.isConnected(new_component.group_parts.metaParent, new_component.pynode.partsGroup)) # Save test scene pm.renameFile( self.get_temp_filename( "anim_component_test_instance_from_meta.ma")) pm.saveFile(f=1)
def __setitem__(self, key, value): if not pm.hasAttr(self._node, key): raise KeyError('{0} has no attribute {1}'.format(self._node, key)) attribute = self._node.attr(key) wasLocked = attribute.isLocked() if wasLocked: attribute.unlock() try: if attribute.type() == Attribute.Type.MESSAGE: if attribute.isMulti(): self.__setMultiMessage(attribute, value) else: self.__setSingleMessage(attribute, value) else: if attribute.isMulti(): self.__setMultiAttr(attribute, value) else: attribute.set(value) except Exception as error: raise error finally: if wasLocked: attribute.lock()
def __init__(self, *args, **kwargs): self.log = logging.getLogger(self.__class__.__name__) if not args: self._node = self.NODE_TYPE(**kwargs) elif len(args) == 1: arg = args[0] if type(arg) == str or type(arg) == unicode: self._node = self.NODE_TYPE(arg, **kwargs) else: if not isinstance(arg, self.NODE_TYPE): raise TypeError('{0} ({1}) is not expected node type {2}.'.format(arg, type(arg), self.NODE_TYPE)) self._node = arg else: raise ValueError('Only one parameter permitted. Must be a Maya node reference.') if not pm.hasAttr(self._node, MayaNode.CLASS_ATTR): self._node.addAttr(MayaNode.CLASS_ATTR, dataType = 'string') self._node.attr(MayaNode.CLASS_ATTR).set('{0}'.format(self.__class__))
def exposeOutput(ctrl, outputNode, rigType, unMirror=0, createJoint=1): if pmc.hasAttr(outputNode, 'outMatrix'): index = outputNode.outMatrix.numElements() if unMirror: m = unMirrorMtx(ctrl.worldMatrix[0], name=ctrl.name().replace('ctrl', '')) m.matrixSum.connect(outputNode.outMatrix[index]) else: ctrl.worldMatrix[0].connect(outputNode.outMatrix[index]) if createJoint: pmc.select(None) j = pmc.joint(name=ctrl.name().replace('ctrl', 'Out_Jnt')) j.segmentScaleCompensate.set(0) pmc.addAttr(j, ln='jointIndex', at='short', k=0) pmc.addAttr(j, ln='rigType', dt='string') j.rigType.set(rigType) j.jointIndex.set(index) d = pmc.createNode('decomposeMatrix', name=ctrl.name().replace('ctrl', 'mtx2Srt_utl')) outputNode.outMatrix[index].connect(d.inputMatrix) d.outputTranslate.connect(j.t) d.outputRotate.connect(j.r) d.outputScale.connect(j.s) return j
def _check_created_node(cls): """ Catches all network nodes that are meta types. If they aren't in the meta dictionary they will be added. Should only apply to copied meta nodes and imported meta nodes as they dont go through the normal meta node create function. Always runs deferred, therefore this will not reliably catch metas from a batch process. If this is needed look at using update_meta_dictionary from your batch (scene load/new will also run update_meta_dictionary). """ m_obj = cls.created_m_objs.pop(0) m_objs_uuid = om2.MFnDependencyNode(m_obj).uuid() if m_objs_uuid.valid(): uuid = m_objs_uuid.asString() nodes = pm.ls(uuid) if nodes: if pm.hasAttr(nodes[0], META_TYPE): if nodes[0].attr(META_TYPE).get( ) in meta.core.Register.__meta_types__.keys(): metanode_class = meta.core.Register.__meta_types__[ nodes[0].attr(META_TYPE).get()] if all(metanode.uuid != uuid for metanode in cls.meta_dict.get( metanode_class.meta_type, [])): if metanode_class.meta_type not in cls.meta_dict: cls.meta_dict[metanode_class.meta_type] = [] new_meta = metanode_class(nodes[0]) cls.meta_dict[metanode_class.meta_type].append( new_meta) om2.MUserEventMessage.postUserEvent( cls.create_event, (metanode_class.meta_type, new_meta)) new_meta.created_event()
def assert_cache(namespace, path): cache_group = assert_group_chain('animated', '{}_group'.format(namespace), 'cache') pm.hide(cache_group) if not pm.hasAttr(cache_group, 'mmCachePath'): cache_group.addAttr('mmCachePath', dataType='string') nodes = pm.listRelatives(cache_group, children=True) if nodes: existing_path = cache_group.attr('mmCachePath').get() if not existing_path: raise ValueError("Cache group {} has children, but no mmCachePath set.".format(cache_group)) if existing_path == path: print(' NOTE: Already up to date.') return nodes, True print(' WARNING: Out of date; deleting.') pm.delete(nodes) nodes = None if not nodes: before = set(pm.ls(assemblies=True)) pm.AbcImport(path, ft='{}:[^:]*$'.format(namespace)) nodes = list(set(pm.ls(assemblies=True)) - before) for node in nodes: pm.parent(node, cache_group) cache_group.attr('mmCachePath').set(path) return nodes, False
def get_current_SDKs(): """ If SDK ctls are selected, will return only the SDK nodes Attatched to those in the selection. If nothing is selected, will get all the SDK nodes in the scene and return them. Returns: SDKs_to_set (list) - list of SDKs as Pynodes """ SDKs_to_set = [] all_ctls = [] user_sel = pm.ls(sl=True) # If something selected, Get all SDK ctls in sel. if len(user_sel) > 0: for item in user_sel: if pm.hasAttr(item, "is_SDK"): if item not in all_ctls: all_ctls.append(item) if len(all_ctls) == 0: pm.warning("Please select a SDK ctl") else: # Get all ctls with is_SDK attr for item in pm.ls("*.is_SDK"): SDK_ctl = item.node() if SDK_ctl not in all_ctls: all_ctls.append(pm.PyNode(SDK_ctl)) if all_ctls: # getting all SDKs attatched to Ctls for ctl in all_ctls: for sdk, sdkInfo in sdk_io.getAllSDKInfoFromNode(ctl).items(): SDKs_to_set.append(pm.PyNode(sdk)) return SDKs_to_set
def setOutlinerRGB(nodes, rgb): if not isinstance(nodes, list): nodes = [nodes] for node in nodes: if pm.hasAttr(node, 'useOutlinerColor'): node.useOutlinerColor.set(1) node.outlinerColor.set(rgb)
def resetOutlinerRGB(nodes): if not isinstance(nodes, list): nodes = [nodes] for node in nodes: if pm.hasAttr(node, 'useOutlinerColor'): node.useOutlinerColor.set(0) node.outlinerColor.set(0,0,0)
def getLimbFkControls(metaNode, *args): fkControls = [] if metaNode: for attr in ["ShoulderFK", "HipFK"]: if pm.hasAttr(metaNode, attr): fkControls.append(pm.listConnections(metaNode + "." + attr)[0]) for attr in ["ElbowFK", "KneeFK"]: if pm.hasAttr(metaNode, attr): fkControls.append(pm.listConnections(metaNode + "." + attr)[0]) for attr in ["WristFK", "AnkleFK"]: if pm.hasAttr(metaNode, attr): fkControls.append(pm.listConnections(metaNode + "." + attr)[0]) for attr in ["FootFK"]: if pm.hasAttr(metaNode, attr): fkControls.append(pm.listConnections(metaNode + "." + attr)[0]) return fkControls
def paste_channelbox_attributes(data=None, objects=None): if not data: pm.warning('Nothing to paste from.') return for obj in objects: for k, cat in data.iteritems(): for at, value in cat['main_attributes'].iteritems(): if pm.hasAttr(obj, at): pm.setAttr(obj + '.' + at, float(value)) shape_node = obj.getShape() if shape_node: for at, value in cat['shape_attributes'].iteritems(): if pm.hasAttr(shape_node, at): pm.setAttr(shape_node + '.' + at, float(value))
def _findBindNodes(): # Grab a list of every bind node in the scene return [ obj for obj in pmc.ls(dag=True) if pmc.hasAttr(obj, 'bindTarget', checkShape=False) ]
def find_coordinate_space_node(node): for conn in node.attr('message').connections(d=True, s=False): if pm.hasAttr(conn, 'nodeType') and conn.attr( 'nodeType').get() == 'CoordinateSpaceReferences': return conn raise Exception('Node %s doesn\'t have a coordinate space attribute.' % node)
def addDisplayAttr(obj): ''' Adds an attr (if needed) to control displaying the full shape or not. ''' attrName = 'display' shapes = core.shape.getShapes(obj) curves = ls(shapes, type='nurbsCurve') surfaces = ls(shapes, type='nurbsSurface') if curves and surfaces: if not hasAttr(obj, attrName): obj.addAttr(attrName, at='enum', enumName='outline:full:surface', k=False, dv=1) curveVis = createNode('condition') obj.attr(attrName) >> curveVis.firstTerm curveVis.secondTerm.set(2) curveVis.operation.set(4) curveVis.colorIfTrueR.set(1) curveVis.colorIfFalseR.set(0) for curve in curves: curveVis.outColorR >> curve.visibility obj.attr(attrName).set(cb=True) for surface in surfaces: obj.attr(attrName) >> surface.visibility
def delete_materials(): """delete all material networks that have surfacing attributes""" all_shading_groups = pm.ls(type="shadingEngine") to_delete = [] for shading_group in all_shading_groups: if pm.hasAttr(shading_group, ATTR_MATERIAL): to_delete.append(shading_group) pm.delete(to_delete)
def resetViewportColor(nodes): for node in nodes: if pm.hasAttr(node, 'overrideEnabled'): node.overrideEnabled.set(0) node.overrideDisplayType.set(0) node.overrideRGBColors.set(0) node.overrideColor.set(0, 0, 0) shapes = pm.listRelatives(sel, shapes=True) for shape in shapes: if pm.hasAttr(shape, 'overrideEnabled'): shape.overrideEnabled.set(0) shape.overrideDisplayType.set(0) shape.overrideRGBColors.set(0) shape.overrideColorR.set(0) shape.overrideColorG.set(0) shape.overrideColorB.set(0) shape.overrideColor.set(0)
def removeSelectedNodes(): nodes = [obj for obj in pmc.selected() if pmc.hasAttr(obj, 'bindTarget')] if len(nodes) > 0: for node in nodes: _removeNode(node) else: logging.warning('No valid nodes selected')
def _setSingleConnection(obj, attrName, value): if value: if isinstance(value, basestring): PyNode(value).message >> messageAttr( obj, attrName ) else: value.message >> messageAttr( obj, attrName ) else: if hasAttr(obj.node(), attrName): obj.attr(attrName).disconnect()
def getOutputs(): outputDict = {} outputs = [ node for node in pmc.ls(type='transform') if pmc.hasAttr(node, 'outputType') ] for output in outputs: outputDict[output.outputType.get()] = output return outputDict
def showLayer(layer='', show=True): layers_list = ['main', 'near', 'far'] if not layer: # we show all objects in the stereo layer if layer is empty for l in layers_list: if pm.objExists('stereo_'+l): tmp = pm.PyNode('stereo_'+l) tmp.attr('v').set(1) if pm.hasAttr(tmp, 'stereo_hidden'): for o in tmp.attr('stereo_hidden').get().split(';'): try: if pm.objExists(o): pm.setAttr(o+'.overrideVisibility', 1) pm.setAttr(o+'.overrideEnabled', 0) except: print traceback.format_exc() return for l in layers_list: if l==layer: if pm.objExists('stereo_'+l): tmp = pm.PyNode('stereo_'+l) tmp.attr('v').set(int(show)) if pm.hasAttr(tmp, 'stereo_hidden'): for o in tmp.attr('stereo_hidden').get().split(';'): try: if pm.objExists(o): pm.setAttr(o+'.overrideVisibility', int(show)) pm.setAttr(o+'.overrideEnabled', int(not show)) except: print traceback.format_exc() else: if pm.objExists('stereo_'+l): tmp = pm.PyNode('stereo_'+l) tmp.attr('v').set(int(not show)) if pm.hasAttr(tmp, 'stereo_hidden'): for o in tmp.attr('stereo_hidden').get().split(';'): try: if pm.objExists(o): pm.setAttr(o+'.overrideEnabled', int(show)) pm.setAttr(o+'.overrideVisibility', int(not show)) except: print traceback.format_exc()
def isOverrideAR(self, m): if not pm.referenceQuery(m,isNodeReferenced=1):return False ref = m.referenceFile() if not ref:return False refNode = ref.refNode if not refNode:return False if pm.hasAttr(refNode,'AROrign'): print pm.getAttr(refNode.name()+'.AROrign') return True return False
def syncTextures(error=False): oSync = Sync() paths = set() for fn in pym.ls(type="file"): if pym.hasAttr(fn, "fileTextureName"): ftn = fn.fileTextureName.get() mapfolder = oSync.strip(pym.Path(ftn).parent) if mapfolder not in paths: paths.add(mapfolder) syncPath(mapfolder)
def getObjectsFromLayer(layer): objects = [] if not pm.objExists(layer): return layer = pm.PyNode(layer) if not pm.hasAttr(layer, 'stereo_layer'): return obj_string = layer.stereo_layer.get() if obj_string: objects = [pm.PyNode(o.strip()) for o in obj_string.split(';') if pm.objExists(o.strip())] return objects
def getSceneObjectIdList(self): #deselect all pm.select(cl = True) #list all scene objects sceneObjList = pm.ls(fl = True) #Iterate through scene objects list and if obj has vrayObjId attr then add to objIdList objIdList = [] for obj in sceneObjList: #attrs added on geometry if(pm.hasAttr(obj, 'vrayObjectID', checkShape = True)): objIdList.append(pm.getAttr(obj.vrayObjectID)) #cover vrops elif((pm.hasAttr(obj, 'objectIDEnabled')) and (pm.hasAttr(obj, 'objectID'))): if(obj.objectIDEnabled.get()): objIdList.append(pm.getAttr(obj.objectID)) #return duplicate free list return sorted(list(set(objIdList)))
def matchFkToIk(fkControls, msgAttr='ikjoints', autoKey=True): """ Matches fkControls to match the current pose of the underlying ik duplicate joint chains Finds the ik joints using a previously created message connection to the attribute msgAttr """ ikJoints = None switchControl = None switchAttr = None for ctl in fkControls: if pmc.hasAttr(ctl, msgAttr): ikJoints = pmc.listConnections('{0}.{1}'.format(ctl, msgAttr), destination=False, source=True) attr = pmc.listConnections('{0}.ikfk'.format(ctl), destination=False, source=True, plugs=True, scn=True)[0] switchControl = attr.node() switchAttr = attr.name(includeNode=False) break if autoKey: frameBeforeCurrent = pmc.currentTime(q=True) - 1 pmc.setKeyframe(switchControl, attribute=switchAttr, time=frameBeforeCurrent, value=0, outTangentType='step') pmc.setKeyframe(fkControls, attribute='rotate', time=frameBeforeCurrent, outTangentType='step') pmc.setKeyframe(switchControl, attribute=switchAttr, value=1, outTangentType='step') for ikj, ctl in izip(ikJoints, fkControls): alignObjects(ctl, ikj, position=False, rotation=True) if autoKey: pmc.setKeyframe(fkControls, attribute='rotate') pmc.headsUpMessage('BAMF!')
def test_transformAttr(self): self.assertTrue(pm.hasAttr(self.loc, 'tx', checkShape=False)) self.assertTrue(pm.hasAttr(self.loc, 'tx', checkShape=True)) self.assertTrue(self.loc.hasAttr('tx', checkShape=False)) self.assertTrue(self.loc.hasAttr('tx', checkShape=True))
def test_shapeAttr(self): self.assertFalse(pm.hasAttr(self.loc, 'localPositionX', checkShape=False)) self.assertTrue(pm.hasAttr(self.loc, 'localPositionX', checkShape=True)) self.assertFalse(self.loc.hasAttr('localPositionX', checkShape=False)) self.assertTrue(self.loc.hasAttr('localPositionX', checkShape=True))
def test_badAttr(self): self.assertFalse(pm.hasAttr(self.loc, 'foobar', checkShape=False)) self.assertFalse(pm.hasAttr(self.loc, 'foobar', checkShape=True)) self.assertFalse(self.loc.hasAttr('foobar', checkShape=False)) self.assertFalse(self.loc.hasAttr('foobar', checkShape=True))
def __getitem__(self, item): if pm.hasAttr(self._node, item): return self._node.getAttr(item) return None