Bumped version to 1.6.2

This is very useful for opening render output directories from Blender,
as those will only exist after rendering has started.

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, 5, 9999),
+    'version': (1, 6, 2),
     'blender': (2, 77, 0),
     'location': 'Addon Preferences panel, and Ctrl+Shift+Alt+A anywhere for texture browser',
     'description': 'Texture library browser and Blender Sync. Requires the Blender ID addon '
@@ -94,6 +94,8 @@ def register():
     image_sharing.register()
     attract.register()
 
+    blender.handle_project_update()
+
 
 def _monkey_patch_requests():
     """Monkey-patch old versions of Requests.

blender_cloud/attract/__init__.py

@@ -60,6 +60,9 @@ from bpy.types import Operator, Panel, AddonPreferences
 
 log = logging.getLogger(__name__)
 
+# Global flag used to determine whether panels etc. can be drawn.
+attract_is_active = False
+
 
 def active_strip(context):
     try:
@@ -139,6 +142,9 @@ def shot_id_use(strips):
 def compute_strip_conflicts(scene):
     """Sets the strip property atc_object_id_conflict for each strip."""
 
+    if not attract_is_active:
+        return
+
     if not scene or not scene.sequence_editor or not scene.sequence_editor.sequences_all:
         return
 
@@ -161,7 +167,13 @@ def scene_update_post_handler(scene):
     compute_strip_conflicts(scene)
 
 
-class ToolsPanel(Panel):
+class AttractPollMixin:
+    @classmethod
+    def poll(cls, context):
+        return attract_is_active
+
+
+class ToolsPanel(AttractPollMixin, Panel):
     bl_label = 'Attract'
     bl_space_type = 'SEQUENCE_EDITOR'
     bl_region_type = 'UI'
@@ -238,7 +250,7 @@ class ToolsPanel(Panel):
             layout.operator(ATTRACT_OT_submit_all.bl_idname)
 
 
-class AttractOperatorMixin:
+class AttractOperatorMixin(AttractPollMixin):
     """Mix-in class for all Attract operators."""
 
     def _project_needs_setup_error(self):
@@ -261,7 +273,7 @@ class AttractOperatorMixin:
         from .. import pillar, blender
 
         prefs = blender.preferences()
-        project = self.find_project(prefs.attract_project.project)
+        project = self.find_project(prefs.project.project)
 
         # FIXME: Eve doesn't seem to handle the $elemMatch projection properly,
         # even though it works fine in MongoDB itself. As a result, we have to
@@ -295,7 +307,7 @@ class AttractOperatorMixin:
                                'cut_in_timeline_in_frames': strip.frame_final_start},
                 'order': 0,
                 'node_type': 'attract_shot',
-                'project': blender.preferences().attract_project.project,
+                'project': blender.preferences().project.project,
                 'user': user_uuid}
 
         # Create a Node item with the attract API
@@ -373,7 +385,7 @@ class AttractShotFetchUpdate(AttractOperatorMixin, Operator):
 
     @classmethod
     def poll(cls, context):
-        return any(selected_shots(context))
+        return AttractOperatorMixin.poll(context) and any(selected_shots(context))
 
     def execute(self, context):
         for strip in selected_shots(context):
@@ -393,6 +405,9 @@ class AttractShotRelink(AttractShotFetchUpdate):
 
     @classmethod
     def poll(cls, context):
+        if not AttractOperatorMixin.poll(context):
+            return False
+
         strip = active_strip(context)
         return strip is not None and not getattr(strip, 'atc_object_id', None)
 
@@ -433,7 +448,8 @@ class ATTRACT_OT_shot_open_in_browser(AttractOperatorMixin, Operator):
 
     @classmethod
     def poll(cls, context):
-        return bool(context.selected_sequences and active_strip(context))
+        return AttractOperatorMixin.poll(context) and \
+               bool(context.selected_sequences and active_strip(context))
 
     def execute(self, context):
         from ..blender import PILLAR_WEB_SERVER_URL
@@ -459,7 +475,8 @@ class AttractShotDelete(AttractOperatorMixin, Operator):
 
     @classmethod
     def poll(cls, context):
-        return bool(context.selected_sequences)
+        return AttractOperatorMixin.poll(context) and \
+               bool(context.selected_sequences)
 
     def execute(self, context):
         from .. import pillar
@@ -511,7 +528,8 @@ class AttractStripUnlink(AttractOperatorMixin, Operator):
 
     @classmethod
     def poll(cls, context):
-        return bool(context.selected_sequences)
+        return AttractOperatorMixin.poll(context) and \
+               bool(context.selected_sequences)
 
     def execute(self, context):
         unlinked_ids = set()
@@ -554,7 +572,8 @@ class AttractShotSubmitSelected(AttractOperatorMixin, Operator):
 
     @classmethod
     def poll(cls, context):
-        return bool(context.selected_sequences)
+        return AttractOperatorMixin.poll(context) and \
+               bool(context.selected_sequences)
 
     def execute(self, context):
         # Check that the project is set up for Attract.
@@ -610,7 +629,8 @@ class ATTRACT_OT_open_meta_blendfile(AttractOperatorMixin, Operator):
 
     @classmethod
     def poll(cls, context):
-        return bool(any(cls.filename_from_metadata(s) for s in context.selected_sequences))
+        return AttractOperatorMixin.poll(context) and \
+               bool(any(cls.filename_from_metadata(s) for s in context.selected_sequences))
 
     @staticmethod
     def filename_from_metadata(strip):
@@ -677,7 +697,7 @@ class ATTRACT_OT_make_shot_thumbnail(AttractOperatorMixin,
 
     @classmethod
     def poll(cls, context):
-        return bool(context.selected_sequences)
+        return AttractOperatorMixin.poll(context) and bool(context.selected_sequences)
 
     @contextlib.contextmanager
     def thumbnail_render_settings(self, context, thumbnail_width=512):
@@ -843,7 +863,7 @@ class ATTRACT_OT_make_shot_thumbnail(AttractOperatorMixin,
         from .. import blender
 
         prefs = blender.preferences()
-        project = self.find_project(prefs.attract_project.project)
+        project = self.find_project(prefs.project.project)
 
         self.log.info('Uploading file %s', filename)
         resp = await pillar.pillar_call(
@@ -873,7 +893,8 @@ class ATTRACT_OT_copy_id_to_clipboard(AttractOperatorMixin, Operator):
 
     @classmethod
     def poll(cls, context):
-        return bool(context.selected_sequences and active_strip(context))
+        return AttractOperatorMixin.poll(context) and \
+               bool(context.selected_sequences and active_strip(context))
 
     def execute(self, context):
         strip = active_strip(context)
@@ -905,6 +926,29 @@ def draw_strip_movie_meta(self, context):
     box.label('Original Frame Range: %s-%s' % (sfra, efra))
 
 
+def activate():
+    global attract_is_active
+
+    log.info('Activating Attract')
+    attract_is_active = True
+    bpy.app.handlers.scene_update_post.append(scene_update_post_handler)
+    draw.callback_enable()
+
+
+def deactivate():
+    global attract_is_active
+
+    log.info('Deactivating Attract')
+    attract_is_active = False
+    draw.callback_disable()
+
+    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
+
+
 def register():
     bpy.types.Sequence.atc_is_synced = bpy.props.BoolProperty(name="Is Synced")
     bpy.types.Sequence.atc_object_id = bpy.props.StringProperty(name="Attract Object ID")
@@ -942,13 +986,9 @@ def register():
     bpy.utils.register_class(ATTRACT_OT_make_shot_thumbnail)
     bpy.utils.register_class(ATTRACT_OT_copy_id_to_clipboard)
 
-    bpy.app.handlers.scene_update_post.append(scene_update_post_handler)
-    draw.callback_enable()
-
 
 def unregister():
-    draw.callback_disable()
+    deactivate()
-    bpy.app.handlers.scene_update_post.remove(scene_update_post_handler)
     bpy.utils.unregister_module(__name__)
     del bpy.types.Sequence.atc_is_synced
     del bpy.types.Sequence.atc_object_id

blender_cloud/attract/draw.py

@@ -172,6 +172,11 @@ 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

@@ -20,7 +20,7 @@
 
 Separated from __init__.py so that we can import & run from non-Blender environments.
 """
-
+import functools
 import logging
 import os.path
 
@@ -109,13 +109,61 @@ class SyncStatusProperties(PropertyGroup):
 def bcloud_available_projects(self, context):
     """Returns the list of items used by BlenderCloudProjectGroup.project EnumProperty."""
 
-    attr_proj = preferences().attract_project
+    projs = preferences().project.available_projects
-    projs = attr_proj.available_projects
     if not projs:
         return [('', 'No projects available in your Blender Cloud', '')]
     return [(p['_id'], p['name'], '') for p in projs]
 
 
+@functools.lru_cache(1)
+def project_extensions(project_id) -> set:
+    """Returns the extensions the project is enabled for.
+
+    At the moment of writing these are 'attract' and 'flamenco'.
+    """
+
+    log.debug('Finding extensions for project %s', project_id)
+
+    # We can't use our @property, since the preferences may be loaded from a
+    # preferences blend file, in which case it is not constructed from Python code.
+    available_projects = preferences().project.get('available_projects', [])
+    if not available_projects:
+        log.debug('No projects available.')
+        return set()
+
+    proj = next((p for p in available_projects
+                 if p['_id'] == project_id), None)
+    if proj is None:
+        log.debug('Project %s not found in available projects.', project_id)
+        return set()
+
+    return set(proj.get('enabled_for', ()))
+
+
+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=[
@@ -129,7 +177,9 @@ class BlenderCloudProjectGroup(PropertyGroup):
     project = EnumProperty(
         items=bcloud_available_projects,
         name='Cloud project',
-        description='Which Blender Cloud project to work with')
+        description='Which Blender Cloud project to work with',
+        update=handle_project_update
+    )
 
     # List of projects is stored in 'available_projects' ID property,
     # because I don't know how to store a variable list of strings in a proper RNA property.
@@ -140,6 +190,7 @@ class BlenderCloudProjectGroup(PropertyGroup):
     @available_projects.setter
     def available_projects(self, new_projects):
         self['available_projects'] = new_projects
+        handle_project_update()
 
 
 class BlenderCloudPreferences(AddonPreferences):
@@ -155,21 +206,22 @@ class BlenderCloudPreferences(AddonPreferences):
     )
 
     local_texture_dir = StringProperty(
-        name='Default Blender Cloud texture storage directory',
+        name='Default Blender Cloud Texture Storage Directory',
         subtype='DIR_PATH',
         default='//textures')
 
     open_browser_after_share = BoolProperty(
-        name='Open browser after sharing file',
+        name='Open Browser after Sharing File',
         description='When enabled, Blender will open a webbrowser',
         default=True
     )
 
-    # TODO: store local path with the Attract project, so that people
+    # TODO: store project-dependent properties with the project, so that people
-    # can switch projects and the local path switches with it.
+    # can switch projects and the Attract and Flamenco properties switch with it.
-    attract_project = PointerProperty(type=BlenderCloudProjectGroup)
+    project = PointerProperty(type=BlenderCloudProjectGroup)
+
     attract_project_local_path = StringProperty(
-        name='Local project path',
+        name='Local Project Path',
         description='Local path of your Attract project, used to search for blend files; '
                     'usually best to set to an absolute path',
         subtype='DIR_PATH',
@@ -180,19 +232,19 @@ class BlenderCloudPreferences(AddonPreferences):
     # 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_job_file_path = StringProperty(
-        name='Job file path',
+        name='Job File 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.
     flamenco_job_output_path = StringProperty(
-        name='Job output path',
+        name='Job Output Path',
         description='Path where to store output files, should be accessible for Workers',
         subtype='DIR_PATH',
         default='/render/_flamenco/output')
     flamenco_job_output_strip_components = IntProperty(
-        name='Job output path strip components',
+        name='Job Output Path Strip Components',
         description='The final output path comprises of the job output path, and the blend file '
                     'path relative to the project with this many path components stripped off '
                     'the front',
@@ -200,6 +252,11 @@ class BlenderCloudPreferences(AddonPreferences):
         default=0,
         soft_max=4,
     )
+    flamenco_open_browser_after_submit = BoolProperty(
+        name='Open Browser after Submitting Job',
+        description='When enabled, Blender will open a webbrowser',
+        default=True
+    )
 
     def draw(self, context):
         import textwrap
@@ -214,8 +271,8 @@ class BlenderCloudPreferences(AddonPreferences):
             blender_id_profile = None
         else:
             blender_id_profile = blender_id.get_active_profile()
-
         if blender_id is None:
+
             msg_icon = 'ERROR'
             text = 'This add-on requires Blender ID'
             help_text = 'Make sure that the Blender ID add-on is installed and activated'
@@ -281,12 +338,21 @@ class BlenderCloudPreferences(AddonPreferences):
         share_box.label('Image Sharing on Blender Cloud', icon_value=icon('CLOUD'))
         share_box.prop(self, 'open_browser_after_share')
 
+        # Project selector
+        project_box = layout.box()
+        project_box.enabled = self.project.status in {'NONE', 'IDLE'}
+
+        self.draw_project_selector(project_box, self.project)
+        extensions = project_extensions(self.project.project)
+
         # Attract stuff
-        attract_box = layout.box()
+        if 'attract' in extensions:
-        self.draw_attract_buttons(attract_box, self.attract_project)
+            attract_box = project_box.column()
+            self.draw_attract_buttons(attract_box, self.project)
 
         # Flamenco stuff
-        flamenco_box = layout.box()
+        if 'flamenco' in extensions:
+            flamenco_box = project_box.column()
             self.draw_flamenco_buttons(flamenco_box, self.flamenco_manager, context)
 
     def draw_subscribe_button(self, layout):
@@ -323,12 +389,11 @@ class BlenderCloudPreferences(AddonPreferences):
         else:
             row_pull.label('Cloud Sync is running.')
 
-    def draw_attract_buttons(self, attract_box, bcp: BlenderCloudProjectGroup):
+    def draw_project_selector(self, project_box, bcp: BlenderCloudProjectGroup):
-        attract_row = attract_box.row(align=True)
+        project_row = project_box.row(align=True)
-        attract_row.label('Attract', icon_value=icon('CLOUD'))
+        project_row.label('Project settings', icon_value=icon('CLOUD'))
 
-        attract_row.enabled = bcp.status in {'NONE', 'IDLE'}
+        row_buttons = project_row.row(align=True)
-        row_buttons = attract_row.row(align=True)
 
         projects = bcp.available_projects
         project = bcp.project
@@ -345,27 +410,38 @@ class BlenderCloudPreferences(AddonPreferences):
         else:
             row_buttons.label('Fetching available projects.')
 
-        attract_box.prop(self, 'attract_project_local_path')
+        enabled_for = project_extensions(project)
+        if project:
+            if enabled_for:
+                project_box.label('This project is set up for: %s' %
+                                  ', '.join(sorted(enabled_for)))
+            else:
+                project_box.label('This project is not set up for Attract or Flamenco')
+
+    def draw_attract_buttons(self, attract_box, bcp: BlenderCloudProjectGroup):
+        header_row = attract_box.row(align=True)
+        header_row.label('Attract:', icon_value=icon('CLOUD'))
+        attract_box.prop(self, 'attract_project_local_path',
+                         text='Local Attract project path')
 
     def draw_flamenco_buttons(self, flamenco_box, bcp: flamenco.FlamencoManagerGroup, context):
-        flamenco_row = flamenco_box.row(align=True)
+        header_row = flamenco_box.row(align=True)
-        flamenco_row.label('Flamenco', icon_value=icon('CLOUD'))
+        header_row.label('Flamenco:', icon_value=icon('CLOUD'))
 
-        flamenco_row.enabled = bcp.status in {'NONE', 'IDLE'}
+        manager_box = flamenco_box.row(align=True)
-        row_buttons = flamenco_row.row(align=True)
 
         if bcp.status in {'NONE', 'IDLE'}:
             if not bcp.available_managers or not bcp.manager:
-                row_buttons.operator('flamenco.managers',
+                manager_box.operator('flamenco.managers',
                                      text='Find Flamenco Managers',
                                      icon='FILE_REFRESH')
             else:
-                row_buttons.prop(bcp, 'manager', text='Manager')
+                manager_box.prop(bcp, 'manager', text='Manager')
-                row_buttons.operator('flamenco.managers',
+                manager_box.operator('flamenco.managers',
                                      text='',
                                      icon='FILE_REFRESH')
         else:
-            row_buttons.label('Fetching available managers.')
+            manager_box.label('Fetching available managers.')
 
         path_box = flamenco_box.row(align=True)
         path_box.prop(self, 'flamenco_job_file_path')
@@ -379,20 +455,21 @@ class BlenderCloudPreferences(AddonPreferences):
         props.path = self.flamenco_job_output_path
 
         job_output_box.prop(self, 'flamenco_job_output_strip_components',
-                            text='Strip components')
+                            text='Strip Components')
 
         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))
             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.')
 
-        # TODO: make a reusable way to select projects, and use that for Attract and Flamenco.
+        flamenco_box.prop(self, 'flamenco_open_browser_after_submit')
-        note_box = flamenco_box.column(align=True)
-        note_box.label('NOTE: For now, Flamenco uses the same project as Attract.')
-        note_box.label('This will change in a future version of the add-on.')
 
 
 class PillarCredentialsUpdate(pillar.PillarOperatorMixin,
@@ -477,7 +554,7 @@ class PILLAR_OT_projects(async_loop.AsyncModalOperatorMixin,
 
         self.log.info('Going to fetch projects for user %s', self.user_id)
 
-        preferences().attract_project.status = 'FETCHING'
+        preferences().project.status = 'FETCHING'
 
         # Get all projects, except the home project.
         projects_user = await pillar_call(
@@ -486,7 +563,8 @@ class PILLAR_OT_projects(async_loop.AsyncModalOperatorMixin,
                        'category': {'$ne': 'home'}},
              'sort': '-_created',
              'projection': {'_id': True,
-                            'name': True},
+                            'name': True,
+                            'extension_props': True},
              })
 
         projects_shared = await pillar_call(
@@ -495,20 +573,34 @@ class PILLAR_OT_projects(async_loop.AsyncModalOperatorMixin,
                        'permissions.groups.group': {'$in': self.db_user.groups}},
              'sort': '-_created',
              'projection': {'_id': True,
-                            'name': True},
+                            'name': True,
+                            'extension_props': True},
              })
 
         # We need to convert to regular dicts before storing in ID properties.
         # Also don't store more properties than we need.
-        projects = [{'_id': p['_id'], 'name': p['name']} for p in projects_user['_items']] + \
+        def reduce_properties(project_list):
-                   [{'_id': p['_id'], 'name': p['name']} for p in projects_shared['_items']]
+            for p in project_list:
+                p = p.to_dict()
+                extension_props = p.get('extension_props', {})
+                enabled_for = list(extension_props.keys())
 
-        preferences().attract_project.available_projects = projects
+                self._log.debug('Project %r is enabled for %s', p['name'], enabled_for)
+                yield {
+                    '_id': p['_id'],
+                    'name': p['name'],
+                    'enabled_for': enabled_for,
+                }
+
+        projects = list(reduce_properties(projects_user['_items'])) + \
+                   list(reduce_properties(projects_shared['_items']))
+
+        preferences().project.available_projects = projects
 
         self.quit()
 
     def quit(self):
-        preferences().attract_project.status = 'IDLE'
+        preferences().project.status = 'IDLE'
         super().quit()
 
 

blender_cloud/flamenco/__init__.py

@@ -34,6 +34,9 @@ from ..utils import pyside_cache, redraw
 
 log = logging.getLogger(__name__)
 
+# Global flag used to determine whether panels etc. can be drawn.
+flamenco_is_active = False
+
 
 @pyside_cache('manager')
 def available_managers(self, context):
@@ -73,8 +76,15 @@ class FlamencoManagerGroup(PropertyGroup):
         self['available_managers'] = new_managers
 
 
+class FlamencoPollMixin:
+    @classmethod
+    def poll(cls, context):
+        return flamenco_is_active
+
+
 class FLAMENCO_OT_fmanagers(async_loop.AsyncModalOperatorMixin,
                             pillar.AuthenticatedPillarOperatorMixin,
+                            FlamencoPollMixin,
                             Operator):
     """Fetches the Flamenco Managers available to the user"""
     bl_idname = 'flamenco.managers'
@@ -115,6 +125,7 @@ class FLAMENCO_OT_fmanagers(async_loop.AsyncModalOperatorMixin,
 
 class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
                          pillar.AuthenticatedPillarOperatorMixin,
+                         FlamencoPollMixin,
                          Operator):
     """Performs a Blender render on Flamenco."""
     bl_idname = 'flamenco.render'
@@ -128,22 +139,16 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
         if not await self.authenticate(context):
             return
 
-        context.window_manager.progress_begin(0, 4)
-        context.window_manager.progress_update(1)
-
-        from pillarsdk import exceptions as sdk_exceptions
         from ..blender import preferences
 
-        filepath = Path(context.blend_data.filepath)
         scene = context.scene
 
-        # The file extension should be determined by the render settings, not necessarily
+        # Save to a different file, specifically for Flamenco.
-        # by the setttings in the output panel.
+        context.window_manager.flamenco_status = 'PACKING'
-        scene.render.use_file_extension = True
+        filepath = await self._save_blendfile(context)
-        bpy.ops.wm.save_mainfile()
 
         # Determine where the render output will be stored.
-        render_output = render_output_path(context)
+        render_output = render_output_path(context, filepath)
         if render_output is None:
             self.report({'ERROR'}, 'Current file is outside of project path.')
             self.quit()
@@ -155,26 +160,40 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
         if not outfile:
             return
 
-        context.window_manager.progress_update(3)
-
         # Create the job at Flamenco Server.
         prefs = preferences()
 
+        context.window_manager.flamenco_status = 'COMMUNICATING'
         settings = {'blender_cmd': '{blender}',
-                    'chunk_size': scene.flamenco_render_chunk_size,
+                    'chunk_size': scene.flamenco_render_fchunk_size,
                     'filepath': str(outfile),
                     'frames': scene.flamenco_render_frame_range,
                     'render_output': str(render_output),
                     }
+
+        # 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
+            settings['cycles_sample_count'] = samples
+            settings['format'] = 'EXR'
+
         try:
             job_info = await create_job(self.user_id,
-                                        prefs.attract_project.project,
+                                        prefs.project.project,
                                         prefs.flamenco_manager.manager,
                                         scene.flamenco_render_job_type,
                                         settings,
                                         'Render %s' % filepath.name,
                                         priority=scene.flamenco_render_job_priority)
-        except sdk_exceptions.ResourceInvalid as ex:
+        except Exception as ex:
             self.report({'ERROR'}, 'Error creating Flamenco job: %s' % ex)
             self.quit()
             return
@@ -186,6 +205,25 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
             job_info['missing_files'] = [str(mf) for mf in missing_sources]
             json.dump(job_info, outfile, sort_keys=True, indent=4)
 
+        # 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
+        # handy in case of failures.
+        try:
+            self.log.info('Removing temporary file %s', filepath)
+            filepath.unlink()
+        except Exception as ex:
+            self.report({'ERROR'}, 'Unable to remove file: %s' % ex)
+            self.quit()
+            return
+
+        if prefs.flamenco_open_browser_after_submit:
+            import webbrowser
+            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'])
+            webbrowser.open_new_tab(url)
+
         # Do a final report.
         if missing_sources:
             names = (ms.name for ms in missing_sources)
@@ -193,11 +231,49 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
                         '; '.join(names))
         else:
             self.report({'INFO'}, 'Flamenco job created.')
+
         self.quit()
 
+    async def _save_blendfile(self, context):
+        """Save to a different file, specifically for Flamenco.
+
+        We shouldn't overwrite the artist's file.
+        We can compress, since this file won't be managed by SVN and doesn't need diffability.
+        """
+
+        render = context.scene.render
+
+        # Remember settings we need to restore after saving.
+        old_use_file_extension = render.use_file_extension
+        old_use_overwrite = render.use_overwrite
+        old_use_placeholder = render.use_placeholder
+
+        try:
+
+            # The file extension should be determined by the render settings, not necessarily
+            # by the setttings in the output panel.
+            render.use_file_extension = True
+
+            # Rescheduling should not overwrite existing frames.
+            render.use_overwrite = False
+            render.use_placeholder = 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),
+                                        compress=True,
+                                        copy=True)
+        finally:
+            # Restore the settings we changed, even after an exception.
+            render.use_file_extension = old_use_file_extension
+            render.use_overwrite = old_use_overwrite
+            render.use_placeholder = old_use_placeholder
+
+        return filepath
+
     def quit(self):
         super().quit()
-        bpy.context.window_manager.progress_end()
+        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.
@@ -243,7 +319,7 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
         return outfile, missing_sources
 
 
-class FLAMENCO_OT_scene_to_frame_range(Operator):
+class FLAMENCO_OT_scene_to_frame_range(FlamencoPollMixin, Operator):
     """Sets the scene frame range as the Flamenco render frame range."""
     bl_idname = 'flamenco.scene_to_frame_range'
     bl_label = 'Sets the scene frame range as the Flamenco render frame range'
@@ -256,6 +332,7 @@ class FLAMENCO_OT_scene_to_frame_range(Operator):
 
 
 class FLAMENCO_OT_copy_files(Operator,
+                             FlamencoPollMixin,
                              async_loop.AsyncModalOperatorMixin):
     """Uses BAM to copy the current blendfile + dependencies to the target directory."""
     bl_idname = 'flamenco.copy_files'
@@ -269,6 +346,8 @@ class FLAMENCO_OT_copy_files(Operator,
         from . import bam_interface
         from ..blender import preferences
 
+        context.window_manager.flamenco_status = 'PACKING'
+
         missing_sources = await bam_interface.bam_copy(
             Path(context.blend_data.filepath),
             Path(preferences().flamenco_job_file_path),
@@ -280,9 +359,18 @@ class FLAMENCO_OT_copy_files(Operator,
 
         self.quit()
 
+    def quit(self):
+        super().quit()
+        bpy.context.window_manager.flamenco_status = 'IDLE'
+
+
+class FLAMENCO_OT_explore_file_path(FlamencoPollMixin,
+                                    Operator):
+    """Opens the Flamenco job storage path in a file explorer.
+
+    If the path cannot be found, this operator tries to open its parent.
+    """
 
-class FLAMENCO_OT_explore_file_path(Operator):
-    """Opens the Flamenco job storage path in a file explorer."""
     bl_idname = 'flamenco.explore_file_path'
     bl_label = 'Open in file explorer'
     bl_description = __doc__.rstrip('.')
@@ -291,15 +379,30 @@ class FLAMENCO_OT_explore_file_path(Operator):
 
     def execute(self, context):
         import platform
-        import subprocess
+        import pathlib
-        import os
+
+        # Possibly open a parent of the path
+        to_open = pathlib.Path(self.path)
+        while to_open.parent != to_open:  # while we're not at the root
+            if to_open.exists():
+                break
+            to_open = to_open.parent
+        else:
+            self.report({'ERROR'}, 'Unable to open %s or any of its parents.' % self.path)
+            return {'CANCELLED'}
+        to_open = str(to_open)
 
         if platform.system() == "Windows":
-            os.startfile(self.path)
+            import os
+            os.startfile(to_open)
+
         elif platform.system() == "Darwin":
-            subprocess.Popen(["open", self.path])
+            import subprocess
+            subprocess.Popen(["open", to_open])
+
         else:
-            subprocess.Popen(["xdg-open", self.path])
+            import subprocess
+            subprocess.Popen(["xdg-open", to_open])
 
         return {'FINISHED'}
 
@@ -353,7 +456,7 @@ def is_image_type(render_output_type: str) -> bool:
 @functools.lru_cache(1)
 def _render_output_path(
         local_project_path: str,
-        blend_filepath: str,
+        blend_filepath: Path,
         flamenco_job_output_strip_components: int,
         flamenco_job_output_path: str,
         render_image_format: str,
@@ -365,27 +468,40 @@ def _render_output_path(
     is fast.
     """
 
+    try:
         project_path = Path(bpy.path.abspath(local_project_path)).resolve()
-    blendfile = Path(blend_filepath)
+    except FileNotFoundError:
+        # Path.resolve() will raise a FileNotFoundError if the project path doesn't exist.
+        return None
 
     try:
-        proj_rel = blendfile.parent.relative_to(project_path)
+        proj_rel = blend_filepath.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)
-    dir_components = output_top.joinpath(*rel_parts) / blendfile.stem
+
+    # 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'.
+    stem = blend_filepath.stem
+    if stem.endswith('.flamenco'):
+        stem = stem[:-9]
+
+    dir_components = output_top.joinpath(*rel_parts) / stem
 
     # Blender will have to append the file extensions by itself.
     if is_image_type(render_image_format):
-        return dir_components / '#####'
+        return dir_components / '######'
     return dir_components / flamenco_render_frame_range
 
 
-def render_output_path(context) -> typing.Optional[PurePath]:
+def render_output_path(context, filepath: Path = None) -> typing.Optional[PurePath]:
     """Returns the render output path to be sent to Flamenco.
 
+    :param context: the Blender context (used to find Flamenco preferences etc.)
+    :param filepath: the Path of the blend file to render, or None for the current file.
+
     Returns None when the current blend file is outside the project path.
     """
 
@@ -394,9 +510,12 @@ def render_output_path(context) -> typing.Optional[PurePath]:
     scene = context.scene
     prefs = preferences()
 
+    if filepath is None:
+        filepath = Path(context.blend_data.filepath)
+
     return _render_output_path(
         prefs.attract_project_local_path,
-        context.blend_data.filepath,
+        filepath,
         prefs.flamenco_job_output_strip_components,
         prefs.flamenco_job_output_path,
         scene.render.image_settings.file_format,
@@ -404,7 +523,7 @@ def render_output_path(context) -> typing.Optional[PurePath]:
     )
 
 
-class FLAMENCO_PT_render(bpy.types.Panel):
+class FLAMENCO_PT_render(bpy.types.Panel, FlamencoPollMixin):
     bl_label = "Flamenco Render"
     bl_space_type = 'PROPERTIES'
     bl_region_type = 'WINDOW'
@@ -418,21 +537,24 @@ class FLAMENCO_PT_render(bpy.types.Panel):
 
         prefs = preferences()
 
-        layout.prop(context.scene, 'flamenco_render_job_priority')
+        labeled_row = layout.split(0.25, align=True)
-        layout.prop(context.scene, 'flamenco_render_chunk_size')
+        labeled_row.label('Job Type:')
-
-        labeled_row = layout.split(0.2, align=True)
-        labeled_row.label('Job type:')
         labeled_row.prop(context.scene, 'flamenco_render_job_type', text='')
 
-        labeled_row = layout.split(0.2, align=True)
+        labeled_row = layout.split(0.25, align=True)
-        labeled_row.label('Frame range:')
+        labeled_row.label('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')
+
+        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.2, align=True)
+        labeled_row = readonly_stuff.split(0.25, align=True)
         labeled_row.label('Storage:')
         prop_btn_row = labeled_row.row(align=True)
         prop_btn_row.label(prefs.flamenco_job_file_path)
@@ -440,10 +562,11 @@ class FLAMENCO_PT_render(bpy.types.Panel):
                                       text='', icon='DISK_DRIVE')
         props.path = prefs.flamenco_job_file_path
 
-        labeled_row = readonly_stuff.split(0.2, align=True)
+        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:
@@ -452,17 +575,38 @@ class FLAMENCO_PT_render(bpy.types.Panel):
                                           text='', icon='DISK_DRIVE')
             props.path = str(render_output.parent)
 
+            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)
 
-        if not context.scene.render.use_overwrite:
+
-            warnbox = layout.box().column(align=True)
+def activate():
-            warnbox.label('Please enable "Overwrite" in the Output panel,')
+    """Activates draw callbacks, menu items etc. for Flamenco."""
-            warnbox.label('or re-queueing this job might not do anything.')
+
+    global flamenco_is_active
+    log.info('Activating Flamenco')
+    flamenco_is_active = True
+
+
+def deactivate():
+    """Deactivates draw callbacks, menu items etc. for Flamenco."""
+
+    global flamenco_is_active
+    log.info('Deactivating Flamenco')
+    flamenco_is_active = False
 
 
 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)
@@ -472,36 +616,62 @@ def register():
     bpy.utils.register_class(FLAMENCO_PT_render)
 
     scene = bpy.types.Scene
-    scene.flamenco_render_chunk_size = IntProperty(
+    scene.flamenco_render_fchunk_size = IntProperty(
-        name='Chunk size',
+        name='Frame Chunk Size',
         description='Maximum number of frames to render per task',
-        default=10,
+        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_frame_range = StringProperty(
-        name='Frame range',
+        name='Frame Range',
         description='Frames to render, in "printer range" notation'
     )
     scene.flamenco_render_job_type = EnumProperty(
-        name='Job type',
+        name='Job Type',
         items=[
-            ('blender-render', 'Simple Blender render', 'Not tiled, not resumable, just render'),
+            ('blender-render', 'Simple Render', 'Simple frame-by-frame render'),
-        ],
+            ('blender-render-progressive', 'Progressive Render',
-        description='Flamenco render job type',
+             'Each frame is rendered multiple times with different Cycles sample chunks, then combined'),
+        ]
     )
+
     scene.flamenco_render_job_priority = IntProperty(
-        name='Job priority',
+        name='Job Priority',
         min=0,
         default=50,
         max=100,
         description='Higher numbers mean higher priority'
     )
 
+    bpy.types.WindowManager.flamenco_status = EnumProperty(
+        items=[
+            ('IDLE', 'IDLE', 'Not doing anything.'),
+            ('PACKING', 'PACKING', 'BAM-packing all dependencies.'),
+            ('COMMUNICATING', 'COMMUNICATING', 'Communicating with Flamenco Server.'),
+        ],
+        name='flamenco_status',
+        default='IDLE',
+        description='Current status of the Flamenco add-on',
+        update=redraw)
+
 
 def unregister():
+    deactivate()
     bpy.utils.unregister_module(__name__)
 
     try:
-        del bpy.types.Scene.flamenco_render_chunk_size
+        del bpy.types.Scene.flamenco_render_fchunk_size
+    except AttributeError:
+        pass
+    try:
+        del bpy.types.Scene.flamenco_render_schunk_count
     except AttributeError:
         pass
     try:
@@ -516,3 +686,7 @@ def unregister():
         del bpy.types.Scene.flamenco_render_job_priority
     except AttributeError:
         pass
+    try:
+        del bpy.types.WindowManager.flamenco_status
+    except AttributeError:
+        pass

blender_cloud/pillar.py

@@ -860,6 +860,13 @@ class AuthenticatedPillarOperatorMixin(PillarOperatorMixin):
             self.report({'ERROR'}, 'Please log in on Blender ID first.')
             self.quit()
             return False
+        except requests.exceptions.ConnectionError:
+            self.log.exception('Error checking pillar credentials.')
+            self.report({'ERROR'}, 'Unable to connect to Blender Cloud, '
+                                   'check your internet connection.')
+            self.quit()
+            return False
+
 
         self.user_id = self.db_user['_id']
         return True

setup.py

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