blender-cloud-addon/blender_cloud/blender.py

# ##### BEGIN GPL LICENSE BLOCK #####
#
#  This program is free software; you can redistribute it and/or
#  modify it under the terms of the GNU General Public License
#  as published by the Free Software Foundation; either version 2
#  of the License, or (at your option) any later version.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software Foundation,
#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# ##### END GPL LICENSE BLOCK #####

"""Blender-specific code.

Separated from __init__.py so that we can import & run from non-Blender environments.
"""
import functools
import logging
import os.path
import tempfile

import bpy
from bpy.types import AddonPreferences, Operator, WindowManager, Scene, PropertyGroup
from bpy.props import (
    StringProperty,
    EnumProperty,
    PointerProperty,
    BoolProperty,
    IntProperty,
)
import rna_prop_ui

from . import compatibility, pillar, async_loop, flamenco, project_specific
from .utils import pyside_cache, redraw

PILLAR_WEB_SERVER_URL = os.environ.get("BCLOUD_SERVER", "https://cloud.blender.org/")
PILLAR_SERVER_URL = "%sapi/" % PILLAR_WEB_SERVER_URL

ADDON_NAME = "blender_cloud"
log = logging.getLogger(__name__)
icons = None


@pyside_cache("version")
def blender_syncable_versions(self, context):
    """Returns the list of items used by SyncStatusProperties.version EnumProperty."""

    bss = context.window_manager.blender_sync_status
    versions = bss.available_blender_versions
    if not versions:
        return [("", "No settings stored in your Blender Cloud", "")]
    return [(v, v, "") for v in versions]


@compatibility.convert_properties
class SyncStatusProperties(PropertyGroup):
    status = EnumProperty(
        items=[
            ("NONE", "NONE", "We have done nothing at all yet."),
            (
                "IDLE",
                "IDLE",
                "User requested something, which is done, and we are now idle.",
            ),
            ("SYNCING", "SYNCING", "Synchronising with Blender Cloud."),
        ],
        name="status",
        description="Current status of Blender Sync",
        update=redraw,
    )

    version = EnumProperty(
        items=blender_syncable_versions,
        name="Version of Blender from which to pull",
        description="Version of Blender from which to pull",
    )

    message = StringProperty(name="message", update=redraw)
    level = EnumProperty(
        items=[
            ("INFO", "INFO", ""),
            ("WARNING", "WARNING", ""),
            ("ERROR", "ERROR", ""),
            ("SUBSCRIBE", "SUBSCRIBE", ""),
        ],
        name="level",
        update=redraw,
    )

    def report(self, level: set, message: str):
        assert len(level) == 1, "level should be a set of one string, not %r" % level
        self.level = level.pop()
        self.message = message

        # Message can also be empty, just to erase it from the GUI.
        # No need to actually log those.
        if message:
            try:
                loglevel = logging._nameToLevel[self.level]
            except KeyError:
                loglevel = logging.WARNING
            log.log(loglevel, message)

    # List of syncable versions is stored in 'available_blender_versions' ID property,
    # because I don't know how to store a variable list of strings in a proper RNA property.
    @property
    def available_blender_versions(self) -> list:
        return self.get("available_blender_versions", [])

    @available_blender_versions.setter
    def available_blender_versions(self, new_versions):
        self["available_blender_versions"] = new_versions


@pyside_cache("project")
def bcloud_available_projects(self, context):
    """Returns the list of items used by BlenderCloudProjectGroup.project EnumProperty."""

    projs = preferences().project.available_projects
    if not projs:
        return [("", "No projects available in your Blender Cloud", "")]
    return [(p["_id"], p["name"], "") for p in projs]


@functools.lru_cache(1)
def project_extensions(project_id) -> set:
    """Returns the extensions the project is enabled for.

    At the moment of writing these are 'attract' and 'flamenco'.
    """

    log.debug("Finding extensions for project %s", project_id)

    # We can't use our @property, since the preferences may be loaded from a
    # preferences blend file, in which case it is not constructed from Python code.
    available_projects = preferences().project.get("available_projects", [])
    if not available_projects:
        log.debug("No projects available.")
        return set()

    proj = next((p for p in available_projects if p["_id"] == project_id), None)
    if proj is None:
        log.debug("Project %s not found in available projects.", project_id)
        return set()

    return set(proj.get("enabled_for", ()))


@compatibility.convert_properties
class BlenderCloudProjectGroup(PropertyGroup):
    status = EnumProperty(
        items=[
            ("NONE", "NONE", "We have done nothing at all yet"),
            (
                "IDLE",
                "IDLE",
                "User requested something, which is done, and we are now idle",
            ),
            ("FETCHING", "FETCHING", "Fetching available projects from Blender Cloud"),
        ],
        name="status",
        update=redraw,
    )

    project = EnumProperty(
        items=bcloud_available_projects,
        name="Cloud project",
        description="Which Blender Cloud project to work with",
        update=project_specific.handle_project_update,
    )

    # List of projects is stored in 'available_projects' ID property,
    # because I don't know how to store a variable list of strings in a proper RNA property.
    @property
    def available_projects(self) -> list:
        return self.get("available_projects", [])

    @available_projects.setter
    def available_projects(self, new_projects):
        self["available_projects"] = new_projects
        project_specific.handle_project_update()


@compatibility.convert_properties
class BlenderCloudPreferences(AddonPreferences):
    bl_idname = ADDON_NAME

    # The following property is read-only to limit the scope of the
    # addon and allow for proper testing within this scope.
    pillar_server = StringProperty(
        name="Blender Cloud Server",
        description="URL of the Blender Cloud backend server",
        default=PILLAR_SERVER_URL,
        get=lambda self: PILLAR_SERVER_URL,
    )

    local_texture_dir = StringProperty(
        name="Default Blender Cloud Texture Storage Directory",
        subtype="DIR_PATH",
        default="//textures",
    )

    open_browser_after_share = BoolProperty(
        name="Open Browser after Sharing File",
        description="When enabled, Blender will open a webbrowser",
        default=True,
    )

    # TODO: store project-dependent properties with the project, so that people
    # can switch projects and the Attract and Flamenco properties switch with it.
    project = PointerProperty(type=BlenderCloudProjectGroup)

    cloud_project_local_path = StringProperty(
        name="Local Project Path",
        description="Local path of your Attract project, used to search for blend files; "
        "usually best to set to an absolute path",
        subtype="DIR_PATH",
        default="//../",
        update=project_specific.store,
    )

    flamenco_manager = PointerProperty(type=flamenco.FlamencoManagerGroup)
    flamenco_exclude_filter = StringProperty(
        name="File Exclude Filter",
        description='Space-separated list of filename filters, like "*.abc *.mkv", to prevent '
        "matching files from being packed into the output directory",
        default="",
        update=project_specific.store,
    )
    flamenco_job_file_path = StringProperty(
        name="Job Storage Path",
        description="Path where to store job files, should be accesible for Workers too",
        subtype="DIR_PATH",
        default=tempfile.gettempdir(),
        update=project_specific.store,
    )
    flamenco_job_output_path = StringProperty(
        name="Job Output Path",
        description="Path where to store output files, should be accessible for Workers",
        subtype="DIR_PATH",
        default=tempfile.gettempdir(),
        update=project_specific.store,
    )
    flamenco_job_output_strip_components = IntProperty(
        name="Job Output Path Strip Components",
        description="The final output path comprises of the job output path, and the blend file "
        "path relative to the project with this many path components stripped off "
        "the front",
        min=0,
        default=0,
        soft_max=4,
        update=project_specific.store,
    )
    flamenco_relative_only = BoolProperty(
        name="Relative Paths Only",
        description="When enabled, only assets that are referred to with a relative path are "
        "packed, and assets referred to by an absolute path are excluded from the "
        "BAT pack. When disabled, all assets are packed",
        default=False,
        update=project_specific.store,
    )

    flamenco_open_browser_after_submit = BoolProperty(
        name="Open Browser after Submitting Job",
        description="When enabled, Blender will open a webbrowser",
        default=True,
    )
    flamenco_show_quit_after_submit_button = BoolProperty(
        name='Show "Submit & Quit" button',
        description='When enabled, next to the "Render on Flamenco" button there will be a button '
        '"Submit & Quit" that silently quits Blender after submitting the render job '
        "to Flamenco",
        default=False,
    )

    def draw(self, context):
        import textwrap

        layout = self.layout

        # Carefully try and import the Blender ID addon
        try:
            import blender_id
        except ImportError:
            blender_id = None
            blender_id_profile = None
        else:
            blender_id_profile = blender_id.get_active_profile()
        if blender_id is None:

            msg_icon = "ERROR"
            text = "This add-on requires Blender ID"
            help_text = (
                "Make sure that the Blender ID add-on is installed and activated"
            )
        elif not blender_id_profile:
            msg_icon = "ERROR"
            text = "You are logged out."
            help_text = "To login, go to the Blender ID add-on preferences."
        elif bpy.app.debug and pillar.SUBCLIENT_ID not in blender_id_profile.subclients:
            msg_icon = "QUESTION"
            text = "No Blender Cloud credentials."
            help_text = (
                "You are logged in on Blender ID, but your credentials have not "
                "been synchronized with Blender Cloud yet. Press the Update "
                "Credentials button."
            )
        else:
            msg_icon = "WORLD_DATA"
            text = "You are logged in as %s." % blender_id_profile.username
            help_text = (
                "To logout or change profile, "
                "go to the Blender ID add-on preferences."
            )

        # Authentication stuff
        auth_box = layout.box()
        auth_box.label(text=text, icon=msg_icon)

        help_lines = textwrap.wrap(help_text, 80)
        for line in help_lines:
            auth_box.label(text=line)
        if bpy.app.debug:
            auth_box.operator("pillar.credentials_update")

        # Texture browser stuff
        texture_box = layout.box()
        texture_box.enabled = msg_icon != "ERROR"
        sub = texture_box.column()
        sub.label(
            text="Local directory for downloaded textures", icon_value=icon("CLOUD")
        )
        sub.prop(self, "local_texture_dir", text="Default")
        sub.prop(context.scene, "local_texture_dir", text="Current scene")

        # Blender Sync stuff
        bss = context.window_manager.blender_sync_status
        bsync_box = layout.box()
        bsync_box.enabled = msg_icon != "ERROR"
        row = bsync_box.row().split(**compatibility.factor(0.33))
        row.label(text="Blender Sync with Blender Cloud", icon_value=icon("CLOUD"))

        icon_for_level = {
            "INFO": "NONE",
            "WARNING": "INFO",
            "ERROR": "ERROR",
            "SUBSCRIBE": "ERROR",
        }
        msg_icon = icon_for_level[bss.level] if bss.message else "NONE"
        message_container = row.row()
        message_container.label(text=bss.message, icon=msg_icon)

        sub = bsync_box.column()

        if bss.level == "SUBSCRIBE":
            self.draw_subscribe_button(sub)
        self.draw_sync_buttons(sub, bss)

        # Image Share stuff
        share_box = layout.box()
        share_box.label(text="Image Sharing on Blender Cloud", icon_value=icon("CLOUD"))
        share_box.prop(self, "open_browser_after_share")

        # Project selector
        project_box = layout.box()
        project_box.enabled = self.project.status in {"NONE", "IDLE"}

        self.draw_project_selector(project_box, self.project)
        extensions = project_extensions(self.project.project)

        # Flamenco stuff
        if "flamenco" in extensions:
            flamenco_box = project_box.column()
            self.draw_flamenco_buttons(flamenco_box, self.flamenco_manager, context)

    def draw_subscribe_button(self, layout):
        layout.operator("pillar.subscribe", icon="WORLD")

    def draw_sync_buttons(self, layout, bss):
        layout.enabled = bss.status in {"NONE", "IDLE"}

        buttons = layout.column()
        row_buttons = buttons.row().split(**compatibility.factor(0.5))
        row_push = row_buttons.row()
        row_pull = row_buttons.row(align=True)

        row_push.operator(
            "pillar.sync",
            text="Save %i.%i settings" % bpy.app.version[:2],
            icon="TRIA_UP",
        ).action = "PUSH"

        versions = bss.available_blender_versions
        if bss.status in {"NONE", "IDLE"}:
            if not versions:
                row_pull.operator(
                    "pillar.sync", text="Find version to load", icon="TRIA_DOWN"
                ).action = "REFRESH"
            else:
                props = row_pull.operator(
                    "pillar.sync",
                    text="Load %s settings" % bss.version,
                    icon="TRIA_DOWN",
                )
                props.action = "PULL"
                props.blender_version = bss.version
                row_pull.operator(
                    "pillar.sync", text="", icon=compatibility.SYNC_SELECT_VERSION_ICON
                ).action = "SELECT"
        else:
            row_pull.label(text="Cloud Sync is running.")

    def draw_project_selector(self, project_box, bcp: BlenderCloudProjectGroup):
        project_row = project_box.row(align=True)
        project_row.label(text="Project settings", icon_value=icon("CLOUD"))

        row_buttons = project_row.row(align=True)

        projects = bcp.available_projects
        project = bcp.project
        if bcp.status in {"NONE", "IDLE"}:
            if not projects:
                row_buttons.operator(
                    "pillar.projects", text="Find project to load", icon="FILE_REFRESH"
                )
            else:
                row_buttons.prop(bcp, "project")
                row_buttons.operator("pillar.projects", text="", icon="FILE_REFRESH")
                props = row_buttons.operator(
                    "pillar.project_open_in_browser", text="", icon="WORLD"
                )
                props.project_id = project
        else:
            row_buttons.label(text="Fetching available projects.")

        enabled_for = project_extensions(project)
        if not project:
            return

        if not enabled_for:
            project_box.label(text="This project is not set up for Attract or Flamenco")
            return

        project_box.label(
            text="This project is set up for: %s" % ", ".join(sorted(enabled_for))
        )

        # This is only needed when the project is set up for either Attract or Flamenco.
        project_box.prop(self, "cloud_project_local_path", text="Local Project Path")

    def draw_flamenco_buttons(
        self, flamenco_box, bcp: flamenco.FlamencoManagerGroup, context
    ):
        header_row = flamenco_box.row(align=True)
        header_row.label(text="Flamenco:", icon_value=icon("CLOUD"))

        manager_split = flamenco_box.split(**compatibility.factor(0.32), align=True)
        manager_split.label(text="Manager:")
        manager_box = manager_split.row(align=True)

        if bcp.status in {"NONE", "IDLE"}:
            if not bcp.available_managers:
                manager_box.operator(
                    "flamenco.managers",
                    text="Find Flamenco Managers",
                    icon="FILE_REFRESH",
                )
            else:
                manager_box.prop(bcp, "manager", text="")
                manager_box.operator("flamenco.managers", text="", icon="FILE_REFRESH")
        else:
            manager_box.label(text="Fetching available managers.")

        path_split = flamenco_box.split(**compatibility.factor(0.32), align=True)
        path_split.label(text="Job File Path:")
        path_box = path_split.row(align=True)
        path_box.prop(self, "flamenco_job_file_path", text="")
        props = path_box.operator(
            "flamenco.explore_file_path", text="", icon="DISK_DRIVE"
        )
        props.path = self.flamenco_job_file_path

        job_output_box = flamenco_box.column(align=True)
        path_split = job_output_box.split(**compatibility.factor(0.32), align=True)
        path_split.label(text="Job Output Path:")
        path_box = path_split.row(align=True)
        path_box.prop(self, "flamenco_job_output_path", text="")
        props = path_box.operator(
            "flamenco.explore_file_path", text="", icon="DISK_DRIVE"
        )
        props.path = self.flamenco_job_output_path
        job_output_box.prop(self, "flamenco_exclude_filter")

        prop_split = job_output_box.split(**compatibility.factor(0.32), align=True)
        prop_split.label(text="Strip Components:")
        prop_split.prop(self, "flamenco_job_output_strip_components", text="")

        from .flamenco import render_output_path

        path_box = job_output_box.row(align=True)
        output_path = render_output_path(context)
        if output_path:
            path_box.label(text=str(output_path))
            props = path_box.operator(
                "flamenco.explore_file_path", text="", icon="DISK_DRIVE"
            )
            props.path = str(output_path.parent)
        else:
            path_box.label(
                text="Blend file is not in your project path, "
                "unable to give output path example."
            )

        flamenco_box.prop(self, "flamenco_relative_only")
        flamenco_box.prop(self, "flamenco_open_browser_after_submit")
        flamenco_box.prop(self, "flamenco_show_quit_after_submit_button")


class PillarCredentialsUpdate(pillar.PillarOperatorMixin, Operator):
    """Updates the Pillar URL and tests the new URL."""

    bl_idname = "pillar.credentials_update"
    bl_label = "Update credentials"
    bl_description = "Resynchronises your Blender ID login with Blender Cloud"

    log = logging.getLogger("bpy.ops.%s" % bl_idname)

    @classmethod
    def poll(cls, context):
        # Only allow activation when the user is actually logged in.
        return cls.is_logged_in(context)

    @classmethod
    def is_logged_in(cls, context):
        try:
            import blender_id
        except ImportError:
            return False

        return blender_id.is_logged_in()

    def execute(self, context):
        import blender_id
        import asyncio

        # Only allow activation when the user is actually logged in.
        if not self.is_logged_in(context):
            self.report({"ERROR"}, "No active profile found")
            return {"CANCELLED"}

        try:
            loop = asyncio.get_event_loop()
            loop.run_until_complete(self.check_credentials(context, set()))
        except blender_id.BlenderIdCommError as ex:
            log.exception("Error sending subclient-specific token to Blender ID")
            self.report({"ERROR"}, "Failed to sync Blender ID to Blender Cloud")
            return {"CANCELLED"}
        except Exception as ex:
            log.exception("Error in test call to Pillar")
            self.report({"ERROR"}, "Failed test connection to Blender Cloud")
            return {"CANCELLED"}

        self.report({"INFO"}, "Blender Cloud credentials & endpoint URL updated.")
        return {"FINISHED"}


class PILLAR_OT_subscribe(Operator):
    """Opens a browser to subscribe the user to the Cloud."""

    bl_idname = "pillar.subscribe"
    bl_label = "Subscribe to the Cloud"
    bl_description = "Opens a page in a web browser to subscribe to the Blender Cloud"

    def execute(self, context):
        import webbrowser

        webbrowser.open_new_tab("https://cloud.blender.org/join")
        self.report({"INFO"}, "We just started a browser for you.")

        return {"FINISHED"}


@compatibility.convert_properties
class PILLAR_OT_project_open_in_browser(Operator):
    bl_idname = "pillar.project_open_in_browser"
    bl_label = "Open in Browser"
    bl_description = "Opens a webbrowser to show the project"

    project_id = StringProperty(name="Project ID")

    def execute(self, context):
        if not self.project_id:
            return {"CANCELLED"}

        import webbrowser
        import urllib.parse

        import pillarsdk
        from .pillar import sync_call

        project = sync_call(
            pillarsdk.Project.find, self.project_id, {"projection": {"url": True}}
        )

        if log.isEnabledFor(logging.DEBUG):
            import pprint

            log.debug("found project: %s", pprint.pformat(project.to_dict()))

        url = urllib.parse.urljoin(PILLAR_WEB_SERVER_URL, "p/" + project.url)
        webbrowser.open_new_tab(url)
        self.report({"INFO"}, "Opened a browser at %s" % url)

        return {"FINISHED"}


class PILLAR_OT_projects(
    async_loop.AsyncModalOperatorMixin,
    pillar.AuthenticatedPillarOperatorMixin,
    Operator,
):
    """Fetches the projects available to the user"""

    bl_idname = "pillar.projects"
    bl_label = "Fetch available projects"

    stop_upon_exception = True
    _log = logging.getLogger("bpy.ops.%s" % bl_idname)

    async def async_execute(self, context):
        if not await self.authenticate(context):
            return

        import pillarsdk
        from .pillar import pillar_call

        self.log.info("Going to fetch projects for user %s", self.user_id)

        preferences().project.status = "FETCHING"

        # Get all projects, except the home project.
        projects_user = await pillar_call(
            pillarsdk.Project.all,
            {
                "where": {"user": self.user_id, "category": {"$ne": "home"}},
                "sort": "-name",
                "projection": {"_id": True, "name": True, "extension_props": True},
            },
        )

        projects_shared = await pillar_call(
            pillarsdk.Project.all,
            {
                "where": {
                    "user": {"$ne": self.user_id},
                    "permissions.groups.group": {"$in": self.db_user.groups},
                },
                "sort": "-name",
                "projection": {"_id": True, "name": True, "extension_props": True},
            },
        )

        # We need to convert to regular dicts before storing in ID properties.
        # Also don't store more properties than we need.
        def reduce_properties(project_list):
            for p in project_list:
                p = p.to_dict()
                extension_props = p.get("extension_props", {})
                enabled_for = list(extension_props.keys())

                self._log.debug("Project %r is enabled for %s", p["name"], enabled_for)
                yield {
                    "_id": p["_id"],
                    "name": p["name"],
                    "enabled_for": enabled_for,
                }

        projects = list(reduce_properties(projects_user["_items"])) + list(
            reduce_properties(projects_shared["_items"])
        )

        def proj_sort_key(project):
            return project.get("name")

        preferences().project.available_projects = sorted(projects, key=proj_sort_key)

        self.quit()

    def quit(self):
        preferences().project.status = "IDLE"
        super().quit()


class PILLAR_PT_image_custom_properties(rna_prop_ui.PropertyPanel, bpy.types.Panel):
    """Shows custom properties in the image editor."""

    bl_space_type = "IMAGE_EDITOR"
    bl_region_type = "UI"
    bl_label = "Custom Properties"

    _context_path = "edit_image"
    _property_type = bpy.types.Image


def ctx_preferences():
    """Returns bpy.context.preferences in a 2.79-compatible way."""
    try:
        return bpy.context.preferences
    except AttributeError:
        return bpy.context.user_preferences


def preferences() -> BlenderCloudPreferences:
    return ctx_preferences().addons[ADDON_NAME].preferences


def load_custom_icons():
    global icons

    if icons is not None:
        # Already loaded
        return

    import bpy.utils.previews

    icons = bpy.utils.previews.new()
    my_icons_dir = os.path.join(os.path.dirname(__file__), "icons")
    icons.load("CLOUD", os.path.join(my_icons_dir, "icon-cloud.png"), "IMAGE")


def unload_custom_icons():
    global icons

    if icons is None:
        # Already unloaded
        return

    bpy.utils.previews.remove(icons)
    icons = None


def icon(icon_name: str) -> int:
    """Returns the icon ID for the named icon.

    Use with layout.operator('pillar.image_share', icon_value=icon('CLOUD'))
    """

    return icons[icon_name].icon_id


def register():
    bpy.utils.register_class(BlenderCloudProjectGroup)
    bpy.utils.register_class(BlenderCloudPreferences)
    bpy.utils.register_class(PillarCredentialsUpdate)
    bpy.utils.register_class(SyncStatusProperties)
    bpy.utils.register_class(PILLAR_OT_subscribe)
    bpy.utils.register_class(PILLAR_OT_projects)
    bpy.utils.register_class(PILLAR_OT_project_open_in_browser)
    bpy.utils.register_class(PILLAR_PT_image_custom_properties)

    addon_prefs = preferences()

    WindowManager.last_blender_cloud_location = StringProperty(
        name="Last Blender Cloud browser location", default="/"
    )

    def default_if_empty(scene, context):
        """The scene's local_texture_dir, if empty, reverts to the addon prefs."""

        if not scene.local_texture_dir:
            scene.local_texture_dir = addon_prefs.local_texture_dir

    Scene.local_texture_dir = StringProperty(
        name="Blender Cloud texture storage directory for current scene",
        subtype="DIR_PATH",
        default=addon_prefs.local_texture_dir,
        update=default_if_empty,
    )

    WindowManager.blender_sync_status = PointerProperty(type=SyncStatusProperties)

    load_custom_icons()


def unregister():
    unload_custom_icons()

    bpy.utils.unregister_class(BlenderCloudProjectGroup)
    bpy.utils.unregister_class(PillarCredentialsUpdate)
    bpy.utils.unregister_class(BlenderCloudPreferences)
    bpy.utils.unregister_class(SyncStatusProperties)
    bpy.utils.unregister_class(PILLAR_OT_subscribe)
    bpy.utils.unregister_class(PILLAR_OT_projects)
    bpy.utils.unregister_class(PILLAR_OT_project_open_in_browser)
    bpy.utils.unregister_class(PILLAR_PT_image_custom_properties)

    del WindowManager.last_blender_cloud_location
    del WindowManager.blender_sync_status