blender-cloud-addon/blender_cloud/attract/__init__.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 #####

# <pep8 compliant>

# Old info, kept here for reference, so that we can merge wiki pages,
# descriptions, etc.
#
# bl_info = {
#     "name": "Attract",
#     "author": "Francesco Siddi, Inês Almeida, Antony Riakiotakis",
#     "version": (0, 2, 0),
#     "blender": (2, 76, 0),
#     "location": "Video Sequence Editor",
#     "description":
#         "Blender integration with the Attract task tracking service"
#         ". *requires the Blender ID add-on",
#     "wiki_url": "http://wiki.blender.org/index.php/Extensions:2.6/Py/"
#                 "Scripts/Workflow/Attract",
#     "category": "Workflow",
#     "support": "TESTING"
# }

import contextlib
import functools
import logging

if "bpy" in locals():
    import importlib

    draw = importlib.reload(draw)
    pillar = importlib.reload(pillar)
    async_loop = importlib.reload(async_loop)
    blender = importlib.reload(blender)
else:
    import bpy

    if bpy.app.version < (2, 80):
        from . import draw_27 as draw
    else:
        from . import draw
    from .. import pillar, async_loop, blender

import bpy
import pillarsdk
from pillarsdk.nodes import Node
from pillarsdk.projects import Project
from pillarsdk import exceptions as sdk_exceptions

from bpy.types import Operator, Panel, AddonPreferences
import bl_ui.space_sequencer

log = logging.getLogger(__name__)

# Global flag used to determine whether panels etc. can be drawn.
attract_is_active = False


def active_strip(context):
    try:
        return context.scene.sequence_editor.active_strip
    except AttributeError:
        return None


def selected_shots(context):
    """Generator, yields selected strips if they are Attract shots."""
    selected_sequences = context.selected_sequences

    if selected_sequences is None:
        return

    for strip in selected_sequences:
        atc_object_id = getattr(strip, 'atc_object_id')
        if not atc_object_id:
            continue

        yield strip


def all_shots(context):
    """Generator, yields all strips if they are Attract shots."""
    sequence_editor = context.scene.sequence_editor

    if sequence_editor is None:
        # we should throw an exception, but at least this change prevents an error
        return []

    for strip in context.scene.sequence_editor.sequences_all:
        atc_object_id = getattr(strip, 'atc_object_id')
        if not atc_object_id:
            continue

        yield strip


def shown_strips(context):
    """Returns the strips from the current meta-strip-stack, or top-level strips.

    What is returned depends on what the user is currently editing.
    """

    if context.scene.sequence_editor.meta_stack:
        return context.scene.sequence_editor.meta_stack[-1].sequences

    return context.scene.sequence_editor.sequences


def remove_atc_props(strip):
    """Resets the attract custom properties assigned to a VSE strip"""

    strip.atc_name = ""
    strip.atc_description = ""
    strip.atc_object_id = ""
    strip.atc_is_synced = False


def shot_id_use(strips):
    """Returns a mapping from shot Object ID to a list of strips that use it."""

    import collections

    # Count the number of uses per Object ID, so that we can highlight double use.
    ids_in_use = collections.defaultdict(list)
    for strip in strips:
        if not getattr(strip, 'atc_is_synced', False):
            continue

        ids_in_use[strip.atc_object_id].append(strip)

    return ids_in_use


def compute_strip_conflicts(scene):
    """Sets the strip property atc_object_id_conflict for each strip."""

    if not attract_is_active:
        return

    if not scene or not scene.sequence_editor or not scene.sequence_editor.sequences_all:
        return

    tag_redraw = False
    ids_in_use = shot_id_use(scene.sequence_editor.sequences_all)
    for strips in ids_in_use.values():
        is_conflict = len(strips) > 1
        for strip in strips:
            if strip.atc_object_id_conflict != is_conflict:
                tag_redraw = True
            strip.atc_object_id_conflict = is_conflict

    if tag_redraw:
        draw.tag_redraw_all_sequencer_editors()
    return ids_in_use


@bpy.app.handlers.persistent
def scene_update_post_handler(scene):
    compute_strip_conflicts(scene)


class AttractPollMixin:
    @classmethod
    def poll(cls, context):
        return attract_is_active


class ATTRACT_PT_tools(AttractPollMixin, Panel):
    bl_label = 'Attract'
    bl_space_type = 'SEQUENCE_EDITOR'
    bl_region_type = 'UI'
    bl_category = 'Strip'

    def draw_header(self, context):
        strip = active_strip(context)
        if strip and strip.atc_object_id:
            self.layout.prop(strip, 'atc_is_synced', text='')

    def draw(self, context):
        strip = active_strip(context)
        layout = self.layout
        strip_types = {'MOVIE', 'IMAGE', 'META', 'COLOR'}

        if strip and strip.type in strip_types and strip.atc_object_id:
            self._draw_attractstrip_buttons(context, strip)
        elif context.selected_sequences:
            if len(context.selected_sequences) > 1:
                noun = 'Selected Strips'
            else:
                noun = 'This Strip'
            layout.operator(ATTRACT_OT_submit_selected.bl_idname,
                            text='Submit %s as New Shot' % noun)
            layout.operator('attract.shot_relink')
        else:
            layout.operator(ATTRACT_OT_submit_all.bl_idname)
        layout.operator(ATTRACT_OT_project_open_in_browser.bl_idname, icon='WORLD')

    def _draw_attractstrip_buttons(self, context, strip):
        """Draw buttons when selected strips are Attract shots."""

        layout = self.layout
        selshots = list(selected_shots(context))

        if len(selshots) > 1:
            noun = '%i Shots' % len(selshots)
        else:
            noun = 'This Shot'
        if strip.atc_object_id_conflict:
            warnbox = layout.box()
            warnbox.alert = True
            warnbox.label(text='Warning: This shot is linked to multiple sequencer strips.',
                          icon='ERROR')
        layout.prop(strip, 'atc_name', text='Name')
        layout.prop(strip, 'atc_status', text='Status')
        # Create a special sub-layout for read-only properties.
        ro_sub = layout.column(align=True)
        ro_sub.enabled = False
        ro_sub.prop(strip, 'atc_description', text='Description')
        ro_sub.prop(strip, 'atc_notes', text='Notes')
        if strip.atc_is_synced:
            sub = layout.column(align=True)
            row = sub.row(align=True)
            if bpy.ops.attract.submit_selected.poll():
                row.operator('attract.submit_selected',
                             text='Submit %s' % noun,
                             icon='TRIA_UP')
            else:
                row.operator(ATTRACT_OT_submit_all.bl_idname)
            row.operator(ATTRACT_OT_shot_fetch_update.bl_idname,
                         text='', icon='FILE_REFRESH')
            row.operator(ATTRACT_OT_shot_open_in_browser.bl_idname,
                         text='', icon='WORLD')
            row.operator(ATTRACT_OT_copy_id_to_clipboard.bl_idname,
                         text='', icon='COPYDOWN')
            sub.operator(ATTRACT_OT_make_shot_thumbnail.bl_idname,
                         text='Render Thumbnail for %s' % noun,
                         icon='RENDER_STILL')

            # Group more dangerous operations.
            dangerous_sub = layout.split(**blender.factor(0.6), align=True)
            dangerous_sub.operator('attract.strip_unlink',
                                   text='Unlink %s' % noun,
                                   icon='PANEL_CLOSE')
            dangerous_sub.operator(ATTRACT_OT_shot_delete.bl_idname,
                                   text='Delete %s' % noun,
                                   icon='CANCEL')


class AttractOperatorMixin(AttractPollMixin):
    """Mix-in class for all Attract operators."""

    def _project_needs_setup_error(self):
        self.report({'ERROR'}, 'Your Blender Cloud project is not set up for Attract.')
        return {'CANCELLED'}

    @functools.lru_cache()
    def find_project(self, project_uuid: str) -> Project:
        """Finds a single project.

        Caches the result in memory to prevent more than one call to Pillar.
        """

        from .. import pillar

        project = pillar.sync_call(Project.find_one, {'where': {'_id': project_uuid}})
        return project

    def find_node_type(self, node_type_name: str) -> dict:
        from .. import pillar, blender

        prefs = blender.preferences()
        project = self.find_project(prefs.project.project)

        # FIXME: Eve doesn't seem to handle the $elemMatch projection properly,
        # even though it works fine in MongoDB itself. As a result, we have to
        # search for the node type.
        node_type_list = project['node_types']
        node_type = next((nt for nt in node_type_list if nt['name'] == node_type_name), None)

        if not node_type:
            return self._project_needs_setup_error()

        return node_type

    def submit_new_strip(self, strip):
        from .. import pillar, blender

        # Define the shot properties
        user_uuid = pillar.pillar_user_uuid()
        if not user_uuid:
            self.report({'ERROR'}, 'Your Blender Cloud user ID is not known, '
                                   'update your credentials.')
            return {'CANCELLED'}

        prop = {'name': strip.name,
                'description': '',
                'properties': {'status': 'todo',
                               'notes': '',
                               'used_in_edit': True,
                               'trim_start_in_frames': strip.frame_offset_start,
                               'trim_end_in_frames': strip.frame_offset_end,
                               'duration_in_edit_in_frames': strip.frame_final_duration,
                               'cut_in_timeline_in_frames': strip.frame_final_start},
                'order': 0,
                'node_type': 'attract_shot',
                'project': blender.preferences().project.project,
                'user': user_uuid}

        # Create a Node item with the attract API
        node = Node(prop)
        post = pillar.sync_call(node.create)

        # Populate the strip with the freshly generated ObjectID and info
        if not post:
            self.report({'ERROR'}, 'Error creating node! Check the console for now.')
            return {'CANCELLED'}

        strip.atc_object_id = node['_id']
        strip.atc_is_synced = True
        strip.atc_name = node['name']
        strip.atc_description = node['description']
        strip.atc_notes = node['properties']['notes']
        strip.atc_status = node['properties']['status']

        draw.tag_redraw_all_sequencer_editors()

    def submit_update(self, strip):
        import pillarsdk
        from .. import pillar

        patch = {
            'op': 'from-blender',
            '$set': {
                'name': strip.atc_name,
                'properties.trim_start_in_frames': strip.frame_offset_start,
                'properties.trim_end_in_frames': strip.frame_offset_end,
                'properties.duration_in_edit_in_frames': strip.frame_final_duration,
                'properties.cut_in_timeline_in_frames': strip.frame_final_start,
                'properties.status': strip.atc_status,
                'properties.used_in_edit': True,
            }
        }

        node = pillarsdk.Node({'_id': strip.atc_object_id})
        result = pillar.sync_call(node.patch, patch)
        log.info('PATCH result: %s', result)

    def relink(self, strip, atc_object_id, *, refresh=False):
        from .. import pillar

        # The node may have been deleted, so we need to send a 'relink' before we try
        # to fetch the node itself.
        node = Node({'_id': atc_object_id})
        pillar.sync_call(node.patch, {'op': 'relink'})

        try:
            node = pillar.sync_call(Node.find, atc_object_id, caching=False)
        except (sdk_exceptions.ResourceNotFound, sdk_exceptions.MethodNotAllowed):
            verb = 'refresh' if refresh else 'relink'
            self.report({'ERROR'}, 'Shot %r not found on the Attract server, unable to %s.'
                        % (atc_object_id, verb))
            strip.atc_is_synced = False
            return {'CANCELLED'}

        strip.atc_is_synced = True
        if not refresh:
            strip.atc_name = node.name
            strip.atc_object_id = node['_id']

        # We do NOT set the position/cuts of the shot, that always has to come from Blender.
        strip.atc_status = node.properties.status
        strip.atc_notes = node.properties.notes or ''
        strip.atc_description = node.description or ''
        draw.tag_redraw_all_sequencer_editors()


class ATTRACT_OT_shot_fetch_update(AttractOperatorMixin, Operator):
    bl_idname = "attract.shot_fetch_update"
    bl_label = "Fetch Update From Attract"
    bl_description = 'Update status, description & notes from Attract'

    @classmethod
    def poll(cls, context):
        return AttractOperatorMixin.poll(context) and any(selected_shots(context))

    def execute(self, context):
        for strip in selected_shots(context):
            status = self.relink(strip, strip.atc_object_id, refresh=True)
            # We don't abort when one strip fails. All selected shots should be
            # refreshed, even if one can't be found (for example).
            if not isinstance(status, set):
                self.report({'INFO'}, "Shot {0} refreshed".format(strip.atc_name))
        return {'FINISHED'}


class ATTRACT_OT_shot_relink(AttractOperatorMixin, Operator):
    bl_idname = "attract.shot_relink"
    bl_label = "Relink With Attract"

    strip_atc_object_id = bpy.props.StringProperty()

    @classmethod
    def poll(cls, context):
        if not AttractOperatorMixin.poll(context):
            return False

        strip = active_strip(context)
        return strip is not None and not getattr(strip, 'atc_object_id', None)

    def execute(self, context):
        strip = active_strip(context)

        status = self.relink(strip, self.strip_atc_object_id)
        if isinstance(status, set):
            return status

        strip.atc_object_id = self.strip_atc_object_id
        self.report({'INFO'}, "Shot {0} relinked".format(strip.atc_name))

        return {'FINISHED'}

    def invoke(self, context, event):
        maybe_id = context.window_manager.clipboard
        if len(maybe_id) == 24:
            try:
                int(maybe_id, 16)
            except ValueError:
                pass
            else:
                self.strip_atc_object_id = maybe_id

        return context.window_manager.invoke_props_dialog(self)

    def draw(self, context):
        layout = self.layout
        col = layout.column()
        col.prop(self, 'strip_atc_object_id', text='Shot ID')


class ATTRACT_OT_shot_open_in_browser(AttractOperatorMixin, Operator):
    bl_idname = 'attract.shot_open_in_browser'
    bl_label = 'Open in Browser'
    bl_description = 'Opens a webbrowser to show the shot on Attract'

    @classmethod
    def poll(cls, context):
        return AttractOperatorMixin.poll(context) and \
               bool(context.selected_sequences and active_strip(context))

    def execute(self, context):
        from ..blender import PILLAR_WEB_SERVER_URL
        import webbrowser
        import urllib.parse

        strip = active_strip(context)

        url = urllib.parse.urljoin(PILLAR_WEB_SERVER_URL,
                                   'nodes/%s/redir' % strip.atc_object_id)
        webbrowser.open_new_tab(url)
        self.report({'INFO'}, 'Opened a browser at %s' % url)

        return {'FINISHED'}


class ATTRACT_OT_shot_delete(AttractOperatorMixin, Operator):
    bl_idname = 'attract.shot_delete'
    bl_label = 'Delete Shot'
    bl_description = 'Remove this shot from Attract'

    confirm = bpy.props.BoolProperty(name='confirm')

    @classmethod
    def poll(cls, context):
        return AttractOperatorMixin.poll(context) and \
               bool(context.selected_sequences)

    def execute(self, context):
        from .. import pillar

        if not self.confirm:
            self.report({'WARNING'}, 'Delete aborted.')
            return {'CANCELLED'}

        removed = kept = 0
        for strip in selected_shots(context):
            node = pillar.sync_call(Node.find, strip.atc_object_id)
            if not pillar.sync_call(node.delete):
                self.report({'ERROR'}, 'Unable to delete shot %s on Attract.' % strip.atc_name)
                kept += 1
                continue
            remove_atc_props(strip)
            removed += 1

        if kept:
            self.report({'ERROR'}, 'Removed %i shots, but was unable to remove %i' %
                        (removed, kept))
        else:
            self.report({'INFO'}, 'Removed all %i shots from Attract' % removed)

        draw.tag_redraw_all_sequencer_editors()
        return {'FINISHED'}

    def invoke(self, context, event):
        self.confirm = False
        return context.window_manager.invoke_props_dialog(self)

    def draw(self, context):
        layout = self.layout
        col = layout.column()

        selshots = list(selected_shots(context))
        if len(selshots) > 1:
            noun = '%i shots' % len(selshots)
        else:
            noun = 'this shot'

        col.prop(self, 'confirm', text="I hereby confirm: delete %s from The Edit." % noun)


class ATTRACT_OT_strip_unlink(AttractOperatorMixin, Operator):
    bl_idname = 'attract.strip_unlink'
    bl_label = 'Unlink Shot From This Strip'
    bl_description = 'Remove Attract props from the selected strip(s)'

    @classmethod
    def poll(cls, context):
        return AttractOperatorMixin.poll(context) and \
               bool(context.selected_sequences)

    def execute(self, context):
        unlinked_ids = set()

        # First remove the Attract properties from the strips.
        for strip in context.selected_sequences:
            atc_object_id = getattr(strip, 'atc_object_id')
            remove_atc_props(strip)

            if atc_object_id:
                unlinked_ids.add(atc_object_id)

        # For all Object IDs that are no longer in use in the edit, let Attract know.
        # This should be done with care, as the shot could have been attached to multiple
        # strips.
        id_to_shots = compute_strip_conflicts(context.scene)
        for oid in unlinked_ids:
            if len(id_to_shots[oid]):
                # Still in use
                continue

            node = Node({'_id': oid})
            pillar.sync_call(node.patch, {'op': 'unlink'})

        if len(unlinked_ids) == 1:
            shot_id = unlinked_ids.pop()
            context.window_manager.clipboard = shot_id
            self.report({'INFO'}, 'Copied unlinked shot ID %s to clipboard' % shot_id)
        else:
            self.report({'INFO'}, '%i shots have been marked as Unused.' % len(unlinked_ids))

        draw.tag_redraw_all_sequencer_editors()
        return {'FINISHED'}


class ATTRACT_OT_submit_selected(AttractOperatorMixin, Operator):
    bl_idname = 'attract.submit_selected'
    bl_label = 'Submit All Selected'
    bl_description = 'Submits all selected strips to Attract'

    @classmethod
    def poll(cls, context):
        return AttractOperatorMixin.poll(context) and \
               bool(context.selected_sequences)

    def execute(self, context):
        # Check that the project is set up for Attract.
        maybe_error = self.find_node_type('attract_shot')
        if isinstance(maybe_error, set):
            return maybe_error

        for strip in context.selected_sequences:
            status = self.submit(strip)
            if isinstance(status, set):
                return status

        self.report({'INFO'}, 'All selected strips sent to Attract.')

        return {'FINISHED'}

    def submit(self, strip):
        atc_object_id = getattr(strip, 'atc_object_id', None)

        # Submit as new?
        if not atc_object_id:
            return self.submit_new_strip(strip)

        # Or just save to Attract.
        return self.submit_update(strip)


class ATTRACT_OT_submit_all(AttractOperatorMixin, Operator):
    bl_idname = 'attract.submit_all'
    bl_label = 'Submit All Shots to Attract'
    bl_description = 'Updates Attract with the current state of the edit'

    def execute(self, context):
        # Check that the project is set up for Attract.
        maybe_error = self.find_node_type('attract_shot')
        if isinstance(maybe_error, set):
            return maybe_error

        for strip in all_shots(context):
            status = self.submit_update(strip)
            if isinstance(status, set):
                return status

        self.report({'INFO'}, 'All strips re-sent to Attract.')

        return {'FINISHED'}


class ATTRACT_OT_open_meta_blendfile(AttractOperatorMixin, Operator):
    bl_idname = 'attract.open_meta_blendfile'
    bl_label = 'Open Blendfile'
    bl_description = 'Open Blendfile from movie strip metadata'

    @classmethod
    def poll(cls, context):
        return AttractOperatorMixin.poll(context) and \
               bool(any(cls.filename_from_metadata(s) for s in context.selected_sequences))

    @staticmethod
    def filename_from_metadata(strip):
        """Returns the blendfile name from the strip metadata, or None."""

        # Metadata is a dict like:
        # meta = {'END_FRAME': '88',
        #         'BLEND_FILE': 'metadata-test.blend',
        #         'SCENE': 'SüperSčene',
        #         'FRAME_STEP': '1',
        #         'START_FRAME': '32'}

        meta = strip.get('metadata', None)
        if not meta:
            return None

        return meta.get('BLEND_FILE', None) or None

    def execute(self, context):
        for strip in context.selected_sequences:
            meta = strip.get('metadata', None)
            if not meta:
                continue

            fname = meta.get('BLEND_FILE', None)
            if not fname: continue

            scene = meta.get('SCENE', None)
            self.open_in_new_blender(fname, scene)

        return {'FINISHED'}

    def open_in_new_blender(self, fname, scene):
        """
        :type fname: str
        :type scene: str
        """
        import subprocess
        import sys

        cmd = [
            bpy.app.binary_path,
            str(fname),
        ]

        cmd[1:1] = [v for v in sys.argv if v.startswith('--enable-')]

        if scene:
            cmd.extend(['--python-expr',
                        'import bpy; bpy.context.screen.scene = bpy.data.scenes["%s"]' % scene])
            cmd.extend(['--scene', scene])

        subprocess.Popen(cmd)


class ATTRACT_OT_make_shot_thumbnail(AttractOperatorMixin,
                                     async_loop.AsyncModalOperatorMixin,
                                     Operator):
    bl_idname = 'attract.make_shot_thumbnail'
    bl_label = 'Render Shot Thumbnail'
    bl_description = 'Renders the current frame, and uploads it as thumbnail for the shot'

    stop_upon_exception = True

    @classmethod
    def poll(cls, context):
        return AttractOperatorMixin.poll(context) and bool(context.selected_sequences)

    @contextlib.contextmanager
    def thumbnail_render_settings(self, context, thumbnail_width=512):
        # Remember current settings so we can restore them later.
        orig_res_x = context.scene.render.resolution_x
        orig_res_y = context.scene.render.resolution_y
        orig_percentage = context.scene.render.resolution_percentage
        orig_file_format = context.scene.render.image_settings.file_format
        orig_quality = context.scene.render.image_settings.quality

        try:
            # Update the render size to something thumbnaily.
            factor = orig_res_y / orig_res_x
            context.scene.render.resolution_x = thumbnail_width
            context.scene.render.resolution_y = round(thumbnail_width * factor)
            context.scene.render.resolution_percentage = 100
            context.scene.render.image_settings.file_format = 'JPEG'
            context.scene.render.image_settings.quality = 85

            yield
        finally:
            # Return the render settings to normal.
            context.scene.render.resolution_x = orig_res_x
            context.scene.render.resolution_y = orig_res_y
            context.scene.render.resolution_percentage = orig_percentage
            context.scene.render.image_settings.file_format = orig_file_format
            context.scene.render.image_settings.quality = orig_quality

    @contextlib.contextmanager
    def temporary_current_frame(self, context):
        """Allows the context to set the scene current frame, restores it on exit.

        Yields the initial current frame, so it can be used for reference in the context.
        """
        current_frame = context.scene.frame_current
        try:
            yield current_frame
        finally:
            context.scene.frame_current = current_frame

    async def async_execute(self, context):
        nr_of_strips = len(context.selected_sequences)
        do_multishot = nr_of_strips > 1

        with self.temporary_current_frame(context) as original_curframe:
            # The multishot and singleshot branches do pretty much the same thing,
            # but report differently to the user.
            if do_multishot:
                context.window_manager.progress_begin(0, nr_of_strips)
                try:
                    self.report({'INFO'}, 'Rendering thumbnails for %i selected shots.' %
                                nr_of_strips)

                    strips = sorted(context.selected_sequences, key=self.by_frame)
                    for idx, strip in enumerate(strips):
                        context.window_manager.progress_update(idx)

                        # Pick the middle frame, except for the strip the original current frame
                        # marker was over.
                        if not self.strip_contains(strip, original_curframe):
                            self.set_middle_frame(context, strip)
                        else:
                            context.scene.frame_set(original_curframe)
                        await self.thumbnail_strip(context, strip)

                        if self._state == 'QUIT':
                            return
                    context.window_manager.progress_update(nr_of_strips)
                finally:
                    context.window_manager.progress_end()

            else:
                strip = active_strip(context)
                if not self.strip_contains(strip, original_curframe):
                    self.report({'WARNING'}, 'Rendering middle frame as thumbnail for active shot.')
                    self.set_middle_frame(context, strip)
                else:
                    self.report({'INFO'}, 'Rendering current frame as thumbnail for active shot.')

                context.window_manager.progress_begin(0, 1)
                context.window_manager.progress_update(0)
                try:
                    await self.thumbnail_strip(context, strip)
                finally:
                    context.window_manager.progress_update(1)
                    context.window_manager.progress_end()

                if self._state == 'QUIT':
                    return

        self.report({'INFO'}, 'Thumbnail uploaded to Attract')
        self.quit()

    @staticmethod
    def strip_contains(strip, framenr: int) -> bool:
        """Returns True iff the strip covers the given frame number"""
        return strip.frame_final_start <= framenr <= strip.frame_final_end

    @staticmethod
    def set_middle_frame(context, strip):
        """Sets the current frame to the middle frame of the strip."""

        middle = round((strip.frame_final_start + strip.frame_final_end) / 2)
        context.scene.frame_set(middle)

    @staticmethod
    def by_frame(sequence_strip) -> int:
        """Returns the start frame number of the sequence strip.

        This can be used for sorting strips by time.
        """

        return sequence_strip.frame_final_start

    async def thumbnail_strip(self, context, strip):
        atc_object_id = getattr(strip, 'atc_object_id', None)
        if not atc_object_id:
            self.report({'ERROR'}, 'Strip %s not set up for Attract' % strip.name)
            self.quit()
            return

        with self.thumbnail_render_settings(context):
            bpy.ops.render.render()
        file_id = await self.upload_via_tempdir(bpy.data.images['Render Result'],
                                                'attract_shot_thumbnail.jpg')

        if file_id is None:
            self.quit()
            return

        # Update the shot to include this file as the picture.
        node = pillarsdk.Node({'_id': atc_object_id})
        await pillar.pillar_call(
            node.patch,
            {
                'op': 'from-blender',
                '$set': {
                    'picture': file_id,
                }
            })

    async def upload_via_tempdir(self, datablock, filename_on_cloud) -> pillarsdk.Node:
        """Saves the datablock to file, and uploads it to the cloud.

        Saving is done to a temporary directory, which is removed afterwards.

        Returns the node.
        """
        import tempfile
        import os.path

        with tempfile.TemporaryDirectory() as tmpdir:
            filepath = os.path.join(tmpdir, filename_on_cloud)
            self.log.debug('Saving %s to %s', datablock, filepath)
            datablock.save_render(filepath)
            return await self.upload_file(filepath)

    async def upload_file(self, filename: str, fileobj=None):
        """Uploads a file to the cloud, attached to the image sharing node.

        Returns the node.
        """
        from .. import blender

        prefs = blender.preferences()
        project = self.find_project(prefs.project.project)

        self.log.info('Uploading file %s', filename)
        resp = await pillar.pillar_call(
            pillarsdk.File.upload_to_project,
            project['_id'],
            'image/jpeg',
            filename,
            fileobj=fileobj)

        self.log.debug('Returned data: %s', resp)
        try:
            file_id = resp['file_id']
        except KeyError:
            self.log.error('Upload did not succeed, response: %s', resp)
            self.report({'ERROR'}, 'Unable to upload thumbnail to Attract: %s' % resp)
            return None

        self.log.info('Created file %s', file_id)
        self.report({'INFO'}, 'File succesfully uploaded to the cloud!')

        return file_id


class ATTRACT_OT_copy_id_to_clipboard(AttractOperatorMixin, Operator):
    bl_idname = 'attract.copy_id_to_clipboard'
    bl_label = 'Copy shot ID to clipboard'

    @classmethod
    def poll(cls, context):
        return AttractOperatorMixin.poll(context) and \
               bool(context.selected_sequences and active_strip(context))

    def execute(self, context):
        strip = active_strip(context)

        context.window_manager.clipboard = strip.atc_object_id
        self.report({'INFO'}, 'Shot ID %s copied to clipboard' % strip.atc_object_id)

        return {'FINISHED'}


class ATTRACT_OT_project_open_in_browser(Operator):
    bl_idname = 'attract.project_open_in_browser'
    bl_label = 'Open Project in Browser'
    bl_description = 'Opens a webbrowser to show the project in Attract'

    project_id = bpy.props.StringProperty(name='Project ID', default='')

    def execute(self, context):
        import webbrowser
        import urllib.parse

        import pillarsdk
        from ..pillar import sync_call
        from ..blender import PILLAR_WEB_SERVER_URL, preferences

        if not self.project_id:
            self.project_id = preferences().project.project

        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, 'attract/' + project.url)
        webbrowser.open_new_tab(url)
        self.report({'INFO'}, 'Opened a browser at %s' % url)

        return {'FINISHED'}


class ATTRACT_PT_strip_metadata(bl_ui.space_sequencer.SequencerButtonsPanel, Panel):
    bl_label = "Metadata"
    bl_parent_id = "SEQUENCER_PT_info"
    bl_category = "Strip"
    bl_options = {'DEFAULT_CLOSED'}

    def draw(self, context):
        strip = active_strip(context)
        if not strip:
            return

        meta = strip.get('metadata', None)
        if not meta:
            return None

        box = self.layout.column(align=True)
        row = box.row(align=True)
        fname = meta.get('BLEND_FILE', None) or None
        if fname:
            row.label(text='Original Blendfile: %s' % fname)
            row.operator(ATTRACT_OT_open_meta_blendfile.bl_idname,
                         text='', icon='FILE_BLEND')
        sfra = meta.get('START_FRAME', '?')
        efra = meta.get('END_FRAME', '?')
        box.label(text='Original Frame Range: %s-%s' % (sfra, efra))


def activate():
    global attract_is_active

    log.info('Activating Attract')
    attract_is_active = True

    # TODO: properly fix 2.8 compatibility; this is just a workaround.
    if hasattr(bpy.app.handlers, 'scene_update_post'):
        bpy.app.handlers.scene_update_post.append(scene_update_post_handler)
    draw.callback_enable()


def deactivate():
    global attract_is_active

    log.info('Deactivating Attract')
    attract_is_active = False
    draw.callback_disable()

    # TODO: properly fix 2.8 compatibility; this is just a workaround.
    if hasattr(bpy.app.handlers, 'scene_update_post'):
        try:
            bpy.app.handlers.scene_update_post.remove(scene_update_post_handler)
        except ValueError:
            # This is thrown when scene_update_post_handler does not exist in the handler list.
            pass


_rna_classes = [cls for cls in locals().values()
                if isinstance(cls, type) and cls.__name__.startswith('ATTRACT')]
log.info('RNA classes:\n%s', '\n'.join([repr(cls) for cls in _rna_classes]))


def register():
    bpy.types.Sequence.atc_is_synced = bpy.props.BoolProperty(name="Is Synced")
    bpy.types.Sequence.atc_object_id = bpy.props.StringProperty(name="Attract Object ID")
    bpy.types.Sequence.atc_object_id_conflict = bpy.props.BoolProperty(
        name='Object ID Conflict',
        description='Attract Object ID used multiple times',
        default=False)
    bpy.types.Sequence.atc_name = bpy.props.StringProperty(name="Shot Name")
    bpy.types.Sequence.atc_description = bpy.props.StringProperty(name="Shot Description")
    bpy.types.Sequence.atc_notes = bpy.props.StringProperty(name="Shot Notes")

    # TODO: get this from the project's node type definition.
    bpy.types.Sequence.atc_status = bpy.props.EnumProperty(
        items=[
            ('on_hold', 'On Hold', 'The shot is on hold'),
            ('todo', 'Todo', 'Waiting'),
            ('in_progress', 'In Progress', 'The show has been assigned'),
            ('review', 'Review', ''),
            ('final', 'Final', ''),
        ],
        name="Status")
    bpy.types.Sequence.atc_order = bpy.props.IntProperty(name="Order")

    for cls in _rna_classes:
        bpy.utils.register_class(cls)


def unregister():
    deactivate()
    for cls in _rna_classes:
        try:
            bpy.utils.unregister_class(cls)
        except RuntimeError:
            log.warning('Unable to unregister class %r, probably already unregistered', cls)

    del bpy.types.Sequence.atc_is_synced
    del bpy.types.Sequence.atc_object_id
    del bpy.types.Sequence.atc_object_id_conflict
    del bpy.types.Sequence.atc_name
    del bpy.types.Sequence.atc_description
    del bpy.types.Sequence.atc_notes
    del bpy.types.Sequence.atc_status
    del bpy.types.Sequence.atc_order