python/api2/modules/JSONPatternCreator.py

from builtins import object
import sys
import json
import maya.cmds as cmds
import maya.api.OpenMaya as omAPI
from pyJsonAttrPatternInfo import PyJsonAttrPatternInfo as JsonKeys
from pyJsonAttrPatternInfo import jsonDebug as jsonDebug

#======================================================================
def attributeTypeName(node, attr):
    """
    Find the name of an attribute's type. Some translation is required since
    some construction types don't exactly match the class type as returned
    by the attributeQuery command.

    Returns None if the type is either unknown or not one of the ones this
    script currently supports.
    """
    attributeType = cmds.attributeQuery( attr, node=node, attributeType=True )

    if attributeType in JsonKeys.kNumericTypes:
        return attributeType

    if attributeType in JsonKeys.kTypeMatrix:
        return attributeType

    if attributeType == JsonKeys.kTypeEnum:
        return attributeType

    if attributeType == JsonKeys.kTypeMessage:
        return attributeType

    if attributeType == JsonKeys.kTypeString:
        return attributeType

    return None

#======================================================================
class JSONPatternCreator(object):
    """
    Utility class to build JSON pattern objects from a set of attributes.
    The most common use is to create a set of patterns from a node and
    print them out using:
        import json
        import JSONPatternCreator
        patternCreator = JSONPatternCreator.JSONPatternCreator()
        jsonNodePattern = patternCreator.nodeAsJSON( mayaNodeName )
        json.dumps( jsonNodePattern, sort_keys=True, indent=4, separators=(',', ': ') )
    """

    def __init__(self):
        """
        Initialize the pattern creator.
        """
        self.node = None
        self.dgNode = None
        self.nodeType = None

    #======================================================================
    def numericAttributeAsJSON(self, attr):
        """
        Find the numeric-specific attribute parameters
            attr   = Attribute belonging to the pattern
            RETURN = JSON object representing the numeric-attribute-specific parameters
                     It's best to merge these into the main object one by one, rather
                     than making it a sub-object.
        """
        pattern = {}

        # Set default value(s)
        defaultValue = cmds.attributeQuery( attr, node=self.node, listDefault=True )
        if defaultValue != None and len(defaultValue) > 0:
            pattern[JsonKeys.kKeyDefault] = defaultValue[0]

        # Set min/max values
        if cmds.attributeQuery( attr, node=self.node, minExists=True ):
            value = cmds.attributeQuery( attr, node=self.node, min=True )
            if value != None:
                if len(value) == 1:
                    pattern[JsonKeys.kKeyMin] = value[0]
                elif len(value) > 1:
                    pattern[JsonKeys.kKeyMin] = value

        if cmds.attributeQuery( attr, node=self.node, maxExists=True ):
            value = cmds.attributeQuery( attr, node=self.node, max=True )
            if value != None:
                if len(value) == 1:
                    pattern[JsonKeys.kKeyMax] = value[0]
                elif len(value) > 1:
                    pattern[JsonKeys.kKeyMax] = value

        if cmds.attributeQuery( attr, node=self.node, softMinExists=True ):
            value = cmds.attributeQuery( attr, node=self.node, softMin=True )
            if value != None:
                pattern[JsonKeys.kKeySoftMin] = value[0]

        if cmds.attributeQuery( attr, node=self.node, softMaxExists=True ):
            value = cmds.attributeQuery( attr, node=self.node, softMax=True )
            if value != None:
                pattern[JsonKeys.kKeySoftMax] = value[0]

        return pattern

    #======================================================================
    def compoundAttributeAsJSON(self, attr):
        """
        Find the compound-specific attribute parameters
            attr   = Attribute belonging to the pattern
            RETURN = JSON object representing the compound-attribute-specific parameters
                     It's best to merge these into the main object one by one, rather
                     than making it a sub-object.
        """
        pattern = {}
        # TODO:
        return pattern

    #======================================================================
    def lightDataAttributeAsJSON(self, attr):
        """
        Find the lightData-specific attribute parameters
            attr   = Attribute belonging to the pattern
            RETURN = JSON object representing the lightData-attribute-specific parameters
                     It's best to merge these into the main object one by one, rather
                     than making it a sub-object.
        """
        pattern = {}
        # TODO:
        return pattern

    #======================================================================
    def stringAttributeAsJSON(self, attr):
        """
        Find the string-specific attribute parameters
            attr   = Attribute belonging to the pattern
            RETURN = JSON object representing the string-attribute-specific parameters
                     It's best to merge these into the main object one by one, rather
                     than making it a sub-object.
        """
        pattern = {}
        stringDefault = cmds.attributeQuery( attr, node=self.node, listDefault=True )
        if stringDefault != None and len(stringDefault) > 0:
            pattern[JsonKeys.kKeyDefault] = stringDefault[0]
        return pattern

    #======================================================================
    def matrixAttributeAsJSON(self, attr):
        """
        Find the matrix-specific attribute parameters
            attr   = Attribute belonging to the pattern
            RETURN = JSON object representing the matrix-attribute-specific parameters
                     It's best to merge these into the main object one by one, rather
                     than making it a sub-object.
        """
        pattern = {}
        matrixDefault = cmds.attributeQuery( attr, node=self.node, listDefault=True )
        if matrixDefault != None and len(matrixDefault) > 0:
            pattern[JsonKeys.kKeyDefault] = matrixDefault[0]
        return pattern

    #======================================================================
    def typedAttributeAsJSON(self, attr):
        """
        Find the typed-specific attribute parameters
            attr   = Attribute belonging to the pattern
            RETURN = JSON object representing the typed-attribute-specific parameters
                     It's best to merge these into the main object one by one, rather
                     than making it a sub-object.
        """
        pattern = {}
        # TODO: 
        return pattern

    #======================================================================
    def enumAttributeAsJSON(self, attr):
        """
        Find the enum-specific attribute parameters
            attr   = Attribute belonging to the pattern
            RETURN = JSON object representing the enum-attribute-specific parameters
                     It's best to merge these into the main object one by one, rather
                     than making it a sub-object.
        """
        pattern = {}
        enumDefault = cmds.attributeQuery( attr, node=self.node, listDefault=True )
        if enumDefault != None and len(enumDefault) > 0:
            pattern[JsonKeys.kKeyDefault] = int(enumDefault[0])
        enumList = cmds.attributeQuery( attr, node=self.node, listEnum=True)
        if enumList != None and len(enumList) > 0:
            pattern[JsonKeys.kKeyEnumNames] = enumList[0].split(':')
        return pattern

    #======================================================================
    def attributeAsJSON(self, attr):
        """
        Convert the attribute into its JSON attribute pattern equivalent.
            attr   = Attribute belonging to the pattern
            RETURN = JSON object representing the attribute
        """
        jsonDebug( 'attributeAsJSON(%s)' % attr)
        jsonAttr = {}
        jsonAttr['name'] = attr
    
        shortName = cmds.attributeQuery( attr, node=self.node, shortName=True )
        # No need to write it if they two names are the same
        if shortName != attr: jsonAttr['shortName'] = shortName
    
        niceName = cmds.attributeQuery( attr, node=self.node, niceName=True )
        jsonAttr['niceName'] = niceName
    
        attributeType = attributeTypeName(self.node, attr)
        jsonAttr['attributeType'] = attributeType
        jsonDebug( '... type %s' % attributeType )
    
        categories = cmds.attributeQuery( attr, node=self.node, categories=True )
        if categories != None and len(categories) > 0:
            jsonAttr['categories'] = categories
    
        # Some flags default to false, some default to true, some are
        # code-dependent. Force setting of the ones who have changed
        # from their defaults, or whose defaults are unknown.
        #
        # Keep the list alphabetical for convenience
        flagList = []
        if cmds.attributeQuery( attr, node=self.node, affectsAppearance=True ):
            flagList.append( 'affectsAppearance' )
        if cmds.attributeQuery( attr, node=self.node, affectsWorldspace=True ):
            flagList.append( 'affectsWorldspace' )
        if not cmds.attributeQuery( attr, node=self.node, cachedInternally=True ):
            flagList.append( '!cached' )
        if not cmds.attributeQuery( attr, node=self.node, writable=True ):
            flagList.append( '!canConnectAsDst' )
        isReadable = True
        if not cmds.attributeQuery( attr, node=self.node, readable=True ):
            isReadable = False
            flagList.append( '!canConnectAsSrc' )
        if cmds.attributeQuery( attr, node=self.node, multi=True ):
            flagList.append( 'array' )
            # You can't set the indexMatters flag unless the attribute is an
            # unreadable array attribute. (It might be set otherwise, but just
            # by accident and the API doesn't support setting it incorrectly.)
            if cmds.attributeQuery( attr, node=self.node, indexMatters=True ) and not isReadable:
                flagList.append( 'indexMatters' )
        if cmds.attributeQuery( attr, node=self.node, channelBox=True ):
            flagList.append( 'channelBox' )
        if not cmds.attributeQuery( attr, node=self.node, connectable=True ):
            flagList.append( '!connectable' )
        if cmds.attributeQuery( attr, node=self.node, hidden=True ):
            flagList.append( 'hidden' )
        if cmds.attributeQuery( attr, node=self.node, indeterminant=True ):
            flagList.append( 'indeterminant' )
        if cmds.attributeQuery( attr, node=self.node, internalSet=True ):
            flagList.append( 'internal' )
        if cmds.attributeQuery( attr, node=self.node, keyable=True ):
            flagList.append( 'keyable' )
        else:
            flagList.append( '!keyable' )
        if cmds.attributeQuery( attr, node=self.node, renderSource=True ):
            flagList.append( 'renderSource' )
        if not cmds.attributeQuery( attr, node=self.node, storable=True ):
            flagList.append( '!storable' )
        if cmds.attributeQuery( attr, node=self.node, usedAsColor=True ):
            flagList.append( 'usedAsColor' )
        if cmds.attributeQuery( attr, node=self.node, usedAsFilename=True ):
            flagList.append( 'usedAsFilename' )
        if cmds.attributeQuery( attr, node=self.node, usesMultiBuilder=True ):
            flagList.append( 'usesArrayDataBuilder' )
        if cmds.attributeQuery( attr, node=self.node, worldspace=True ):
            flagList.append( 'worldspace' )
    
        # Write out the flag collection
        if len(flagList) > 0:
            jsonAttr['flags'] = flagList

        # Get attribute-type specific JSON parameters
        extraInfo = None
        if attributeType == 'enum':
            jsonDebug( '... decoding enum attribute parameters' )
            extraInfo = self.enumAttributeAsJSON(attr )
        elif attributeType in JsonKeys.kNumericTypes:
            jsonDebug( '... decoding numeric attribute parameters' )
            extraInfo = self.numericAttributeAsJSON(attr )
        elif attributeType in JsonKeys.kTypeMatrix:
            jsonDebug( '... decoding matrix attribute parameters' )
            extraInfo = self.matrixAttributeAsJSON(attr )
        elif attributeType == 'string':
            jsonDebug( '... decoding string attribute parameters' )
            extraInfo = self.stringAttributeAsJSON(attr )
        elif attributeType == 'message':
            jsonDebug( '... decoding message attribute parameters' )
        elif attributeType == 'compound':
            jsonDebug( '... decoding compound attribute parameters' )
            extraInfo = self.compoundAttributeAsJSON(attr )
        elif attributeType == 'lightData':
            jsonDebug( '... decoding lightData attribute parameters' )
            extraInfo = self.lightDataAttributeAsJSON(attr )
        elif attributeType == 'typed':
            jsonDebug( '... decoding typed attribute parameters' )
            extraInfo = self.typedAttributeAsJSON(attr )

        if extraInfo != None:
            for extraKey in extraInfo:
                jsonAttr[extraKey] = extraInfo[extraKey]
    
        return jsonAttr

    #======================================================================
    def attributeListAsJSON(self, patternName, attrs):
        """
        Convert the list of attributes into a JSON attribute pattern object.
        Any attributes not supported will be written out as an (ignored) JSON property
        "unsupportedAttributes".
            patternName = Name of the new pattern
            attrs       = Attributes belonging to the pattern
            RETURN      = JSON object containing the pattern for the attribute list
        """
        # Firewall to ignore bad input
        if patternName == None or len(patternName) == 0:
            raise ValueError( 'Pattern name cannot be empty' )
        if attrs == None or len(attrs) == 0:
            return None

        unsupportedAttrs = []
        supportedAttrs = []
        pattern = {}
        pattern["name"] = patternName
    
        for attr in attrs:
            attrType = attributeTypeName( self.node, attr )
            if attrType != None:
                supportedAttrs.append( attr )
            else:
                unsupportedAttrs.append( '%s:%s' % (attr, cmds.attributeQuery( attr, node=self.node, attributeType=True )) )
        unsupportedAttrs.sort()
        supportedAttrs.sort()
        
        if len(unsupportedAttrs) > 0:
            pattern["unsupportedAttributes"] = unsupportedAttrs
    
        attrPatternList = []
        for attr in supportedAttrs:
            attrPatternList.append( self.attributeAsJSON( attr ) )
        pattern["attributes"] = attrPatternList
    
        return pattern

    #======================================================================
    def nodeAsJSON(self, node):
        """
        node    = Node based on which the pattern is to be created
        RETURN  = JSON object containing patterns for all node attributes

        Method to walk through the list of attributes in a node and return the
        supported types out in a JSON attribute pattern format. The returned
        object can then be written out to a file or processed directly as a 
        JSON attribute pattern.

        There will be up to three attribute patterns specified in the object,
        one for each of static, dynamic, and extension attributes. Each of the
        patterns is only created if there is at least one attribute of that type.

        The names of the patterns for a node named "NODE" will be:
            dynamic_NODE
            static_NODE
            extension_NODE
        You really don't need me to explain which is which do you?
        """
        self.node = node    # Need this local for getting attribute info
        self.dgNode = omAPI.MSelectionList().add(node).getDependNode(0)
        jsonDebug( 'Getting node information from %s' % str(self.dgNode) )
        patternList = []

        try:
            dynamicAttributes = cmds.listAttr( node, userDefined=True )
            extensionAttributes = cmds.listAttr( node, extension=True )
            allAttributes = cmds.listAttr( node )
            staticAttributes = [attr for attr in allAttributes if not attr in extensionAttributes and not attr in dynamicAttributes]
            #----------------------------------------------------------------------
            # Add the static attribute pattern to the string if there are any
            newPattern = self.attributeListAsJSON( "static_%s" % node, staticAttributes )
            if newPattern != None:
                patternList.append( newPattern )

            #----------------------------------------------------------------------
            # Add the dynamic attribute pattern to the string if there are any
            newPattern = self.attributeListAsJSON( "dynamic_%s" % node, dynamicAttributes )
            if newPattern != None:
                patternList.append( newPattern )

            #----------------------------------------------------------------------
            # Add the extension attribute pattern to the string if there are any
            newPattern = self.attributeListAsJSON( "extension_%s" % node, extensionAttributes )
            if newPattern != None:
                patternList.append( newPattern )

        except Exception as e:
            print('ERR: Failed pattern creation on node %s (%s)' % (node, str(e)))

        # The pattern should be all built up now
        return patternList

    #======================================================================
    def test(self):
        """
        Run an internal consistency test on the pattern creator to verify its
        functions are operating correctly.
        """
        factoryIsLoaded = cmds.pluginInfo('pyJsonAttrPatternFactory.py', query=True, loaded=True)
        if not factoryIsLoaded:
            try:
                cmds.loadPlugin('pyJsonAttrPatternFactory.py', quiet=True)
            except:
                # Repotest environment won't find it so skip it then
                return False
        factoryIsLoaded = cmds.pluginInfo('pyJsonAttrPatternFactory.py', query=True, loaded=True)
        # If the environment isn't set up to find the plugin there's
        # nothing we can do about it. It's not a failure of the test so
        # don't report anything other than a warning that the test could
        # not be run.
        if not factoryIsLoaded:
            print('Warning: JSON attribute pattern factory could not be loaded, test aborted')
            return False

        patterns = """
        [
            {
                "name": "testPattern",
                "attributes": [
                    {
                        "name"          : "floatWithRanges",
                        "shortName"     : "fwr",
                        "defaultValue"  : 0.5,
                        "min"           : -10.0,
                        "max"           : 20.0,
                        "softMin"       : 1.0,
                        "softMax"       : 10.0,
                        "attributeType" : "float"
                    } ,
                    {
                        "name"          : "float3WithRanges",
                        "shortName"     : "ftwr",
                        "defaultValue"  : [7.5, 7.6, 7.7],
                        "min"           : [-17.0, -17.1, -17.2],
                        "max"           : [27.0, 27.1, 27.2],
                        "attributeType" : "float3"
                    } 
                ]
            }
        ]
        """
        cmds.createAttrPatterns( patternType='json', patternDefinition=patterns )
        cmds.file( force=True, new=True )
        node = cmds.createNode( 'addMatrix' )
        cmds.applyAttrPattern( node, patternName='testPattern' )

        jsonString = self.nodeAsJSON( node )
        print(json.dumps(jsonString, indent=4, separators=(',', ': ')))