ufe runtime handlers

[gelshoffNV]

I'm trying to override the usd AttributeHandler by creating my own ufe.AttributesHandler which will call my ufe.Attributes class if the usd not has certain properties, otherwise, it just returns the default usd handler. Overriding and returning the usd handler works, but when I return my custom ufe.Attributes class, certain select callbacks don't seem to work and the AttributeEditor doesn't update with the attributes returned by my class. If I call methods interactively in the script editor, I see all the correct stuff: attributeNames, attribute, etc. I thought it might be a pybind issue, so I started keeping handles to all my instances, but that didn't work. I also made sure to override all methods, not just the pure virtual ones. The frustrating part for me is, I remember having a prototype of this working months ago, and coming back to it, it's not working...possibly some maya updates have caused this, haven't had a chance to install older releases to try. Has anyone tried messing with these ufe handlers?

[seando-adsk]

@gelshoffNV From reading your post it appears that you are doing all of this in Python (instead of C++) - is that correct? It should work, but not something that we have tried since we ported the Ufe-Usd code from python to C++. Would you be able to share your code with us? You can take out any parts you want to keep secret. Just the basic overriding code and returning of your interfaces(s).

Thanks, Sean

[gelshoffNV]

import logging
import ufe


logger = logging.getLogger()

class MyUndoableCommand(ufe.UndoableCommand):
    def execute(self):
        logger.info("EXE")

    def undo(self):
        logger.info("UNDO")

    def redo(self):
        logger.info("REDO")


class MyAttribute(object):
    _value = False
    
    def __init__(self, name):
        super(MyAttribute, self).__init__()
        self._name = name
    
    def get(self):
        return self._value
        
    def set(self, value):
        self._value = value
        
class MyAttributeBool(ufe.Attribute):
    def __init__(self, item, attr):
        super(MyAttributeBool, self).__init__(item)
        self._item = item
        self._attr = attr
    
    def __str__(self) -> str:
        return "1"

    def get(self):
        return self._attr.get()
        
    def set(self, value):
        self._attr.set(value)
    
    def sceneItem(self):
        return self._item
    
    @property
    def name(self):
        return self._attr._name
        
    @property
    def type(self):
        return ufe.Attribute.kBool
        
    def setCmd(self, value):
        return MyUndoableCommand()

    def hasValue(self):
        return True
        
    def getDocumentation(self):
        return ""

    def clearMetadata(self, key):
        return True

    def getMetadata(self, key):
        return ufe.Value()

    def hasMetadata(self, key):
        return False

    def setMetadata(self, key, value):
        return True

    def setMetadataCmd(self, key, value):
        return MyUndoableCommand()

class MyAttributes(ufe.Attributes):
    def __init__(self, item, usdAttributes):
        super(MyAttributes, self).__init__()
        self._item = item
        self._usdAttributes = usdAttributes
        self._attrs = {
            'one': MyAttributeBool(item, MyAttribute('one')),
            'two': MyAttributeBool(item, MyAttribute('two'))
        }

    @staticmethod
    def attributes(item):
        return MyAttributesHandler.getInstance().attributes(item)

    @property
    def attributeNames(self):
        return self._usdAttributes.attributeNames+list(self._attrs.keys())

    def hasAttribute(self, name):
        if name in self._attrs:
            return True
        
        return self._usdAttributes.hasAttribute(name)
        
    def attributeType(self, name):
        if name in self._attrs:
            return ufe.Attribute.kBool
        
        return self._usdAttributes.attributeType(name)

    def sceneItem(self):
        return self._item


def getMyAttribute(attrs, name):
    attr = attrs._attrs.get(name)
    if attr:
        return attr

    return attrs._usdAttributes.attribute(name)

def myAttributeFactory(attrs, attrName):
    return getMyAttribute(attrs, attrName)

MyAttributes.attribute = myAttributeFactory


class MyAttributesHandler(ufe.AttributesHandler):
    _instance = None

    @classmethod
    def getInstance(cls, usdAttrHandler=None):
        if cls._instance is None:
            cls._instance = cls()

        if usdAttrHandler is not None:
            cls._instance._usdHandler = usdAttrHandler
        return cls._instance
    
    def attributes(self, item):
        return MyAttributes(item, self._usdHandler.attributes(item))


usdId = ufe.RunTimeMgr.instance().getId('USD')
usdAttrHandler = ufe.RunTimeMgr.instance().attributesHandler(usdId)
myAttrHandler = MyAttributesHandler.getInstance(usdAttrHandler=usdAttrHandler)

ufe.RunTimeMgr.instance().setAttributesHandler(usdId, myAttrHandler)

[gelshoffNV]

If I make my handler return self._usdHandler.attributes(item), it works...so it seems like it's some issue with the Attributes or Attribute class. I've tried debugging the AETemplate in maya-usd, trying to see if it's something there, but the AETemplate doesn't appear to get called. Right now I'm looking at the HiearchyHandler, since it returns a SceneItem, and maybe because USD returns a subclass of that, it messes up...I also have some code to override the ContextHandler to show my own RMB menus, but I don't remember why I monkey patched one of the methods, possibly I wasn't able to get the registration to work in that as well...but monkeypatching the attributes method isn't possible, as it's read-only.

[gelshoffNV]

I tested my contextOpsHandler without monkeypatching and it works, also been able to register other handlers, so it seems like I'm doing something wrong in my AttributeHandler, or just something's not working correctly in Maya.

[pierrebai-adsk]

Hi,

I've investigated your problem. There is no simple fix so far, as it uncovered internal problems in the C++ / Python bindings. But I do have some work-around, but they are ugly and I cannot vouch that they will always work in the future, although there are no reason why they would break.

There are two issues at play:

1. In some circumstances, the C++ / Python bindings lose track of objects returned by Python function.
2. C++ class members that have been expose to Python as properties cannot be cleanly implemented in Python without either breaking calls from C++ or breaking access in Python.

The work-around are:

1. Make sure objects returned in Python are kept alive by keeping references to them in Python before returning them. For this, a cache can do.
2. Make sure class attributes that are properties can be accessed both as a value or as a function. One way to achieve this is to wrapped the return value into something that can also be called.

Concretely, in the code file attached below:

1. We use a class called keep_alive_cache to keep objects alive.
2. We use functions called make_callable and make_const_callable to turn a value into an object that hold the value and can be called to return the value.

I hope these work-around fix all your problems.

The fixed example:

fixed_custom_handler.txt

[gelshoffNV]

Thanks for the response, that's great! I thought it might have to do with the bindings, might be something to consider / solve if maya-usd moves to pybind...saw there was a discussion about moving away from boost, but didn't hear the new direction. I'll give your workaround a try, have some concerns about the caching, but might be fine for my use case.

[pierrebai-adsk]

UFE already uses pybind, which is actually one of the causes of the problem, so pybind cannot be the solution. The problem only occurs in some circumstances, so it is unclear at this point if it is a pybind bug (unlikely) or that we are misusing it in some obscure way we have not yet figured out.

The caching part does not need to have any functionality, it is merely there to keep objects alive while being used by the UFE / Maya run-time to extract attributes. I only provided it as an example of one generic approach, but feel free to improve upon it or adapt it to your own use cases or restriction. The only salient point is that the returned object must be kept alive for long enough for the C++ side to hold on to it.