Bumped version to 1.14

The properties are still declared in the Python 3.5 compatible assignment
notation, and a class decorator that converts those to class annotations
as preferred by Blender 2.80.

CHANGELOG.md

@@ -1,5 +1,44 @@
 # Blender Cloud changelog
 
+## Version 1.14 (2019-10-10)
+
+- Upgraded BAT to 1.2 for missing smoke caches, compatibility with Blender 2.81, and some
+  Windows-specific fixes.
+- Removed warnings on the terminal when running Blender 2.80+
+
+
+## Version 1.13 (2019-04-18)
+
+- Upgraded BAT to 1.1.1 for a compatibility fix with Blender 2.79
+- Flamenco: Support for Flamenco Manager settings versioning + for settings version 2.
+  When using Blender Cloud Add-on 1.12 or older, Flamenco Server will automatically convert the
+  Manager settings to version 1.
+- More Blender 2.80 compatibility fixes
+
+
+## Version 1.12 (2019-03-25)
+
+- Flamenco: Change how progressive render tasks are created. Instead of the artist setting a fixed
+  number of sample chunks, they can now set a maximum number of samples for each render task.
+  Initial render tasks are created with a low number of samples, and subsequent tasks have an
+  increasing number of samples, up to the set maximum. The total number of samples of the final
+  render is still equal to the number of samples configured in the blend file.
+  Requires Flamenco Server 2.2 or newer.
+- Flamenco: Added a hidden "Submit & Quit" button. This button can be enabled in the add-on
+  preferences and and then be available on the Flamenco Render panel. Pressing the button will
+  silently close Blender after the job has been submitted to Flamenco (for example to click,
+  walk away, and free up memory for when the same machine is part of the render farm).
+- Flamenco: Name render jobs just 'thefile' instead of 'Render thefile.flamenco.blend'.
+  This makes the job overview on Flamenco Server cleaner.
+- Flamenco: support Shaman servers. See https://www.flamenco.io/docs/user_manual/shaman/
+  for more info.
+- Flamenco: The 'blender-video-chunks' job type now also allows MP4 and MOV video containers.
+
+
+## Version 1.11.1 (2019-01-04)
+
+- Bundled missing Texture Browser icons.
+
 
 ## Version 1.11.0 (2019-01-04)
 

blender_cloud/__init__.py

@@ -21,7 +21,7 @@
 bl_info = {
     'name': 'Blender Cloud',
     "author": "Sybren A. Stüvel, Francesco Siddi, Inês Almeida, Antony Riakiotakis",
-    'version': (1, 11, 0),
+    'version': (1, 14),
     '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 '

blender_cloud/attract/__init__.py

@@ -47,6 +47,7 @@ if "bpy" in locals():
     pillar = importlib.reload(pillar)
     async_loop = importlib.reload(async_loop)
     blender = importlib.reload(blender)
+    compatibility = importlib.reload(compatibility)
 else:
     import bpy
 
@@ -54,7 +55,7 @@ else:
         from . import draw_27 as draw
     else:
         from . import draw
-    from .. import pillar, async_loop, blender
+    from .. import pillar, async_loop, blender, compatibility
 
 import bpy
 import pillarsdk
@@ -63,6 +64,7 @@ from pillarsdk.projects import Project
 from pillarsdk import exceptions as sdk_exceptions
 
 from bpy.types import Operator, Panel, AddonPreferences
+import bl_ui.space_sequencer
 
 log = logging.getLogger(__name__)
 
@@ -251,7 +253,7 @@ class ATTRACT_PT_tools(AttractPollMixin, Panel):
                          icon='RENDER_STILL')
 
             # Group more dangerous operations.
-            dangerous_sub = layout.split(**blender.factor(0.6), align=True)
+            dangerous_sub = layout.split(**compatibility.factor(0.6), align=True)
             dangerous_sub.operator('attract.strip_unlink',
                                    text='Unlink %s' % noun,
                                    icon='PANEL_CLOSE')
@@ -407,6 +409,7 @@ class ATTRACT_OT_shot_fetch_update(AttractOperatorMixin, Operator):
         return {'FINISHED'}
 
 
+@compatibility.convert_properties
 class ATTRACT_OT_shot_relink(AttractOperatorMixin, Operator):
     bl_idname = "attract.shot_relink"
     bl_label = "Relink With Attract"
@@ -476,6 +479,7 @@ class ATTRACT_OT_shot_open_in_browser(AttractOperatorMixin, Operator):
         return {'FINISHED'}
 
 
+@compatibility.convert_properties
 class ATTRACT_OT_shot_delete(AttractOperatorMixin, Operator):
     bl_idname = 'attract.shot_delete'
     bl_label = 'Delete Shot'
@@ -639,8 +643,7 @@ class ATTRACT_OT_open_meta_blendfile(AttractOperatorMixin, Operator):
 
     @classmethod
     def poll(cls, context):
-        return AttractOperatorMixin.poll(context) and \
-               bool(any(cls.filename_from_metadata(s) for s in context.selected_sequences))
+        return bool(any(cls.filename_from_metadata(s) for s in context.selected_sequences))
 
     @staticmethod
     def filename_from_metadata(strip):
@@ -915,6 +918,7 @@ class ATTRACT_OT_copy_id_to_clipboard(AttractOperatorMixin, Operator):
         return {'FINISHED'}
 
 
+@compatibility.convert_properties
 class ATTRACT_OT_project_open_in_browser(Operator):
     bl_idname = 'attract.project_open_in_browser'
     bl_label = 'Open Project in Browser'
@@ -946,25 +950,31 @@ class ATTRACT_OT_project_open_in_browser(Operator):
         return {'FINISHED'}
 
 
-def draw_strip_movie_meta(self, context):
-    strip = active_strip(context)
-    if not strip:
-        return
+class ATTRACT_PT_strip_metadata(bl_ui.space_sequencer.SequencerButtonsPanel, Panel):
+    bl_label = "Metadata"
+    bl_parent_id = "SEQUENCER_PT_source"
+    bl_category = "Strip"
+    bl_options = {'DEFAULT_CLOSED'}
 
-    meta = strip.get('metadata', None)
-    if not meta:
-        return None
+    def draw(self, context):
+        strip = active_strip(context)
+        if not strip:
+            return
 
-    box = self.layout.column(align=True)
-    row = box.row(align=True)
-    fname = meta.get('BLEND_FILE', None) or None
-    if fname:
-        row.label(text='Original Blendfile: %s' % fname)
-        row.operator(ATTRACT_OT_open_meta_blendfile.bl_idname,
-                     text='', icon='FILE_BLEND')
-    sfra = meta.get('START_FRAME', '?')
-    efra = meta.get('END_FRAME', '?')
-    box.label(text='Original Frame Range: %s-%s' % (sfra, efra))
+        meta = strip.get('metadata', None)
+        if not meta:
+            return None
+
+        box = self.layout.column(align=True)
+        row = box.row(align=True)
+        fname = meta.get('BLEND_FILE', None) or None
+        if fname:
+            row.label(text='Original Blendfile: %s' % fname)
+            row.operator(ATTRACT_OT_open_meta_blendfile.bl_idname,
+                         text='', icon='FILE_BLEND')
+        sfra = meta.get('START_FRAME', '?')
+        efra = meta.get('END_FRAME', '?')
+        box.label(text='Original Frame Range: %s-%s' % (sfra, efra))
 
 
 def activate():
@@ -1023,8 +1033,6 @@ def register():
         name="Status")
     bpy.types.Sequence.atc_order = bpy.props.IntProperty(name="Order")
 
-    bpy.types.SEQUENCER_PT_edit.append(draw_strip_movie_meta)
-
     for cls in _rna_classes:
         bpy.utils.register_class(cls)
 

blender_cloud/blender.py

@@ -30,7 +30,7 @@ from bpy.types import AddonPreferences, Operator, WindowManager, Scene, Property
 from bpy.props import StringProperty, EnumProperty, PointerProperty, BoolProperty, IntProperty
 import rna_prop_ui
 
-from . import pillar, async_loop, flamenco, project_specific
+from . import compatibility, pillar, async_loop, flamenco, project_specific
 from .utils import pyside_cache, redraw
 
 PILLAR_WEB_SERVER_URL = os.environ.get('BCLOUD_SERVER', 'https://cloud.blender.org/')
@@ -40,23 +40,6 @@ ADDON_NAME = 'blender_cloud'
 log = logging.getLogger(__name__)
 icons = None
 
-if bpy.app.version < (2, 80):
-    SYNC_SELECT_VERSION_ICON = 'DOTSDOWN'
-else:
-    SYNC_SELECT_VERSION_ICON = 'DOWNARROW_HLT'
-
-
-@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):
@@ -69,6 +52,7 @@ def blender_syncable_versions(self, context):
     return [(v, v, '') for v in versions]
 
 
+@compatibility.convert_properties
 class SyncStatusProperties(PropertyGroup):
     status = EnumProperty(
         items=[
@@ -156,6 +140,7 @@ def project_extensions(project_id) -> set:
     return set(proj.get('enabled_for', ()))
 
 
+@compatibility.convert_properties
 class BlenderCloudProjectGroup(PropertyGroup):
     status = EnumProperty(
         items=[
@@ -185,6 +170,7 @@ class BlenderCloudProjectGroup(PropertyGroup):
         project_specific.handle_project_update()
 
 
+@compatibility.convert_properties
 class BlenderCloudPreferences(AddonPreferences):
     bl_idname = ADDON_NAME
 
@@ -267,6 +253,13 @@ class BlenderCloudPreferences(AddonPreferences):
         description='When enabled, Blender will open a webbrowser',
         default=True,
     )
+    flamenco_show_quit_after_submit_button = BoolProperty(
+        name='Show "Submit & Quit" button',
+        description='When enabled, next to the "Render on Flamenco" button there will be a button '
+                    '"Submit & Quit" that silently quits Blender after submitting the render job '
+                    'to Flamenco',
+        default=False,
+    )
 
     def draw(self, context):
         import textwrap
@@ -324,7 +317,7 @@ 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(**factor(0.33))
+        row = bsync_box.row().split(**compatibility.factor(0.33))
         row.label(text='Blender Sync with Blender Cloud', icon_value=icon('CLOUD'))
 
         icon_for_level = {
@@ -367,7 +360,7 @@ class BlenderCloudPreferences(AddonPreferences):
         layout.enabled = bss.status in {'NONE', 'IDLE'}
 
         buttons = layout.column()
-        row_buttons = buttons.row().split(**factor(0.5))
+        row_buttons = buttons.row().split(**compatibility.factor(0.5))
         row_push = row_buttons.row()
         row_pull = row_buttons.row(align=True)
 
@@ -376,21 +369,20 @@ class BlenderCloudPreferences(AddonPreferences):
                           icon='TRIA_UP').action = 'PUSH'
 
         versions = bss.available_blender_versions
-        version = bss.version
         if bss.status in {'NONE', 'IDLE'}:
-            if not versions or not version:
+            if not versions:
                 row_pull.operator('pillar.sync',
                                   text='Find version to load',
                                   icon='TRIA_DOWN').action = 'REFRESH'
             else:
                 props = row_pull.operator('pillar.sync',
-                                          text='Load %s settings' % version,
+                                          text='Load %s settings' % bss.version,
                                           icon='TRIA_DOWN')
                 props.action = 'PULL'
-                props.blender_version = version
+                props.blender_version = bss.version
                 row_pull.operator('pillar.sync',
                                   text='',
-                                  icon=SYNC_SELECT_VERSION_ICON).action = 'SELECT'
+                                  icon=compatibility.SYNC_SELECT_VERSION_ICON).action = 'SELECT'
         else:
             row_pull.label(text='Cloud Sync is running.')
 
@@ -403,7 +395,7 @@ class BlenderCloudPreferences(AddonPreferences):
         projects = bcp.available_projects
         project = bcp.project
         if bcp.status in {'NONE', 'IDLE'}:
-            if not projects or not project:
+            if not projects:
                 row_buttons.operator('pillar.projects',
                                      text='Find project to load',
                                      icon='FILE_REFRESH')
@@ -438,12 +430,12 @@ class BlenderCloudPreferences(AddonPreferences):
         header_row = flamenco_box.row(align=True)
         header_row.label(text='Flamenco:', icon_value=icon('CLOUD'))
 
-        manager_split = flamenco_box.split(**factor(0.32), align=True)
+        manager_split = flamenco_box.split(**compatibility.factor(0.32), align=True)
         manager_split.label(text='Manager:')
         manager_box = manager_split.row(align=True)
 
         if bcp.status in {'NONE', 'IDLE'}:
-            if not bcp.available_managers or not bcp.manager:
+            if not bcp.available_managers:
                 manager_box.operator('flamenco.managers',
                                      text='Find Flamenco Managers',
                                      icon='FILE_REFRESH')
@@ -455,7 +447,7 @@ class BlenderCloudPreferences(AddonPreferences):
         else:
             manager_box.label(text='Fetching available managers.')
 
-        path_split = flamenco_box.split(**factor(0.32), align=True)
+        path_split = flamenco_box.split(**compatibility.factor(0.32), align=True)
         path_split.label(text='Job File Path:')
         path_box = path_split.row(align=True)
         path_box.prop(self, 'flamenco_job_file_path', text='')
@@ -463,7 +455,7 @@ class BlenderCloudPreferences(AddonPreferences):
         props.path = self.flamenco_job_file_path
 
         job_output_box = flamenco_box.column(align=True)
-        path_split = job_output_box.split(**factor(0.32), align=True)
+        path_split = job_output_box.split(**compatibility.factor(0.32), align=True)
         path_split.label(text='Job Output Path:')
         path_box = path_split.row(align=True)
         path_box.prop(self, 'flamenco_job_output_path', text='')
@@ -471,7 +463,7 @@ class BlenderCloudPreferences(AddonPreferences):
         props.path = self.flamenco_job_output_path
         job_output_box.prop(self, 'flamenco_exclude_filter')
 
-        prop_split = job_output_box.split(**factor(0.32), align=True)
+        prop_split = job_output_box.split(**compatibility.factor(0.32), align=True)
         prop_split.label(text='Strip Components:')
         prop_split.prop(self, 'flamenco_job_output_strip_components', text='')
 
@@ -489,6 +481,7 @@ class BlenderCloudPreferences(AddonPreferences):
 
         flamenco_box.prop(self, 'flamenco_relative_only')
         flamenco_box.prop(self, 'flamenco_open_browser_after_submit')
+        flamenco_box.prop(self, 'flamenco_show_quit_after_submit_button')
 
 
 class PillarCredentialsUpdate(pillar.PillarOperatorMixin,
@@ -554,6 +547,7 @@ class PILLAR_OT_subscribe(Operator):
         return {'FINISHED'}
 
 
+@compatibility.convert_properties
 class PILLAR_OT_project_open_in_browser(Operator):
     bl_idname = 'pillar.project_open_in_browser'
     bl_label = 'Open in Browser'

blender_cloud/compatibility.py

@@ -0,0 +1,70 @@
+"""Compatibility functions to support Blender 2.79 and 2.80+ in one code base."""
+import functools
+
+import bpy
+
+
+if bpy.app.version < (2, 80):
+    SYNC_SELECT_VERSION_ICON = 'DOTSDOWN'
+else:
+    SYNC_SELECT_VERSION_ICON = 'DOWNARROW_HLT'
+
+
+# Get references to all property definition functions in bpy.props,
+# so that they can be used to replace 'x = IntProperty()' to 'x: IntProperty()'
+# dynamically when working on Blender 2.80+
+__all_prop_funcs = {
+    getattr(bpy.props, propname)
+    for propname in dir(bpy.props)
+    if propname.endswith('Property')
+}
+
+def convert_properties(class_):
+    """Class decorator to avoid warnings in Blender 2.80+
+
+    This decorator replaces property definitions like this:
+
+        someprop = bpy.props.IntProperty()
+
+    to annotations, as introduced in Blender 2.80:
+
+        someprop: bpy.props.IntProperty()
+
+    No-op if running on Blender 2.79 or older.
+    """
+
+    if bpy.app.version < (2, 80):
+        return class_
+
+    if not hasattr(class_, '__annotations__'):
+        class_.__annotations__ = {}
+
+    attrs_to_delete = []
+    for name, value in class_.__dict__.items():
+        if not isinstance(value, tuple) or len(value) != 2:
+            continue
+
+        prop_func, kwargs = value
+        if prop_func not in __all_prop_funcs:
+            continue
+
+        # This is a property definition, replace it with annotation.
+        attrs_to_delete.append(name)
+        class_.__annotations__[name] = value
+
+    for attr_name in attrs_to_delete:
+        delattr(class_, attr_name)
+
+    return class_
+
+
+@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}

blender_cloud/flamenco/__init__.py

@@ -34,12 +34,13 @@ if "bpy" in locals():
         bat_interface = importlib.reload(bat_interface)
         sdk = importlib.reload(sdk)
         blender = importlib.reload(blender)
+        compatibility = importlib.reload(compatibility)
     except NameError:
         from . import bat_interface, sdk
-        from .. import blender
+        from .. import blender, compatibility
 else:
     from . import bat_interface, sdk
-    from .. import blender
+    from .. import blender, compatibility
 
 import bpy
 from bpy.types import AddonPreferences, Operator, WindowManager, Scene, PropertyGroup
@@ -69,6 +70,21 @@ VIDEO_CONTAINER_TO_EXTENSION = {
     'FLASH': '.flv',
 }
 
+SHAMAN_URL_SCHEMES = {'shaman://', 'shaman+http://', 'shaman+https://'}
+
+
+def scene_sample_count(scene) -> int:
+    """Determine nr of render samples for this scene."""
+    if scene.cycles.progressive == 'BRANCHED_PATH':
+        samples = scene.cycles.aa_samples
+    else:
+        samples = scene.cycles.samples
+
+    if scene.cycles.use_square_samples:
+        samples **= 2
+
+    return samples
+
 
 @pyside_cache('manager')
 def available_managers(self, context):
@@ -105,6 +121,25 @@ def manager_updated(self: 'FlamencoManagerGroup', context):
                                             pppm)
 
 
+def silently_quit_blender():
+    """Quit Blender without any confirmation popup."""
+
+    try:
+        prefs = bpy.context.preferences
+    except AttributeError:
+        # Backward compatibility with Blender < 2.80
+        prefs = bpy.context.user_preferences
+
+    try:
+        prefs.view.use_save_prompt = False
+    except AttributeError:
+        # Backward compatibility with Blender < 2.80
+        prefs.view.use_quit_dialog = False
+
+    bpy.ops.wm.quit_blender()
+
+
+@compatibility.convert_properties
 class FlamencoManagerGroup(PropertyGroup):
     manager = EnumProperty(
         items=available_managers,
@@ -166,18 +201,26 @@ class FLAMENCO_OT_fmanagers(async_loop.AsyncModalOperatorMixin,
         from ..blender import preferences
 
         prefs = preferences()
+        mypref = self.mypref
 
         self.log.info('Going to fetch managers for user %s', self.user_id)
 
-        self.mypref.status = 'FETCHING'
+        mypref.status = 'FETCHING'
         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.
-        as_list = [{'_id': p['_id'], 'name': p['name']} for p in managers['_items']]
+        as_list = [{'_id': man['_id'], 'name': man['name']}
+                   for man in managers['_items']]
+
+        current_manager = mypref.manager
+        mypref.available_managers = as_list
+
+        # Prevent warnings about the current manager not being in the EnumProperty items.
+        if as_list and not any(man['_id'] == current_manager for man in as_list):
+            mypref.manager = as_list[0]['_id']
 
-        self.mypref.available_managers = as_list
         self.quit()
 
     def quit(self):
@@ -197,6 +240,7 @@ def guess_output_file_extension(output_format: str, scene) -> str:
         return '.' + container.lower()
 
 
+@compatibility.convert_properties
 class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
                          pillar.AuthenticatedPillarOperatorMixin,
                          FlamencoPollMixin,
@@ -209,6 +253,8 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
     stop_upon_exception = True
     log = logging.getLogger('%s.FLAMENCO_OT_render' % __name__)
 
+    quit_after_submit = BoolProperty()
+
     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.
@@ -268,17 +314,10 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
 
         # Add extra settings specific to the job type
         if scene.flamenco_render_job_type == 'blender-render-progressive':
-            if scene.cycles.progressive == 'BRANCHED_PATH':
-                samples = scene.cycles.aa_samples
-            else:
-                samples = scene.cycles.samples
-
-            if scene.cycles.use_square_samples:
-                samples **= 2
-
-            settings['cycles_num_chunks'] = scene.flamenco_render_schunk_count
+            samples = scene_sample_count(scene)
+            settings['cycles_sample_cap'] = scene.flamenco_render_chunk_sample_cap
             settings['cycles_sample_count'] = samples
-            settings['format'] = 'EXR'
+            settings['format'] = 'OPEN_EXR'
 
         # Let Flamenco Server know whether we'll output images or video.
         output_format = settings.get('format') or scene.render.image_settings.file_format
@@ -302,57 +341,50 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
             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
+        job_name = self._make_job_name(filepath)
         try:
             job_info = await create_job(self.user_id,
                                         project_id,
                                         manager_id,
                                         scene.flamenco_render_job_type,
                                         settings,
-                                        'Render %s' % filepath.name,
+                                        job_name,
                                         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)
+            message = str(ex)
+            if isinstance(ex, pillarsdk.exceptions.BadRequest):
+                payload = ex.response.json()
+                try:
+                    message = payload['_error']['message']
+                except KeyError:
+                    pass
+            self.log.exception('Error creating Flamenco job')
+            self.report({'ERROR'}, 'Error creating Flamenco job: %s' % message)
             self.quit()
             return
 
-        # Store the job ID in a file in the output dir.
-        with open(str(outdir / 'jobinfo.json'), 'w', encoding='utf8') as outfile:
-            import json
+        # BAT-pack the files to the destination directory.
+        job_id = job_info['_id']
+        outdir, outfile, missing_sources = await self.bat_pack(job_id, filepath)
+        if not outfile:
+            return
 
-            # 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()
+        # Store the job ID in a file in the output dir, if we can.
+        # TODO: Make it possible to create this file first and then send it to BAT for packing.
+        if outdir is not None:
+            await self._create_jobinfo_json(
+                outdir, job_info, manager_id, project_id, missing_sources)
 
-            # 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)
+        # Now that the files have been transfered, PATCH the job at the Manager
+        # to kick off the job compilation.
+        job_filepath = manager.replace_path(outfile)
+        self.log.info('Final file path: %s', job_filepath)
+        new_settings = {'filepath': job_filepath}
+        await self.compile_job(job_id, new_settings)
 
         # 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 BAT-pack, but it may come in
@@ -370,7 +402,7 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
             from urllib.parse import urljoin
             from ..blender import PILLAR_WEB_SERVER_URL
 
-            url = urljoin(PILLAR_WEB_SERVER_URL, '/flamenco/jobs/%s/redir' % job_info['_id'])
+            url = urljoin(PILLAR_WEB_SERVER_URL, '/flamenco/jobs/%s/redir' % job_id)
             webbrowser.open_new_tab(url)
 
         # Do a final report.
@@ -381,8 +413,54 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
         else:
             self.report({'INFO'}, 'Flamenco job created.')
 
+        if self.quit_after_submit:
+            silently_quit_blender()
+
         self.quit()
 
+    async def _create_jobinfo_json(self, outdir: Path, job_info: dict,
+                                   manager_id: str, project_id: str,
+                                   missing_sources: typing.List[Path]):
+        from ..blender import preferences
+        prefs = preferences()
+        with open(str(outdir / 'jobinfo.json'), 'w', encoding='utf8') as outfile:
+            import json
+
+            # 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, '-unknown-')
+
+            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)
+
+    def _make_job_name(self, filepath: Path) -> str:
+        """Turn a file to render into the render job name."""
+
+        job_name = filepath.name
+        if job_name.endswith('.blend'):
+            job_name = job_name[:-6]
+        if job_name.endswith('.flamenco'):
+            job_name = job_name[:-9]
+
+        return job_name
+
     def validate_job_settings(self, context, settings: dict) -> bool:
         """Perform settings validations for the selected job type.
 
@@ -397,8 +475,9 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
                 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.')
+            if settings['output_file_extension'] not in {'.mkv', '.mp4', '.mov'}:
+                self.report({'ERROR'}, 'Job type requires rendering to Matroska or '
+                                       'MP4 files, not %r.' % settings['output_file_extension'])
                 return False
 
         return True
@@ -422,6 +501,14 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
         old_use_overwrite = render.use_overwrite
         old_use_placeholder = render.use_placeholder
 
+        disable_denoiser = (context.scene.flamenco_render_job_type == 'blender-render-progressive'
+                            and render.engine == 'CYCLES')
+        if disable_denoiser:
+            use_denoising = [layer.cycles.use_denoising
+                             for layer in context.scene.view_layers]
+        else:
+            use_denoising = []
+
         try:
 
             # The file extension should be determined by the render settings, not necessarily
@@ -432,6 +519,10 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
             render.use_overwrite = False
             render.use_placeholder = False
 
+            if disable_denoiser:
+                for layer in context.scene.view_layers:
+                    layer.cycles.use_denoising = False
+
             filepath = Path(context.blend_data.filepath).with_suffix('.flamenco.blend')
             self.log.info('Saving copy to temporary file %s', filepath)
             bpy.ops.wm.save_as_mainfile(filepath=str(filepath),
@@ -443,17 +534,26 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
             render.use_overwrite = old_use_overwrite
             render.use_placeholder = old_use_placeholder
 
+            if disable_denoiser:
+                for denoise, layer in zip(use_denoising, context.scene.view_layers):
+                    layer.cycles.use_denoising = denoise
+
         return filepath
 
-    async def bat_pack(self, filepath: Path) \
-            -> typing.Tuple[Path, typing.Optional[Path], typing.List[Path]]:
+    async def bat_pack(self, job_id: str, filepath: Path) \
+            -> typing.Tuple[typing.Optional[Path], typing.Optional[PurePath], typing.List[Path]]:
         """BAT-packs the blendfile to the destination directory.
 
         Returns the path of the destination blend file.
 
+        :param job_id: the job ID given to us by Flamenco Server.
         :param filepath: the blend file to pack (i.e. the current blend file)
-        :returns: the destination directory, the destination blend file or None
-            if there were errors BAT-packing, and a list of missing paths.
+        :returns: A tuple of:
+            - The destination directory, or None if it does not exist on a
+              locally-reachable filesystem (for example when sending files to
+              a Shaman server).
+            - The destination blend file, or None if there were errors BAT-packing,
+            - A list of missing paths.
         """
 
         from datetime import datetime
@@ -461,19 +561,49 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
 
         prefs = preferences()
 
+        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('projdir: %s', projdir)
+
+        if any(prefs.flamenco_job_file_path.startswith(scheme) for scheme in SHAMAN_URL_SCHEMES):
+            endpoint, _ = bat_interface.parse_shaman_endpoint(prefs.flamenco_job_file_path)
+            self.log.info('Sending BAT pack to Shaman at %s', endpoint)
+            try:
+                outfile, missing_sources = await bat_interface.copy(
+                    bpy.context, filepath, projdir, '/', exclusion_filter,
+                    packer_class=bat_interface.ShamanPacker,
+                    relative_only=relative_only,
+                    endpoint=endpoint,
+                    checkout_id=job_id,
+                    manager_id=prefs.flamenco_manager.manager,
+                )
+            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, None, []
+            except bat_interface.Aborted:
+                self.log.warning('BAT Pack was aborted')
+                self.report({'WARNING'}, 'Aborted Flamenco file packing/transferring')
+                self.quit()
+                return None, None, []
+
+            bpy.context.window_manager.flamenco_status = 'DONE'
+            outfile = PurePath('{shaman}') / outfile
+            return None, outfile, missing_sources
+
         # Create a unique directory that is still more or less identifyable.
         # This should work better than a random ID.
         unique_dir = '%s-%s-%s' % (datetime.now().isoformat('-').replace(':', ''),
                                    self.db_user['username'],
                                    filepath.stem)
         outdir = Path(prefs.flamenco_job_file_path) / unique_dir
-        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)
@@ -502,6 +632,20 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
         bpy.context.window_manager.flamenco_status = 'DONE'
         return outdir, outfile, missing_sources
 
+    async def compile_job(self, job_id: str, new_settings: dict) -> None:
+        """Request Flamenco Server to start compiling the job."""
+
+        payload = {
+            'op': 'construct',
+            'settings': new_settings,
+        }
+
+        from .sdk import Job
+        from ..pillar import pillar_call
+
+        job = Job({'_id': job_id})
+        await pillar_call(job.patch, payload, caching=False)
+
 
 def scene_frame_range(context) -> str:
     """Returns the frame range string for the current scene."""
@@ -588,6 +732,7 @@ class FLAMENCO_OT_abort(Operator, FlamencoPollMixin):
         return {'FINISHED'}
 
 
+@compatibility.convert_properties
 class FLAMENCO_OT_explore_file_path(FlamencoPollMixin,
                                     Operator):
     """Opens the Flamenco job storage path in a file explorer.
@@ -655,6 +800,19 @@ class FLAMENCO_OT_disable_output_path_override(Operator):
         return {'FINISHED'}
 
 
+@compatibility.convert_properties
+class FLAMENCO_OT_set_recommended_sample_cap(Operator):
+    bl_idname = 'flamenco.set_recommended_sample_cap'
+    bl_label = 'Set Recommended Maximum Sample Count'
+    bl_description = 'Set the recommended maximum samples per render task'
+
+    sample_cap = IntProperty()
+
+    def execute(self, context):
+        context.scene.flamenco_render_chunk_sample_cap = self.sample_cap
+        return {'FINISHED'}
+
+
 async def create_job(user_id: str,
                      project_id: str,
                      manager_id: str,
@@ -672,7 +830,7 @@ async def create_job(user_id: str,
     from ..pillar import pillar_call
 
     job_attrs = {
-        'status': 'queued',
+        'status': 'waiting-for-files',
         'priority': priority,
         'name': job_name,
         'settings': job_settings,
@@ -809,7 +967,7 @@ class FLAMENCO_PT_render(bpy.types.Panel, FlamencoPollMixin):
 
         prefs = preferences()
 
-        labeled_row = layout.split(**blender.factor(0.25), align=True)
+        labeled_row = layout.split(**compatibility.factor(0.25), align=True)
         labeled_row.label(text='Manager:')
         prop_btn_row = labeled_row.row(align=True)
 
@@ -827,26 +985,57 @@ class FLAMENCO_PT_render(bpy.types.Panel, FlamencoPollMixin):
         else:
             prop_btn_row.label(text='Fetching available managers.')
 
-        labeled_row = layout.split(**blender.factor(0.25), align=True)
+        labeled_row = layout.split(**compatibility.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(**blender.factor(0.25), align=True)
+        # Job-type-specific options go directly below the job type selector.
+        box = layout.box()
+        if getattr(context.scene, 'flamenco_render_job_type', None) == 'blender-render-progressive':
+            if bpy.app.version < (2, 80):
+                box.alert = True
+                box.label(text='Progressive rendering requires Blender 2.80 or newer.',
+                          icon='ERROR')
+                # This isn't entirely fair, as Blender 2.79 could hypothetically
+                # be used to submit a job to farm running Blender 2.80.
+                return
+
+            if context.scene.render.engine != 'CYCLES':
+                box.alert = True
+                box.label(text='Progressive rendering requires Cycles', icon='ERROR')
+                return
+
+            box.prop(context.scene, 'flamenco_render_chunk_sample_cap')
+
+            sample_count = scene_sample_count(context.scene)
+            recommended_cap = sample_count // 4
+
+            split = box.split(**compatibility.factor(0.4))
+            split.label(text='Total Sample Count: %d' % sample_count)
+            props = split.operator('flamenco.set_recommended_sample_cap',
+                                   text='Recommended Max Samples per Task: %d' % recommended_cap)
+            props.sample_cap = recommended_cap
+
+            if any(layer.cycles.use_denoising for layer in context.scene.view_layers):
+                box.label(text='Progressive Rendering will disable Denoising.', icon='ERROR')
+
+            box.prop(context.scene, 'flamenco_render_fchunk_size',
+                     text='Minimum Frames per Task')
+        else:
+            box.prop(context.scene, 'flamenco_render_fchunk_size')
+
+        labeled_row = layout.split(**compatibility.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')
-
         paths_layout = layout.column(align=True)
 
-        labeled_row = paths_layout.split(**blender.factor(0.25), align=True)
+        labeled_row = paths_layout.split(**compatibility.factor(0.25), align=True)
         labeled_row.label(text='Storage:')
         prop_btn_row = labeled_row.row(align=True)
         prop_btn_row.label(text=prefs.flamenco_job_file_path)
@@ -859,7 +1048,7 @@ class FLAMENCO_PT_render(bpy.types.Panel, FlamencoPollMixin):
             paths_layout.label(text='Unable to render with Flamenco, outside of project directory.')
             return
 
-        labeled_row = paths_layout.split(**blender.factor(0.25), align=True)
+        labeled_row = paths_layout.split(**compatibility.factor(0.25), align=True)
         labeled_row.label(text='Output:')
         prop_btn_row = labeled_row.row(align=True)
 
@@ -878,16 +1067,26 @@ class FLAMENCO_PT_render(bpy.types.Panel, FlamencoPollMixin):
         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 = paths_layout.split(**compatibility.factor(0.25), align=True)
             labeled_row.label(text='Effective Output Path:')
             labeled_row.label(text=str(render_output))
 
+        self.draw_odd_size_warning(layout, context.scene.render)
+
         # 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 prefs.flamenco_show_quit_after_submit_button:
+                ui = layout.split(**compatibility.factor(0.75), align=True)
+            else:
+                ui = layout
+            ui.operator(FLAMENCO_OT_render.bl_idname,
+                        text='Render on Flamenco',
+                        icon='RENDER_ANIMATION').quit_after_submit = False
+            if prefs.flamenco_show_quit_after_submit_button:
+                ui.operator(FLAMENCO_OT_render.bl_idname,
+                            text='Submit & Quit',
+                            icon='RENDER_ANIMATION').quit_after_submit = True
             if bpy.app.debug:
                 layout.operator(FLAMENCO_OT_copy_files.bl_idname)
         elif flamenco_status == 'INVESTIGATING':
@@ -908,6 +1107,29 @@ class FLAMENCO_PT_render(bpy.types.Panel, FlamencoPollMixin):
         elif flamenco_status != 'IDLE' and context.window_manager.flamenco_status_txt:
             layout.label(text=context.window_manager.flamenco_status_txt)
 
+    def draw_odd_size_warning(self, layout, render):
+        render_width = render.resolution_x * render.resolution_percentage // 100
+        render_height = render.resolution_y * render.resolution_percentage // 100
+
+        odd_width = render_width % 2
+        odd_height = render_height % 2
+
+        if not odd_width and not odd_height:
+            return
+
+        box = layout.box()
+        box.alert = True
+
+        if odd_width and odd_height:
+            msg = 'Both X (%d) and Y (%d) resolution are' % (render_width, render_height)
+        elif odd_width:
+            msg = 'X resolution (%d) is' % render_width
+        else:
+            msg = 'Y resolution (%d) is' % render_height
+
+        box.label(text=msg + ' not divisible by 2.', icon='ERROR')
+        box.label(text='Any video rendered from these frames will be padded with black pixels.')
+
 
 def activate():
     """Activates draw callbacks, menu items etc. for Flamenco."""
@@ -961,21 +1183,25 @@ def register():
 
     scene = bpy.types.Scene
     scene.flamenco_render_fchunk_size = IntProperty(
-        name='Frame Chunk Size',
-        description='Maximum number of frames to render per task',
+        name='Frames per Task',
+        description='Number of frames to render per task. For progressive renders this is used '
+                    'when the sample limit is reached -- before that more frames are used',
         min=1,
         default=1,
     )
-    scene.flamenco_render_schunk_count = IntProperty(
-        name='Number of Sample Chunks',
-        description='Number of Cycles samples chunks to use per frame',
-        min=2,
-        default=3,
-        soft_max=10,
+    scene.flamenco_render_chunk_sample_cap = IntProperty(
+        name='Maximum Samples per Task',
+        description='Maximum number of samples per render task; a lower number creates more '
+                    'shorter-running tasks. Values between 1/10 and 1/4 of the total sample count '
+                    'seem sensible',
+        min=1,
+        soft_min=5,
+        default=100,
+        soft_max=1000,
     )
     scene.flamenco_render_frame_range = StringProperty(
         name='Frame Range',
-        description='Frames to render, in "printer range" notation'
+        description='Frames to render, in "printer range" notation',
     )
     scene.flamenco_render_job_type = EnumProperty(
         name='Job Type',
@@ -997,7 +1223,7 @@ def register():
 
     scene.flamenco_render_job_priority = IntProperty(
         name='Job Priority',
-        min=0,
+        min=1,
         default=50,
         max=100,
         description='Higher numbers mean higher priority'
@@ -1057,7 +1283,7 @@ def unregister():
             log.warning('Unable to unregister class %r, probably already unregistered', cls)
 
     for name in ('flamenco_render_fchunk_size',
-                 'flamenco_render_schunk_count',
+                 'flamenco_render_chunk_sample_cap',
                  'flamenco_render_frame_range',
                  'flamenco_render_job_type',
                  'flamenco_start_paused',

blender_cloud/flamenco/bat_interface.py

@@ -6,10 +6,11 @@ import pathlib
 import re
 import threading
 import typing
+import urllib.parse
 
 import bpy
 from blender_asset_tracer import pack
-from blender_asset_tracer.pack import progress, transfer
+from blender_asset_tracer.pack import progress, transfer, shaman
 
 log = logging.getLogger(__name__)
 
@@ -19,6 +20,7 @@ _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
+parse_shaman_endpoint = shaman.parse_endpoint
 
 
 class BatProgress(progress.Callback):
@@ -63,8 +65,8 @@ class BatProgress(progress.Callback):
         else:
             self._txt('Pack of %s done' % output_blendfile.name)
 
-    def pack_aborted(self):
-        self._txt('Aborted')
+    def pack_aborted(self, reason: str):
+        self._txt('Aborted: %s' % reason)
         self._status('ABORTED')
 
     def trace_blendfile(self, filename: pathlib.Path) -> None:
@@ -93,13 +95,46 @@ class BatProgress(progress.Callback):
         pass
 
 
+class ShamanPacker(shaman.ShamanPacker):
+    """Packer with support for getting an auth token from Flamenco Server."""
+
+    def __init__(self,
+                 bfile: pathlib.Path,
+                 project: pathlib.Path,
+                 target: str,
+                 endpoint: str,
+                 checkout_id: str,
+                 *,
+                 manager_id: str,
+                 **kwargs) -> None:
+        self.manager_id = manager_id
+        super().__init__(bfile, project, target, endpoint, checkout_id, **kwargs)
+
+    def _get_auth_token(self) -> str:
+        """get a token from Flamenco Server"""
+
+        from ..blender import PILLAR_SERVER_URL
+        from ..pillar import blender_id_subclient, uncached_session, SUBCLIENT_ID
+
+        url = urllib.parse.urljoin(PILLAR_SERVER_URL,
+                                   'flamenco/jwt/generate-token/%s' % self.manager_id)
+        auth_token = blender_id_subclient()['token']
+
+        resp = uncached_session.get(url, auth=(auth_token, SUBCLIENT_ID))
+        resp.raise_for_status()
+        return resp.text
+
+
 async def copy(context,
                base_blendfile: pathlib.Path,
                project: pathlib.Path,
-               target: pathlib.Path,
+               target: str,
                exclusion_filter: str,
                *,
-               relative_only: bool) -> typing.Tuple[pathlib.Path, typing.Set[pathlib.Path]]:
+               relative_only: bool,
+               packer_class=pack.Packer,
+               **packer_args) \
+        -> 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.
@@ -108,11 +143,11 @@ async def copy(context,
     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:
+    packer = packer_class(base_blendfile, project, target,
+                          compress=True, relative_only=relative_only, **packer_args)
+    with packer:
         with _packer_lock:
             if exclusion_filter:
                 # There was a mistake in an older version of the property tooltip,

blender_cloud/flamenco/sdk.py

@@ -1,5 +1,6 @@
 import functools
 import pathlib
+import typing
 
 from pillarsdk.resource import List, Find, Create
 
@@ -9,8 +10,28 @@ class Manager(List, Find):
     path = 'flamenco/managers'
     PurePlatformPath = pathlib.PurePath
 
-    @functools.lru_cache()
-    def _sorted_path_replacements(self) -> list:
+    @functools.lru_cache(maxsize=1)
+    def _path_replacements(self) -> list:
+        """Defer to _path_replacements_vN() to get path replacement vars.
+
+        Returns a list of tuples (variable name, variable value).
+        """
+        settings_version = self.settings_version or 1
+        try:
+            settings_func = getattr(self, '_path_replacements_v%d' % settings_version)
+        except AttributeError:
+            raise RuntimeError('This manager has unsupported settings version %d; '
+                               'upgrade Blender Cloud add-on')
+
+        def longest_value_first(item):
+            var_name, var_value = item
+            return -len(var_value), var_value, var_name
+
+        replacements = settings_func()
+        replacements.sort(key=longest_value_first)
+        return replacements
+
+    def _path_replacements_v1(self) -> typing.List[typing.Tuple[str, str]]:
         import platform
 
         if self.path_replacement is None:
@@ -18,22 +39,45 @@ class Manager(List, Find):
 
         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)
+                for varname, platform_replacements in items
                 if this_platform in platform_replacements]
 
+    def _path_replacements_v2(self) -> typing.List[typing.Tuple[str, str]]:
+        import platform
+
+        if not self.variables:
+            return []
+
+        this_platform = platform.system().lower()
+        audiences = {'users', 'all'}
+
+        replacements = []
+        for var_name, variable in self.variables.to_dict().items():
+            # Path replacement requires bidirectional variables.
+            if variable.get('direction') != 'twoway':
+                continue
+
+            for var_value in variable.get('values', []):
+                if var_value.get('audience') not in audiences:
+                    continue
+                if var_value.get('platform', '').lower() != this_platform:
+                    continue
+
+                replacements.append((var_name, var_value.get('value')))
+        return 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.
         """
+        assert isinstance(some_path, pathlib.PurePath), \
+            'some_path should be a PurePath, not %r' % some_path
 
-        for varname, path in self._sorted_path_replacements():
+        for varname, path in self._path_replacements():
             replacement = self.PurePlatformPath(path)
             try:
                 relpath = some_path.relative_to(replacement)
@@ -52,3 +96,14 @@ class Job(List, Find, Create):
     """
     path = 'flamenco/jobs'
     ensure_query_projections = {'project': 1}
+
+    def patch(self, payload: dict, api=None):
+        import pillarsdk.utils
+
+        api = api or self.api
+
+        url = pillarsdk.utils.join_url(self.path, str(self['_id']))
+        headers = pillarsdk.utils.merge_dict(self.http_headers(),
+                                             {'Content-Type': 'application/json'})
+        response = api.patch(url, payload, headers=headers)
+        return response

blender_cloud/image_sharing.py

@@ -25,7 +25,7 @@ import bpy
 import pillarsdk
 from pillarsdk import exceptions as sdk_exceptions
 from .pillar import pillar_call
-from . import async_loop, pillar, home_project, blender
+from . import async_loop, compatibility, pillar, home_project, blender
 
 REQUIRES_ROLES_FOR_IMAGE_SHARING = {'subscriber', 'demo'}
 IMAGE_SHARING_GROUP_NODE_NAME = 'Image sharing'
@@ -53,6 +53,7 @@ async def find_image_sharing_group_id(home_project_id, user_id):
     return share_group['_id']
 
 
+@compatibility.convert_properties
 class PILLAR_OT_image_share(pillar.PillarOperatorMixin,
                             async_loop.AsyncModalOperatorMixin,
                             bpy.types.Operator):

blender_cloud/pillar.py

@@ -26,7 +26,8 @@ from contextlib import closing, contextmanager
 import urllib.parse
 import pathlib
 
-import requests
+import requests.adapters
+import requests.packages.urllib3.util.retry
 import requests.structures
 import pillarsdk
 import pillarsdk.exceptions
@@ -42,7 +43,16 @@ RFC1123_DATE_FORMAT = '%a, %d %b %Y %H:%M:%S GMT'
 
 _pillar_api = {}  # will become a mapping from bool (cached/non-cached) to pillarsdk.Api objects.
 log = logging.getLogger(__name__)
+
+_retries = requests.packages.urllib3.util.retry.Retry(
+    total=10,
+    backoff_factor=0.05,
+)
+_http_adapter = requests.adapters.HTTPAdapter(max_retries=_retries)
 uncached_session = requests.session()
+uncached_session.mount('https://', _http_adapter)
+uncached_session.mount('http://', _http_adapter)
+
 _testing_blender_id_profile = None  # Just for testing, overrides what is returned by blender_id_profile.
 _downloaded_urls = set()  # URLs we've downloaded this Blender session.
 

blender_cloud/project_specific.py

@@ -114,7 +114,7 @@ def handle_project_update(_=None, _2=None):
             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]
+            prefs.flamenco_manager.manager = prefs.flamenco_manager.available_managers[0]['_id']
 
 
 def store(_=None, _2=None):

blender_cloud/settings_sync.py

@@ -35,7 +35,7 @@ import asyncio
 import pillarsdk
 from pillarsdk import exceptions as sdk_exceptions
 from .pillar import pillar_call
-from . import async_loop, blender, pillar, cache, blendfile, home_project
+from . import async_loop, blender, compatibility, pillar, cache, blendfile, home_project
 
 SETTINGS_FILES_TO_UPLOAD = ['userpref.blend', 'startup.blend']
 
@@ -196,6 +196,7 @@ async def available_blender_versions(home_project_id: str, user_id: str) -> list
 
 
 # noinspection PyAttributeOutsideInit
+@compatibility.convert_properties
 class PILLAR_OT_sync(pillar.PillarOperatorMixin,
                      async_loop.AsyncModalOperatorMixin,
                      bpy.types.Operator):
@@ -416,11 +417,20 @@ class PILLAR_OT_sync(pillar.PillarOperatorMixin,
         bss = bpy.context.window_manager.blender_sync_status
         bss.available_blender_versions = versions
 
-        if versions:
+        if not versions:
             # There are versions to sync, so we can remove the status message.
             # However, if there aren't any, the status message shows why, and
             # shouldn't be erased.
-            self.bss_report({'INFO'}, '')
+            return
+
+        # Prevent warnings that the current value of the EnumProperty isn't valid.
+        current_version = '%d.%d' % bpy.app.version[:2]
+        if current_version in versions:
+            bss.version = current_version
+        else:
+            bss.version = versions[0]
+
+        self.bss_report({'INFO'}, '')
 
     async def download_settings_file(self, fname: str, temp_dir: str):
         config_dir = pathlib.Path(bpy.utils.user_resource('CONFIG'))

blender_cloud/texture_browser/__init__.py

@@ -26,7 +26,7 @@ import bpy
 import bgl
 
 import pillarsdk
-from .. import async_loop, pillar, cache, blender, utils
+from .. import async_loop, compatibility, pillar, cache, blender, utils
 from . import menu_item as menu_item_mod  # so that we can have menu items called 'menu_item'
 from . import nodes
 
@@ -512,7 +512,7 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
         ex = self.async_task.exception()
         if isinstance(ex, pillar.UserNotLoggedInError):
             ex_msg = 'You are not logged in on Blender ID. Please log in at User Preferences, ' \
-                     'System, Blender ID.'
+                     'Add-ons, Blender ID Authentication.'
         else:
             ex_msg = str(ex)
             if not ex_msg:
@@ -648,6 +648,7 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
         self.scroll_offset_target = self.scroll_offset = 0
 
 
+@compatibility.convert_properties
 class PILLAR_OT_switch_hdri(pillar.PillarOperatorMixin,
                             async_loop.AsyncModalOperatorMixin,
                             bpy.types.Operator):
@@ -776,7 +777,7 @@ def _hdri_download_panel(self, current_image):
                     current_image.name)
         return
 
-    row = self.layout.row(align=True).split(**blender.factor(0.3))
+    row = self.layout.row(align=True).split(**compatibility.factor(0.3))
     row.label(text='HDRi', icon_value=blender.icon('CLOUD'))
     row.prop(current_image, 'hdri_variation', text='')
 

blender_cloud/texture_browser/draw.py

@@ -11,8 +11,12 @@ import bpy
 import gpu
 from gpu_extras.batch import batch_for_shader
 
-shader = gpu.shader.from_builtin('2D_UNIFORM_COLOR')
-texture_shader = gpu.shader.from_builtin('2D_IMAGE')
+if bpy.app.background:
+    shader = None
+    texture_shader = None
+else:
+    shader = gpu.shader.from_builtin('2D_UNIFORM_COLOR')
+    texture_shader = gpu.shader.from_builtin('2D_IMAGE')
 
 Float2 = typing.Tuple[float, float]
 Float3 = typing.Tuple[float, float, float]
@@ -101,3 +105,8 @@ def bind_texture(texture: bpy.types.Image):
     """Bind a Blender image to a GL texture slot."""
     bgl.glActiveTexture(bgl.GL_TEXTURE0)
     bgl.glBindTexture(bgl.GL_TEXTURE_2D, texture.bindcode)
+
+
+def load_texture(texture: bpy.types.Image) -> int:
+    """Load the texture, return OpenGL error code."""
+    return texture.gl_load()

blender_cloud/texture_browser/draw_27.py

@@ -88,3 +88,8 @@ def aabox_with_texture(v1: Float2, v2: Float2):
 def bind_texture(texture: bpy.types.Image):
     """Bind a Blender image to a GL texture slot."""
     bgl.glBindTexture(bgl.GL_TEXTURE_2D, texture.bindcode[0])
+
+
+def load_texture(texture: bpy.types.Image) -> int:
+    """Load the texture, return OpenGL error code."""
+    return texture.gl_load(filter=bgl.GL_NEAREST, mag=bgl.GL_NEAREST)

blender_cloud/texture_browser/menu_item.py

@@ -164,7 +164,7 @@ class MenuItem:
 
         texture = self.icon
         if texture:
-            err = texture.gl_load(filter=bgl.GL_NEAREST, mag=bgl.GL_NEAREST)
+            err = draw.load_texture(texture)
             assert not err, 'OpenGL error: %i' % err
 
         # ------ TEXTURE ---------#

blender_cloud/utils.py

@@ -94,7 +94,10 @@ def pyside_cache(propname):
                 result = wrapped(self, context)
                 return result
             finally:
-                rna_type, rna_info = getattr(self.bl_rna, propname)
+                try:
+                    rna_type, rna_info = self.bl_rna.__annotations__[propname]
+                except AttributeError:
+                    rna_type, rna_info = getattr(self.bl_rna, propname)
                 rna_info['_cached_result'] = result
         return wrapper
     return decorator

requirements.txt

@@ -1,9 +1,9 @@
 # Primary requirements:
 -e git+https://github.com/sybrenstuvel/cachecontrol.git@sybren-filecache-delete-crash-fix#egg=CacheControl
 lockfile==0.12.2
-pillarsdk==1.7.0
+pillarsdk==1.8.0
 wheel==0.29.0
-blender-asset-tracer>=0.8
+blender-asset-tracer==1.2.1
 
 # Secondary requirements:
 asn1crypto==0.24.0

setup.py

@@ -123,8 +123,8 @@ class BuildWheels(Command):
         """Downloads a wheel from PyPI and saves it in self.wheels_path."""
 
         subprocess.check_call([
-            'pip', 'download',
-            '--no-deps',
+            sys.executable, '-m', 'pip',
+            'download', '--no-deps',
             '--dest', str(self.wheels_path),
             requirement[0]
         ])
@@ -236,12 +236,16 @@ setup(
               'wheels': BuildWheels},
     name='blender_cloud',
     description='The Blender Cloud addon allows browsing the Blender Cloud from Blender.',
-    version='1.11.0',
+    version='1.14',
     author='Sybren A. Stüvel',
     author_email='sybren@stuvel.eu',
     packages=find_packages('.'),
-    data_files=[('blender_cloud', ['README.md', 'README-flamenco.md', 'CHANGELOG.md']),
-                ('blender_cloud/icons', glob.glob('blender_cloud/icons/*'))],
+    data_files=[
+        ('blender_cloud', ['README.md', 'README-flamenco.md', 'CHANGELOG.md']),
+        ('blender_cloud/icons', glob.glob('blender_cloud/icons/*')),
+        ('blender_cloud/texture_browser/icons',
+         glob.glob('blender_cloud/texture_browser/icons/*'))
+    ],
     scripts=[],
     url='https://developer.blender.org/diffusion/BCA/',
     license='GNU General Public License v2 or later (GPLv2+)',

update_version.sh

@@ -19,4 +19,4 @@ echo git commit -m \'Bumped version to $VERSION\' setup.py blender_cloud/__init_
 echo git tag -a version-$VERSION -m \'Tagged version $VERSION\'
 echo
 echo "To build a distribution ZIP:"
-echo python setup.py bdist
+echo python3 setup.py bdist