maya-brew 0.0.4__py3-none-any.whl

maya_brew/__init__.py

@@ -0,0 +1,50 @@
+import logging
+import os
+
+import maya.api._OpenMaya_py2 as OpenMaya2  # noqa
+import maya.cmds as cmds  # noqa: F401
+
+PACKAGE_NAME = "MAYA_BREW"
+
+
+def get_bool_env_variable(name: str, default=True):
+    value = os.getenv(name)
+    if value is None:
+        return default
+    return value.lower() in ("true", "1", "t", "yes", "y")
+
+
+MAYA_BREW_AUTOINIT = get_bool_env_variable(f"{PACKAGE_NAME}_AUTOINIT", True)
+
+
+def init():
+    old_handlers = logging.root.handlers[:]
+    old_log_level = logging.getLogger().level
+    import maya_brew.log
+    from maya_brew.maya_initializer.shared import is_interactive_maya
+
+    interactive = is_interactive_maya()
+    if interactive:
+        maya_brew.log.configure(use_colors=False)
+    else:
+        maya_brew.log.configure(
+            use_colors=get_bool_env_variable(f"{PACKAGE_NAME}_USE_LOG_COLORS", True)
+        )
+    logger = maya_brew.log.get_logger(__name__)
+    logger.info("Initializing maya...")
+    os.environ["MAYA_NO_WARNING_FOR_MISSING_DEFAULT_RENDERER"] = "1"
+    if is_interactive_maya():
+        from maya_brew.maya_initializer import interactive_init
+
+        interactive_init.initialize_maya()
+    else:
+        from maya_brew.maya_initializer import standalone_init
+
+        standalone_init.initialize_maya()
+    logging.root.handlers = old_handlers
+    logging.getLogger().setLevel(old_log_level)
+    logging.debug("maya initialized")
+
+
+if MAYA_BREW_AUTOINIT:
+    init()

maya_brew/attributes/node_attribute.py

@@ -0,0 +1,176 @@
+import typing
+
+from .. import OpenMaya2, cmds
+from ..nodes import cast
+from ..nodes.node_types import DagNode, Node
+
+PlugInput = typing.Union[OpenMaya2.MPlug, str]
+A = typing.TypeVar("A", bound="Attribute")
+
+
+class Attribute:
+    _getter_type: str
+
+    def __new__(cls: type[A], plug_or_path: PlugInput) -> A:
+        if cls is not Attribute:
+            return typing.cast(A, super().__new__(cls))
+
+        if isinstance(plug_or_path, OpenMaya2.MPlug):
+            plug = plug_or_path
+        elif isinstance(plug_or_path, str):
+            plug = cls._plug_from_path(plug_or_path)
+        else:
+            raise ValueError("plug_or_path must be an MPlug or attribute path string.")
+
+        try:
+            mobj_attr = plug.attribute()
+        except (RuntimeError, ValueError) as e:
+            raise RuntimeError(
+                f"Failed to obtain MObject attribute for plug {plug}"
+            ) from e
+
+        api_type = getattr(mobj_attr, "apiTypeStr", None)
+        if not api_type:
+            raise RuntimeError(
+                f"Attribute object for plug {plug} has no apiTypeStr; cannot dispatch."
+            )
+
+        try:
+            subclass: type[Attribute] = _API_TYPE_SUBCLASS_MAP[api_type]
+        except KeyError:
+            raise NotImplementedError(
+                f"Unsupported attribute apiTypeStr '{api_type}'. "
+                f"Known types: {sorted(_API_TYPE_SUBCLASS_MAP)}"
+            )
+
+        instance = super().__new__(subclass)
+        setattr(instance, "_pre_init_plug", plug)
+        return typing.cast(A, instance)
+
+    @typing.overload
+    def __init__(self, plug_or_path: str): ...
+
+    @typing.overload
+    def __init__(self, plug_or_path: OpenMaya2.MPlug): ...
+
+    def __init__(self, plug_or_path: PlugInput):
+        # _pre_init_plug is injected by Attribute.__new__ ONLY when the user called
+        # Attribute(...) (base class factory dispatch). Direct subclass construction
+        # (e.g. FloatAttribute(...)) bypasses that path, so pre will be None and we
+        # must resolve plug_or_path here.
+        pre = getattr(self, "_pre_init_plug", None)
+        if pre is not None:
+            self.plug = pre
+            delattr(self, "_pre_init_plug")
+            return
+
+        if isinstance(plug_or_path, OpenMaya2.MPlug):
+            self.plug = plug_or_path
+        elif isinstance(plug_or_path, str):
+            self.plug = self._plug_from_path(plug_or_path)
+        else:
+            raise ValueError("plug_or_path must be an MPlug or attribute path string.")
+
+    @staticmethod
+    def _plug_from_path(path: str) -> OpenMaya2.MPlug:
+        """
+        Resolve a string path to an MPlug.
+        :param path: The full path to the attribute, e.g. '|grp|node|nodeShape.visibility'
+        :return: The MPlug for the attribute.
+        """
+        # Split path into node path and attribute name
+        if "." not in path:
+            raise ValueError(
+                "Attribute path must include a '.' separating node and attribute."
+            )
+        node_path, attr_name = path.rsplit(".", 1)
+        node_dag_path = cast.get_dag_path_from_string(node_path)
+        node = DagNode(node_dag_path.fullPathName())
+        plug = Attribute._get_plug_from_node(node, attr_name)
+        return plug
+
+    def __str__(self):
+        return self.name()
+
+    def get(self):
+        return self._get_plug_value(self.plug)
+
+    def set(self, value):
+        attr_name = self.plug.name()
+        cmds.setAttr(attr_name, value)
+
+    def node(self):
+        return self._get_node_from_plug(self.plug)
+
+    def name(self):
+        raise NotImplementedError
+
+    def connect(self, dest: "Attribute", force: bool = False, next_available=False):
+        """
+        Connect this attribute to another attribute.
+        :param dest: The destination attribute to connect to.
+        :param force: Whether to force the connection if the destination is already connected.
+        :param next_available: Whether to connect to the next available index if the destination is an array attribute.
+        """
+        cmds.connectAttr(
+            self.plug.name(),
+            dest.plug.name(),
+            force=force,
+            nextAvailable=next_available,
+        )
+
+    def disconnect(self, dest: "Attribute", next_available=False):
+        """
+        Disconnect this attribute from another attribute.
+        :param dest: The destination attribute to disconnect from.
+        :param next_available: Whether to disconnect from the next available index if the destination is an
+        array attribute.
+        """
+        cmds.disconnectAttr(
+            self.plug.name(), dest.plug.name(), nextAvailable=next_available
+        )
+
+    @classmethod
+    def _get_value(cls, node: DagNode, attr_name: str):
+        plug = cls._get_plug_from_node(node, attr_name)
+        return cls._get_plug_value(plug)
+
+    @staticmethod
+    def _get_plug_from_node(node: DagNode, attr_name: str) -> OpenMaya2.MPlug:
+        fn_dep = node.get_mfndependency_node()
+        return fn_dep.findPlug(attr_name, False)
+
+    @staticmethod
+    def _get_node_from_plug(plug: OpenMaya2.MPlug) -> Node:
+        mobj = plug.node()
+        if mobj.hasFn(OpenMaya2.MFn.kDagNode):
+            return DagNode(OpenMaya2.MFnDagNode(mobj).fullPathName())
+        else:
+            name = OpenMaya2.MFnDependencyNode(mobj).name()
+            return Node(name)
+
+    @classmethod
+    def _get_plug_value(cls, plug: OpenMaya2.MPlug):
+        return getattr(plug, cls._getter_type)()
+
+
+class FloatAttribute(Attribute):
+    _getter_type = "asDouble"
+
+
+class MessageAttribute(Attribute):
+    _getter_type = "kMessage"
+
+    @classmethod
+    def _get_plug_value(cls, plug: OpenMaya2.MPlug):
+        raise AttributeError("Message attributes do not hold data.")
+
+    @classmethod
+    def set(cls, value):
+        raise AttributeError("Message attributes are not settable.")
+
+
+_API_TYPE_SUBCLASS_MAP = {
+    "kDoubleLinearAttribute": FloatAttribute,
+    "kMessageAttribute": MessageAttribute,
+}

maya_brew/exceptions.py

@@ -0,0 +1,4 @@
+class MayaBrewException(Exception):
+    """Base class for all MayaBrew exceptions."""
+
+    pass

maya_brew/log.py

@@ -0,0 +1,338 @@
+"""
+Utilities for setting up logging in modules
+"""
+
+import datetime
+import fnmatch
+import logging
+import os
+import sys
+import threading
+import time
+from typing import Callable, List, Optional, Union
+
+import structlog
+
+from . import PACKAGE_NAME, get_bool_env_variable
+
+PROPAGATE = get_bool_env_variable(f"{PACKAGE_NAME}_LOG_PROPAGATE", False)
+
+
+TELEMETRY_PROCESSORS: List[Callable] = []
+
+
+def telemetry_runner(target_logger, method_name, event_dict):
+    """
+    Runs processors for telemetry events or events where logger is enabled for event level.
+    Drops telemetry events after processing
+    """
+    is_telemetry_event = event_dict.get("event_type") == "telemetry"
+    if is_telemetry_event:
+        run_telemetry_processors(target_logger, method_name, event_dict)
+        raise structlog.DropEvent
+    event_level = event_dict.get("level")
+    numeric_level = getattr(logging, event_level.upper(), None)
+    if target_logger.isEnabledFor(numeric_level):
+        run_telemetry_processors(target_logger, method_name, event_dict)
+    return event_dict
+
+
+def run_telemetry_processors(target_logger, method_name, event_dict):
+    for processor in TELEMETRY_PROCESSORS:
+        processor(target_logger, method_name, event_dict)
+        return event_dict
+
+
+def format_console_time(target_logger, method_name, event_dict):
+    event_dict["timestamp"] = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    return event_dict
+
+
+def configure(use_colors=False):
+    # maya doesn't seem to play nice with colors, and once structlog is configured to use colors it seems to
+    # cause problems when reconfiguring without
+
+    if not structlog.is_configured():
+        logging.basicConfig(level=logging.INFO)
+        logging.Logger.propagate = bool(PROPAGATE)
+
+    structlog.configure(
+        processors=[
+            structlog.stdlib.add_log_level,
+            structlog.contextvars.merge_contextvars,
+            structlog.stdlib.PositionalArgumentsFormatter(),
+            structlog.processors.TimeStamper(fmt="iso", utc=False),
+            structlog.processors.CallsiteParameterAdder(
+                {
+                    structlog.processors.CallsiteParameter.FILENAME,
+                    structlog.processors.CallsiteParameter.PATHNAME,
+                    structlog.processors.CallsiteParameter.MODULE,
+                    structlog.processors.CallsiteParameter.FUNC_NAME,
+                    structlog.processors.CallsiteParameter.LINENO,
+                }
+            ),
+            structlog.processors.StackInfoRenderer(),
+            structlog.processors.UnicodeDecoder(),
+            telemetry_runner,
+            format_console_time,
+            structlog.dev.ConsoleRenderer(colors=use_colors),
+        ],
+        context_class=dict,
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        wrapper_class=structlog.stdlib.BoundLogger,
+        cache_logger_on_first_use=True,
+    )
+
+
+class LogLevelContextManager:
+    def __init__(self, target_logger, level):
+        self.logger = target_logger
+        self.level = level
+        self.previous_level = target_logger.getEffectiveLevel()
+
+    def __enter__(self):
+        self.logger.setLevel(self.level)
+
+    def __call__(self, func):
+        """Allow class to be used as decorator"""
+
+        def decorator(*args, **kwargs):
+            with self:
+                return func(*args, **kwargs)
+
+        return decorator
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.logger.setLevel(self.previous_level)
+
+
+class LogAllLevelsContextManager:
+    def __init__(self, min_level=logging.CRITICAL):
+        self.min_level = min_level
+
+    def __enter__(self):
+        logging.disable(self.min_level)
+
+    def __call__(self, func):
+        """Allow class to be used as decorator"""
+
+        def decorator(*args, **kwargs):
+            with self:
+                return func(*args, **kwargs)
+
+        return decorator
+
+    def __exit__(self, exit_type, exit_value, exit_traceback):
+        logging.disable(logging.NOTSET)
+
+
+class SuppressStdOutStdErr:
+    """
+    A context manager for doing a "deep suppression" of stdout and stderr in
+    Python, i.e. will suppress all print, even if the print originates in a
+    compiled C/Fortran sub-function.
+       This will not suppress raised exceptions, since exceptions are printed
+    to stderr just before a script exits, and after the context manager has
+    exited (at least, I think that is why it lets exceptions through).
+
+    """
+
+    def __init__(
+        self, filter_list: Optional[Union[List[str], str]] = None, enable=True
+    ) -> None:
+        self.enable = enable
+        if self.enable:
+            if filter_list is None:
+                self.filter_words = []
+            elif isinstance(filter_list, str):
+                self.filter_words = [filter_list]
+            else:
+                self.filter_words = filter_list
+
+    def __enter__(self):
+        if self.enable:
+            self._stdout = sys.stdout
+            self._stderr = sys.stderr
+            self._stdout_pipe = os.pipe()
+            self._stderr_pipe = os.pipe()
+            self._stdout_fd = os.dup(1)
+            self._stderr_fd = os.dup(2)
+            os.dup2(self._stdout_pipe[1], 1)
+            os.dup2(self._stderr_pipe[1], 2)
+            self._stdout_thread = self._start_thread(self._stdout_pipe[0], self._stdout)
+            self._stderr_thread = self._start_thread(self._stderr_pipe[0], self._stderr)
+            os.close(self._stdout_pipe[1])
+            os.close(self._stderr_pipe[1])
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if self.enable:
+            os.dup2(self._stdout_fd, 1)
+            os.dup2(self._stderr_fd, 2)
+
+            os.close(self._stdout_fd)
+            os.close(self._stderr_fd)
+
+            if self._stdout_thread.is_alive():
+                self._stdout_thread.join()
+            if self._stderr_thread.is_alive():
+                self._stderr_thread.join()
+
+    def _should_filter(self, line) -> bool:
+        if not self.filter_words:
+            return True
+        line = line.strip()
+        for pattern in self.filter_words:
+            pattern = pattern
+            if "*" in pattern:
+                if fnmatch.fnmatch(line, pattern):
+                    return True
+            else:
+                if pattern in line:
+                    return True
+        return False
+
+    def _start_thread(self, read_fd, write_stream):
+        def _filter_output():
+            read_file = os.fdopen(read_fd)
+            try:
+                for line in read_file:
+                    if not self._should_filter(line):
+                        write_stream.write(line)
+                        write_stream.flush()
+            finally:
+                read_file.close()
+
+        thread = threading.Thread(target=_filter_output)
+        thread.daemon = True
+        thread.start()
+        return thread
+
+
+class ExecutionTimer:
+    def __init__(self):
+        self.elapsed_time = None
+
+    def __enter__(self):
+        self.start_time = time.time()
+        return self
+
+    def __exit__(self, type, value, traceback):
+        end_time = time.time()
+        self.elapsed_time = end_time - self.start_time
+
+
+class SilenceContextManager(SuppressStdOutStdErr):
+    pass
+
+
+class SingleLevelFilter(logging.Filter):
+    def __init__(self, passlevel, reject):
+        super(SingleLevelFilter, self).__init__()
+        self.passlevel = passlevel
+        self.reject = reject
+
+    def filter(self, record):
+        if self.reject:
+            return record.levelno != self.passlevel
+        else:
+            return record.levelno == self.passlevel
+
+
+class CustomLogger(structlog.stdlib.BoundLogger):
+    timer: ExecutionTimer
+    info_handler: logging.StreamHandler
+
+    @staticmethod
+    def all_log_levels(min_level=logging.CRITICAL):
+        return LogAllLevelsContextManager(min_level)
+
+    @staticmethod
+    def silence(filter_list: Optional[List[str]] = None, enable=True):
+        return SilenceContextManager(filter_list=filter_list, enable=enable)
+
+    @staticmethod
+    def at_level(target_logger, level):
+        return LogLevelContextManager(target_logger, level)
+
+    @staticmethod
+    def info_to_stdout(target_logger=None):
+        h1 = logging.StreamHandler(sys.stdout)
+        f1 = SingleLevelFilter(logging.INFO, False)
+        h1.addFilter(f1)
+        target_logger.addHandler(h1)
+
+    @staticmethod
+    def send_telemetry(*args, **kwargs):
+        """Sends message to any telemetry handlers on logger"""
+        raise NotImplementedError
+
+    def setLevel(self, level: Union[int, str]) -> None:
+        super().setLevel(level)  # type: ignore[arg-type]
+
+
+class TelemetryHandler:
+    """Abstract class for logging handlers to send telemetry data"""
+
+    pass
+
+
+def get_logger(name) -> CustomLogger:
+    """
+    Simple stream-logger that can also be used as a context manager.
+    Be aware of the hacky adding of methods to existing logger,
+    but overriding return type to get correct inspection in IDEs
+    """
+    logger = structlog.stdlib.get_logger(name)  # noqa
+
+    # Hacks since current versions of pytest doesn't allow subclassing
+    # of logging.getLogger
+    setattr(logger, "all_log_levels", CustomLogger.all_log_levels)
+
+    def _silence(*args, **kwargs):
+        return CustomLogger.silence(*args, **kwargs)  # noqa
+
+    setattr(logger, "silence", _silence)
+
+    setattr(logger, "timer", ExecutionTimer)
+
+    def _send_telemetry(*args, **kwargs):
+        kwargs["event_type"] = "telemetry"
+        logger.info(*args, **kwargs)
+
+    setattr(logger, "send_telemetry", _send_telemetry)
+
+    def _info_to_stdout():
+        return CustomLogger.info_to_stdout(logger)
+
+    setattr(logger, "info_to_stdout", _info_to_stdout)
+
+    def at_level(level):
+        return CustomLogger.at_level(logger, level)
+
+    setattr(logger, "at_level", at_level)
+    return logger  # type: ignore[return-value]
+
+
+def mock_telemetry_processor(logger, method_name, event_dict):
+    print(f"Sending to some telemetry service: {event_dict}")
+    return event_dict
+
+
+configure()
+
+if __name__ == "__main__":
+    TELEMETRY_PROCESSORS.append(mock_telemetry_processor)
+    configure(use_colors=True)
+    example_logger = get_logger(__name__)
+    example_logger.info("Logging configured")
+    example_logger.debug(
+        "This is a debug message and shouldn't be displayed as logging level is set to info"
+    )
+    example_logger.setLevel("DEBUG")
+    with example_logger.silence(filter_list=["filtered"]):
+        example_logger.info("this should be filtered out")
+        example_logger.info("this should not be silenced!")
+    example_logger.debug(
+        "This is a debug message and should be displayed as logging level is set to debug"
+    )

maya_brew/maya_initializer/interactive_init.py

@@ -0,0 +1,18 @@
+from .. import log
+from .interactive_utils import SuppressScriptEditorOutput
+
+# note this logger is defined before SilenceMayaContextManager is added so will not
+# silence script editor output
+logger = log.get_logger(__name__)
+# logger.setLevel("DEBUG")
+
+
+class SilenceMayaContextManager(
+    SuppressScriptEditorOutput, log.LogAllLevelsContextManager
+):
+    pass
+
+
+def initialize_maya():
+    log.SilenceContextManager = SilenceMayaContextManager
+    logger.debug("Initializing interactive maya...")

maya_brew/maya_initializer/interactive_utils.py

@@ -0,0 +1,26 @@
+import maya.OpenMaya as OpenMaya1
+
+
+class SuppressScriptEditorOutput:
+    """
+    Suppresses output to the scriptEditor
+    """
+
+    def __init__(self):
+        self.callback_id = OpenMaya1.MCommandMessage.addCommandOutputFilterCallback(
+            self.suppress
+        )
+
+    @staticmethod
+    def suppress(_, __, filter_output, ___):
+        """
+        This is the callback function that gets called when Maya wants to
+        print something suppressing the print
+        """
+        OpenMaya1.MScriptUtil.setBool(filter_output, True)
+
+    def __enter__(self):
+        pass
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        OpenMaya1.MMessage.removeCallback(self.callback_id)

maya_brew/maya_initializer/shared.py

@@ -0,0 +1,10 @@
+def is_interactive_maya():
+    """
+    Checks if maya is running in interactive mode
+    """
+    import maya.cmds as cmds
+
+    try:
+        return not cmds.about(batch=True)  # noqa
+    except (AttributeError, ImportError):
+        return False

maya_brew/maya_initializer/standalone_init.py

@@ -0,0 +1,27 @@
+from ..log import get_logger
+
+logger = get_logger(__name__)
+# logger.setLevel("DEBUG")
+
+
+def initialize_maya():
+    if cmds_about_exists():
+        return
+    with logger.silence(["This plugin does not support createPlatformOpenGLContext!"]):
+        import maya.standalone
+
+        maya.standalone.initialize(name="initialized_by_maya_brew")
+    logger.debug("initialized maya standalone")
+
+
+def cmds_about_exists():
+    try:
+        from maya.cmds import about  # noqa: F401
+
+        return True
+    except ImportError:
+        return False
+
+
+if __name__ == "__main__":
+    initialize_maya()

maya_brew/nodes/cast.py

@@ -0,0 +1,65 @@
+from .. import OpenMaya2, cmds, exceptions
+
+
+class NodeCastingException(exceptions.MayaBrewException):
+    """Base class for node casting exceptions."""
+
+    pass
+
+
+class InvalidDagPath(NodeCastingException, RuntimeError, ValueError, TypeError):
+    """Exception raised when a DAG path is invalid."""
+
+    pass
+
+
+class NonExistingDagPath(NodeCastingException, RuntimeError, ValueError, TypeError):
+    """Exception raised when a DAG path is invalid."""
+
+    pass
+
+
+class MultipleMatchingNodes(NodeCastingException):
+    """Exception raised when multiple nodes match a given name."""
+
+    pass
+
+
+class NoMatchingNodes(NodeCastingException):
+    """Exception raised when no nodes match a given name."""
+
+    pass
+
+
+def get_dag_path_from_string(node_path: str) -> OpenMaya2.MDagPath:
+    """
+    Convert a string representation of a node path to an OpenMaya2.MDagPath object.
+    """
+    selection_list = OpenMaya2.MSelectionList()
+    try:
+        selection_list.add(node_path)
+        dag_path = selection_list.getDagPath(0)
+    except RuntimeError as e:
+        if "Object does not exist" in str(e):
+            raise NonExistingDagPath(f"Dag Path does not exist: {node_path}") from e
+        raise
+    except TypeError as e:
+        if "item is not a DAG path" in str(e):
+            raise InvalidDagPath(f"{node_path} exists but is not a dag object") from e
+        raise
+    return dag_path
+
+
+def get_long_name_from_maya_string(name: str) -> str:
+    """
+    Convert a unique maya.cmds node string to a long name.
+    """
+    matching_nodes = cmds.ls(name, long=True)
+    if not matching_nodes:
+        raise NoMatchingNodes(f"No objects matching '{name}' in scene")
+    num_nodes = len(matching_nodes)
+    if num_nodes > 1:
+        raise MultipleMatchingNodes(
+            f"Multiple objects matching '{name}' in scene. Found {num_nodes} nodes: {matching_nodes}"
+        )
+    return matching_nodes[0]

maya_brew/nodes/node_types.py

@@ -0,0 +1,87 @@
+from typing import Any, Callable, Dict, Self
+
+from .. import OpenMaya2, cmds
+from ..log import get_logger
+from ..nodes import cast
+
+logger = get_logger(__name__)
+logger.setLevel("DEBUG")
+
+
+class Node:
+    _cmds_creator: Callable[..., str]
+    _cmds_creator_args: Dict[str, Any] = {}
+
+    def __init__(self, node_path: str):
+        self.node_path = node_path
+
+    def __str__(self):
+        return self.node_path
+
+    def __repr__(self):
+        return f'{type(self).__name__}("{str(self)}")'
+
+    def rename(self, new_name: str, *args, **kwargs) -> str:
+        """
+        Rename the current node. If new name is not unique maya will resolve a new unique name.
+        :param new_name: The new name of the node.
+        :return: The new name of the node.
+        """
+        actual_new_name = cmds.rename(str(self), new_name, *args, **kwargs)
+        self.node_path = actual_new_name
+        return actual_new_name
+
+    def _cmd_caller(self, func_name, *args, **kwargs):
+        return cmds.attr(func_name, self.node_path, *args, **kwargs)
+
+    @classmethod
+    def create(cls, name: str, **kwargs) -> Self:
+        """
+        Create a new transform node.
+        :param name: The name of the new transform node.
+        :return: The new transform node.
+        """
+        kwargs.update(cls._cmds_creator_args)
+        kwargs["name"] = name
+        cmds_value = cls._cmds_creator(**kwargs)  # noqa: E1102
+        if cmds_value != name:
+            logger.debug(f"Name was not unique. New name: {cmds_value}.")
+        return cls(cmds_value)
+
+
+class DagNode(Node):
+    def __init__(self, node_path: str):
+        super().__init__(node_path)
+        self.dag_path = cast.get_dag_path_from_string(node_path)
+
+    def __str__(self):
+        return self.get_full_path()
+
+    def get_depend_node(self) -> OpenMaya2.MObject:
+        """
+        Get the depend node of the current node.
+        :return: The depend node of the current node.
+        """
+        return self.dag_path.node()
+
+    def get_full_path(self) -> str:
+        """
+        Get the full path of the current node.
+        :return: The full path of the current node.
+        """
+        full_path = self.dag_path.fullPathName()
+        if not full_path:
+            logger.warning(f"Node has been deleted. Original path: {self.node_path}")
+        return full_path
+
+    def get_mfndependency_node(self) -> OpenMaya2.MFnDependencyNode:
+        """
+        Get the MFnDependencyNode of the current node.
+        :return: The MFnDependencyNode of the current node.
+        """
+        return OpenMaya2.MFnDependencyNode(self.get_depend_node())
+
+
+class Transform(DagNode):
+    _cmds_creator = cmds.group
+    _cmds_creator_args = {"empty": True}

maya_brew/scene.py

@@ -0,0 +1,25 @@
+import maya_brew
+
+from .exceptions import MayaBrewException
+
+
+class SceneException(MayaBrewException):
+    """Base class for scene-related exceptions."""
+
+    pass
+
+
+class UnsavedChanges(SceneException, RuntimeError):
+    """Exception raised when there are unsaved changes in the scene."""
+
+    pass
+
+
+def new_file(force=True):
+    try:
+        return maya_brew.cmds.file(newFile=True, force=force)
+    except RuntimeError as e:
+        message = str(e).strip()
+        if message == "Unsaved changes.":
+            raise UnsavedChanges(message) from e
+        raise SceneException(message) from e

maya_brew/utils.py

@@ -0,0 +1,26 @@
+import importlib
+import sys
+from pathlib import Path
+
+from .log import get_logger
+
+logger = get_logger(__name__)
+logger.setLevel("DEBUG")
+
+
+def reload_mb():
+    """
+    Workaround to reload entire maya-brew library.
+    Removes all maya-brew modules from 'sys.modules' and imports it again
+    """
+
+    import maya_brew
+
+    mb_path = Path(maya_brew.__file__)
+    mb_modules = list()
+    for m in [p for p in sys.modules if p.startswith(mb_path.parent.name)]:
+        mb_modules.append(m)
+        sys.modules.pop(m)
+    for m in mb_modules:
+        logger.debug(f"re-importing {m}")
+        importlib.import_module(m)

maya_brew-0.0.4.dist-info/METADATA

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: maya-brew
+Version: 0.0.4
+Summary: Safe interaction with python in maya
+Project-URL: Homepage, https://github.com/mortenbohne/maya-brew
+Project-URL: Repository, https://github.com/mortenbohne/maya-brew
+Project-URL: Documentation, https://github.com/mortenbohne/maya-brew#readme
+Project-URL: Issues, https://github.com/mortenbohne/maya-brew/issues
+Project-URL: Changelog, https://github.com/mortenbohne/maya-brew/releases
+Author-email: Morten Bøhne <github@mortenbohne.dk>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: 3d,autodesk,maya,pipeline
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Graphics :: 3D Modeling
+Requires-Python: >=3.11
+Requires-Dist: colorama
+Requires-Dist: structlog
+Provides-Extra: dev
+Requires-Dist: maya-stubs; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# maya-brew
+
+> **Status: Pre-Alpha** – Interfaces are experimental and may change without notice. Pin exact versions if using in
+> automation.
+
+What you need after a long day of wrestling with Maya Python.
+
+[![Super-Linter](https://github.com/mortenbohne/maya-brew/actions/workflows/linter.yml/badge.svg)](https://github.com/marketplace/actions/super-linter)
+
+---
+
+## Overview
+
+`maya-brew` aims to provide safer, more structured interaction patterns when scripting or tooling inside Autodesk Maya.
+
+Goals:
+
+- Reduce foot‑guns when using Python inside Maya
+- Offer utilities that behave well with Maya’s quirks
+
+## Background
+
+`maya-brew` draws inspiration from some of the ergonomic goals that motivated
+[PyMEL](https://github.com/LumaPictures/pymel): making Maya’s Python interface feel more “Pythonic,” safer, and more
+discoverable. PyMEL historically provided rich object wrappers around nodes, attributes, and other scene elements;
+for many workflows this improved readability and reduced boilerplate.
+
+However, over time several practical factors led to the decision to start a lightweight alternative instead of
+extending PyMEL itself:
+
+- Scope & Complexity: PyMEL’s dynamic wrapping and layered abstractions can introduce startup overhead, indirection, and
+  occasional debugging friction.
+- Historical Churn: A long evolution, multiple contributors, and some legacy design choices make selective modernization
+  non‑trivial.
+- Maintenance & Momentum: While still usable, PyMEL no longer appears to have the same pace of active development or
+  broad community push it once did.
+- Adoption Fit: Many pipelines only need a thin set of safety/ergonomic helpers—not a full object layer over
+  `maya.cmds`.
+
+### Acknowledgment
+
+PyMEL significantly influenced how many technical artists approach Maya scripting, and this project stands on that
+conceptual foundation. `maya-brew` simply narrows the focus: take the useful ergonomic ideas, shed the heavy wrapping,
+and keep to the canonical APIs.

maya_brew-0.0.4.dist-info/RECORD

@@ -0,0 +1,19 @@
+maya_brew/__init__.py,sha256=OkRwh4MmWcBtsttw3kkR8SEZhlK7rNLoQQexzRLEmTI,1431
+maya_brew/exceptions.py,sha256=se87z8Fo6phDroKCtNd4detMQuS6nabNeqjeqYW41_Y,96
+maya_brew/log.py,sha256=bK8sIJjD8Hziy3_N2maz3HWU0OFPl9SO1SoqpZoRf_A,10735
+maya_brew/scene.py,sha256=8gNR1bIr99cUiyH9PQUTiqcWKOEZzflRFOBsSMRe5qQ,598
+maya_brew/utils.py,sha256=HeqXcMHHilT4B5bOobAH9ZHwtCuKe4nVu_3DiS7aFsw,618
+maya_brew/attributes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maya_brew/attributes/node_attribute.py,sha256=J8Vf_qWDDfzdIPWx1PLo82sb8bKKVac6U_FuWRusiCc,5997
+maya_brew/maya_initializer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maya_brew/maya_initializer/interactive_init.py,sha256=a6KCLDRUUuK9W9rzKzb2Lf0t6p-8yVmGkVshIffob5A,500
+maya_brew/maya_initializer/interactive_utils.py,sha256=vpq7TVjAj0L1Wcbaq3IEqLZODcfeeytLC5bDzL05QxQ,692
+maya_brew/maya_initializer/shared.py,sha256=Ot58zYLhHCOMR_AU9Rw65BwvKXioGRsD9_jSUqfRIcs,245
+maya_brew/maya_initializer/standalone_init.py,sha256=iWV3eMSzeYO1uqT9oRYSyB6Tn-XlPOeTmI8l4LajUmw,594
+maya_brew/nodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maya_brew/nodes/cast.py,sha256=fuEsSbkulwzQ2r12Pk7Ux6ays85u9e5SsTRAW8ejsQo,1906
+maya_brew/nodes/node_types.py,sha256=NYZ1-Eqh5ks-org6xeXhWMQx-jroXspUMRx_Qk8RmvI,2707
+maya_brew-0.0.4.dist-info/METADATA,sha256=iR0pNoE1OHXIHbZ4wuwowYVhE7WaHjED_2HeuQpUojM,3112
+maya_brew-0.0.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+maya_brew-0.0.4.dist-info/licenses/LICENSE,sha256=M8rkKXCsDdVH3gxjabYl5pH9TzX9GrMmwlXyjlwjnkE,1070
+maya_brew-0.0.4.dist-info/RECORD,,

maya_brew-0.0.4.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

maya_brew-0.0.4.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Morten Bøhne
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.