Bumped version to 1.4.4 to release some bug fixes.

This branch doesn't contain Flamenco or Attract, since the project
selection still needs work.

blender_cloud/__init__.py

@@ -20,13 +20,13 @@
 
 bl_info = {
     'name': 'Blender Cloud',
-    "author": "Sybren A. Stüvel, Francesco Siddi, Inês Almeida, Antony Riakiotakis",
-    'version': (1, 5, 0),
+    'author': 'Sybren A. Stüvel and Francesco Siddi',
+    'version': (1, 4, 4),
     'blender': (2, 77, 0),
     'location': 'Addon Preferences panel, and Ctrl+Shift+Alt+A anywhere for texture browser',
     'description': 'Texture library browser and Blender Sync. Requires the Blender ID addon '
                    'and Blender 2.77a or newer.',
-    'wiki_url': 'https://wiki.blender.org/index.php/Extensions:2.6/Py/'
+    'wiki_url': 'http://wiki.blender.org/index.php/Extensions:2.6/Py/'
                 'Scripts/System/BlenderCloud',
     'category': 'System',
 }
@@ -78,10 +78,9 @@ def register():
         texture_browser = reload_mod('texture_browser')
         settings_sync = reload_mod('settings_sync')
         image_sharing = reload_mod('image_sharing')
-        attract = reload_mod('attract')
     else:
         from . import (blender, texture_browser, async_loop, settings_sync, blendfile, home_project,
-                       image_sharing, attract)
+                       image_sharing)
 
     async_loop.setup_asyncio_executor()
     async_loop.register()
@@ -90,7 +89,6 @@ def register():
     blender.register()
     settings_sync.register()
     image_sharing.register()
-    attract.register()
 
 
 def _monkey_patch_requests():
@@ -111,10 +109,9 @@ def _monkey_patch_requests():
 
 
 def unregister():
-    from . import blender, texture_browser, async_loop, settings_sync, image_sharing, attract
+    from . import blender, texture_browser, async_loop, settings_sync, image_sharing
 
     image_sharing.unregister()
-    attract.unregister()
     settings_sync.unregister()
     blender.unregister()
     texture_browser.unregister()

blender_cloud/attract/__init__.py

@@ -1,888 +0,0 @@
-# ##### 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)
-else:
-    from . import draw
-    from .. import pillar, async_loop
-
-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
-
-log = logging.getLogger(__name__)
-
-
-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."""
-
-    for strip in context.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."""
-
-    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 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 ToolsPanel(Panel):
-    bl_label = 'Attract'
-    bl_space_type = 'SEQUENCE_EDITOR'
-    bl_region_type = 'UI'
-
-    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'}
-
-        selshots = list(selected_shots(context))
-        if strip and strip.type in strip_types and strip.atc_object_id:
-            if len(selshots) > 1:
-                noun = 'Selected Shots'
-            else:
-                noun = 'This Shot'
-
-            if strip.atc_object_id_conflict:
-                warnbox = layout.box()
-                warnbox.alert = True
-                warnbox.label('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)
-                else:
-                    row.operator(ATTRACT_OT_submit_all.bl_idname)
-                row.operator(AttractShotFetchUpdate.bl_idname,
-                             text='', icon='FILE_REFRESH')
-                row.operator(ATTRACT_OT_shot_open_in_browser.bl_idname,
-                             text='', icon='WORLD')
-                sub.operator(ATTRACT_OT_make_shot_thumbnail.bl_idname,
-                             text='Render Thumbnail for %s' % noun)
-
-                # Group more dangerous operations.
-                dangerous_sub = layout.column(align=True)
-                dangerous_sub.operator(AttractShotDelete.bl_idname)
-                dangerous_sub.operator('attract.strip_unlink')
-
-        elif context.selected_sequences:
-            if len(context.selected_sequences) > 1:
-                noun = 'Selected Strips'
-            else:
-                noun = 'This Strip'
-            layout.operator(AttractShotSubmitSelected.bl_idname,
-                            text='Submit %s as New Shot' % noun)
-            layout.operator('attract.shot_relink')
-        else:
-            layout.operator(ATTRACT_OT_submit_all.bl_idname)
-
-
-class AttractOperatorMixin:
-    """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.attract_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,
-                               '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().attract_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.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 AttractShotFetchUpdate(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 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 AttractShotRelink(AttractShotFetchUpdate):
-    bl_idname = "attract.shot_relink"
-    bl_label = "Relink With Attract"
-
-    strip_atc_object_id = bpy.props.StringProperty()
-
-    @classmethod
-    def poll(cls, context):
-        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'
-
-    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 AttractShotDelete(AttractOperatorMixin, Operator):
-    bl_idname = 'attract.shot_delete'
-    bl_label = 'Delete Shot'
-    bl_description = 'Remove this shot from Attract'
-
-    confirm = bpy.props.BoolProperty(name='confirm')
-
-    def execute(self, context):
-        from .. import pillar
-
-        if not self.confirm:
-            self.report({'WARNING'}, 'Delete aborted.')
-            return {'CANCELLED'}
-
-        strip = active_strip(context)
-        node = pillar.sync_call(Node.find, strip.atc_object_id)
-        if not pillar.sync_call(node.delete):
-            print('Unable to delete the strip node on Attract.')
-            return {'CANCELLED'}
-
-        remove_atc_props(strip)
-        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()
-        col.prop(self, 'confirm', text="I hereby confirm: delete this shot from The Edit.")
-
-
-class AttractStripUnlink(AttractOperatorMixin, Operator):
-    bl_idname = 'attract.strip_unlink'
-    bl_label = 'Unlink Shot From This Strip'
-    bl_description = 'Remove Attract props from the selected strip(s)'
-
-    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'})
-            self.report({'INFO'}, 'Shot %s has been marked as Unused.' % oid)
-
-        draw.tag_redraw_all_sequencer_editors()
-        return {'FINISHED'}
-
-
-class AttractShotSubmitSelected(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 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 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 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.attract_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
-
-
-def draw_strip_movie_meta(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('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('Original Frame Range: %s-%s' % (sfra, efra))
-
-
-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")
-
-    bpy.types.SEQUENCER_PT_edit.append(draw_strip_movie_meta)
-
-    bpy.utils.register_class(ToolsPanel)
-    bpy.utils.register_class(AttractShotRelink)
-    bpy.utils.register_class(AttractShotDelete)
-    bpy.utils.register_class(AttractStripUnlink)
-    bpy.utils.register_class(AttractShotFetchUpdate)
-    bpy.utils.register_class(AttractShotSubmitSelected)
-    bpy.utils.register_class(ATTRACT_OT_submit_all)
-    bpy.utils.register_class(ATTRACT_OT_open_meta_blendfile)
-    bpy.utils.register_class(ATTRACT_OT_shot_open_in_browser)
-    bpy.utils.register_class(ATTRACT_OT_make_shot_thumbnail)
-
-    bpy.app.handlers.scene_update_post.append(scene_update_post_handler)
-    draw.callback_enable()
-
-
-def unregister():
-    draw.callback_disable()
-    bpy.app.handlers.scene_update_post.remove(scene_update_post_handler)
-    bpy.utils.unregister_module(__name__)
-    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

blender_cloud/attract/draw.py

@@ -1,177 +0,0 @@
-# ##### 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>
-
-import bpy
-import logging
-import collections
-
-log = logging.getLogger(__name__)
-
-strip_status_colour = {
-    None: (0.7, 0.7, 0.7),
-    'approved': (0.6392156862745098, 0.8784313725490196, 0.30196078431372547),
-    'final': (0.9058823529411765, 0.9607843137254902, 0.8274509803921568),
-    'in_progress': (1.0, 0.7450980392156863, 0.0),
-    'on_hold': (0.796078431372549, 0.6196078431372549, 0.08235294117647059),
-    'review': (0.8941176470588236, 0.9607843137254902, 0.9764705882352941),
-    'todo': (1.0, 0.5019607843137255, 0.5019607843137255)
-}
-
-CONFLICT_COLOUR = (0.576, 0.118, 0.035)  # RGB tuple
-
-
-def get_strip_rectf(strip):
-    # Get x and y in terms of the grid's frames and channels
-    x1 = strip.frame_final_start
-    x2 = strip.frame_final_end
-    y1 = strip.channel + 0.2
-    y2 = strip.channel - 0.2 + 1
-
-    return x1, y1, x2, y2
-
-
-def draw_underline_in_strip(strip_coords, pixel_size_x, color):
-    from bgl import glColor4f, glRectf, glEnable, glDisable, GL_BLEND
-    import bgl
-
-    context = bpy.context
-
-    # Strip coords
-    s_x1, s_y1, s_x2, s_y2 = strip_coords
-
-    # be careful not to draw over the current frame line
-    cf_x = context.scene.frame_current_final
-
-    bgl.glPushAttrib(bgl.GL_COLOR_BUFFER_BIT | bgl.GL_LINE_BIT)
-
-    glColor4f(*color)
-    glEnable(GL_BLEND)
-    bgl.glLineWidth(2)
-    bgl.glBegin(bgl.GL_LINES)
-
-    bgl.glVertex2f(s_x1, s_y1)
-    if s_x1 < cf_x < s_x2:
-        # Bad luck, the line passes our strip
-        bgl.glVertex2f(cf_x - pixel_size_x, s_y1)
-        bgl.glVertex2f(cf_x + pixel_size_x, s_y1)
-    bgl.glVertex2f(s_x2, s_y1)
-
-    bgl.glEnd()
-    bgl.glPopAttrib()
-
-
-def draw_strip_conflict(strip_coords, pixel_size_x):
-    """Draws conflicting states between strips."""
-
-    import bgl
-
-    s_x1, s_y1, s_x2, s_y2 = strip_coords
-    bgl.glPushAttrib(bgl.GL_COLOR_BUFFER_BIT | bgl.GL_LINE_BIT)
-
-    # Always draw the full rectangle, the conflict should be resolved and thus stand out.
-    bgl.glColor3f(*CONFLICT_COLOUR)
-    bgl.glLineWidth(2)
-
-    bgl.glBegin(bgl.GL_LINE_LOOP)
-    bgl.glVertex2f(s_x1, s_y1)
-    bgl.glVertex2f(s_x2, s_y1)
-    bgl.glVertex2f(s_x2, s_y2)
-    bgl.glVertex2f(s_x1, s_y2)
-    bgl.glEnd()
-
-    bgl.glPopAttrib()
-
-
-def draw_callback_px():
-    context = bpy.context
-
-    if not context.scene.sequence_editor:
-        return
-
-    from . import shown_strips
-
-    region = context.region
-    xwin1, ywin1 = region.view2d.region_to_view(0, 0)
-    xwin2, ywin2 = region.view2d.region_to_view(region.width, region.height)
-    one_pixel_further_x, one_pixel_further_y = region.view2d.region_to_view(1, 1)
-    pixel_size_x = one_pixel_further_x - xwin1
-
-    strips = shown_strips(context)
-
-    for strip in strips:
-        if not strip.atc_object_id:
-            continue
-
-        # Get corners (x1, y1), (x2, y2) of the strip rectangle in px region coords
-        strip_coords = get_strip_rectf(strip)
-
-        # check if any of the coordinates are out of bounds
-        if strip_coords[0] > xwin2 or strip_coords[2] < xwin1 or strip_coords[1] > ywin2 or \
-                        strip_coords[3] < ywin1:
-            continue
-
-        # Draw
-        status = strip.atc_status
-        if status in strip_status_colour:
-            color = strip_status_colour[status]
-        else:
-            color = strip_status_colour[None]
-
-        alpha = 1.0 if strip.atc_is_synced else 0.5
-
-        draw_underline_in_strip(strip_coords, pixel_size_x, color + (alpha,))
-        if strip.atc_is_synced and strip.atc_object_id_conflict:
-            draw_strip_conflict(strip_coords, pixel_size_x)
-
-
-def tag_redraw_all_sequencer_editors():
-    context = bpy.context
-
-    # Py cant access notifiers
-    for window in context.window_manager.windows:
-        for area in window.screen.areas:
-            if area.type == 'SEQUENCE_EDITOR':
-                for region in area.regions:
-                    if region.type == 'WINDOW':
-                        region.tag_redraw()
-
-
-# This is a list so it can be changed instead of set
-# if it is only changed, it does not have to be declared as a global everywhere
-cb_handle = []
-
-
-def callback_enable():
-    if cb_handle:
-        return
-
-    cb_handle[:] = bpy.types.SpaceSequenceEditor.draw_handler_add(
-        draw_callback_px, (), 'WINDOW', 'POST_VIEW'),
-
-    tag_redraw_all_sequencer_editors()
-
-
-def callback_disable():
-    if not cb_handle:
-        return
-
-    bpy.types.SpaceSequenceEditor.draw_handler_remove(cb_handle[0], 'WINDOW')
-
-    tag_redraw_all_sequencer_editors()

blender_cloud/blender.py

@@ -29,11 +29,10 @@ from bpy.types import AddonPreferences, Operator, WindowManager, Scene, Property
 from bpy.props import StringProperty, EnumProperty, PointerProperty, BoolProperty
 import rna_prop_ui
 
-from . import pillar, async_loop
+from . import pillar
 
-PILLAR_WEB_SERVER_URL = 'https://cloud.blender.org/'
-# PILLAR_WEB_SERVER_URL = 'http://pillar-web:5001/'
-PILLAR_SERVER_URL = '%sapi/' % PILLAR_WEB_SERVER_URL
+PILLAR_SERVER_URL = 'https://cloud.blender.org/api/'
+# PILLAR_SERVER_URL = 'http://pillar:5001/api/'
 
 ADDON_NAME = 'blender_cloud'
 log = logging.getLogger(__name__)
@@ -45,39 +44,7 @@ def redraw(self, context):
     context.area.tag_redraw()
 
 
-def pyside_cache(propname):
-
-    if callable(propname):
-        raise TypeError('Usage: pyside_cache("property_name")')
-
-    def decorator(wrapped):
-        """Stores the result of the callable in Python-managed memory.
-
-        This is to work around the warning at
-        https://www.blender.org/api/blender_python_api_master/bpy.props.html#bpy.props.EnumProperty
-        """
-
-        import functools
-
-        @functools.wraps(wrapped)
-        # We can't use (*args, **kwargs), because EnumProperty explicitly checks
-        # for the number of fixed positional arguments.
-        def wrapper(self, context):
-            result = None
-            try:
-                result = wrapped(self, context)
-                return result
-            finally:
-                rna_type, rna_info = getattr(self.bl_rna, propname)
-                rna_info['_cached_result'] = result
-        return wrapper
-    return decorator
-
-
-@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:
@@ -137,43 +104,6 @@ class SyncStatusProperties(PropertyGroup):
         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."""
-
-    attr_proj = preferences().attract_project
-    projs = attr_proj.available_projects
-    if not projs:
-        return [('', 'No projects available in your Blender Cloud', '')]
-    return [(p['_id'], p['name'], '') for p in projs]
-
-
-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')
-
-    # 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
-
-
 class BlenderCloudPreferences(AddonPreferences):
     bl_idname = ADDON_NAME
 
@@ -197,16 +127,6 @@ class BlenderCloudPreferences(AddonPreferences):
         default=True
     )
 
-    # TODO: store local path with the Attract project, so that people
-    # can switch projects and the local path switches with it.
-    attract_project = PointerProperty(type=BlenderCloudProjectGroup)
-    attract_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='//../')
-
     def draw(self, context):
         import textwrap
 
@@ -285,12 +205,9 @@ class BlenderCloudPreferences(AddonPreferences):
         # Image Share stuff
         share_box = layout.box()
         share_box.label('Image Sharing on Blender Cloud', icon_value=icon('CLOUD'))
+        texture_box.enabled = msg_icon != 'ERROR'
         share_box.prop(self, 'open_browser_after_share')
 
-        # Attract stuff
-        attract_box = layout.box()
-        self.draw_attract_buttons(attract_box, self.attract_project)
-
     def draw_subscribe_button(self, layout):
         layout.operator('pillar.subscribe', icon='WORLD')
 
@@ -325,37 +242,12 @@ class BlenderCloudPreferences(AddonPreferences):
         else:
             row_pull.label('Cloud Sync is running.')
 
-    def draw_attract_buttons(self, attract_box, bcp: BlenderCloudProjectGroup):
-        attract_row = attract_box.row(align=True)
-        attract_row.label('Attract', icon_value=icon('CLOUD'))
-
-        attract_row.enabled = bcp.status in {'NONE', 'IDLE'}
-        row_buttons = attract_row.row(align=True)
-
-        projects = bcp.available_projects
-        project = bcp.project
-        if bcp.status in {'NONE', 'IDLE'}:
-            if not projects or not project:
-                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')
-        else:
-            row_buttons.label('Fetching available projects.')
-
-        attract_box.prop(self, 'attract_project_local_path')
-
 
 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)
 
@@ -402,7 +294,6 @@ 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
@@ -413,67 +304,6 @@ class PILLAR_OT_subscribe(Operator):
         return {'FINISHED'}
 
 
-class PILLAR_OT_projects(async_loop.AsyncModalOperatorMixin,
-                         pillar.PillarOperatorMixin,
-                         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):
-        import pillarsdk
-        from .pillar import pillar_call
-
-        self._log.info('Checking credentials')
-        try:
-            db_user = await self.check_credentials(context, ())
-        except pillar.UserNotLoggedInError as ex:
-            self._log.info('Not logged in error raised: %s', ex)
-            self.report({'ERROR'}, 'Please log in on Blender ID first.')
-            self.quit()
-            return
-
-        user_id = db_user['_id']
-        self.log.info('Going to fetch projects for user %s', user_id)
-
-        preferences().attract_project.status = 'FETCHING'
-
-        # Get all projects, except the home project.
-        projects_user = await pillar_call(
-            pillarsdk.Project.all,
-            {'where': {'user': user_id,
-                       'category': {'$ne': 'home'}},
-             'sort': '-_created',
-             'projection': {'_id': True,
-                            'name': True},
-             })
-
-        projects_shared = await pillar_call(
-            pillarsdk.Project.all,
-            {'where': {'user': {'$ne': user_id},
-                       'permissions.groups.group': {'$in': db_user.groups}},
-             'sort': '-_created',
-             'projection': {'_id': True,
-                            'name': True},
-             })
-
-        # We need to convert to regular dicts before storing in ID properties.
-        # Also don't store more properties than we need.
-        projects = [{'_id': p['_id'], 'name': p['name']} for p in projects_user['_items']] + \
-                   [{'_id': p['_id'], 'name': p['name']} for p in projects_shared['_items']]
-
-        preferences().attract_project.available_projects = projects
-
-        self.quit()
-
-    def quit(self):
-        preferences().attract_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."""
 
@@ -523,12 +353,10 @@ def icon(icon_name: str) -> int:
 
 
 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_PT_image_custom_properties)
 
     addon_prefs = preferences()
@@ -557,12 +385,10 @@ def register():
 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_PT_image_custom_properties)
 
     del WindowManager.last_blender_cloud_location

blender_cloud/pillar.py

@@ -146,13 +146,6 @@ def blender_id_subclient() -> dict:
     return subclient
 
 
-def pillar_user_uuid() -> str:
-    """Returns the UUID of the Pillar user."""
-
-    import blender_id
-    return blender_id.get_subclient_user_id(SUBCLIENT_ID)
-
-
 def pillar_api(pillar_endpoint: str = None, caching=True) -> pillarsdk.Api:
     """Returns the Pillar SDK API object for the current user.
 
@@ -205,12 +198,6 @@ pillar_semaphore = asyncio.Semaphore(3)
 
 
 async def pillar_call(pillar_func, *args, caching=True, **kwargs):
-    """Calls a Pillar function.
-
-    A semaphore is used to ensure that there won't be too many
-    calls to Pillar simultaneously.
-    """
-
     partial = functools.partial(pillar_func, *args, api=pillar_api(caching=caching), **kwargs)
     loop = asyncio.get_event_loop()
 
@@ -218,12 +205,6 @@ async def pillar_call(pillar_func, *args, caching=True, **kwargs):
         return await loop.run_in_executor(None, partial)
 
 
-def sync_call(pillar_func, *args, caching=True, **kwargs):
-    """Synchronous call to Pillar, ensures the correct Api object is used."""
-
-    return pillar_func(*args, api=pillar_api(caching=caching), **kwargs)
-
-
 async def check_pillar_credentials(required_roles: set):
     """Tries to obtain the user at Pillar using the user's credentials.
 

blender_cloud/texture_browser.py

@@ -553,7 +553,6 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
         """Draws the GUI with OpenGL."""
 
         drawers = {
-            'INITIALIZING': self._draw_initializing,
             'CHECKING_CREDENTIALS': self._draw_checking_credentials,
             'BROWSING': self._draw_browser,
             'DOWNLOADING_TEXTURE': self._draw_downloading,
@@ -654,13 +653,6 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
                                   'Checking login credentials',
                                   (0.0, 0.0, 0.2, 0.6))
 
-    def _draw_initializing(self, context):
-        """OpenGL drawing code for the INITIALIZING state."""
-
-        self._draw_text_on_colour(context,
-                                  'Initializing',
-                                  (0.0, 0.0, 0.2, 0.6))
-
     def _draw_text_on_colour(self, context, text, bgcolour):
         content_height, content_width = self._window_size(context)
         bgl.glEnable(bgl.GL_BLEND)

blender_cloud/utils.py

@@ -16,8 +16,6 @@
 #
 # ##### END GPL LICENSE BLOCK #####
 
-import pathlib
-
 
 def sizeof_fmt(num: int, suffix='B') -> str:
     """Returns a human-readable size.
@@ -31,34 +29,3 @@ def sizeof_fmt(num: int, suffix='B') -> str:
         num /= 1024
 
     return '%.1f Yi%s' % (num, suffix)
-
-
-def find_in_path(path: pathlib.Path, filename: str) -> pathlib.Path:
-    """Performs a breadth-first search for the filename.
-
-    Returns the path that contains the file, or None if not found.
-    """
-
-    import collections
-
-    # Be lenient on our input type.
-    if isinstance(path, str):
-        path = pathlib.Path(path)
-
-    if not path.exists():
-        return None
-    assert path.is_dir()
-
-    to_visit = collections.deque([path])
-    while to_visit:
-        this_path = to_visit.popleft()
-
-        for subpath in this_path.iterdir():
-            if subpath.is_dir():
-                to_visit.append(subpath)
-                continue
-
-            if subpath.name == filename:
-                return subpath
-
-    return None

requirements-dev.txt

@@ -1,8 +0,0 @@
--r requirements.txt
-
-# Primary requirements
-pytest==3.0.3
-
-# Secondary requirements
-py==1.4.31
-

requirements.txt

@@ -1,7 +1,7 @@
 # Primary requirements:
 -e git+https://github.com/sybrenstuvel/cachecontrol.git@sybren-filecache-delete-crash-fix#egg=CacheControl
 lockfile==0.12.2
-pillarsdk==1.6.1
+pillarsdk==1.5.0
 wheel==0.29.0
 
 # Secondary requirements:

setup.py

@@ -196,7 +196,7 @@ setup(
               'wheels': BuildWheels},
     name='blender_cloud',
     description='The Blender Cloud addon allows browsing the Blender Cloud from Blender.',
-    version='1.5.0',
+    version='1.4.4',
     author='Sybren A. Stüvel',
     author_email='sybren@stuvel.eu',
     packages=find_packages('.'),

tests/test_utils.py

@@ -1,25 +0,0 @@
-"""Unittests for blender_cloud.utils."""
-
-import pathlib
-import unittest
-
-from blender_cloud import utils
-
-
-class FindInPathTest(unittest.TestCase):
-    def test_nonexistant_path(self):
-        path = pathlib.Path('/doesnotexistreally')
-        self.assertFalse(path.exists())
-        self.assertIsNone(utils.find_in_path(path, 'jemoeder.blend'))
-
-    def test_really_breadth_first(self):
-        """A depth-first test might find dir_a1/dir_a2/dir_a3/find_me.txt first."""
-
-        path = pathlib.Path(__file__).parent / 'test_really_breadth_first'
-        found = utils.find_in_path(path, 'find_me.txt')
-        self.assertEqual(path / 'dir_b1' / 'dir_b2' / 'find_me.txt', found)
-
-    def test_nonexistant_file(self):
-        path = pathlib.Path(__file__).parent / 'test_really_breadth_first'
-        found = utils.find_in_path(path, 'do_not_find_me.txt')
-        self.assertEqual(None, found)