Add Blender 2.80 support (this will resolve #361)

avalon/blender/__init__.py

@@ -0,0 +1,58 @@
+"""Public API
+
+Anything that isn't defined here is INTERNAL and unreliable for external use.
+
+"""
+
+from .pipeline import (
+    install,
+    uninstall,
+    Creator,
+    Loader,
+    ls,
+    publish,
+    containerise,
+)
+
+from .workio import (
+    open_file,
+    save_file,
+    current_file,
+    has_unsaved_changes,
+    file_extensions,
+    work_root,
+)
+
+from .lib import (
+    lsattr,
+    lsattrs,
+    read,
+    maintained_selection,
+    # unique_name,
+)
+
+
+__all__ = [
+    "install",
+    "uninstall",
+    "Creator",
+    "Loader",
+    "ls",
+    "publish",
+    "containerise",
+
+    # Workfiles API
+    "open",
+    "save",
+    "current_file",
+    "has_unsaved_changes",
+    "file_extensions",
+    "work_root",
+
+    # Utility functions
+    "maintained_selection",
+    "lsattr",
+    "lsattrs",
+    "read",
+    # "unique_name",
+]

avalon/blender/lib.py

@@ -0,0 +1,154 @@
+"""Standalone helper functions."""
+
+import contextlib
+from typing import Dict, List, Union
+
+import bpy
+
+from ..lib import logger
+from . import pipeline
+
+
+def imprint(node: bpy.types.bpy_struct_meta_idprop, data: Dict):
+    r"""Write `data` to `node` as userDefined attributes
+
+    Arguments:
+        node: Long name of node
+        data: Dictionary of key/value pairs
+
+    Example:
+        >>> import bpy
+        >>> def compute():
+        ...   return 6
+        ...
+        >>> bpy.ops.mesh.primitive_cube_add()
+        >>> cube = bpy.context.view_layer.objects.active
+        >>> imprint(cube, {
+        ...   "regularString": "myFamily",
+        ...   "computedValue": lambda: compute()
+        ... })
+        ...
+        >>> cube['avalon']['computedValue']
+        6
+
+    """
+
+    imprint_data = dict()
+
+    for key, value in data.items():
+        if value is None:
+            continue
+
+        if callable(value):
+            # Support values evaluated at imprint
+            value = value()
+
+        if not isinstance(value, (int, float, bool, str, list)):
+            raise TypeError(f"Unsupported type: {type(value)}")
+
+        imprint_data[key] = value
+
+    pipeline.metadata_update(node, imprint_data)
+
+
+def lsattr(attr: str,
+           value: Union[str, int, bool, List, Dict, None] = None) -> List:
+    r"""Return nodes matching `attr` and `value`
+
+    Arguments:
+        attr: Name of Blender property
+        value: Value of attribute. If none
+            is provided, return all nodes with this attribute.
+
+    Example:
+        >>> lsattr("id", "myId")
+        ...   [bpy.data.objects["myNode"]
+        >>> lsattr("id")
+        ...   [bpy.data.objects["myNode"], bpy.data.objects["myOtherNode"]]
+
+    Returns:
+        list
+    """
+    return lsattrs({attr: value})
+
+
+def lsattrs(attrs: Dict) -> List:
+    r"""Return nodes with the given attribute(s).
+
+    Arguments:
+        attrs: Name and value pairs of expected matches
+
+    Example:
+        >>> lsattrs({"age": 5})  # Return nodes with an `age` of 5
+        # Return nodes with both `age` and `color` of 5 and blue
+        >>> lsattrs({"age": 5, "color": "blue"})
+
+    Returns a list.
+
+    """
+    # For now return all objects, not filtered by scene/collection/view_layer.
+    matches = set()
+    for coll in dir(bpy.data):
+        if not isinstance(
+                getattr(bpy.data, coll),
+                bpy.types.bpy_prop_collection,
+        ):
+            continue
+        for node in getattr(bpy.data, coll):
+            for attr, value in attrs.items():
+                avalon_prop = node.get(pipeline.AVALON_PROPERTY)
+                if not avalon_prop:
+                    continue
+                if avalon_prop.get(attr) and (value is None or
+                                              avalon_prop.get(attr) == value):
+                    matches.add(node)
+    return list(matches)
+
+
+def read(node: bpy.types.bpy_struct_meta_idprop):
+    """Return user-defined attributes from `node`"""
+    data = dict(node.get(pipeline.AVALON_PROPERTY))
+
+    # Ignore hidden/internal data
+    data = {
+        key: value
+        for key, value in data.items() if not key.startswith("_")
+    }
+
+    return data
+
+
+@contextlib.contextmanager
+def maintained_selection():
+    r"""Maintain selection during context
+
+    Example:
+        >>> with maintained_selection():
+        ...     # Modify selection
+        ...     bpy.ops.object.select_all(action='DESELECT')
+        >>> # Selection restored
+    """
+
+    previous_selection = bpy.context.selected_objects
+    previous_active = bpy.context.view_layer.objects.active
+    try:
+        yield
+    finally:
+        # Clear the selection
+        for node in bpy.context.selected_objects:
+            node.select_set(state=False)
+        if previous_selection:
+            for node in previous_selection:
+                try:
+                    node.select_set(state=True)
+                except ReferenceError:
+                    # This could happen if a selected node was deleted during
+                    # the context.
+                    logger.exception("Failed to reselect")
+                    continue
+        try:
+            bpy.context.view_layer.objects.active = previous_active
+        except ReferenceError:
+            # This could happen if the active node was deleted during the
+            # context.
+            logger.exception("Failed to set active object.")