broken when imported before maya initialisation in mayapy

[p0las]

maya 2024 on windows 10.

run mayapy
import cmdx
this breaks however:
from cmdx import ContainerNode

with this error:
ImportError: cannot import name 'ContainerNode' from 'cmdx' (cmdx.py)

since there is no maya cmds yet the version check fails:

try:
    __maya_version__ = int(cmds.about(version=True))
except (AttributeError, ValueError):
    __maya_version__ = 2015  # E.g. Preview Release 95

and it is set to maya 2015. this in turn disables ContainerNode:

if __maya_version__ >= 2017:
    class ContainerNode(Node):

which makes the code fail in commandline tools that initialise maya after cmdx was imported.

2024-07-25 18:24:17:  0: STDOUT:   File "cmdx.py", line 7357, in listRelatives
2024-07-25 18:24:17:  0: STDOUT:     _parent = node.parent(type=type)
2024-07-25 18:24:17:  0: STDOUT:   File "cmdx.py", line 1853, in parent
2024-07-25 18:24:17:  0: STDOUT:     return cls(mobject)
2024-07-25 18:24:17:  0: STDOUT:   File "cmdx.py", line 480, in __call__
2024-07-25 18:24:17:  0: STDOUT:     sup = ContainerNode
2024-07-25 18:24:17:  0: STDOUT: NameError: name 'ContainerNode' is not defined

it is not always easy to control the order of imports in more complicated pipelines.

[mottosso]

There are very few things you can do without initialising Maya first; without intialisation, mayapy is just a Python interpreter. Best cmdx can do is call maya.standalone.initialize() automatically, would that suffice?

[p0las]

There are very few things you can do without initialising Maya first; without intialisation, mayapy is just a Python interpreter. Best cmdx can do is call maya.standalone.initialize() automatically, would that suffice?

I'm aware that maya has to be initialised but somehow the way our complex python imports are structured we end up importing cmdx before the initialisation of maya. we do initialise it before running any code but at this point it is too late and cmdx is already missing ContainerNode class that it needs.
to me it feels like the code for maya 2015 is broken as cmdx is trying to use the class that wasn't initialised.
our fix was to simply change the fallback to newer maya than 2017 that excluded the class.

try:
    __maya_version__ = int(cmds.about(version=True))
except (AttributeError, ValueError):
    __maya_version__ = 2018

[mottosso]

Hm, that's interesting. In that case, maybe there's no need to initialise Maya and maybe there's another way to identify the version aside from calling cmds.about. Maybe looking at the path of sys.executable, e.g. c:\program files\autodesk\maya2024\bin\mayapy.exe which contains the string 2024? Can you think of anything else?

[p0las]

we do not have maya installed in the standard way so the path is completely different.
are you sure that the current version is still compatible with maya 2015? I assume that cmdx when initialised as maya 2015 should still work regardless of what maya is actually running. the code that broke on our end is extremely simple:

def _getParentsList(node):
    parent_list = []
    new_item = node
    while new_item:
        relatives = cmdx.listRelatives(new_item, parent=True) or []
        top_node_list = [n for n in relatives if n is not None]
        if top_node_list:
            new_item = top_node_list[0]
            parent_list.append(cmdx.decode(new_item))
        else:
            new_item = None
    return parent_list

it works for a bunch of iterations and then at some point starts to complain about the missing class. I'm not sure what the difference in the nodes in the hierarchy is and why it works for some not the others. but theoretically is should still work even if the module was initialised as maya 2015, shouldn't it?

[mottosso]

Mm, the minimum version overall is 2018 so that line is something that hasn't been updated yet and can safely be set to 2018. But there are still a few instances of __maya_version__ >= 2019 in there, and I expect over time Maya 2026 or whatever will add features that we need to guard against so we'll need some way to identify the version.

[p0las]

yeah. that is problematic. I can try to hunt and see if I can reorganise the imports but this is tricky as we use cmdx in some internal libraries used all over the place. I tried to move the initialisation of maya as early as possible in the __main__ in the tool that broke but that didn't help as the imports already did the damage.
maybe the version should be checked on runtime and lru_cached instead at the import?

[mottosso]

maybe the version should be checked on runtime and lru_cached instead at the import?

Sounds interesting, give it a try and if it works then feel free to make a PR.

[eeyako]

would something like this be a bad idea?:

__maya_version__ = None

def _get_maya_version():
    # Only return from global if it's been set beforehand by cmds.about below
    global __maya_version__
    if __maya_version__:
        return __maya_version__

    # Bypass import errors with sentinel value if Maya has not been initialized
    if not hasattr(cmds, 'about'):
        return float('inf')

    # Fallback to cmds call, should only happen once
    __maya_version__ = int(cmds.about(version=True))
    return __maya_version__

then:

if _get_maya_version() >= 2017:
    class ContainerNode(Node):

class AnimCurve(Node):
    if _get_maya_version() >= 2016:

etc...

[p0las]

you beat me to it. this is more or less what I was thinking. I would have used lru_cache decorator rather than a global variable but your solution is compatible with older python versions with less code.

[mottosso]

This would not actually solve the problem, since _get_maya_version() would still be called on module-import time, and we need something that's called on first use, such that it can be imported ahead of initialising Maya.

A decorator might make the most sense, something to query this version when called the first time.

def with_maya_version(version):
    def decorator(func):
        def wrapper(*args, **kwargs):
           if not hasattr(func, "_maya_version"):
               func._maya_version = _get_maya_version()

           if func._maya_version < version:
              raise RuntimeError("%s requires Maya %s" % (func.__name__, version))

            return func(*args, **kwargs)
        return wrapper
    return decorator

class _AnimCurve(Node):
   # Implementation..

@with_maya_version(2017)
def AnimCurve(mobj, exists=True):
    return _AnimCurve(mobj, exists)

(NOTE: I wrote this here and haven't actually run it)

[p0las]

you are right. the code has to be refactored in a way that is dynamic and not frozen on module import. might be a largish job depending how often in the code you check maya version.