Bumped version to 1.10.0 and marked as released today

This version has lots of Windows-specific fixes.

CHANGELOG.md

@@ -1,5 +1,120 @@
 # Blender Cloud changelog
 
+
+## Version 1.10.0 (2019-01-02)
+
+- Bundles Blender-Asset-Tracer 0.8.
+- Fix crashing Blender when running in background mode (e.g. without GUI).
+- Flamenco: Include extra job parameters to allow for encoding a video at the end of a render
+  job that produced an image sequence.
+- Flamenco: Compress all blend files, and not just the one we save from Blender.
+- Flamenco: Store more info in the `jobinfo.json` file. This is mostly useful for debugging issues
+  on the render farm, as now things like the exclusion filter and Manager settings are logged too.
+- Flamenco: Allow BAT-packing of only those assets that are referred to by relative path (e.g.
+  a path starting with `//`). Assets with an absolute path are ignored, and assumed to be reachable
+  at the same path by the Workers.
+- Flamenco: Added 'blender-video-chunks' job type, meant for rendering the edit of a film from the
+  VSE. This job type requires that the file is configured for rendering to Matroska video
+  files.
+
+  Audio is only extracted when there is an audio codec configured. This is a bit arbitrary, but it's
+  at least a way to tell whether the artist is considering that there is audio of any relevance in
+  the current blend file.
+
+
+## Version 1.9.4 (2018-11-01)
+
+- Fixed Python 3.6 and Blender 2.79b incompatibilities accidentally introduced in 1.9.3.
+
+
+## Version 1.9.3 (2018-10-30)
+
+- Fix drawing of Attract strips in the VSE on Blender 2.8.
+
+
+## Version 1.9.2 (2018-09-17)
+
+- No changes, just a different filename to force a refresh on our
+  hosting platform.
+
+
+## Version 1.9.1 (2018-09-17)
+
+- Fix issue with Python 3.7, which is used by current daily builds of Blender.
+
+
+## Version 1.9 (2018-09-05)
+
+- Last version to support Blender versions before 2.80!
+- Replace BAM with BAT🦇.
+- Don't crash the texture browser when an invalid texture is seen.
+- Support colour strips as Attract shots.
+- Flamenco: allow jobs to be created in 'paused' state.
+- Flamenco: only show Flamenco Managers that are linked to the currently selected project.
+
+
+## Version 1.8 (2018-01-03)
+
+- Distinguish between 'please subscribe' (to get a new subscription) and 'please renew' (to renew an
+  existing subscription).
+- When re-opening the Texture Browser it now opens in the same folder as where it was when closed.
+- In the texture browser, draw the components of the texture (i.e. which map types are available),
+  such as 'bump, normal, specular'.
+- Use Interface Scale setting from user preferences to draw the Texture Browser text.
+- Store project-specific settings in the preferences, such as filesystem paths, for each project,
+  and restore those settings when the project is selected again. Does not touch settings that
+  haven't been set for the newly selected project. These settings are only saved when a setting
+  is updated, so to save your current settings need to update a single setting; this saves all
+  settings for the project.
+- Added button in the User Preferences to open a Cloud project in your webbrowser.
+
+
+## Version 1.7.5 (2017-10-06)
+
+- Sorting the project list alphabetically.
+- Renamed 'Job File Path' to 'Job Storage Path' so it's more explicit.
+- Allow overriding the render output path on a per-scene basis.
+
+
+## Version 1.7.4 (2017-09-05)
+
+- Fix [T52621](https://developer.blender.org/T52621): Fixed class name collision upon add-on
+  registration. This is checked since Blender 2.79.
+- Fix [T48852](https://developer.blender.org/T48852): Screenshot no longer shows "Communicating with
+  Blender Cloud".
+
+
+## Version 1.7.3 (2017-08-08)
+
+- Default to scene frame range when no frame range is given.
+- Refuse to render on Flamenco before blend file is saved at least once.
+- Fixed some Windows-specific issues.
+
+
+## Version 1.7.2 (2017-06-22)
+
+- Fixed compatibility with Blender 2.78c.
+
+
+## Version 1.7.1 (2017-06-13)
+
+- Fixed asyncio issues on Windows
+
+
+## Version 1.7.0 (2017-06-09)
+
+- Fixed reloading after upgrading from 1.4.4 (our last public release).
+- Fixed bug handling a symlinked project path.
+- Added support for Manager-defined path replacement variables.
+
+
+## Version 1.6.4 (2017-04-21)
+
+- Added file exclusion filter for Flamenco. A filter like `*.abc;*.mkv;*.mov` can be
+  used to prevent certain files from being copied to the job storage directory.
+  Requires a Blender that is bundled with BAM 1.1.7 or newer.
+
+
 ## Version 1.6.3 (2017-03-21)
 
 - Fixed bug where local project path wasn't shown for projects only set up for Flamenco
@@ -9,7 +124,7 @@
 
 ## Version 1.6.2 (2017-03-17)
 
-- Flamenco: when opening non-existing file path, open parent instead - Sybren A. Stüvel
+- Flamenco: when opening non-existing file path, open parent instead
 - Fix T50954: Improve Blender Cloud add-on project selector
 
 

blender_cloud/__init__.py

@@ -21,8 +21,8 @@
 bl_info = {
     'name': 'Blender Cloud',
     "author": "Sybren A. Stüvel, Francesco Siddi, Inês Almeida, Antony Riakiotakis",
-    'version': (1, 6, 3),
-    'blender': (2, 77, 0),
+    'version': (1, 10, 0),
+    'blender': (2, 80, 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.',
@@ -65,36 +65,45 @@ def register():
 
         def reload_mod(name):
             modname = '%s.%s' % (__name__, name)
-            module = importlib.reload(sys.modules[modname])
-            sys.modules[modname] = module
-            return module
+            try:
+                old_module = sys.modules[modname]
+            except KeyError:
+                # Wasn't loaded before -- can happen after an upgrade.
+                new_module = importlib.import_module(modname)
+            else:
+                new_module = importlib.reload(old_module)
+
+            sys.modules[modname] = new_module
+            return new_module
 
         reload_mod('blendfile')
         reload_mod('home_project')
         reload_mod('utils')
+        reload_mod('pillar')
 
-        blender = reload_mod('blender')
         async_loop = reload_mod('async_loop')
+        flamenco = reload_mod('flamenco')
+        attract = reload_mod('attract')
         texture_browser = reload_mod('texture_browser')
         settings_sync = reload_mod('settings_sync')
         image_sharing = reload_mod('image_sharing')
-        attract = reload_mod('attract')
-        flamenco = reload_mod('flamenco')
+        blender = reload_mod('blender')
+        project_specific = reload_mod('project_specific')
     else:
         from . import (blender, texture_browser, async_loop, settings_sync, blendfile, home_project,
-                       image_sharing, attract, flamenco)
+                       image_sharing, attract, flamenco, project_specific)
 
     async_loop.setup_asyncio_executor()
     async_loop.register()
 
     flamenco.register()
+    attract.register()
     texture_browser.register()
-    blender.register()
     settings_sync.register()
     image_sharing.register()
-    attract.register()
+    blender.register()
 
-    blender.handle_project_update()
+    project_specific.handle_project_update()
 
 
 def _monkey_patch_requests():

blender_cloud/async_loop.py

@@ -33,17 +33,12 @@ _loop_kicking_operator_running = False
 
 
 def setup_asyncio_executor():
-    """Sets up AsyncIO to run on a single thread.
+    """Sets up AsyncIO to run properly on each platform."""
 
-    This ensures that only one Pillar HTTP call is performed at the same time. Other
-    calls that could be performed in parallel are queued, and thus we can
-    reliably cancel them.
-    """
     import sys
 
-    executor = concurrent.futures.ThreadPoolExecutor()
-
     if sys.platform == 'win32':
+        asyncio.get_event_loop().close()
         # On Windows, the default event loop is SelectorEventLoop, which does
         # not support subprocesses. ProactorEventLoop should be used instead.
         # Source: https://docs.python.org/3/library/asyncio-subprocess.html
@@ -51,9 +46,15 @@ def setup_asyncio_executor():
         asyncio.set_event_loop(loop)
     else:
         loop = asyncio.get_event_loop()
+
+    executor = concurrent.futures.ThreadPoolExecutor(max_workers=10)
     loop.set_default_executor(executor)
     # loop.set_debug(True)
 
+    from . import pillar
+    # No more than this many Pillar calls should be made simultaneously
+    pillar.pillar_semaphore = asyncio.Semaphore(3, loop=loop)
+
 
 def kick_async_loop(*args) -> bool:
     """Performs a single iteration of the asyncio event loop.
@@ -152,7 +153,7 @@ class AsyncLoopModalOperator(bpy.types.Operator):
         _loop_kicking_operator_running = True
 
         wm = context.window_manager
-        self.timer = wm.event_timer_add(0.00001, context.window)
+        self.timer = wm.event_timer_add(0.00001, window=context.window)
 
         return {'RUNNING_MODAL'}
 
@@ -191,7 +192,7 @@ class AsyncModalOperatorMixin:
 
     def invoke(self, context, event):
         context.window_manager.modal_handler_add(self)
-        self.timer = context.window_manager.event_timer_add(1 / 15, context.window)
+        self.timer = context.window_manager.event_timer_add(1 / 15, window=context.window)
 
         self.log.info('Starting')
         self._new_async_task(self.async_execute(context))

blender_cloud/attract/__init__.py

@@ -46,9 +46,15 @@ if "bpy" in locals():
     draw = importlib.reload(draw)
     pillar = importlib.reload(pillar)
     async_loop = importlib.reload(async_loop)
+    blender = importlib.reload(blender)
 else:
-    from . import draw
-    from .. import pillar, async_loop
+    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
@@ -173,10 +179,11 @@ class AttractPollMixin:
         return attract_is_active
 
 
-class ToolsPanel(AttractPollMixin, Panel):
+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)
@@ -186,68 +193,71 @@ class ToolsPanel(AttractPollMixin, Panel):
     def draw(self, context):
         strip = active_strip(context)
         layout = self.layout
-        strip_types = {'MOVIE', 'IMAGE', 'META'}
+        strip_types = {'MOVIE', 'IMAGE', 'META', 'COLOR'}
 
-        selshots = list(selected_shots(context))
         if strip and strip.type in strip_types and strip.atc_object_id:
-            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('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(AttractShotFetchUpdate.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(0.6, align=True)
-                dangerous_sub.operator('attract.strip_unlink',
-                                       text='Unlink %s' % noun,
-                                       icon='PANEL_CLOSE')
-                dangerous_sub.operator(AttractShotDelete.bl_idname,
-                                       text='Delete %s' % noun,
-                                       icon='CANCEL')
-
+            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(AttractShotSubmitSelected.bl_idname,
+            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):
@@ -378,7 +388,7 @@ class AttractOperatorMixin(AttractPollMixin):
         draw.tag_redraw_all_sequencer_editors()
 
 
-class AttractShotFetchUpdate(AttractOperatorMixin, Operator):
+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'
@@ -397,7 +407,7 @@ class AttractShotFetchUpdate(AttractOperatorMixin, Operator):
         return {'FINISHED'}
 
 
-class AttractShotRelink(AttractShotFetchUpdate):
+class ATTRACT_OT_shot_relink(AttractOperatorMixin, Operator):
     bl_idname = "attract.shot_relink"
     bl_label = "Relink With Attract"
 
@@ -466,7 +476,7 @@ class ATTRACT_OT_shot_open_in_browser(AttractOperatorMixin, Operator):
         return {'FINISHED'}
 
 
-class AttractShotDelete(AttractOperatorMixin, Operator):
+class ATTRACT_OT_shot_delete(AttractOperatorMixin, Operator):
     bl_idname = 'attract.shot_delete'
     bl_label = 'Delete Shot'
     bl_description = 'Remove this shot from Attract'
@@ -521,7 +531,7 @@ class AttractShotDelete(AttractOperatorMixin, Operator):
         col.prop(self, 'confirm', text="I hereby confirm: delete %s from The Edit." % noun)
 
 
-class AttractStripUnlink(AttractOperatorMixin, Operator):
+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)'
@@ -565,7 +575,7 @@ class AttractStripUnlink(AttractOperatorMixin, Operator):
         return {'FINISHED'}
 
 
-class AttractShotSubmitSelected(AttractOperatorMixin, Operator):
+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'
@@ -905,6 +915,37 @@ class ATTRACT_OT_copy_id_to_clipboard(AttractOperatorMixin, Operator):
         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'}
+
+
 def draw_strip_movie_meta(self, context):
     strip = active_strip(context)
     if not strip:
@@ -918,12 +959,12 @@ def draw_strip_movie_meta(self, context):
     row = box.row(align=True)
     fname = meta.get('BLEND_FILE', None) or None
     if fname:
-        row.label('Original Blendfile: %s' % 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('Original Frame Range: %s-%s' % (sfra, efra))
+    box.label(text='Original Frame Range: %s-%s' % (sfra, efra))
 
 
 def activate():
@@ -931,7 +972,10 @@ def activate():
 
     log.info('Activating Attract')
     attract_is_active = True
-    bpy.app.handlers.scene_update_post.append(scene_update_post_handler)
+
+    # 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()
 
 
@@ -942,11 +986,18 @@ def deactivate():
     attract_is_active = False
     draw.callback_disable()
 
-    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
+    # 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():
@@ -974,22 +1025,18 @@ def register():
 
     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.utils.register_class(ATTRACT_OT_copy_id_to_clipboard)
+    for cls in _rna_classes:
+        bpy.utils.register_class(cls)
 
 
 def unregister():
     deactivate()
-    bpy.utils.unregister_module(__name__)
+    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

blender_cloud/attract/draw.py

@@ -18,9 +18,12 @@
 
 # <pep8 compliant>
 
-import bpy
 import logging
-import collections
+import typing
+
+import bpy
+import bgl
+import gpu
 
 log = logging.getLogger(__name__)
 
@@ -34,10 +37,74 @@ strip_status_colour = {
     'todo': (1.0, 0.5019607843137255, 0.5019607843137255)
 }
 
-CONFLICT_COLOUR = (0.576, 0.118, 0.035)  # RGB tuple
+CONFLICT_COLOUR = (0.576, 0.118, 0.035, 1.0)  # RGBA tuple
+
+gpu_vertex_shader = '''
+uniform mat4 ModelViewProjectionMatrix;
+
+layout (location = 0) in vec2 pos;
+layout (location = 1) in vec4 color;
+
+out vec4 lineColor; // output to the fragment shader
+
+void main()
+{
+    gl_Position = ModelViewProjectionMatrix * vec4(pos.x, pos.y, 0.0, 1.0);
+    lineColor = color;
+}
+'''
+
+gpu_fragment_shader = '''
+out vec4 fragColor;
+in vec4 lineColor;
+
+void main()
+{
+    fragColor = lineColor;
+}
+'''
+
+Float2 = typing.Tuple[float, float]
+Float3 = typing.Tuple[float, float, float]
+Float4 = typing.Tuple[float, float, float, float]
 
 
-def get_strip_rectf(strip):
+class AttractLineDrawer:
+
+    def __init__(self):
+        self._format = gpu.types.GPUVertFormat()
+        self._pos_id = self._format.attr_add(
+            id="pos",
+            comp_type="F32",
+            len=2,
+            fetch_mode="FLOAT")
+        self._color_id = self._format.attr_add(
+            id="color",
+            comp_type="F32",
+            len=4,
+            fetch_mode="FLOAT")
+
+        self.shader = gpu.types.GPUShader(gpu_vertex_shader, gpu_fragment_shader)
+
+    def draw(self,
+             coords: typing.List[Float2],
+             colors: typing.List[Float4]):
+        if not coords:
+            return
+
+        bgl.glEnable(bgl.GL_BLEND)
+        bgl.glLineWidth(2.0)
+
+        vbo = gpu.types.GPUVertBuf(len=len(coords), format=self._format)
+        vbo.attr_fill(id=self._pos_id, data=coords)
+        vbo.attr_fill(id=self._color_id, data=colors)
+
+        batch = gpu.types.GPUBatch(type="LINES", buf=vbo)
+        batch.program_set(self.shader)
+        batch.draw()
+
+
+def get_strip_rectf(strip) -> Float4:
     # Get x and y in terms of the grid's frames and channels
     x1 = strip.frame_final_start
     x2 = strip.frame_final_end
@@ -47,59 +114,56 @@ def get_strip_rectf(strip):
     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
-
+def underline_in_strip(strip_coords: Float4,
+                       pixel_size_x: float,
+                       color: Float4,
+                       out_coords: typing.List[Float2],
+                       out_colors: typing.List[Float4]):
     # 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
+    cf_x = bpy.context.scene.frame_current_final
 
-    bgl.glPushAttrib(bgl.GL_COLOR_BUFFER_BIT | bgl.GL_LINE_BIT)
+    # TODO(Sybren): figure out how to pass one colour per line,
+    # instead of one colour per vertex.
+    out_coords.append((s_x1, s_y1))
+    out_colors.append(color)
 
-    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)
+        # Bad luck, the line passes our strip, so draw two lines.
+        out_coords.append((cf_x - pixel_size_x, s_y1))
+        out_colors.append(color)
 
-    bgl.glEnd()
-    bgl.glPopAttrib()
+        out_coords.append((cf_x + pixel_size_x, s_y1))
+        out_colors.append(color)
+
+    out_coords.append((s_x2, s_y1))
+    out_colors.append(color)
 
 
-def draw_strip_conflict(strip_coords, pixel_size_x):
+def strip_conflict(strip_coords: Float4,
+                   out_coords: typing.List[Float2],
+                   out_colors: typing.List[Float4]):
     """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)
+    # TODO(Sybren): draw a rectangle instead of a line.
+    out_coords.append((s_x1, s_y2))
+    out_colors.append(CONFLICT_COLOUR)
 
-    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()
+    out_coords.append((s_x2, s_y1))
+    out_colors.append(CONFLICT_COLOUR)
 
-    bgl.glPopAttrib()
+    out_coords.append((s_x2, s_y2))
+    out_colors.append(CONFLICT_COLOUR)
+
+    out_coords.append((s_x1, s_y1))
+    out_colors.append(CONFLICT_COLOUR)
 
 
-def draw_callback_px():
+def draw_callback_px(line_drawer: AttractLineDrawer):
     context = bpy.context
 
     if not context.scene.sequence_editor:
@@ -115,6 +179,10 @@ def draw_callback_px():
 
     strips = shown_strips(context)
 
+    coords = []  # type: typing.List[Float2]
+    colors = []  # type: typing.List[Float4]
+
+    # Collect all the lines (vertex coords + vertex colours) to draw.
     for strip in strips:
         if not strip.atc_object_id:
             continue
@@ -124,7 +192,7 @@ def draw_callback_px():
 
         # 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:
+                strip_coords[3] < ywin1:
             continue
 
         # Draw
@@ -136,9 +204,11 @@ def draw_callback_px():
 
         alpha = 1.0 if strip.atc_is_synced else 0.5
 
-        draw_underline_in_strip(strip_coords, pixel_size_x, color + (alpha,))
+        underline_in_strip(strip_coords, pixel_size_x, color + (alpha,), coords, colors)
         if strip.atc_is_synced and strip.atc_object_id_conflict:
-            draw_strip_conflict(strip_coords, pixel_size_x)
+            strip_conflict(strip_coords, coords, colors)
+
+    line_drawer.draw(coords, colors)
 
 
 def tag_redraw_all_sequencer_editors():
@@ -162,8 +232,13 @@ def callback_enable():
     if cb_handle:
         return
 
+    # Doing GPU stuff in the background crashes Blender, so let's not.
+    if bpy.app.background:
+        return
+
+    line_drawer = AttractLineDrawer()
     cb_handle[:] = bpy.types.SpaceSequenceEditor.draw_handler_add(
-        draw_callback_px, (), 'WINDOW', 'POST_VIEW'),
+        draw_callback_px, (line_drawer,), 'WINDOW', 'POST_VIEW'),
 
     tag_redraw_all_sequencer_editors()
 

blender_cloud/attract/draw_27.py

@@ -0,0 +1,182 @@
+# ##### 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
+
+    try:
+        bpy.types.SpaceSequenceEditor.draw_handler_remove(cb_handle[0], 'WINDOW')
+    except ValueError:
+        # Thrown when already removed.
+        pass
+    cb_handle.clear()
+
+    tag_redraw_all_sequencer_editors()

blender_cloud/blender.py

@@ -23,25 +23,36 @@ Separated from __init__.py so that we can import & run from non-Blender environm
 import functools
 import logging
 import os.path
+import tempfile
 
 import bpy
 from bpy.types import AddonPreferences, Operator, WindowManager, Scene, PropertyGroup
 from bpy.props import StringProperty, EnumProperty, PointerProperty, BoolProperty, IntProperty
 import rna_prop_ui
 
-from . import pillar, async_loop, flamenco
+from . import pillar, async_loop, flamenco, project_specific
 from .utils import pyside_cache, redraw
 
-PILLAR_WEB_SERVER_URL = 'https://cloud.blender.org/'
-# PILLAR_WEB_SERVER_URL = 'http://pillar-web:5001/'
+PILLAR_WEB_SERVER_URL = os.environ.get('BCLOUD_SERVER', 'https://cloud.blender.org/')
 PILLAR_SERVER_URL = '%sapi/' % PILLAR_WEB_SERVER_URL
 
 ADDON_NAME = 'blender_cloud'
 log = logging.getLogger(__name__)
-
 icons = None
 
 
+@functools.lru_cache()
+def factor(factor: float) -> dict:
+    """Construct keyword argument for UILayout.split().
+
+    On Blender 2.8 this returns {'factor': factor}, and on earlier Blenders it returns
+    {'percentage': factor}.
+    """
+    if bpy.app.version < (2, 80, 0):
+        return {'percentage': factor}
+    return {'factor': factor}
+
+
 @pyside_cache('version')
 def blender_syncable_versions(self, context):
     """Returns the list of items used by SyncStatusProperties.version EnumProperty."""
@@ -140,30 +151,6 @@ def project_extensions(project_id) -> set:
     return set(proj.get('enabled_for', ()))
 
 
-def handle_project_update(_=None, _2=None):
-    """Handles changing projects, which may cause extensions to be disabled/enabled.
-
-    Ignores arguments so that it can be used as property update callback.
-    """
-
-    project_id = preferences().project.project
-    log.info('Updating internal state to reflect extensions enabled on current project %s.',
-             project_id)
-
-    project_extensions.cache_clear()
-
-    from blender_cloud import attract, flamenco
-    attract.deactivate()
-    flamenco.deactivate()
-
-    enabled_for = project_extensions(project_id)
-    log.info('Project extensions: %s', enabled_for)
-    if 'attract' in enabled_for:
-        attract.activate()
-    if 'flamenco' in enabled_for:
-        flamenco.activate()
-
-
 class BlenderCloudProjectGroup(PropertyGroup):
     status = EnumProperty(
         items=[
@@ -178,7 +165,7 @@ class BlenderCloudProjectGroup(PropertyGroup):
         items=bcloud_available_projects,
         name='Cloud project',
         description='Which Blender Cloud project to work with',
-        update=handle_project_update
+        update=project_specific.handle_project_update
     )
 
     # List of projects is stored in 'available_projects' ID property,
@@ -190,13 +177,13 @@ class BlenderCloudProjectGroup(PropertyGroup):
     @available_projects.setter
     def available_projects(self, new_projects):
         self['available_projects'] = new_projects
-        handle_project_update()
+        project_specific.handle_project_update()
 
 
 class BlenderCloudPreferences(AddonPreferences):
     bl_idname = ADDON_NAME
 
-    # The following two properties are read-only to limit the scope of the
+    # The following property is read-only to limit the scope of the
     # addon and allow for proper testing within this scope.
     pillar_server = StringProperty(
         name='Blender Cloud Server',
@@ -225,24 +212,32 @@ class BlenderCloudPreferences(AddonPreferences):
         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='//../')
+        default='//../',
+        update=project_specific.store,
+    )
 
     flamenco_manager = PointerProperty(type=flamenco.FlamencoManagerGroup)
-    # TODO: before making Flamenco public, change the defaults to something less Institute-specific.
-    # NOTE: The assumption is that the workers can also find the files in the same path.
-    #       This assumption is true for the Blender Institute.
+    flamenco_exclude_filter = StringProperty(
+        name='File Exclude Filter',
+        description='Space-separated list of filename filters, like "*.abc *.mkv", to prevent '
+                    'matching files from being packed into the output directory',
+        default='',
+        update=project_specific.store,
+    )
     flamenco_job_file_path = StringProperty(
-        name='Job File Path',
+        name='Job Storage Path',
         description='Path where to store job files, should be accesible for Workers too',
         subtype='DIR_PATH',
-        default='/render/_flamenco/storage')
-
-    # TODO: before making Flamenco public, change the defaults to something less Institute-specific.
+        default=tempfile.gettempdir(),
+        update=project_specific.store,
+    )
     flamenco_job_output_path = StringProperty(
         name='Job Output Path',
         description='Path where to store output files, should be accessible for Workers',
         subtype='DIR_PATH',
-        default='/render/_flamenco/output')
+        default=tempfile.gettempdir(),
+        update=project_specific.store,
+    )
     flamenco_job_output_strip_components = IntProperty(
         name='Job Output Path Strip Components',
         description='The final output path comprises of the job output path, and the blend file '
@@ -251,11 +246,21 @@ class BlenderCloudPreferences(AddonPreferences):
         min=0,
         default=0,
         soft_max=4,
+        update=project_specific.store,
     )
+    flamenco_relative_only = BoolProperty(
+        name='Relative Paths Only',
+        description='When enabled, only assets that are referred to with a relative path are '
+                    'packed, and assets referred to by an absolute path are excluded from the '
+                    'BAT pack. When disabled, all assets are packed.',
+        default=False,
+        update=project_specific.store,
+    )
+
     flamenco_open_browser_after_submit = BoolProperty(
         name='Open Browser after Submitting Job',
         description='When enabled, Blender will open a webbrowser',
-        default=True
+        default=True,
     )
 
     def draw(self, context):
@@ -314,8 +319,8 @@ class BlenderCloudPreferences(AddonPreferences):
         bss = context.window_manager.blender_sync_status
         bsync_box = layout.box()
         bsync_box.enabled = msg_icon != 'ERROR'
-        row = bsync_box.row().split(percentage=0.33)
-        row.label('Blender Sync with Blender Cloud', icon_value=icon('CLOUD'))
+        row = bsync_box.row().split(**factor(0.33))
+        row.label(text='Blender Sync with Blender Cloud', icon_value=icon('CLOUD'))
 
         icon_for_level = {
             'INFO': 'NONE',
@@ -325,7 +330,7 @@ class BlenderCloudPreferences(AddonPreferences):
         }
         msg_icon = icon_for_level[bss.level] if bss.message else 'NONE'
         message_container = row.row()
-        message_container.label(bss.message, icon=msg_icon)
+        message_container.label(text=bss.message, icon=msg_icon)
 
         sub = bsync_box.column()
 
@@ -335,7 +340,7 @@ class BlenderCloudPreferences(AddonPreferences):
 
         # Image Share stuff
         share_box = layout.box()
-        share_box.label('Image Sharing on Blender Cloud', icon_value=icon('CLOUD'))
+        share_box.label(text='Image Sharing on Blender Cloud', icon_value=icon('CLOUD'))
         share_box.prop(self, 'open_browser_after_share')
 
         # Project selector
@@ -357,7 +362,7 @@ class BlenderCloudPreferences(AddonPreferences):
         layout.enabled = bss.status in {'NONE', 'IDLE'}
 
         buttons = layout.column()
-        row_buttons = buttons.row().split(percentage=0.5)
+        row_buttons = buttons.row().split(**factor(0.5))
         row_push = row_buttons.row()
         row_pull = row_buttons.row(align=True)
 
@@ -382,11 +387,11 @@ class BlenderCloudPreferences(AddonPreferences):
                                   text='',
                                   icon='DOTSDOWN').action = 'SELECT'
         else:
-            row_pull.label('Cloud Sync is running.')
+            row_pull.label(text='Cloud Sync is running.')
 
     def draw_project_selector(self, project_box, bcp: BlenderCloudProjectGroup):
         project_row = project_box.row(align=True)
-        project_row.label('Project settings', icon_value=icon('CLOUD'))
+        project_row.label(text='Project settings', icon_value=icon('CLOUD'))
 
         row_buttons = project_row.row(align=True)
 
@@ -402,29 +407,35 @@ class BlenderCloudPreferences(AddonPreferences):
                 row_buttons.operator('pillar.projects',
                                      text='',
                                      icon='FILE_REFRESH')
+                props = row_buttons.operator('pillar.project_open_in_browser',
+                                             text='',
+                                             icon='WORLD')
+                props.project_id = project
         else:
-            row_buttons.label('Fetching available projects.')
+            row_buttons.label(text='Fetching available projects.')
 
         enabled_for = project_extensions(project)
         if not project:
             return
 
         if not enabled_for:
-            project_box.label('This project is not set up for Attract or Flamenco')
+            project_box.label(text='This project is not set up for Attract or Flamenco')
             return
 
-        project_box.label('This project is set up for: %s' %
-                          ', '.join(sorted(enabled_for)))
+        project_box.label(text='This project is set up for: %s' %
+                               ', '.join(sorted(enabled_for)))
 
         # This is only needed when the project is set up for either Attract or Flamenco.
         project_box.prop(self, 'cloud_project_local_path',
-                         text='Local Cloud project path')
+                         text='Local Project Path')
 
     def draw_flamenco_buttons(self, flamenco_box, bcp: flamenco.FlamencoManagerGroup, context):
         header_row = flamenco_box.row(align=True)
-        header_row.label('Flamenco:', icon_value=icon('CLOUD'))
+        header_row.label(text='Flamenco:', icon_value=icon('CLOUD'))
 
-        manager_box = flamenco_box.row(align=True)
+        manager_split = flamenco_box.split(**factor(0.32), align=True)
+        manager_split.label(text='Manager:')
+        manager_box = manager_split.row(align=True)
 
         if bcp.status in {'NONE', 'IDLE'}:
             if not bcp.available_managers or not bcp.manager:
@@ -432,39 +443,46 @@ class BlenderCloudPreferences(AddonPreferences):
                                      text='Find Flamenco Managers',
                                      icon='FILE_REFRESH')
             else:
-                manager_box.prop(bcp, 'manager', text='Manager')
+                manager_box.prop(bcp, 'manager', text='')
                 manager_box.operator('flamenco.managers',
                                      text='',
                                      icon='FILE_REFRESH')
         else:
-            manager_box.label('Fetching available managers.')
+            manager_box.label(text='Fetching available managers.')
 
-        path_box = flamenco_box.row(align=True)
-        path_box.prop(self, 'flamenco_job_file_path')
+        path_split = flamenco_box.split(**factor(0.32), align=True)
+        path_split.label(text='Job File Path:')
+        path_box = path_split.row(align=True)
+        path_box.prop(self, 'flamenco_job_file_path', text='')
         props = path_box.operator('flamenco.explore_file_path', text='', icon='DISK_DRIVE')
         props.path = self.flamenco_job_file_path
 
         job_output_box = flamenco_box.column(align=True)
-        path_box = job_output_box.row(align=True)
-        path_box.prop(self, 'flamenco_job_output_path')
+        path_split = job_output_box.split(**factor(0.32), align=True)
+        path_split.label(text='Job Output Path:')
+        path_box = path_split.row(align=True)
+        path_box.prop(self, 'flamenco_job_output_path', text='')
         props = path_box.operator('flamenco.explore_file_path', text='', icon='DISK_DRIVE')
         props.path = self.flamenco_job_output_path
+        job_output_box.prop(self, 'flamenco_exclude_filter')
 
-        job_output_box.prop(self, 'flamenco_job_output_strip_components',
-                            text='Strip Components')
+        prop_split = job_output_box.split(**factor(0.32), align=True)
+        prop_split.label(text='Strip Components:')
+        prop_split.prop(self, 'flamenco_job_output_strip_components', text='')
 
         from .flamenco import render_output_path
 
         path_box = job_output_box.row(align=True)
         output_path = render_output_path(context)
         if output_path:
-            path_box.label(str(output_path))
+            path_box.label(text=str(output_path))
             props = path_box.operator('flamenco.explore_file_path', text='', icon='DISK_DRIVE')
             props.path = str(output_path.parent)
         else:
-            path_box.label('Blend file is not in your project path, '
-                           'unable to give output path example.')
+            path_box.label(text='Blend file is not in your project path, '
+                                'unable to give output path example.')
 
+        flamenco_box.prop(self, 'flamenco_relative_only')
         flamenco_box.prop(self, 'flamenco_open_browser_after_submit')
 
 
@@ -531,6 +549,36 @@ class PILLAR_OT_subscribe(Operator):
         return {'FINISHED'}
 
 
+class PILLAR_OT_project_open_in_browser(Operator):
+    bl_idname = 'pillar.project_open_in_browser'
+    bl_label = 'Open in Browser'
+    bl_description = 'Opens a webbrowser to show the project'
+
+    project_id = StringProperty(name='Project ID')
+
+    def execute(self, context):
+        if not self.project_id:
+            return {'CANCELLED'}
+
+        import webbrowser
+        import urllib.parse
+
+        import pillarsdk
+        from .pillar import sync_call
+
+        project = sync_call(pillarsdk.Project.find, self.project_id, {'projection': {'url': True}})
+
+        if log.isEnabledFor(logging.DEBUG):
+            import pprint
+            log.debug('found project: %s', pprint.pformat(project.to_dict()))
+
+        url = urllib.parse.urljoin(PILLAR_WEB_SERVER_URL, 'p/' + project.url)
+        webbrowser.open_new_tab(url)
+        self.report({'INFO'}, 'Opened a browser at %s' % url)
+
+        return {'FINISHED'}
+
+
 class PILLAR_OT_projects(async_loop.AsyncModalOperatorMixin,
                          pillar.AuthenticatedPillarOperatorMixin,
                          Operator):
@@ -557,7 +605,7 @@ class PILLAR_OT_projects(async_loop.AsyncModalOperatorMixin,
             pillarsdk.Project.all,
             {'where': {'user': self.user_id,
                        'category': {'$ne': 'home'}},
-             'sort': '-_created',
+             'sort': '-name',
              'projection': {'_id': True,
                             'name': True,
                             'extension_props': True},
@@ -567,7 +615,7 @@ class PILLAR_OT_projects(async_loop.AsyncModalOperatorMixin,
             pillarsdk.Project.all,
             {'where': {'user': {'$ne': self.user_id},
                        'permissions.groups.group': {'$in': self.db_user.groups}},
-             'sort': '-_created',
+             'sort': '-name',
              'projection': {'_id': True,
                             'name': True,
                             'extension_props': True},
@@ -591,7 +639,10 @@ class PILLAR_OT_projects(async_loop.AsyncModalOperatorMixin,
         projects = list(reduce_properties(projects_user['_items'])) + \
                    list(reduce_properties(projects_shared['_items']))
 
-        preferences().project.available_projects = projects
+        def proj_sort_key(project):
+            return project.get('name')
+
+        preferences().project.available_projects = sorted(projects, key=proj_sort_key)
 
         self.quit()
 
@@ -611,8 +662,16 @@ class PILLAR_PT_image_custom_properties(rna_prop_ui.PropertyPanel, bpy.types.Pan
     _property_type = bpy.types.Image
 
 
+def ctx_preferences():
+    """Returns bpy.context.preferences in a 2.79-compatible way."""
+    try:
+        return bpy.context.preferences
+    except AttributeError:
+        return bpy.context.user_preferences
+
+
 def preferences() -> BlenderCloudPreferences:
-    return bpy.context.user_preferences.addons[ADDON_NAME].preferences
+    return ctx_preferences().addons[ADDON_NAME].preferences
 
 
 def load_custom_icons():
@@ -655,6 +714,7 @@ def register():
     bpy.utils.register_class(SyncStatusProperties)
     bpy.utils.register_class(PILLAR_OT_subscribe)
     bpy.utils.register_class(PILLAR_OT_projects)
+    bpy.utils.register_class(PILLAR_OT_project_open_in_browser)
     bpy.utils.register_class(PILLAR_PT_image_custom_properties)
 
     addon_prefs = preferences()
@@ -689,6 +749,7 @@ def unregister():
     bpy.utils.unregister_class(SyncStatusProperties)
     bpy.utils.unregister_class(PILLAR_OT_subscribe)
     bpy.utils.unregister_class(PILLAR_OT_projects)
+    bpy.utils.unregister_class(PILLAR_OT_project_open_in_browser)
     bpy.utils.unregister_class(PILLAR_PT_image_custom_properties)
 
     del WindowManager.last_blender_cloud_location

blender_cloud/flamenco/__init__.py

@@ -20,16 +20,32 @@
 
 The preferences are managed blender.py, the rest of the Flamenco-specific stuff is here.
 """
+
 import functools
 import logging
+import os
 from pathlib import Path, PurePath
 import typing
 
+if "bpy" in locals():
+    import importlib
+
+    try:
+        bat_interface = importlib.reload(bat_interface)
+        sdk = importlib.reload(sdk)
+        blender = importlib.reload(blender)
+    except NameError:
+        from . import bat_interface, sdk
+        from .. import blender
+else:
+    from . import bat_interface, sdk
+    from .. import blender
+
 import bpy
 from bpy.types import AddonPreferences, Operator, WindowManager, Scene, PropertyGroup
 from bpy.props import StringProperty, EnumProperty, PointerProperty, BoolProperty, IntProperty
 
-from .. import async_loop, pillar
+from .. import async_loop, pillar, project_specific, utils
 from ..utils import pyside_cache, redraw
 
 log = logging.getLogger(__name__)
@@ -37,6 +53,22 @@ log = logging.getLogger(__name__)
 # Global flag used to determine whether panels etc. can be drawn.
 flamenco_is_active = False
 
+# 'image' file formats that actually produce a video.
+VIDEO_FILE_FORMATS = {'FFMPEG', 'AVI_RAW', 'AVI_JPEG'}
+
+# Video container name (from bpy.context.scene.render.ffmpeg.format) to file
+# extension mapping. Any container name not listed here will be converted to
+# lower case and prepended with a period. This is basically copied from
+# Blender's source, get_file_extensions() in writeffmpeg.c.
+VIDEO_CONTAINER_TO_EXTENSION = {
+    'QUICKTIME': '.mov',
+    'MPEG1': '.mpg',
+    'MPEG2': '.dvd',
+    'MPEG4': '.mp4',
+    'OGG': '.ogv',
+    'FLASH': '.flv',
+}
+
 
 @pyside_cache('manager')
 def available_managers(self, context):
@@ -50,11 +82,36 @@ def available_managers(self, context):
     return [(p['_id'], p['name'], '') for p in mngrs]
 
 
+def manager_updated(self: 'FlamencoManagerGroup', context):
+    from ..blender import preferences
+
+    flamenco_manager_id = self.manager
+    log.debug('manager updated to %r', flamenco_manager_id)
+
+    prefs = preferences()
+    project_id = prefs.project.project
+    ps = prefs.get('project_settings', {}).get(project_id, {})
+
+    # Load per-project, per-manager settings for the current Manager.
+    try:
+        pppm = ps['flamenco_managers_settings'][flamenco_manager_id]
+    except KeyError:
+        # No settings for this manager, so nothing to do.
+        return
+
+    with project_specific.mark_as_loading():
+        project_specific.update_preferences(prefs,
+                                            project_specific.FLAMENCO_PER_PROJECT_PER_MANAGER,
+                                            pppm)
+
+
 class FlamencoManagerGroup(PropertyGroup):
     manager = EnumProperty(
         items=available_managers,
         name='Flamenco Manager',
-        description='Which Flamenco Manager to use for jobs')
+        description='Which Flamenco Manager to use for jobs',
+        update=manager_updated,
+    )
 
     status = EnumProperty(
         items=[
@@ -74,6 +131,7 @@ class FlamencoManagerGroup(PropertyGroup):
     @available_managers.setter
     def available_managers(self, new_managers):
         self['available_managers'] = new_managers
+        project_specific.store()
 
 
 class FlamencoPollMixin:
@@ -105,11 +163,15 @@ class FLAMENCO_OT_fmanagers(async_loop.AsyncModalOperatorMixin,
 
         from .sdk import Manager
         from ..pillar import pillar_call
+        from ..blender import preferences
+
+        prefs = preferences()
 
         self.log.info('Going to fetch managers for user %s', self.user_id)
 
         self.mypref.status = 'FETCHING'
-        managers = await pillar_call(Manager.all)
+        params = {'where': '{"projects" : "%s"}' % prefs.project.project}
+        managers = await pillar_call(Manager.all, params)
 
         # We need to convert to regular dicts before storing in ID properties.
         # Also don't store more properties than we need.
@@ -123,6 +185,18 @@ class FLAMENCO_OT_fmanagers(async_loop.AsyncModalOperatorMixin,
         super().quit()
 
 
+def guess_output_file_extension(output_format: str, scene) -> str:
+    """Return extension, including period, like '.png' or '.mkv'."""
+    if output_format not in VIDEO_FILE_FORMATS:
+        return scene.render.file_extension
+
+    container = scene.render.ffmpeg.format
+    try:
+        return VIDEO_CONTAINER_TO_EXTENSION[container]
+    except KeyError:
+        return '.' + container.lower()
+
+
 class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
                          pillar.AuthenticatedPillarOperatorMixin,
                          FlamencoPollMixin,
@@ -136,15 +210,26 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
     log = logging.getLogger('%s.FLAMENCO_OT_render' % __name__)
 
     async def async_execute(self, context):
+        # Refuse to start if the file hasn't been saved. It's okay if
+        # it's dirty, but we do need a filename and a location.
+        if not os.path.exists(context.blend_data.filepath):
+            self.report({'ERROR'}, 'Please save your Blend file before using '
+                                   'the Blender Cloud addon.')
+            self.quit()
+            return
+
         if not await self.authenticate(context):
             return
 
+        import pillarsdk.exceptions
+        from .sdk import Manager
+        from ..pillar import pillar_call
         from ..blender import preferences
 
         scene = context.scene
 
         # Save to a different file, specifically for Flamenco.
-        context.window_manager.flamenco_status = 'PACKING'
+        context.window_manager.flamenco_status = 'SAVING'
         filepath = await self._save_blendfile(context)
 
         # Determine where the render output will be stored.
@@ -155,20 +240,30 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
             return
         self.log.info('Will output render files to %s', render_output)
 
-        # BAM-pack the files to the destination directory.
-        outfile, missing_sources = await self.bam_pack(filepath)
-        if not outfile:
-            return
-
-        # Create the job at Flamenco Server.
+        # Fetch Manager for doing path replacement.
+        self.log.info('Going to fetch manager %s', self.user_id)
         prefs = preferences()
 
-        context.window_manager.flamenco_status = 'COMMUNICATING'
+        manager_id = prefs.flamenco_manager.manager
+        try:
+            manager = await pillar_call(Manager.find, manager_id)
+        except pillarsdk.exceptions.ResourceNotFound:
+            self.report({'ERROR'}, 'Manager %s not found, refresh your managers in '
+                                   'the Blender Cloud add-on settings.' % manager_id)
+            self.quit()
+            return
+
+        # Construct as much of the job settings as we can before BAT-packing.
+        # Validation should happen as soon as possible (BAT-packing can take minutes).
+        frame_range = scene.flamenco_render_frame_range.strip() or scene_frame_range(context)
         settings = {'blender_cmd': '{blender}',
                     'chunk_size': scene.flamenco_render_fchunk_size,
-                    'filepath': str(outfile),
-                    'frames': scene.flamenco_render_frame_range,
-                    'render_output': str(render_output),
+                    'frames': frame_range,
+                    'render_output': manager.replace_path(render_output),
+
+                    # Used for FFmpeg combining output frames into a video.
+                    'fps': scene.render.fps / scene.render.fps_base,
+                    'extract_audio': scene.render.ffmpeg.audio_codec != 'NONE',
                     }
 
         # Add extra settings specific to the job type
@@ -185,28 +280,82 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
             settings['cycles_sample_count'] = samples
             settings['format'] = 'EXR'
 
+        # Let Flamenco Server know whether we'll output images or video.
+        output_format = settings.get('format') or scene.render.image_settings.file_format
+        if output_format in VIDEO_FILE_FORMATS:
+            settings['images_or_video'] = 'video'
+        else:
+            settings['images_or_video'] = 'images'
+
+            # Always pass the file format, even though it won't be
+            # necessary for the actual render command (the blend file
+            # already has the correct setting). It's used by other
+            # commands, such as FFmpeg combining output frames into
+            # a video.
+            #
+            # Note that this might be overridden above when the job type
+            # requires a specific file format.
+            settings.setdefault('format', scene.render.image_settings.file_format)
+        settings['output_file_extension'] = guess_output_file_extension(output_format, scene)
+
+        if not self.validate_job_settings(context, settings):
+            self.quit()
+            return
+
+        # BAT-pack the files to the destination directory.
+        outdir, outfile, missing_sources = await self.bat_pack(filepath)
+        if not outfile:
+            return
+        settings['filepath'] = manager.replace_path(outfile)
+
+        # Create the job at Flamenco Server.
+        context.window_manager.flamenco_status = 'COMMUNICATING'
+
+        project_id = prefs.project.project
         try:
             job_info = await create_job(self.user_id,
-                                        prefs.project.project,
-                                        prefs.flamenco_manager.manager,
+                                        project_id,
+                                        manager_id,
                                         scene.flamenco_render_job_type,
                                         settings,
                                         'Render %s' % filepath.name,
-                                        priority=scene.flamenco_render_job_priority)
+                                        priority=scene.flamenco_render_job_priority,
+                                        start_paused=scene.flamenco_start_paused)
         except Exception as ex:
             self.report({'ERROR'}, 'Error creating Flamenco job: %s' % ex)
             self.quit()
             return
 
         # Store the job ID in a file in the output dir.
-        with open(str(outfile.parent / 'jobinfo.json'), 'w', encoding='utf8') as outfile:
+        with open(str(outdir / 'jobinfo.json'), 'w', encoding='utf8') as outfile:
             import json
 
-            job_info['missing_files'] = [str(mf) for mf in missing_sources]
-            json.dump(job_info, outfile, sort_keys=True, indent=4)
+            # Version 1: Only the job doc was saved, with 'missing_files' added inside it.
+            # Version 2:
+            #   - '_meta' key was added to indicate version.
+            #   - 'job' is saved in a 'job' key, 'misssing_files' still top-level key.
+            #   - 'exclusion_filter', 'project_settings', and 'flamenco_manager_settings'
+            #      keys were added.
+            project_settings = prefs.get('project_settings', {}).get(project_id, {})
+            if hasattr(project_settings, 'to_dict'):
+                project_settings = project_settings.to_dict()
+
+            # Pop out some settings so that settings of irrelevant Managers are excluded.
+            flamenco_managers_settings = project_settings.pop('flamenco_managers_settings', {})
+            flamenco_manager_settings = flamenco_managers_settings.pop(manager_id)
+
+            info = {
+                '_meta': {'version': 2},
+                'job': job_info,
+                'missing_files': [str(mf) for mf in missing_sources],
+                'exclusion_filter': (prefs.flamenco_exclude_filter or '').strip(),
+                'project_settings': project_settings,
+                'flamenco_manager_settings': flamenco_manager_settings,
+            }
+            json.dump(info, outfile, sort_keys=True, indent=4, cls=utils.JSONEncoder)
 
         # We can now remove the local copy we made with bpy.ops.wm.save_as_mainfile().
-        # Strictly speaking we can already remove it after the BAM-pack, but it may come in
+        # Strictly speaking we can already remove it after the BAT-pack, but it may come in
         # handy in case of failures.
         try:
             self.log.info('Removing temporary file %s', filepath)
@@ -234,6 +383,31 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
 
         self.quit()
 
+    def validate_job_settings(self, context, settings: dict) -> bool:
+        """Perform settings validations for the selected job type.
+
+        :returns: True if ok, False if there was an error.
+        """
+
+        job_type = context.scene.flamenco_render_job_type
+        if job_type == 'blender-video-chunks':
+            # This is not really a requirement, but should catch the mistake where it was
+            # left at the default setting (at the moment of writing that's 1 frame per chunk).
+            if context.scene.flamenco_render_fchunk_size < 10:
+                self.report({'ERROR'}, 'Job type requires chunks of at least 10 frames.')
+                return False
+
+            if settings['output_file_extension'] != '.mkv':
+                self.report({'ERROR'}, 'Job type requires rendering to Matroska files.')
+                return False
+
+        return True
+
+    def quit(self):
+        if bpy.context.window_manager.flamenco_status != 'ABORTED':
+            bpy.context.window_manager.flamenco_status = 'DONE'
+        super().quit()
+
     async def _save_blendfile(self, context):
         """Save to a different file, specifically for Flamenco.
 
@@ -271,34 +445,34 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
 
         return filepath
 
-    def quit(self):
-        super().quit()
-        bpy.context.window_manager.flamenco_status = 'IDLE'
-
-    async def bam_pack(self, filepath: Path) -> (typing.Optional[Path], typing.List[Path]):
-        """BAM-packs the blendfile to the destination directory.
+    async def bat_pack(self, filepath: Path) -> (Path, typing.Optional[Path], typing.List[Path]):
+        """BAT-packs the blendfile to the destination directory.
 
         Returns the path of the destination blend file.
 
         :param filepath: the blend file to pack (i.e. the current blend file)
-        :returns: the destination blend file, or None if there were errors BAM-packing,
-            and a list of missing paths.
+        :returns: the destination directory, the destination blend file or None
+            if there were errors BAT-packing, and a list of missing paths.
         """
 
         from datetime import datetime
         from ..blender import preferences
-        from . import bam_interface
 
         prefs = preferences()
 
         # Create a unique directory that is still more or less identifyable.
         # This should work better than a random ID.
-        # BAM doesn't like output directories that end in '.blend'.
         unique_dir = '%s-%s-%s' % (datetime.now().isoformat('-').replace(':', ''),
                                    self.db_user['username'],
                                    filepath.stem)
         outdir = Path(prefs.flamenco_job_file_path) / unique_dir
-        outfile = outdir / filepath.name
+        proj_abspath = bpy.path.abspath(prefs.cloud_project_local_path)
+        projdir = Path(proj_abspath).resolve()
+        exclusion_filter = (prefs.flamenco_exclude_filter or '').strip()
+        relative_only = prefs.flamenco_relative_only
+
+        self.log.debug('outdir : %s', outdir)
+        self.log.debug('projdir: %s', projdir)
 
         try:
             outdir.mkdir(parents=True)
@@ -306,17 +480,33 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
             self.log.exception('Unable to create output path %s', outdir)
             self.report({'ERROR'}, 'Unable to create output path: %s' % ex)
             self.quit()
-            return None, []
+            return outdir, None, []
 
         try:
-            missing_sources = await bam_interface.bam_copy(filepath, outfile)
-        except bam_interface.CommandExecutionError as ex:
-            self.log.exception('Unable to execute BAM pack')
-            self.report({'ERROR'}, 'Unable to execute BAM pack: %s' % ex)
+            outfile, missing_sources = await bat_interface.copy(
+                bpy.context, filepath, projdir, outdir, exclusion_filter,
+                relative_only=relative_only)
+        except bat_interface.FileTransferError as ex:
+            self.log.error('Could not transfer %d files, starting with %s',
+                           len(ex.files_remaining), ex.files_remaining[0])
+            self.report({'ERROR'}, 'Unable to transfer %d files' % len(ex.files_remaining))
             self.quit()
-            return None, []
+            return outdir, None, []
+        except bat_interface.Aborted:
+            self.log.warning('BAT Pack was aborted')
+            self.report({'WARNING'}, 'Aborted Flamenco file packing/transferring')
+            self.quit()
+            return outdir, None, []
 
-        return outfile, missing_sources
+        bpy.context.window_manager.flamenco_status = 'DONE'
+        return outdir, outfile, missing_sources
+
+
+def scene_frame_range(context) -> str:
+    """Returns the frame range string for the current scene."""
+
+    s = context.scene
+    return '%i-%i' % (s.frame_start, s.frame_end)
 
 
 class FLAMENCO_OT_scene_to_frame_range(FlamencoPollMixin, Operator):
@@ -326,42 +516,75 @@ class FLAMENCO_OT_scene_to_frame_range(FlamencoPollMixin, Operator):
     bl_description = __doc__.rstrip('.')
 
     def execute(self, context):
-        s = context.scene
-        s.flamenco_render_frame_range = '%i-%i' % (s.frame_start, s.frame_end)
+        context.scene.flamenco_render_frame_range = scene_frame_range(context)
         return {'FINISHED'}
 
 
 class FLAMENCO_OT_copy_files(Operator,
                              FlamencoPollMixin,
                              async_loop.AsyncModalOperatorMixin):
-    """Uses BAM to copy the current blendfile + dependencies to the target directory."""
+    """Uses BAT to copy the current blendfile + dependencies to the target directory.
+
+    This operator is not used directly, but can be useful for testing.
+    """
     bl_idname = 'flamenco.copy_files'
     bl_label = 'Copy files to target'
     bl_description = __doc__.rstrip('.')
 
     stop_upon_exception = True
 
-    async def async_execute(self, context):
+    async def async_execute(self, context) -> None:
         from pathlib import Path
-        from . import bam_interface
         from ..blender import preferences
 
-        context.window_manager.flamenco_status = 'PACKING'
+        prefs = preferences()
+        exclusion_filter = (prefs.flamenco_exclude_filter or '').strip()
 
-        missing_sources = await bam_interface.bam_copy(
-            Path(context.blend_data.filepath),
-            Path(preferences().flamenco_job_file_path),
-        )
+        storage_path = prefs.flamenco_job_file_path  # type: str
+
+        try:
+            outpath, missing_sources = await bat_interface.copy(
+                context,
+                Path(context.blend_data.filepath),
+                Path(prefs.cloud_project_local_path),
+                Path(storage_path),
+                exclusion_filter
+            )
+        except bat_interface.FileTransferError as ex:
+            self.log.error('Could not transfer %d files, starting with %s',
+                           len(ex.files_remaining), ex.files_remaining[0])
+            self.report({'ERROR'}, 'Unable to transfer %d files' % len(ex.files_remaining))
+            self.quit()
+            return
+        except bat_interface.Aborted:
+            self.log.warning('BAT Pack was aborted')
+            self.report({'WARNING'}, 'Aborted Flamenco file packing/transferring')
+            self.quit()
+            return
 
         if missing_sources:
             names = (ms.name for ms in missing_sources)
             self.report({'ERROR'}, 'Missing source files: %s' % '; '.join(names))
-
+        else:
+            self.report({'INFO'}, 'Written %s' % outpath)
+        context.window_manager.flamenco_status = 'DONE'
         self.quit()
 
-    def quit(self):
-        super().quit()
-        bpy.context.window_manager.flamenco_status = 'IDLE'
+
+class FLAMENCO_OT_abort(Operator, FlamencoPollMixin):
+    """Aborts a running Flamenco file packing/transfer operation."""
+    bl_idname = 'flamenco.abort'
+    bl_label = 'Abort'
+    bl_description = __doc__.rstrip('.')
+
+    @classmethod
+    def poll(cls, context):
+        return super().poll(context) and context.window_manager.flamenco_status != 'ABORTING'
+
+    def execute(self, context):
+        context.window_manager.flamenco_status = 'ABORTING'
+        bat_interface.abort()
+        return {'FINISHED'}
 
 
 class FLAMENCO_OT_explore_file_path(FlamencoPollMixin,
@@ -407,6 +630,30 @@ class FLAMENCO_OT_explore_file_path(FlamencoPollMixin,
         return {'FINISHED'}
 
 
+class FLAMENCO_OT_enable_output_path_override(Operator):
+    """Enables the 'override output path' setting."""
+
+    bl_idname = 'flamenco.enable_output_path_override'
+    bl_label = 'Enable Overriding of Output Path'
+    bl_description = 'Click to specify a non-default Output Path for this particular job'
+
+    def execute(self, context):
+        context.scene.flamenco_do_override_output_path = True
+        return {'FINISHED'}
+
+
+class FLAMENCO_OT_disable_output_path_override(Operator):
+    """Disables the 'override output path' setting."""
+
+    bl_idname = 'flamenco.disable_output_path_override'
+    bl_label = 'disable Overriding of Output Path'
+    bl_description = 'Click to use the default Output Path'
+
+    def execute(self, context):
+        context.scene.flamenco_do_override_output_path = False
+        return {'FINISHED'}
+
+
 async def create_job(user_id: str,
                      project_id: str,
                      manager_id: str,
@@ -415,7 +662,8 @@ async def create_job(user_id: str,
                      job_name: str = None,
                      *,
                      priority: int = 50,
-                     job_description: str = None) -> dict:
+                     job_description: str = None,
+                     start_paused=False) -> dict:
     """Creates a render job at Flamenco Server, returning the job object as dictionary."""
 
     import json
@@ -434,6 +682,8 @@ async def create_job(user_id: str,
     }
     if job_description:
         job_attrs['description'] = job_description
+    if start_paused:
+        job_attrs['start_paused'] = True
 
     log.info('Going to create Flamenco job:\n%s',
              json.dumps(job_attrs, indent=4, sort_keys=True))
@@ -457,11 +707,13 @@ def is_image_type(render_output_type: str) -> bool:
 def _render_output_path(
         local_project_path: str,
         blend_filepath: Path,
+        flamenco_render_job_type: str,
         flamenco_job_output_strip_components: int,
         flamenco_job_output_path: str,
         render_image_format: str,
         flamenco_render_frame_range: str,
-) -> typing.Optional[PurePath]:
+        *,
+        include_rel_path: bool = True) -> typing.Optional[PurePath]:
     """Cached version of render_output_path()
 
     This ensures that redraws of the Flamenco Render and Add-on preferences panels
@@ -475,12 +727,17 @@ def _render_output_path(
         return None
 
     try:
-        proj_rel = blend_filepath.parent.relative_to(project_path)
+        blend_abspath = blend_filepath.resolve().absolute()
+    except FileNotFoundError:
+        # Path.resolve() will raise a FileNotFoundError if the path doesn't exist.
+        return None
+
+    try:
+        proj_rel = blend_abspath.parent.relative_to(project_path)
     except ValueError:
         return None
 
-    rel_parts = proj_rel.parts[flamenco_job_output_strip_components:]
-    output_top = Path(flamenco_job_output_path)
+    output_top = PurePath(flamenco_job_output_path)
 
     # Strip off '.flamenco' too; we use 'xxx.flamenco.blend' as job file, but
     # don't want to have all the output paths ending in '.flamenco'.
@@ -488,7 +745,14 @@ def _render_output_path(
     if stem.endswith('.flamenco'):
         stem = stem[:-9]
 
-    dir_components = output_top.joinpath(*rel_parts) / stem
+    if flamenco_render_job_type == 'blender-video-chunks':
+        return output_top / ('YYYY_MM_DD_SEQ-%s.mkv' % stem)
+
+    if include_rel_path:
+        rel_parts = proj_rel.parts[flamenco_job_output_strip_components:]
+        dir_components = output_top.joinpath(*rel_parts) / stem
+    else:
+        dir_components = output_top
 
     # Blender will have to append the file extensions by itself.
     if is_image_type(render_image_format):
@@ -513,13 +777,20 @@ def render_output_path(context, filepath: Path = None) -> typing.Optional[PurePa
     if filepath is None:
         filepath = Path(context.blend_data.filepath)
 
+    if scene.flamenco_do_override_output_path:
+        job_output_path = scene.flamenco_override_output_path
+    else:
+        job_output_path = prefs.flamenco_job_output_path
+
     return _render_output_path(
         prefs.cloud_project_local_path,
         filepath,
+        scene.flamenco_render_job_type,
         prefs.flamenco_job_output_strip_components,
-        prefs.flamenco_job_output_path,
+        job_output_path,
         scene.render.image_settings.file_format,
         scene.flamenco_render_frame_range,
+        include_rel_path=not scene.flamenco_do_override_output_path,
     )
 
 
@@ -537,55 +808,104 @@ class FLAMENCO_PT_render(bpy.types.Panel, FlamencoPollMixin):
 
         prefs = preferences()
 
-        labeled_row = layout.split(0.25, align=True)
-        labeled_row.label('Job Type:')
+        labeled_row = layout.split(**blender.factor(0.25), align=True)
+        labeled_row.label(text='Manager:')
+        prop_btn_row = labeled_row.row(align=True)
+
+        bcp = prefs.flamenco_manager
+        if bcp.status in {'NONE', 'IDLE'}:
+            if not bcp.available_managers or not bcp.manager:
+                prop_btn_row.operator('flamenco.managers',
+                                      text='Find Flamenco Managers',
+                                      icon='FILE_REFRESH')
+            else:
+                prop_btn_row.prop(bcp, 'manager', text='')
+                prop_btn_row.operator('flamenco.managers',
+                                      text='',
+                                      icon='FILE_REFRESH')
+        else:
+            prop_btn_row.label(text='Fetching available managers.')
+
+        labeled_row = layout.split(**blender.factor(0.25), align=True)
+        labeled_row.label(text='Job Type:')
         labeled_row.prop(context.scene, 'flamenco_render_job_type', text='')
 
-        labeled_row = layout.split(0.25, align=True)
-        labeled_row.label('Frame Range:')
+        labeled_row = layout.split(**blender.factor(0.25), align=True)
+        labeled_row.label(text='Frame Range:')
         prop_btn_row = labeled_row.row(align=True)
         prop_btn_row.prop(context.scene, 'flamenco_render_frame_range', text='')
         prop_btn_row.operator('flamenco.scene_to_frame_range', text='', icon='ARROW_LEFTRIGHT')
 
         layout.prop(context.scene, 'flamenco_render_job_priority')
         layout.prop(context.scene, 'flamenco_render_fchunk_size')
+        layout.prop(context.scene, 'flamenco_start_paused')
 
         if getattr(context.scene, 'flamenco_render_job_type', None) == 'blender-render-progressive':
             layout.prop(context.scene, 'flamenco_render_schunk_count')
 
-        readonly_stuff = layout.column(align=True)
-        labeled_row = readonly_stuff.split(0.25, align=True)
-        labeled_row.label('Storage:')
+        paths_layout = layout.column(align=True)
+
+        labeled_row = paths_layout.split(**blender.factor(0.25), align=True)
+        labeled_row.label(text='Storage:')
         prop_btn_row = labeled_row.row(align=True)
-        prop_btn_row.label(prefs.flamenco_job_file_path)
+        prop_btn_row.label(text=prefs.flamenco_job_file_path)
         props = prop_btn_row.operator(FLAMENCO_OT_explore_file_path.bl_idname,
                                       text='', icon='DISK_DRIVE')
         props.path = prefs.flamenco_job_file_path
 
-        labeled_row = readonly_stuff.split(0.25, align=True)
-        labeled_row.label('Output:')
-        prop_btn_row = labeled_row.row(align=True)
         render_output = render_output_path(context)
-
         if render_output is None:
-            prop_btn_row.label('Unable to render with Flamenco, outside of project directory.')
-        else:
-            prop_btn_row.label(str(render_output))
-            props = prop_btn_row.operator(FLAMENCO_OT_explore_file_path.bl_idname,
-                                          text='', icon='DISK_DRIVE')
-            props.path = str(render_output.parent)
+            paths_layout.label(text='Unable to render with Flamenco, outside of project directory.')
+            return
 
-            flamenco_status = context.window_manager.flamenco_status
-            if flamenco_status == 'IDLE':
-                layout.operator(FLAMENCO_OT_render.bl_idname,
-                                text='Render on Flamenco',
-                                icon='RENDER_ANIMATION')
-            elif flamenco_status == 'PACKING':
-                layout.label('Flamenco is packing your file + dependencies')
-            elif flamenco_status == 'COMMUNICATING':
-                layout.label('Communicating with Flamenco Server')
-            else:
-                layout.label('Unknown Flamenco status %s' % flamenco_status)
+        labeled_row = paths_layout.split(**blender.factor(0.25), align=True)
+        labeled_row.label(text='Output:')
+        prop_btn_row = labeled_row.row(align=True)
+
+        if context.scene.flamenco_do_override_output_path:
+            prop_btn_row.prop(context.scene, 'flamenco_override_output_path', text='')
+            op = FLAMENCO_OT_disable_output_path_override.bl_idname
+            icon = 'X'
+        else:
+            prop_btn_row.label(text=str(render_output))
+            op = FLAMENCO_OT_enable_output_path_override.bl_idname
+            icon = 'GREASEPENCIL'
+        prop_btn_row.operator(op, icon=icon, text='')
+
+        props = prop_btn_row.operator(FLAMENCO_OT_explore_file_path.bl_idname,
+                                      text='', icon='DISK_DRIVE')
+        props.path = str(render_output.parent)
+
+        if context.scene.flamenco_do_override_output_path:
+            labeled_row = paths_layout.split(**blender.factor(0.25), align=True)
+            labeled_row.label(text='Effective Output Path:')
+            labeled_row.label(text=str(render_output))
+
+        # Show current status of Flamenco.
+        flamenco_status = context.window_manager.flamenco_status
+        if flamenco_status in {'IDLE', 'ABORTED', 'DONE'}:
+            layout.operator(FLAMENCO_OT_render.bl_idname,
+                            text='Render on Flamenco',
+                            icon='RENDER_ANIMATION')
+            if bpy.app.debug:
+                layout.operator(FLAMENCO_OT_copy_files.bl_idname)
+        elif flamenco_status == 'INVESTIGATING':
+            row = layout.row(align=True)
+            row.label(text='Investigating your files')
+            row.operator(FLAMENCO_OT_abort.bl_idname, text='', icon='CANCEL')
+        elif flamenco_status == 'COMMUNICATING':
+            layout.label(text='Communicating with Flamenco Server')
+        elif flamenco_status == 'ABORTING':
+            row = layout.row(align=True)
+            row.label(text='Aborting, please wait.')
+            row.operator(FLAMENCO_OT_abort.bl_idname, text='', icon='CANCEL')
+        if flamenco_status == 'TRANSFERRING':
+            row = layout.row(align=True)
+            row.prop(context.window_manager, 'flamenco_progress',
+                     text=context.window_manager.flamenco_status_txt)
+            row.operator(FLAMENCO_OT_abort.bl_idname, text='', icon='CANCEL')
+        elif flamenco_status != 'IDLE' and context.window_manager.flamenco_status_txt:
+            layout.label(text=context.window_manager.flamenco_status_txt)
 
 
 def activate():
@@ -594,6 +914,7 @@ def activate():
     global flamenco_is_active
     log.info('Activating Flamenco')
     flamenco_is_active = True
+    _render_output_path.cache_clear()
 
 
 def deactivate():
@@ -602,18 +923,40 @@ def deactivate():
     global flamenco_is_active
     log.info('Deactivating Flamenco')
     flamenco_is_active = False
+    _render_output_path.cache_clear()
+
+
+def flamenco_do_override_output_path_updated(scene, context):
+    """Set the override paths to the default, if not yet set."""
+
+    # Only set a default when enabling the override.
+    if not scene.flamenco_do_override_output_path:
+        return
+
+    # Don't overwrite existing setting.
+    if scene.flamenco_override_output_path:
+        return
+
+    from ..blender import preferences
+    scene.flamenco_override_output_path = preferences().flamenco_job_output_path
+    log.info('Setting Override Output Path to %s', scene.flamenco_override_output_path)
+
+
+# FlamencoManagerGroup needs to be registered before classes that use it.
+_rna_classes = [FlamencoManagerGroup]
+_rna_classes.extend(
+    cls for cls in locals().values()
+    if (isinstance(cls, type)
+        and cls.__name__.startswith('FLAMENCO')
+        and cls not in _rna_classes)
+)
 
 
 def register():
     from ..utils import redraw
 
-    bpy.utils.register_class(FlamencoManagerGroup)
-    bpy.utils.register_class(FLAMENCO_OT_fmanagers)
-    bpy.utils.register_class(FLAMENCO_OT_render)
-    bpy.utils.register_class(FLAMENCO_OT_scene_to_frame_range)
-    bpy.utils.register_class(FLAMENCO_OT_copy_files)
-    bpy.utils.register_class(FLAMENCO_OT_explore_file_path)
-    bpy.utils.register_class(FLAMENCO_PT_render)
+    for cls in _rna_classes:
+        bpy.utils.register_class(cls)
 
     scene = bpy.types.Scene
     scene.flamenco_render_fchunk_size = IntProperty(
@@ -639,9 +982,18 @@ def register():
             ('blender-render', 'Simple Render', 'Simple frame-by-frame render'),
             ('blender-render-progressive', 'Progressive Render',
              'Each frame is rendered multiple times with different Cycles sample chunks, then combined'),
+            ('blender-video-chunks', 'Video Chunks',
+             'Render each frame chunk to a video file, then concateate those video files')
         ]
     )
 
+    scene.flamenco_start_paused = BoolProperty(
+        name='Start Paused',
+        description="When enabled, the job will be created in 'paused' state, rather than"
+                    " 'queued'. The job will need manual queueing before it will start",
+        default=False,
+    )
+
     scene.flamenco_render_job_priority = IntProperty(
         name='Job Priority',
         min=0,
@@ -650,42 +1002,71 @@ def register():
         description='Higher numbers mean higher priority'
     )
 
+    scene.flamenco_do_override_output_path = BoolProperty(
+        name='Override Output Path for this Job',
+        description='When enabled, allows you to specify a non-default Output path '
+                    'for this particular job',
+        default=False,
+        update=flamenco_do_override_output_path_updated
+    )
+    scene.flamenco_override_output_path = StringProperty(
+        name='Override Output Path',
+        description='Path where to store output files, should be accessible for Workers',
+        subtype='DIR_PATH',
+        default='')
+
     bpy.types.WindowManager.flamenco_status = EnumProperty(
         items=[
             ('IDLE', 'IDLE', 'Not doing anything.'),
-            ('PACKING', 'PACKING', 'BAM-packing all dependencies.'),
+            ('SAVING', 'SAVING', 'Saving your file.'),
+            ('INVESTIGATING', 'INVESTIGATING', 'Finding all dependencies.'),
+            ('TRANSFERRING', 'TRANSFERRING', 'Transferring all dependencies.'),
             ('COMMUNICATING', 'COMMUNICATING', 'Communicating with Flamenco Server.'),
+            ('DONE', 'DONE', 'Not doing anything, but doing something earlier.'),
+            ('ABORTING', 'ABORTING', 'User requested we stop doing something.'),
+            ('ABORTED', 'ABORTED', 'We stopped doing something.'),
         ],
         name='flamenco_status',
         default='IDLE',
         description='Current status of the Flamenco add-on',
         update=redraw)
 
+    bpy.types.WindowManager.flamenco_status_txt = StringProperty(
+        name='Flamenco Status',
+        default='',
+        description='Textual description of what Flamenco is doing',
+        update=redraw)
+
+    bpy.types.WindowManager.flamenco_progress = IntProperty(
+        name='Flamenco Progress',
+        default=0,
+        description='File transfer progress',
+        subtype='PERCENTAGE',
+        min=0,
+        max=100,
+        update=redraw)
+
 
 def unregister():
     deactivate()
-    bpy.utils.unregister_module(__name__)
+    for cls in _rna_classes:
+        try:
+            bpy.utils.unregister_class(cls)
+        except RuntimeError:
+            log.warning('Unable to unregister class %r, probably already unregistered', cls)
 
-    try:
-        del bpy.types.Scene.flamenco_render_fchunk_size
-    except AttributeError:
-        pass
-    try:
-        del bpy.types.Scene.flamenco_render_schunk_count
-    except AttributeError:
-        pass
-    try:
-        del bpy.types.Scene.flamenco_render_frame_range
-    except AttributeError:
-        pass
-    try:
-        del bpy.types.Scene.flamenco_render_job_type
-    except AttributeError:
-        pass
-    try:
-        del bpy.types.Scene.flamenco_render_job_priority
-    except AttributeError:
-        pass
+    for name in ('flamenco_render_fchunk_size',
+                 'flamenco_render_schunk_count',
+                 'flamenco_render_frame_range',
+                 'flamenco_render_job_type',
+                 'flamenco_start_paused',
+                 'flamenco_render_job_priority',
+                 'flamenco_do_override_output_path',
+                 'flamenco_override_output_path'):
+        try:
+            delattr(bpy.types.Scene, name)
+        except AttributeError:
+            pass
     try:
         del bpy.types.WindowManager.flamenco_status
     except AttributeError:

blender_cloud/flamenco/bam_interface.py

@@ -1,144 +0,0 @@
-"""BAM packing interface for Flamenco."""
-
-import logging
-from pathlib import Path
-import typing
-
-# Timeout of the BAM subprocess, in seconds.
-SUBPROC_READLINE_TIMEOUT = 600
-log = logging.getLogger(__name__)
-
-
-class CommandExecutionError(Exception):
-    """Raised when there was an error executing a BAM command."""
-    pass
-
-
-async def bam_copy(base_blendfile: Path, target_blendfile: Path) -> typing.List[Path]:
-    """Uses BAM to copy the given file and dependencies to the target blendfile.
-
-    Due to the way blendfile_pack.py is programmed/structured, we cannot import it
-    and call a function; it has to be run in a subprocess.
-
-    :raises: asyncio.CanceledError if the task was cancelled.
-    :raises: asyncio.TimeoutError if reading a line from the BAM process timed out.
-    :raises: CommandExecutionError if the subprocess failed or output invalid UTF-8.
-    :returns: a list of missing sources; hopefully empty.
-    """
-
-    import asyncio
-    import shlex
-    import subprocess
-
-    import bpy
-    import io_blend_utils
-
-    args = [
-        bpy.app.binary_path_python,
-        '-m', 'bam.pack',
-        '--input', str(base_blendfile),
-        '--output', str(target_blendfile),
-        '--mode', 'FILE',
-    ]
-
-    cmd_to_log = ' '.join(shlex.quote(s) for s in args)
-    log.info('Executing %s', cmd_to_log)
-
-    proc = await asyncio.create_subprocess_exec(
-        *args,
-        env={'PYTHONPATH': io_blend_utils.pythonpath()},
-        stdin=subprocess.DEVNULL,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.STDOUT,
-    )
-
-    missing_sources = []
-
-    try:
-        while not proc.stdout.at_eof():
-            line = await asyncio.wait_for(proc.stdout.readline(),
-                                          SUBPROC_READLINE_TIMEOUT)
-            if not line:
-                # EOF received, so let's bail.
-                break
-
-            try:
-                line = line.decode('utf8')
-            except UnicodeDecodeError as ex:
-                raise CommandExecutionError('Command produced non-UTF8 output, '
-                                            'aborting: %s' % ex)
-
-            line = line.rstrip()
-            if 'source missing:' in line:
-                path = parse_missing_source(line)
-                missing_sources.append(path)
-                log.warning('Source is missing: %s', path)
-
-            log.info('  %s', line)
-    finally:
-        if proc.returncode is None:
-            # Always wait for the process, to avoid zombies.
-            try:
-                proc.kill()
-            except ProcessLookupError:
-                # The process is already stopped, so killing is impossible. That's ok.
-                log.debug("The process was already stopped, aborting is impossible. That's ok.")
-            await proc.wait()
-        log.info('The process stopped with status code %i', proc.returncode)
-
-    if proc.returncode:
-        raise CommandExecutionError('Process stopped with status %i' % proc.returncode)
-
-    return missing_sources
-
-
-def parse_missing_source(line: str) -> Path:
-    r"""Parses a "missing source" line into a pathlib.Path.
-
-    >>> parse_missing_source(r"  source missing: b'D\xc3\xaffficult \xc3\x9cTF-8 filename'")
-    PosixPath('Dïfficult ÜTF-8 filename')
-    >>> parse_missing_source(r"  source missing: b'D\xfffficult Win1252 f\xeflen\xe6me'")
-    PosixPath('D<EFBFBD>fficult Win1252 f<>len<65>me')
-    """
-
-    _, missing_source = line.split(': ', 1)
-    missing_source_as_bytes = parse_byte_literal(missing_source.strip())
-
-    # The file could originate from any platform, so UTF-8 and the current platform's
-    # filesystem encodings are just guesses.
-    try:
-        missing_source = missing_source_as_bytes.decode('utf8')
-    except UnicodeDecodeError:
-        import sys
-        try:
-            missing_source = missing_source_as_bytes.decode(sys.getfilesystemencoding())
-        except UnicodeDecodeError:
-            missing_source = missing_source_as_bytes.decode('ascii', errors='replace')
-
-    path = Path(missing_source)
-
-    return path
-
-
-def parse_byte_literal(bytes_literal: str) -> bytes:
-    r"""Parses a repr(bytes) output into a bytes object.
-
-    >>> parse_byte_literal(r"b'D\xc3\xaffficult \xc3\x9cTF-8 filename'")
-    b'D\xc3\xaffficult \xc3\x9cTF-8 filename'
-    >>> parse_byte_literal(r"b'D\xeffficult Win1252 f\xeflen\xe6me'")
-    b'D\xeffficult Win1252 f\xeflen\xe6me'
-    """
-
-    # Some very basic assertions to make sure we have a proper bytes literal.
-    assert bytes_literal[0] == "b"
-    assert bytes_literal[1] in {'"', "'"}
-    assert bytes_literal[-1] == bytes_literal[1]
-
-    import ast
-    return ast.literal_eval(bytes_literal)
-
-
-if __name__ == '__main__':
-    import doctest
-
-    doctest.testmod()

blender_cloud/flamenco/bat_interface.py

@@ -0,0 +1,155 @@
+"""BAT🦇 packing interface for Flamenco."""
+
+import asyncio
+import logging
+import pathlib
+import re
+import threading
+import typing
+
+import bpy
+from blender_asset_tracer import pack
+from blender_asset_tracer.pack import progress, transfer
+
+log = logging.getLogger(__name__)
+
+_running_packer = None  # type: pack.Packer
+_packer_lock = threading.RLock()
+
+# For using in other parts of the add-on, so only this file imports BAT.
+Aborted = pack.Aborted
+FileTransferError = transfer.FileTransferError
+
+
+class BatProgress(progress.Callback):
+    """Report progress of BAT Packing to the UI.
+
+    Uses asyncio.run_coroutine_threadsafe() to ensure the UI is only updated
+    from the main thread. This is required since we run the BAT Pack in a
+    background thread.
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.loop = asyncio.get_event_loop()
+
+    def _set_attr(self, attr: str, value):
+
+        async def do_it():
+            setattr(bpy.context.window_manager, attr, value)
+
+        asyncio.run_coroutine_threadsafe(do_it(), loop=self.loop)
+
+    def _txt(self, msg: str):
+        """Set a text in a thread-safe way."""
+        self._set_attr('flamenco_status_txt', msg)
+
+    def _status(self, status: str):
+        """Set the flamenco_status property in a thread-safe way."""
+        self._set_attr('flamenco_status', status)
+
+    def _progress(self, progress: int):
+        """Set the flamenco_progress property in a thread-safe way."""
+        self._set_attr('flamenco_progress', progress)
+
+    def pack_start(self) -> None:
+        self._txt('Starting BAT Pack operation')
+
+    def pack_done(self,
+                  output_blendfile: pathlib.Path,
+                  missing_files: typing.Set[pathlib.Path]) -> None:
+        if missing_files:
+            self._txt('There were %d missing files' % len(missing_files))
+        else:
+            self._txt('Pack of %s done' % output_blendfile.name)
+
+    def pack_aborted(self):
+        self._txt('Aborted')
+        self._status('ABORTED')
+
+    def trace_blendfile(self, filename: pathlib.Path) -> None:
+        """Called for every blendfile opened when tracing dependencies."""
+        self._txt('Inspecting %s' % filename.name)
+
+    def trace_asset(self, filename: pathlib.Path) -> None:
+        if filename.stem == '.blend':
+            return
+        self._txt('Found asset %s' % filename.name)
+
+    def rewrite_blendfile(self, orig_filename: pathlib.Path) -> None:
+        self._txt('Rewriting %s' % orig_filename.name)
+
+    def transfer_file(self, src: pathlib.Path, dst: pathlib.Path) -> None:
+        self._txt('Transferring %s' % src.name)
+
+    def transfer_file_skipped(self, src: pathlib.Path, dst: pathlib.Path) -> None:
+        self._txt('Skipped %s' % src.name)
+
+    def transfer_progress(self, total_bytes: int, transferred_bytes: int) -> None:
+        self._progress(round(100 * transferred_bytes / total_bytes))
+
+    def missing_file(self, filename: pathlib.Path) -> None:
+        # TODO(Sybren): report missing files in a nice way
+        pass
+
+
+async def copy(context,
+               base_blendfile: pathlib.Path,
+               project: pathlib.Path,
+               target: pathlib.Path,
+               exclusion_filter: str,
+               *,
+               relative_only: bool) -> typing.Tuple[pathlib.Path, typing.Set[pathlib.Path]]:
+    """Use BAT🦇 to copy the given file and dependencies to the target location.
+
+    :raises: FileTransferError if a file couldn't be transferred.
+    :returns: the path of the packed blend file, and a set of missing sources.
+    """
+    global _running_packer
+
+    loop = asyncio.get_event_loop()
+
+    wm = bpy.context.window_manager
+
+    with pack.Packer(base_blendfile, project, target, compress=True, relative_only=relative_only) \
+            as packer:
+        with _packer_lock:
+            if exclusion_filter:
+                # There was a mistake in an older version of the property tooltip,
+                # showing semicolon-separated instead of space-separated. We now
+                # just handle both.
+                filter_parts = re.split('[ ;]+', exclusion_filter.strip(' ;'))
+                packer.exclude(*filter_parts)
+
+            packer.progress_cb = BatProgress()
+            _running_packer = packer
+
+        log.debug('awaiting strategise')
+        wm.flamenco_status = 'INVESTIGATING'
+        await loop.run_in_executor(None, packer.strategise)
+
+        log.debug('awaiting execute')
+        wm.flamenco_status = 'TRANSFERRING'
+        await loop.run_in_executor(None, packer.execute)
+
+        log.debug('done')
+        wm.flamenco_status = 'DONE'
+
+    with _packer_lock:
+        _running_packer = None
+
+    return packer.output_path, packer.missing_files
+
+
+def abort() -> None:
+    """Abort a running copy() call.
+
+    No-op when there is no running copy(). Can be called from any thread.
+    """
+
+    with _packer_lock:
+        if _running_packer is None:
+            log.debug('No running packer, ignoring call to bat_abort()')
+            return
+        log.info('Aborting running packer')
+        _running_packer.abort()

blender_cloud/flamenco/sdk.py

@@ -1,9 +1,50 @@
+import functools
+import pathlib
+
 from pillarsdk.resource import List, Find, Create
 
 
 class Manager(List, Find):
     """Manager class wrapping the REST nodes endpoint"""
     path = 'flamenco/managers'
+    PurePlatformPath = pathlib.PurePath
+
+    @functools.lru_cache()
+    def _sorted_path_replacements(self) -> list:
+        import platform
+
+        if self.path_replacement is None:
+            return []
+
+        items = self.path_replacement.to_dict().items()
+
+        def by_length(item):
+            return -len(item[0]), item[0]
+
+        this_platform = platform.system().lower()
+        return [(varname, platform_replacements[this_platform])
+                for varname, platform_replacements in sorted(items, key=by_length)
+                if this_platform in platform_replacements]
+
+    def replace_path(self, some_path: pathlib.PurePath) -> str:
+        """Performs path variable replacement.
+
+        Tries to find platform-specific path prefixes, and replaces them with
+        variables.
+        """
+
+        for varname, path in self._sorted_path_replacements():
+            replacement = self.PurePlatformPath(path)
+            try:
+                relpath = some_path.relative_to(replacement)
+            except ValueError:
+                # Not relative to each other, so no replacement possible
+                continue
+
+            replacement_root = self.PurePlatformPath('{%s}' % varname)
+            return (replacement_root / relpath).as_posix()
+
+        return some_path.as_posix()
 
 
 class Job(List, Find, Create):

blender_cloud/image_sharing.py

@@ -112,7 +112,11 @@ class PILLAR_OT_image_share(pillar.PillarOperatorMixin,
     async def async_execute(self, context):
         """Entry point of the asynchronous operator."""
 
-        self.report({'INFO'}, 'Communicating with Blender Cloud')
+        # We don't want to influence what is included in the screen shot.
+        if self.target == 'SCREENSHOT':
+            print('Blender Cloud add-on is communicating with Blender Cloud')
+        else:
+            self.report({'INFO'}, 'Communicating with Blender Cloud')
 
         try:
             # Refresh credentials
@@ -120,9 +124,8 @@ class PILLAR_OT_image_share(pillar.PillarOperatorMixin,
                 db_user = await self.check_credentials(context, REQUIRES_ROLES_FOR_IMAGE_SHARING)
                 self.user_id = db_user['_id']
                 self.log.debug('Found user ID: %s', self.user_id)
-            except pillar.NotSubscribedToCloudError:
-                self.log.exception('User not subscribed to cloud.')
-                self.report({'ERROR'}, 'Please subscribe to the Blender Cloud.')
+            except pillar.NotSubscribedToCloudError as ex:
+                self._log_subscription_needed(can_renew=ex.can_renew)
                 self._state = 'QUIT'
                 return
             except pillar.UserNotLoggedInError:
@@ -320,15 +323,25 @@ def window_menu(self, context):
     props.screenshot_full = True
 
 
+def get_topbar_menu():
+    """Return the topbar menu in a Blender 2.79 and 2.80 compatible way."""
+    try:
+        menu = bpy.types.TOPBAR_MT_window
+    except AttributeError:
+        # Blender < 2.80
+        menu = bpy.types.INFO_MT_window
+    return menu
+
+
 def register():
     bpy.utils.register_class(PILLAR_OT_image_share)
 
     bpy.types.IMAGE_MT_image.append(image_editor_menu)
-    bpy.types.INFO_MT_window.append(window_menu)
+    get_topbar_menu().append(window_menu)
 
 
 def unregister():
     bpy.utils.unregister_class(PILLAR_OT_image_share)
 
     bpy.types.IMAGE_MT_image.remove(image_editor_menu)
-    bpy.types.INFO_MT_window.remove(window_menu)
+    get_topbar_menu().remove(window_menu)

blender_cloud/pillar.py

@@ -62,7 +62,16 @@ class CredentialsNotSyncedError(UserNotLoggedInError):
 
 
 class NotSubscribedToCloudError(UserNotLoggedInError):
-    """Raised when the user may be logged in on Blender ID, but has no Blender Cloud token."""
+    """Raised when the user does not have an active Cloud subscription.
+
+    :ivar can_renew: True when the user has an inactive subscription that can be renewed,
+        or False when the user has no subscription at all.
+    """
+
+    def __init__(self, can_renew: bool):
+        super().__init__()
+        self.can_renew = can_renew
+        log.warning('Not subscribed to cloud, can_renew=%s', can_renew)
 
 
 class PillarError(RuntimeError):
@@ -115,6 +124,12 @@ def with_existing_dir(filename: str, open_mode: str, encoding=None):
         yield file_object
 
 
+def _shorten(somestr: str, maxlen=40) -> str:
+    """Shortens strings for logging"""
+
+    return (somestr[:maxlen - 3] + '...') if len(somestr) > maxlen else somestr
+
+
 def save_as_json(pillar_resource, json_filename):
     with with_existing_dir(json_filename, 'w') as outfile:
         log.debug('Saving metadata to %r' % json_filename)
@@ -200,8 +215,11 @@ def pillar_api(pillar_endpoint: str = None, caching=True) -> pillarsdk.Api:
     return _pillar_api[caching]
 
 
-# No more than this many Pillar calls should be made simultaneously
-pillar_semaphore = asyncio.Semaphore(3)
+# This is an asyncio.Semaphore object, which is late-instantiated to be sure
+# the asyncio loop has been created properly. On Windows we create a new one,
+# which can cause this semaphore to still be linked against the old default
+# loop.
+pillar_semaphore = None
 
 
 async def pillar_call(pillar_func, *args, caching=True, **kwargs):
@@ -214,8 +232,21 @@ async def pillar_call(pillar_func, *args, caching=True, **kwargs):
     partial = functools.partial(pillar_func, *args, api=pillar_api(caching=caching), **kwargs)
     loop = asyncio.get_event_loop()
 
-    async with pillar_semaphore:
+    # Use explicit calls to acquire() and release() so that we have more control over
+    # how long we wait and how we handle timeouts.
+    try:
+        await asyncio.wait_for(pillar_semaphore.acquire(), timeout=10, loop=loop)
+    except asyncio.TimeoutError:
+        log.info('Waiting for semaphore to call %s', pillar_func.__name__)
+        try:
+            await asyncio.wait_for(pillar_semaphore.acquire(), timeout=50, loop=loop)
+        except asyncio.TimeoutError:
+            raise RuntimeError('Timeout waiting for Pillar Semaphore!')
+
+    try:
         return await loop.run_in_executor(None, partial)
+    finally:
+        pillar_semaphore.release()
 
 
 def sync_call(pillar_func, *args, caching=True, **kwargs):
@@ -251,14 +282,15 @@ async def check_pillar_credentials(required_roles: set):
     except (pillarsdk.UnauthorizedAccess, pillarsdk.ResourceNotFound, pillarsdk.ForbiddenAccess):
         raise CredentialsNotSyncedError()
 
-    roles = db_user.roles or set()
-    log.debug('User has roles %r', roles)
-    if required_roles and not required_roles.intersection(set(roles)):
+    roles = set(db_user.roles or set())
+    log.getChild('check_pillar_credentials').debug('user has roles %r', roles)
+    if required_roles and not required_roles.intersection(roles):
         # Delete the subclient info. This forces a re-check later, which can
         # then pick up on the user's new status.
         del profile.subclients[SUBCLIENT_ID]
         profile.save_json()
-        raise NotSubscribedToCloudError()
+
+        raise NotSubscribedToCloudError(can_renew='has_subscription' in roles)
 
     return db_user
 
@@ -441,9 +473,9 @@ async def download_to_file(url, filename, *,
         log.debug('Downloading was cancelled before doing the GET')
         raise asyncio.CancelledError('Downloading was cancelled')
 
-    log.debug('Performing GET %s', url)
+    log.debug('Performing GET %s', _shorten(url))
     response = await loop.run_in_executor(None, perform_get_request)
-    log.debug('Status %i from GET %s', response.status_code, url)
+    log.debug('Status %i from GET %s', response.status_code, _shorten(url))
     response.raise_for_status()
 
     if response.status_code == 304:
@@ -457,9 +489,9 @@ async def download_to_file(url, filename, *,
         log.debug('Downloading was cancelled before downloading the GET response')
         raise asyncio.CancelledError('Downloading was cancelled')
 
-    log.debug('Downloading response of GET %s', url)
+    log.debug('Downloading response of GET %s', _shorten(url))
     await loop.run_in_executor(None, download_loop)
-    log.debug('Done downloading response of GET %s', url)
+    log.debug('Done downloading response of GET %s', _shorten(url))
 
     # We're done downloading, now we have something cached we can use.
     log.debug('Saving header cache to %s', header_store)
@@ -534,7 +566,8 @@ async def fetch_texture_thumbs(parent_node_uuid: str, desired_size: str,
              for texture_node in texture_nodes)
 
     # raises any exception from failed handle_texture_node() calls.
-    await asyncio.gather(*coros)
+    loop = asyncio.get_event_loop()
+    await asyncio.gather(*coros, loop=loop)
 
     log.info('fetch_texture_thumbs: Done downloading texture thumbnails')
 
@@ -599,7 +632,11 @@ async def download_texture_thumbnail(texture_node, desired_size: str,
         # Cached headers are stored next to thumbnails in sidecar files.
         header_store = '%s.headers' % thumb_path
 
-        await download_to_file(thumb_url, thumb_path, header_store=header_store, future=future)
+        try:
+            await download_to_file(thumb_url, thumb_path, header_store=header_store, future=future)
+        except requests.exceptions.HTTPError as ex:
+            log.error('Unable to download %s: %s', thumb_url, ex)
+            thumb_path = 'ERROR'
 
     loop.call_soon_threadsafe(thumbnail_loaded, texture_node, file_desc, thumb_path)
 
@@ -747,7 +784,8 @@ async def download_texture(texture_node,
                                     future=future)
         downloaders.append(dlr)
 
-    return await asyncio.gather(*downloaders, return_exceptions=True)
+    loop = asyncio.get_event_loop()
+    return await asyncio.gather(*downloaders, return_exceptions=True, loop=loop)
 
 
 async def upload_file(project_id: str, file_path: pathlib.Path, *,
@@ -773,9 +811,9 @@ async def upload_file(project_id: str, file_path: pathlib.Path, *,
         log.debug('Uploading was cancelled before doing the POST')
         raise asyncio.CancelledError('Uploading was cancelled')
 
-    log.debug('Performing POST %s', url)
+    log.debug('Performing POST %s', _shorten(url))
     response = await loop.run_in_executor(None, upload)
-    log.debug('Status %i from POST %s', response.status_code, url)
+    log.debug('Status %i from POST %s', response.status_code, _shorten(url))
     response.raise_for_status()
 
     resp = response.json()
@@ -810,7 +848,6 @@ class PillarOperatorMixin:
         try:
             db_user = await check_pillar_credentials(required_roles)
         except NotSubscribedToCloudError:
-            self._log_subscription_needed()
             raise
         except CredentialsNotSyncedError:
             self.log.info('Credentials not synced, re-syncing automatically.')
@@ -821,7 +858,6 @@ class PillarOperatorMixin:
         try:
             db_user = await refresh_pillar_credentials(required_roles)
         except NotSubscribedToCloudError:
-            self._log_subscription_needed()
             raise
         except CredentialsNotSyncedError:
             self.log.info('Credentials not synced after refreshing, handling as not logged in.')
@@ -833,11 +869,13 @@ class PillarOperatorMixin:
             self.log.info('Credentials refreshed and ok.')
             return db_user
 
-    def _log_subscription_needed(self):
-        self.log.warning(
-            'Please subscribe to the blender cloud at https://cloud.blender.org/join')
-        self.report({'INFO'},
-                    'Please subscribe to the blender cloud at https://cloud.blender.org/join')
+    def _log_subscription_needed(self, *, can_renew: bool, level='ERROR'):
+        if can_renew:
+            msg = 'Please renew your Blender Cloud subscription at https://cloud.blender.org/renew'
+        else:
+            msg = 'Please subscribe to the blender cloud at https://cloud.blender.org/join'
+        self.log.warning(msg)
+        self.report({level}, msg)
 
 
 class AuthenticatedPillarOperatorMixin(PillarOperatorMixin):

blender_cloud/project_specific.py

@@ -0,0 +1,163 @@
+"""Handle saving and loading project-specific settings."""
+
+import contextlib
+import logging
+import typing
+
+# Names of BlenderCloudPreferences properties that are both project-specific
+# and simple enough to store directly in a dict.
+PROJECT_SPECIFIC_SIMPLE_PROPS = (
+    'cloud_project_local_path',
+)
+
+# Names of BlenderCloudPreferences properties that are project-specific and
+# Flamenco Manager-specific, and simple enough to store in a dict.
+FLAMENCO_PER_PROJECT_PER_MANAGER = (
+    'flamenco_exclude_filter',
+    'flamenco_job_file_path',
+    'flamenco_job_output_path',
+    'flamenco_job_output_strip_components',
+    'flamenco_relative_only',
+)
+
+log = logging.getLogger(__name__)
+project_settings_loading = 0  # counter, if > 0 then we're loading stuff.
+
+
+@contextlib.contextmanager
+def mark_as_loading():
+    """Sets project_settings_loading > 0 while the context is active.
+
+    A counter is used to allow for nested mark_as_loading() contexts.
+    """
+    global project_settings_loading
+    project_settings_loading += 1
+    try:
+        yield
+    finally:
+        project_settings_loading -= 1
+
+
+def update_preferences(prefs, names_to_update: typing.Iterable[str],
+                       new_values: typing.Mapping[str, typing.Any]):
+    for name in names_to_update:
+        if not hasattr(prefs, name):
+            log.debug('not setting %r, property cannot be found', name)
+            continue
+
+        if name in new_values:
+            log.debug('setting %r = %r', name, new_values[name])
+            setattr(prefs, name, new_values[name])
+        else:
+            # The property wasn't stored, so set the default value instead.
+            bl_type, args = getattr(prefs.bl_rna, name)
+            log.debug('finding default value for %r', name)
+            if 'default' not in args:
+                log.debug('no default value for %r, not touching', name)
+                continue
+            log.debug('found default value for %r = %r', name, args['default'])
+            setattr(prefs, name, args['default'])
+
+
+def handle_project_update(_=None, _2=None):
+    """Handles changing projects, which may cause extensions to be disabled/enabled.
+
+    Ignores arguments so that it can be used as property update callback.
+    """
+
+    from .blender import preferences, project_extensions
+
+    with mark_as_loading():
+        prefs = preferences()
+        project_id = prefs.project.project
+        log.info('Updating internal state to reflect extensions enabled on current project %s.',
+                 project_id)
+
+        project_extensions.cache_clear()
+
+        from blender_cloud import attract, flamenco
+        attract.deactivate()
+        flamenco.deactivate()
+
+        enabled_for = project_extensions(project_id)
+        log.info('Project extensions: %s', enabled_for)
+        if 'attract' in enabled_for:
+            attract.activate()
+        if 'flamenco' in enabled_for:
+            flamenco.activate()
+
+        # Load project-specific settings from the last time we visited this project.
+        ps = prefs.get('project_settings', {}).get(project_id, {})
+        if not ps:
+            log.debug('no project-specific settings are available, '
+                      'only resetting available Flamenco Managers')
+            # The Flamenco Manager should really be chosen explicitly out of the available
+            # Managers.
+            prefs.flamenco_manager.available_managers = []
+            return
+
+        if log.isEnabledFor(logging.DEBUG):
+            from pprint import pformat
+            log.debug('loading project-specific settings:\n%s', pformat(ps.to_dict()))
+
+        # Restore simple properties.
+        update_preferences(prefs, PROJECT_SPECIFIC_SIMPLE_PROPS, ps)
+
+        # Restore Flamenco settings.
+        prefs.flamenco_manager.available_managers = ps.get('flamenco_available_managers', [])
+        flamenco_manager_id = ps.get('flamenco_manager_id')
+        if flamenco_manager_id:
+            log.debug('setting flamenco manager to %s', flamenco_manager_id)
+            try:
+                # This will trigger a load of Project+Manager-specfic settings.
+                prefs.flamenco_manager.manager = flamenco_manager_id
+            except TypeError:
+                log.warning('manager %s for this project could not be found', flamenco_manager_id)
+        elif prefs.flamenco_manager.available_managers:
+            prefs.flamenco_manager.manager = prefs.flamenco_manager.available_managers[0]
+
+
+def store(_=None, _2=None):
+    """Remember project-specific settings as soon as one of them changes.
+
+    Ignores arguments so that it can be used as property update callback.
+
+    No-op when project_settings_loading=True, to prevent saving project-
+    specific settings while they are actually being loaded.
+    """
+    from .blender import preferences
+
+    global project_settings_loading
+    if project_settings_loading:
+        return
+
+    prefs = preferences()
+    project_id = prefs.project.project
+    all_settings = prefs.get('project_settings', {})
+    ps = all_settings.get(project_id, {})  # either a dict or bpy.types.IDPropertyGroup
+
+    for name in PROJECT_SPECIFIC_SIMPLE_PROPS:
+        ps[name] = getattr(prefs, name)
+
+    # Store project-specific Flamenco settings
+    ps['flamenco_manager_id'] = prefs.flamenco_manager.manager
+    ps['flamenco_available_managers'] = prefs.flamenco_manager.available_managers
+
+    # Store per-project, per-manager settings for the current Manager.
+    pppm = ps.get('flamenco_managers_settings', {})
+    pppm[prefs.flamenco_manager.manager] = {
+        name: getattr(prefs, name) for name in FLAMENCO_PER_PROJECT_PER_MANAGER
+    }
+    ps['flamenco_managers_settings'] = pppm  # IDPropertyGroup has no setdefault() method.
+
+    # Store this project's settings in the preferences.
+    all_settings[project_id] = ps
+    prefs['project_settings'] = all_settings
+
+    if log.isEnabledFor(logging.DEBUG):
+        from pprint import pformat
+        if hasattr(all_settings, 'to_dict'):
+            to_log = all_settings.to_dict()
+        else:
+            to_log = all_settings
+        log.debug('Saving project-specific settings:\n%s', pformat(to_log))

blender_cloud/settings_sync.py

@@ -34,7 +34,7 @@ import asyncio
 import pillarsdk
 from pillarsdk import exceptions as sdk_exceptions
 from .pillar import pillar_call
-from . import async_loop, pillar, cache, blendfile, home_project
+from . import async_loop, blender, pillar, cache, blendfile, home_project
 
 SETTINGS_FILES_TO_UPLOAD = ['userpref.blend', 'startup.blend']
 
@@ -284,9 +284,8 @@ class PILLAR_OT_sync(pillar.PillarOperatorMixin,
                 db_user = await self.check_credentials(context, REQUIRES_ROLES_FOR_SYNC)
                 self.user_id = db_user['_id']
                 log.debug('Found user ID: %s', self.user_id)
-            except pillar.NotSubscribedToCloudError:
-                self.log.exception('User not subscribed to cloud.')
-                self.bss_report({'SUBSCRIBE'}, 'Please subscribe to the Blender Cloud.')
+            except pillar.NotSubscribedToCloudError as ex:
+                self._log_subscription_needed(can_renew=ex.can_renew)
                 self._state = 'QUIT'
                 return
             except pillar.UserNotLoggedInError:
@@ -477,13 +476,13 @@ class PILLAR_OT_sync(pillar.PillarOperatorMixin,
         self.log.info('Overriding machine-local settings in %s', file_path)
 
         # Remember some settings that should not be overwritten from the Cloud.
-        up = bpy.context.user_preferences
+        prefs = blender.ctx_preferences()
         remembered = {}
         for rna_key, python_key in LOCAL_SETTINGS_RNA:
             assert '.' in python_key, 'Sorry, this code assumes there is a dot in the Python key'
 
             try:
-                value = up.path_resolve(python_key)
+                value = prefs.path_resolve(python_key)
             except ValueError:
                 # Setting doesn't exist. This can happen, for example Cycles
                 # settings on a build that doesn't have Cycles enabled.
@@ -492,7 +491,7 @@ class PILLAR_OT_sync(pillar.PillarOperatorMixin,
             # Map enums from strings (in Python) to ints (in DNA).
             dot_index = python_key.rindex('.')
             parent_key, prop_key = python_key[:dot_index], python_key[dot_index + 1:]
-            parent = up.path_resolve(parent_key)
+            parent = prefs.path_resolve(parent_key)
             prop = parent.bl_rna.properties[prop_key]
             if prop.type == 'ENUM':
                 log.debug('Rewriting %s from %r to %r',

blender_cloud/texture_browser.py

@@ -76,12 +76,13 @@ class MenuItem:
     icon_margin_y = 4
     text_margin_x = 6
 
-    text_height = 16
-    text_width = 72
+    text_size = 12
+    text_size_small = 10
 
     DEFAULT_ICONS = {
         'FOLDER': os.path.join(library_icons_path, 'folder.png'),
         'SPINNER': os.path.join(library_icons_path, 'spinner.png'),
+        'ERROR': os.path.join(library_icons_path, 'error.png'),
     }
 
     FOLDER_NODE_TYPES = {'group_texture', 'group_hdri', UpNode.NODE_TYPE, ProjectNode.NODE_TYPE}
@@ -99,6 +100,7 @@ class MenuItem:
         self.node = node  # pillarsdk.Node, contains 'node_type' key to indicate type
         self.file_desc = file_desc  # pillarsdk.File object, or None if a 'folder' node.
         self.label_text = label_text
+        self.small_text = self._small_text_from_node()
         self._thumb_path = ''
         self.icon = None
         self._is_folder = node['node_type'] in self.FOLDER_NODE_TYPES
@@ -118,6 +120,26 @@ class MenuItem:
         self.width = 0
         self.height = 0
 
+    def _small_text_from_node(self) -> str:
+        """Return the components of the texture (i.e. which map types are available)."""
+
+        if not self.node:
+            return ''
+
+        try:
+            node_files = self.node.properties.files
+        except AttributeError:
+            # Happens for nodes that don't have .properties.files.
+            return ''
+        if not node_files:
+            return ''
+
+        map_types = {f.map_type for f in node_files if f.map_type}
+        map_types.discard('color')  # all textures have colour
+        if not map_types:
+            return ''
+        return ', '.join(sorted(map_types))
+
     def sort_key(self):
         """Key for sorting lists of MenuItems."""
         return self._order, self.label_text
@@ -159,6 +181,11 @@ class MenuItem:
         if label_text is not None:
             self.label_text = label_text
 
+        if thumb_path == 'ERROR':
+            self.small_text = 'This open is broken'
+        else:
+            self.small_text = self._small_text_from_node()
+
     @property
     def is_folder(self) -> bool:
         return self._is_folder
@@ -185,15 +212,17 @@ class MenuItem:
         bgl.glRectf(self.x, self.y, self.x + self.width, self.y + self.height)
 
         texture = self.icon
-        err = texture.gl_load(filter=bgl.GL_NEAREST, mag=bgl.GL_NEAREST)
-        assert not err, 'OpenGL error: %i' % err
+        if texture:
+            err = texture.gl_load(filter=bgl.GL_NEAREST, mag=bgl.GL_NEAREST)
+            assert not err, 'OpenGL error: %i' % err
 
         bgl.glColor4f(0.0, 0.0, 1.0, 0.5)
         # bgl.glLineWidth(1.5)
 
         # ------ TEXTURE ---------#
-        bgl.glBindTexture(bgl.GL_TEXTURE_2D, texture.bindcode[0])
-        bgl.glEnable(bgl.GL_TEXTURE_2D)
+        if texture:
+            bgl.glBindTexture(bgl.GL_TEXTURE_2D, texture.bindcode[0])
+            bgl.glEnable(bgl.GL_TEXTURE_2D)
         bgl.glBlendFunc(bgl.GL_SRC_ALPHA, bgl.GL_ONE_MINUS_SRC_ALPHA)
 
         bgl.glColor4f(1, 1, 1, 1)
@@ -210,16 +239,24 @@ class MenuItem:
         bgl.glDisable(bgl.GL_TEXTURE_2D)
         bgl.glDisable(bgl.GL_BLEND)
 
-        texture.gl_free()
+        if texture:
+            texture.gl_free()
 
         # draw some text
         font_id = 0
-        blf.position(font_id,
-                     self.x + self.icon_margin_x + ICON_WIDTH + self.text_margin_x,
-                     self.y + ICON_HEIGHT * 0.5 - 0.25 * self.text_height, 0)
-        blf.size(font_id, self.text_height, self.text_width)
+        text_dpi = blender.ctx_preferences().system.dpi
+        text_x = self.x + self.icon_margin_x + ICON_WIDTH + self.text_margin_x
+        text_y = self.y + ICON_HEIGHT * 0.5 - 0.25 * self.text_size
+        blf.position(font_id, text_x, text_y, 0)
+        blf.size(font_id, self.text_size, text_dpi)
         blf.draw(font_id, self.label_text)
 
+        # draw the small text
+        bgl.glColor4f(1.0, 1.0, 1.0, 0.5)
+        blf.size(font_id, self.text_size_small, text_dpi)
+        blf.position(font_id, text_x, self.y + 0.5 * self.text_size_small, 0)
+        blf.draw(font_id, self.small_text)
+
     def hits(self, mouse_x: int, mouse_y: int) -> bool:
         return self.x < mouse_x < self.x + self.width and self.y < mouse_y < self.y + self.height
 
@@ -311,8 +348,8 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
             self.mouse_y = event.mouse_y
 
         left_mouse_release = event.type == 'LEFTMOUSE' and event.value == 'RELEASE'
-        if self._state == 'PLEASE_SUBSCRIBE' and left_mouse_release:
-            self.open_browser_subscribe()
+        if left_mouse_release and self._state in {'PLEASE_SUBSCRIBE', 'PLEASE_RENEW'}:
+            self.open_browser_subscribe(renew=self._state == 'PLEASE_RENEW')
             self._finish(context)
             return {'FINISHED'}
 
@@ -365,9 +402,9 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
 
         try:
             db_user = await self.check_credentials(context, REQUIRED_ROLES_FOR_TEXTURE_BROWSER)
-        except pillar.NotSubscribedToCloudError:
-            self.log.info('User not subscribed to Blender Cloud.')
-            self._show_subscribe_screen()
+        except pillar.NotSubscribedToCloudError as ex:
+            self._log_subscription_needed(can_renew=ex.can_renew, level='INFO')
+            self._show_subscribe_screen(can_renew=ex.can_renew)
             return None
 
         if db_user is None:
@@ -375,10 +412,14 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
 
         await self.async_download_previews()
 
-    def _show_subscribe_screen(self):
+    def _show_subscribe_screen(self, *, can_renew: bool):
         """Shows the "You need to subscribe" screen."""
 
-        self._state = 'PLEASE_SUBSCRIBE'
+        if can_renew:
+            self._state = 'PLEASE_RENEW'
+        else:
+            self._state = 'PLEASE_SUBSCRIBE'
+
         bpy.context.window.cursor_set('HAND')
 
     def descend_node(self, menu_item: MenuItem):
@@ -457,7 +498,7 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
 
         return menu_item
 
-    def update_menu_item(self, node, *args) -> MenuItem:
+    def update_menu_item(self, node, *args):
         node_uuid = node['_id']
 
         # Just make this thread-safe to be on the safe side.
@@ -538,6 +579,7 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
             self.add_menu_item(node, None, 'SPINNER', texture_node['name'])
 
         def thumbnail_loaded(node, file_desc, thumb_path):
+            self.log.debug('Node %s thumbnail loaded', node['_id'])
             self.update_menu_item(node, file_desc, thumb_path)
 
         await pillar.fetch_texture_thumbs(node_uuid, 's', directory,
@@ -547,6 +589,7 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
 
     def browse_assets(self):
         self.log.debug('Browsing assets at %r', self.current_path)
+        bpy.context.window_manager.last_blender_cloud_location = str(self.current_path)
         self._new_async_task(self.async_download_previews())
 
     def draw_menu(self, context):
@@ -559,6 +602,7 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
             'DOWNLOADING_TEXTURE': self._draw_downloading,
             'EXCEPTION': self._draw_exception,
             'PLEASE_SUBSCRIBE': self._draw_subscribe,
+            'PLEASE_RENEW': self._draw_renew,
         }
 
         if self._state in drawers:
@@ -726,6 +770,11 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
                                   'Click to subscribe to the Blender Cloud',
                                   (0.0, 0.0, 0.2, 0.6))
 
+    def _draw_renew(self, context):
+        self._draw_text_on_colour(context,
+                                  'Click to renew your Blender Cloud subscription',
+                                  (0.0, 0.0, 0.2, 0.6))
+
     def get_clicked(self) -> MenuItem:
 
         for item in self.current_display_content:
@@ -806,11 +855,11 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
                                                      future=signalling_future))
         self.async_task.add_done_callback(texture_download_completed)
 
-    def open_browser_subscribe(self):
+    def open_browser_subscribe(self, *, renew: bool):
         import webbrowser
 
-        webbrowser.open_new_tab('https://cloud.blender.org/join')
-
+        url = 'renew' if renew else 'join'
+        webbrowser.open_new_tab('https://cloud.blender.org/%s' % url)
         self.report({'INFO'}, 'We just started a browser for you.')
 
     def _scroll_smooth(self):
@@ -865,9 +914,8 @@ class PILLAR_OT_switch_hdri(pillar.PillarOperatorMixin,
             try:
                 db_user = await self.check_credentials(context, REQUIRED_ROLES_FOR_TEXTURE_BROWSER)
                 user_id = db_user['_id']
-            except pillar.NotSubscribedToCloudError:
-                self.log.exception('User not subscribed to cloud.')
-                self.report({'ERROR'}, 'Please subscribe to the Blender Cloud.')
+            except pillar.NotSubscribedToCloudError as ex:
+                self._log_subscription_needed(can_renew=ex.can_renew)
                 self._state = 'QUIT'
                 return
             except pillar.UserNotLoggedInError:
@@ -965,8 +1013,8 @@ def _hdri_download_panel(self, current_image):
                     current_image.name)
         return
 
-    row = self.layout.row(align=True).split(0.3)
-    row.label('HDRi', icon_value=blender.icon('CLOUD'))
+    row = self.layout.row(align=True).split(**blender.factor(0.3))
+    row.label(text='HDRi', icon_value=blender.icon('CLOUD'))
     row.prop(current_image, 'hdri_variation', text='')
 
     if current_image.hdri_variation != current_variation:

blender_cloud/utils.py

@@ -16,6 +16,7 @@
 #
 # ##### END GPL LICENSE BLOCK #####
 
+import json
 import pathlib
 
 
@@ -99,4 +100,15 @@ def pyside_cache(propname):
 
 
 def redraw(self, context):
+    if context.area is None:
+        return
     context.area.tag_redraw()
+
+
+class JSONEncoder(json.JSONEncoder):
+    """JSON encoder with support for some Blender types."""
+
+    def default(self, o):
+        if o.__class__.__name__ == 'IDPropertyGroup' and hasattr(o, 'to_dict'):
+            return o.to_dict()
+        return super().default(o)

blender_cloud/wheels/__init__.py

@@ -44,6 +44,12 @@ def load_wheel(module_name, fname_prefix):
                   module_name, module.__file__, fname_prefix)
         return
 
+    sys.path.append(wheel_filename(fname_prefix))
+    module = __import__(module_name)
+    log.debug('Loaded %s from %s', module_name, module.__file__)
+
+
+def wheel_filename(fname_prefix: str) -> str:
     path_pattern = os.path.join(my_dir, '%s*.whl' % fname_prefix)
     wheels = glob.glob(path_pattern)
     if not wheels:
@@ -51,12 +57,11 @@ def load_wheel(module_name, fname_prefix):
 
     # If there are multiple wheels that match, load the latest one.
     wheels.sort()
-    sys.path.append(wheels[-1])
-    module = __import__(module_name)
-    log.debug('Loaded %s from %s', module_name, module.__file__)
+    return wheels[-1]
 
 
 def load_wheels():
+    load_wheel('blender_asset_tracer', 'blender_asset_tracer')
     load_wheel('lockfile', 'lockfile')
     load_wheel('cachecontrol', 'CacheControl')
     load_wheel('pillarsdk', 'pillarsdk')

deploy-to-shared.sh

@@ -0,0 +1,13 @@
+#!/bin/bash -e
+
+FULLNAME="$(python3 setup.py --fullname)"
+echo "Press [ENTER] to deploy $FULLNAME to /shared"
+read dummy
+
+./clear_wheels.sh
+python3 setup.py wheels bdist
+
+DISTDIR=$(pwd)/dist
+cd /shared/software/addons
+rm -vf blender_cloud/wheels/*.whl  # remove obsolete wheel files
+unzip -o $DISTDIR/$FULLNAME.addon.zip

requirements.txt

@@ -1,15 +1,17 @@
 # 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.7.0
 wheel==0.29.0
+blender-asset-tracer>=0.8
 
 # Secondary requirements:
-cffi==1.6.0
-cryptography==1.3.1
-idna==2.1
+asn1crypto==0.24.0
+cffi==1.11.2
+cryptography==2.1.4
+idna==2.6
 pyasn1==0.1.9
-pycparser==2.14
-pyOpenSSL==16.0.0
+pycparser==2.18
+pyOpenSSL==17.5.0
 requests==2.10.0
-six==1.10.0
+six==1.11.0

setup.py

@@ -18,7 +18,6 @@
 # ##### END GPL LICENSE BLOCK #####
 
 import glob
-import os
 import sys
 import shutil
 import subprocess
@@ -29,13 +28,18 @@ import zipfile
 from distutils import log
 from distutils.core import Command
 from distutils.command.bdist import bdist
-from distutils.command.install import install
+from distutils.command.install import install, INSTALL_SCHEMES
 from distutils.command.install_egg_info import install_egg_info
 from setuptools import setup, find_packages
 
 requirement_re = re.compile('[><=]+')
 sys.dont_write_bytecode = True
 
+# Download wheels from pypi. The specific versions are taken from requirements.txt
+wheels = [
+    'lockfile', 'pillarsdk', 'blender-asset-tracer',
+]
+
 
 def set_default_path(var, default):
     """convert CLI-arguments (string) to Paths"""
@@ -60,6 +64,7 @@ class BuildWheels(Command):
         self.wheels_path = None  # path that will contain the installed wheels.
         self.deps_path = None  # path in which dependencies are built.
         self.cachecontrol_path = None  # subdir of deps_path containing CacheControl
+        self.bat_path = None  # subdir of deps_path containing Blender-Asset-Tracer
 
     def finalize_options(self):
         self.my_path = pathlib.Path(__file__).resolve().parent
@@ -69,6 +74,7 @@ class BuildWheels(Command):
         self.deps_path = set_default_path(self.deps_path, self.my_path / 'build/deps')
         self.cachecontrol_path = set_default_path(self.cachecontrol_path,
                                                   self.deps_path / 'cachecontrol')
+        self.bat_path = self.deps_path / 'bat'
 
     def run(self):
         log.info('Storing wheels in %s', self.wheels_path)
@@ -90,16 +96,11 @@ class BuildWheels(Command):
                 # log.info('   - %s = %s / %s', package, line, line_req[-1])
 
         self.wheels_path.mkdir(parents=True, exist_ok=True)
-
-        # Download lockfile, as there is a suitable wheel on pypi.
-        if not list(self.wheels_path.glob('lockfile*.whl')):
-            log.info('Downloading lockfile wheel')
-            self.download_wheel(requirements['lockfile'])
-
-        # Download Pillar Python SDK from pypi.
-        if not list(self.wheels_path.glob('pillarsdk*.whl')):
-            log.info('Downloading Pillar Python SDK wheel')
-            self.download_wheel(requirements['pillarsdk'])
+        for package in wheels:
+            pattern = package.replace('-', '_') + '*.whl'
+            if list(self.wheels_path.glob(pattern)):
+                continue
+            self.download_wheel(requirements[package])
 
         # Build CacheControl.
         if not list(self.wheels_path.glob('CacheControl*.whl')):
@@ -164,6 +165,14 @@ class BlenderAddonBdist(bdist):
         super().initialize_options()
         self.formats = ['zip']
         self.plat_name = 'addon'  # use this instead of 'linux-x86_64' or similar.
+        self.fix_local_prefix()
+
+    def fix_local_prefix(self):
+        """Place data files in blender_cloud instead of local/blender_cloud."""
+        for key in INSTALL_SCHEMES:
+            if 'data' not in INSTALL_SCHEMES[key]:
+                continue
+            INSTALL_SCHEMES[key]['data'] = '$base'
 
     def run(self):
         self.run_command('wheels')
@@ -175,12 +184,12 @@ class BlenderAddonFdist(BlenderAddonBdist):
     """Ensures that 'python setup.py fdist' creates a plain folder structure."""
 
     user_options = [
-            ('dest-path=', None, 'addon installation path'),
+        ('dest-path=', None, 'addon installation path'),
     ]
 
     def initialize_options(self):
         super().initialize_options()
-        self.dest_path = None # path that will contain the addon
+        self.dest_path = None  # path that will contain the addon
 
     def run(self):
         super().run()
@@ -227,11 +236,11 @@ setup(
               'wheels': BuildWheels},
     name='blender_cloud',
     description='The Blender Cloud addon allows browsing the Blender Cloud from Blender.',
-    version='1.6.3',
+    version='1.10.0',
     author='Sybren A. Stüvel',
     author_email='sybren@stuvel.eu',
     packages=find_packages('.'),
-    data_files=[('blender_cloud', ['README.md', 'README-flamenco.md']),
+    data_files=[('blender_cloud', ['README.md', 'README-flamenco.md', 'CHANGELOG.md']),
                 ('blender_cloud/icons', glob.glob('blender_cloud/icons/*'))],
     scripts=[],
     url='https://developer.blender.org/diffusion/BCA/',

tests/test_path_replacement.py

@@ -0,0 +1,95 @@
+"""Unittests for blender_cloud.utils.
+
+This unittest requires bpy to be importable, so build Blender as a module and install it
+into your virtualenv. See https://stuvel.eu/files/bconf2016/#/10 for notes how.
+"""
+
+import datetime
+import pathlib
+import unittest.mock
+
+import pillarsdk.utils
+
+from blender_cloud.flamenco import sdk
+
+
+class PathReplacementTest(unittest.TestCase):
+    def setUp(self):
+        self.test_manager = sdk.Manager({
+            '_created': datetime.datetime(2017, 5, 31, 15, 12, 32, tzinfo=pillarsdk.utils.utc),
+            '_etag': 'c39942ee4bcc4658adcc21e4bcdfb0ae',
+            '_id': '592edd609837732a2a272c62',
+            '_updated': datetime.datetime(2017, 6, 8, 14, 51, 3, tzinfo=pillarsdk.utils.utc),
+            'description': 'Manager formerly known as "testman"',
+            'job_types': {'sleep': {'vars': {}}},
+            'name': '<script>alert("this is a manager")</script>',
+            'owner': '592edd609837732a2a272c63',
+            'path_replacement': {'job_storage': {'darwin': '/Volume/shared',
+                                                 'linux': '/shared',
+                                                 'windows': 's:/'},
+                                 'render': {'darwin': '/Volume/render/',
+                                            'linux': '/render/',
+                                            'windows': 'r:/'},
+                                 'longrender': {'darwin': '/Volume/render/long',
+                                                'linux': '/render/long',
+                                                'windows': 'r:/long'},
+                                 },
+            'projects': ['58cbdd5698377322d95eb55e'],
+            'service_account': '592edd609837732a2a272c60',
+            'stats': {'nr_of_workers': 3},
+            'url': 'http://192.168.3.101:8083/',
+            'user_groups': ['58cbdd5698377322d95eb55f'],
+            'variables': {'blender': {'darwin': '/opt/myblenderbuild/blender',
+                                      'linux': '/home/sybren/workspace/build_linux/bin/blender '
+                                               '--enable-new-depsgraph --factory-startup',
+                                      'windows': 'c:/temp/blender.exe'}}}
+        )
+
+    def test_linux(self):
+        # (expected result, input)
+        test_paths = [
+            ('/doesnotexistreally', '/doesnotexistreally'),
+            ('{render}/agent327/scenes/A_01_03_B', '/render/agent327/scenes/A_01_03_B'),
+            ('{job_storage}/render/agent327/scenes', '/shared/render/agent327/scenes'),
+            ('{longrender}/agent327/scenes', '/render/long/agent327/scenes'),
+        ]
+
+        self._do_test(test_paths, 'linux', pathlib.PurePosixPath)
+
+    def test_windows(self):
+        # (expected result, input)
+        test_paths = [
+            ('c:/doesnotexistreally', 'c:/doesnotexistreally'),
+            ('c:/some/path', r'c:\some\path'),
+            ('{render}/agent327/scenes/A_01_03_B', r'R:\agent327\scenes\A_01_03_B'),
+            ('{render}/agent327/scenes/A_01_03_B', r'r:\agent327\scenes\A_01_03_B'),
+            ('{render}/agent327/scenes/A_01_03_B', r'r:/agent327/scenes/A_01_03_B'),
+            ('{job_storage}/render/agent327/scenes', 's:/render/agent327/scenes'),
+            ('{longrender}/agent327/scenes', 'r:/long/agent327/scenes'),
+        ]
+
+        self._do_test(test_paths, 'windows', pathlib.PureWindowsPath)
+
+    def test_darwin(self):
+        # (expected result, input)
+        test_paths = [
+            ('/Volume/doesnotexistreally', '/Volume/doesnotexistreally'),
+            ('{render}/agent327/scenes/A_01_03_B', r'/Volume/render/agent327/scenes/A_01_03_B'),
+            ('{job_storage}/render/agent327/scenes', '/Volume/shared/render/agent327/scenes'),
+            ('{longrender}/agent327/scenes', '/Volume/render/long/agent327/scenes'),
+        ]
+
+        self._do_test(test_paths, 'darwin', pathlib.PurePosixPath)
+
+    def _do_test(self, test_paths, platform, pathclass):
+        self.test_manager.PurePlatformPath = pathclass
+
+        def mocked_system():
+            return platform
+
+        with unittest.mock.patch('platform.system', mocked_system):
+            for expected_result, input_path in test_paths:
+                as_path_instance = pathclass(input_path)
+                self.assertEqual(expected_result,
+                                 self.test_manager.replace_path(as_path_instance),
+                                 'for input %r on platform %s' % (as_path_instance, platform))

update_version.sh

@@ -17,3 +17,6 @@ echo
 echo "Don't forget to commit and tag:"
 echo git commit -m \'Bumped version to $VERSION\' setup.py blender_cloud/__init__.py
 echo git tag -a version-$VERSION -m \'Tagged version $VERSION\'
+echo
+echo "To build a distribution ZIP:"
+echo python setup.py bdist