Bumped version to 1.8.0

This stores project-specific settings, such as filesystem paths, for each
project, and restores those settings when the project is selected again.
Does not touch settings that haven't been set for the newly selected
project.

CHANGELOG.md

@@ -0,0 +1,94 @@
+# Blender Cloud changelog
+
+## Version 1.8 (in development)
+
+- Distinguish between 'please subscribe' (to get a new subscription) and 'please renew' (to renew an
+  existing subscription).
+- When re-opening the Texture Browser it now opens in the same folder as where it was when closed.
+- In the texture browser, draw the components of the texture (i.e. which map types are available),
+  such as 'bump, normal, specular'.
+- Use Interface Scale setting from user preferences to draw the Texture Browser text.
+- Store project-specific settings in the preferences, such as filesystem paths, for each project,
+  and restore those settings when the project is selected again. Does not touch settings that
+  haven't been set for the newly selected project. These settings are only saved when a setting
+  is updated, so to save your current settings need to update a single setting; this saves all
+  settings for the project.
+- Added button in the User Preferences to open a Cloud project in your webbrowser.
+
+
+## Version 1.7.5 (2017-10-06)
+
+- Sorting the project list alphabetically.
+- Renamed 'Job File Path' to 'Job Storage Path' so it's more explicit.
+- Allow overriding the render output path on a per-scene basis.
+
+
+## Version 1.7.4 (2017-09-05)
+
+- Fix [T52621](https://developer.blender.org/T52621): Fixed class name collision upon add-on
+  registration. This is checked since Blender 2.79.
+- Fix [T48852](https://developer.blender.org/T48852): Screenshot no longer shows "Communicating with
+  Blender Cloud".
+
+
+## Version 1.7.3 (2017-08-08)
+
+- Default to scene frame range when no frame range is given.
+- Refuse to render on Flamenco before blend file is saved at least once.
+- Fixed some Windows-specific issues.
+
+
+## Version 1.7.2 (2017-06-22)
+
+- Fixed compatibility with Blender 2.78c.
+
+
+## Version 1.7.1 (2017-06-13)
+
+- Fixed asyncio issues on Windows
+
+
+## Version 1.7.0 (2017-06-09)
+
+- Fixed reloading after upgrading from 1.4.4 (our last public release).
+- Fixed bug handling a symlinked project path.
+- Added support for Manager-defined path replacement variables.
+
+
+## Version 1.6.4 (2017-04-21)
+
+- Added file exclusion filter for Flamenco. A filter like `*.abc;*.mkv;*.mov` can be
+  used to prevent certain files from being copied to the job storage directory.
+  Requires a Blender that is bundled with BAM 1.1.7 or newer.
+
+
+## Version 1.6.3 (2017-03-21)
+
+- Fixed bug where local project path wasn't shown for projects only set up for Flamenco
+  (and not Attract).
+- Added this CHANGELOG.md file, which will contain user-relevant changes.
+
+
+## Version 1.6.2 (2017-03-17)
+
+- Flamenco: when opening non-existing file path, open parent instead
+- Fix T50954: Improve Blender Cloud add-on project selector
+
+
+## Version 1.6.1 (2017-03-07)
+
+- Show error in GUI when Blender Cloud is unreachable
+- Fixed sample count when using branched path tracing
+
+
+## Version 1.6.0 (2017-02-14)
+
+- Default to frame chunk size of 1 (instead of 10).
+- Turn off "use overwrite" and "use placeholder" for Flamenco blend files.
+- Fixed bugs when blendfile is outside the project directory
+
+
+## Older versions
+
+For the history of older versions, please refer to the
+[Git history](https://developer.blender.org/diffusion/BCA/)

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, 6, 2),
+    'version': (1, 8, 0),
     '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 '
@@ -65,36 +65,45 @@ def register():
 
         def reload_mod(name):
             modname = '%s.%s' % (__name__, name)
-            module = importlib.reload(sys.modules[modname])
+            try:
-            sys.modules[modname] = module
+                old_module = sys.modules[modname]
-            return module
+            except KeyError:
+                # Wasn't loaded before -- can happen after an upgrade.
+                new_module = importlib.import_module(modname)
+            else:
+                new_module = importlib.reload(old_module)
+
+            sys.modules[modname] = new_module
+            return new_module
 
         reload_mod('blendfile')
         reload_mod('home_project')
         reload_mod('utils')
+        reload_mod('pillar')
 
-        blender = reload_mod('blender')
         async_loop = reload_mod('async_loop')
+        flamenco = reload_mod('flamenco')
+        attract = reload_mod('attract')
         texture_browser = reload_mod('texture_browser')
         settings_sync = reload_mod('settings_sync')
         image_sharing = reload_mod('image_sharing')
-        attract = reload_mod('attract')
+        blender = reload_mod('blender')
-        flamenco = reload_mod('flamenco')
+        project_specific = reload_mod('project_specific')
     else:
         from . import (blender, texture_browser, async_loop, settings_sync, blendfile, home_project,
-                       image_sharing, attract, flamenco)
+                       image_sharing, attract, flamenco, project_specific)
 
     async_loop.setup_asyncio_executor()
     async_loop.register()
 
     flamenco.register()
+    attract.register()
     texture_browser.register()
-    blender.register()
     settings_sync.register()
     image_sharing.register()
-    attract.register()
+    blender.register()
 
-    blender.handle_project_update()
+    project_specific.handle_project_update()
 
 
 def _monkey_patch_requests():

blender_cloud/async_loop.py

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

blender_cloud/attract/__init__.py

@@ -173,7 +173,7 @@ class AttractPollMixin:
         return attract_is_active
 
 
-class ToolsPanel(AttractPollMixin, Panel):
+class AttractToolsPanel(AttractPollMixin, Panel):
     bl_label = 'Attract'
     bl_space_type = 'SEQUENCE_EDITOR'
     bl_region_type = 'UI'
@@ -974,7 +974,7 @@ def register():
 
     bpy.types.SEQUENCER_PT_edit.append(draw_strip_movie_meta)
 
-    bpy.utils.register_class(ToolsPanel)
+    bpy.utils.register_class(AttractToolsPanel)
     bpy.utils.register_class(AttractShotRelink)
     bpy.utils.register_class(AttractShotDelete)
     bpy.utils.register_class(AttractStripUnlink)

blender_cloud/blender.py

@@ -23,22 +23,21 @@ Separated from __init__.py so that we can import & run from non-Blender environm
 import functools
 import logging
 import os.path
+import tempfile
 
 import bpy
 from bpy.types import AddonPreferences, Operator, WindowManager, Scene, PropertyGroup
 from bpy.props import StringProperty, EnumProperty, PointerProperty, BoolProperty, IntProperty
 import rna_prop_ui
 
-from . import pillar, async_loop, flamenco
+from . import pillar, async_loop, flamenco, project_specific
 from .utils import pyside_cache, redraw
 
-PILLAR_WEB_SERVER_URL = 'https://cloud.blender.org/'
+PILLAR_WEB_SERVER_URL = os.environ.get('BCLOUD_SERVER', 'https://cloud.blender.org/')
-# PILLAR_WEB_SERVER_URL = 'http://pillar-web:5001/'
 PILLAR_SERVER_URL = '%sapi/' % PILLAR_WEB_SERVER_URL
 
 ADDON_NAME = 'blender_cloud'
 log = logging.getLogger(__name__)
-
 icons = None
 
 
@@ -140,30 +139,6 @@ def project_extensions(project_id) -> set:
     return set(proj.get('enabled_for', ()))
 
 
-def handle_project_update(_=None, _2=None):
-    """Handles changing projects, which may cause extensions to be disabled/enabled.
-
-    Ignores arguments so that it can be used as property update callback.
-    """
-
-    project_id = preferences().project.project
-    log.info('Updating internal state to reflect extensions enabled on current project %s.',
-             project_id)
-
-    project_extensions.cache_clear()
-
-    from blender_cloud import attract, flamenco
-    attract.deactivate()
-    flamenco.deactivate()
-
-    enabled_for = project_extensions(project_id)
-    log.info('Project extensions: %s', enabled_for)
-    if 'attract' in enabled_for:
-        attract.activate()
-    if 'flamenco' in enabled_for:
-        flamenco.activate()
-
-
 class BlenderCloudProjectGroup(PropertyGroup):
     status = EnumProperty(
         items=[
@@ -178,7 +153,7 @@ class BlenderCloudProjectGroup(PropertyGroup):
         items=bcloud_available_projects,
         name='Cloud project',
         description='Which Blender Cloud project to work with',
-        update=handle_project_update
+        update=project_specific.handle_project_update
     )
 
     # List of projects is stored in 'available_projects' ID property,
@@ -190,13 +165,13 @@ class BlenderCloudProjectGroup(PropertyGroup):
     @available_projects.setter
     def available_projects(self, new_projects):
         self['available_projects'] = new_projects
-        handle_project_update()
+        project_specific.handle_project_update()
 
 
 class BlenderCloudPreferences(AddonPreferences):
     bl_idname = ADDON_NAME
 
-    # The following two properties are read-only to limit the scope of the
+    # The following property is read-only to limit the scope of the
     # addon and allow for proper testing within this scope.
     pillar_server = StringProperty(
         name='Blender Cloud Server',
@@ -220,29 +195,37 @@ class BlenderCloudPreferences(AddonPreferences):
     # can switch projects and the Attract and Flamenco properties switch with it.
     project = PointerProperty(type=BlenderCloudProjectGroup)
 
-    attract_project_local_path = StringProperty(
+    cloud_project_local_path = StringProperty(
         name='Local Project Path',
         description='Local path of your Attract project, used to search for blend files; '
                     'usually best to set to an absolute path',
         subtype='DIR_PATH',
-        default='//../')
+        default='//../',
+        update=project_specific.store,
+    )
 
     flamenco_manager = PointerProperty(type=flamenco.FlamencoManagerGroup)
-    # TODO: before making Flamenco public, change the defaults to something less Institute-specific.
+    flamenco_exclude_filter = StringProperty(
-    # NOTE: The assumption is that the workers can also find the files in the same path.
+        name='File Exclude Filter',
-    #       This assumption is true for the Blender Institute.
+        description='Filter like "*.abc;*.mkv" to prevent certain files to be packed '
+                    'into the output directory',
+        default='',
+        update=project_specific.store,
+    )
     flamenco_job_file_path = StringProperty(
-        name='Job File Path',
+        name='Job Storage Path',
         description='Path where to store job files, should be accesible for Workers too',
         subtype='DIR_PATH',
-        default='/render/_flamenco/storage')
+        default=tempfile.gettempdir(),
-
+        update=project_specific.store,
-    # TODO: before making Flamenco public, change the defaults to something less Institute-specific.
+    )
     flamenco_job_output_path = StringProperty(
         name='Job Output Path',
         description='Path where to store output files, should be accessible for Workers',
         subtype='DIR_PATH',
-        default='/render/_flamenco/output')
+        default=tempfile.gettempdir(),
+        update=project_specific.store,
+    )
     flamenco_job_output_strip_components = IntProperty(
         name='Job Output Path Strip Components',
         description='The final output path comprises of the job output path, and the blend file '
@@ -251,11 +234,12 @@ class BlenderCloudPreferences(AddonPreferences):
         min=0,
         default=0,
         soft_max=4,
+        update=project_specific.store,
     )
     flamenco_open_browser_after_submit = BoolProperty(
         name='Open Browser after Submitting Job',
         description='When enabled, Blender will open a webbrowser',
-        default=True
+        default=True,
     )
 
     def draw(self, context):
@@ -345,11 +329,6 @@ class BlenderCloudPreferences(AddonPreferences):
         self.draw_project_selector(project_box, self.project)
         extensions = project_extensions(self.project.project)
 
-        # Attract stuff
-        if 'attract' in extensions:
-            attract_box = project_box.column()
-            self.draw_attract_buttons(attract_box, self.project)
-
         # Flamenco stuff
         if 'flamenco' in extensions:
             flamenco_box = project_box.column()
@@ -407,28 +386,37 @@ class BlenderCloudPreferences(AddonPreferences):
                 row_buttons.operator('pillar.projects',
                                      text='',
                                      icon='FILE_REFRESH')
+                props = row_buttons.operator('pillar.project_open_in_browser',
+                                             text='',
+                                             icon='WORLD')
+                props.project_id = project
         else:
             row_buttons.label('Fetching available projects.')
 
         enabled_for = project_extensions(project)
-        if project:
+        if not project:
-            if enabled_for:
+            return
+
+        if not enabled_for:
+            project_box.label('This project is not set up for Attract or Flamenco')
+            return
+
         project_box.label('This project is set up for: %s' %
                           ', '.join(sorted(enabled_for)))
-            else:
-                project_box.label('This project is not set up for Attract or Flamenco')
 
-    def draw_attract_buttons(self, attract_box, bcp: BlenderCloudProjectGroup):
+        # This is only needed when the project is set up for either Attract or Flamenco.
-        header_row = attract_box.row(align=True)
+        project_box.prop(self, 'cloud_project_local_path',
-        header_row.label('Attract:', icon_value=icon('CLOUD'))
+                         text='Local Cloud Project Path')
-        attract_box.prop(self, 'attract_project_local_path',
-                         text='Local Attract project path')
 
     def draw_flamenco_buttons(self, flamenco_box, bcp: flamenco.FlamencoManagerGroup, context):
+        from .flamenco import bam_interface
+
         header_row = flamenco_box.row(align=True)
         header_row.label('Flamenco:', icon_value=icon('CLOUD'))
 
-        manager_box = flamenco_box.row(align=True)
+        manager_split = flamenco_box.split(0.32, align=True)
+        manager_split.label('Manager:')
+        manager_box = manager_split.row(align=True)
 
         if bcp.status in {'NONE', 'IDLE'}:
             if not bcp.available_managers or not bcp.manager:
@@ -436,26 +424,32 @@ class BlenderCloudPreferences(AddonPreferences):
                                      text='Find Flamenco Managers',
                                      icon='FILE_REFRESH')
             else:
-                manager_box.prop(bcp, 'manager', text='Manager')
+                manager_box.prop(bcp, 'manager', text='')
                 manager_box.operator('flamenco.managers',
                                      text='',
                                      icon='FILE_REFRESH')
         else:
             manager_box.label('Fetching available managers.')
 
-        path_box = flamenco_box.row(align=True)
+        path_split = flamenco_box.split(0.32, align=True)
-        path_box.prop(self, 'flamenco_job_file_path')
+        path_split.label(text='Job File Path:')
+        path_box = path_split.row(align=True)
+        path_box.prop(self, 'flamenco_job_file_path', text='')
         props = path_box.operator('flamenco.explore_file_path', text='', icon='DISK_DRIVE')
         props.path = self.flamenco_job_file_path
 
         job_output_box = flamenco_box.column(align=True)
-        path_box = job_output_box.row(align=True)
+        path_split = job_output_box.split(0.32, align=True)
-        path_box.prop(self, 'flamenco_job_output_path')
+        path_split.label(text='Job Output Path:')
+        path_box = path_split.row(align=True)
+        path_box.prop(self, 'flamenco_job_output_path', text='')
         props = path_box.operator('flamenco.explore_file_path', text='', icon='DISK_DRIVE')
         props.path = self.flamenco_job_output_path
+        job_output_box.prop(self, 'flamenco_exclude_filter')
 
-        job_output_box.prop(self, 'flamenco_job_output_strip_components',
+        prop_split = job_output_box.split(0.32, align=True)
-                            text='Strip Components')
+        prop_split.label('Strip Components:')
+        prop_split.prop(self, 'flamenco_job_output_strip_components', text='')
 
         from .flamenco import render_output_path
 
@@ -535,6 +529,36 @@ class PILLAR_OT_subscribe(Operator):
         return {'FINISHED'}
 
 
+class PILLAR_OT_project_open_in_browser(Operator):
+    bl_idname = 'pillar.project_open_in_browser'
+    bl_label = 'Open in Browser'
+    bl_description = 'Opens a webbrowser to show the project'
+
+    project_id = StringProperty(name='Project ID')
+
+    def execute(self, context):
+        if not self.project_id:
+            return {'CANCELLED'}
+
+        import webbrowser
+        import urllib.parse
+
+        import pillarsdk
+        from .pillar import sync_call
+
+        project = sync_call(pillarsdk.Project.find, self.project_id, {'projection': {'url': True}})
+
+        if log.isEnabledFor(logging.DEBUG):
+            import pprint
+            log.debug('found project: %s', pprint.pformat(project.to_dict()))
+
+        url = urllib.parse.urljoin(PILLAR_WEB_SERVER_URL, 'p/' + project.url)
+        webbrowser.open_new_tab(url)
+        self.report({'INFO'}, 'Opened a browser at %s' % url)
+
+        return {'FINISHED'}
+
+
 class PILLAR_OT_projects(async_loop.AsyncModalOperatorMixin,
                          pillar.AuthenticatedPillarOperatorMixin,
                          Operator):
@@ -561,7 +585,7 @@ class PILLAR_OT_projects(async_loop.AsyncModalOperatorMixin,
             pillarsdk.Project.all,
             {'where': {'user': self.user_id,
                        'category': {'$ne': 'home'}},
-             'sort': '-_created',
+             'sort': '-name',
              'projection': {'_id': True,
                             'name': True,
                             'extension_props': True},
@@ -571,7 +595,7 @@ class PILLAR_OT_projects(async_loop.AsyncModalOperatorMixin,
             pillarsdk.Project.all,
             {'where': {'user': {'$ne': self.user_id},
                        'permissions.groups.group': {'$in': self.db_user.groups}},
-             'sort': '-_created',
+             'sort': '-name',
              'projection': {'_id': True,
                             'name': True,
                             'extension_props': True},
@@ -595,7 +619,10 @@ class PILLAR_OT_projects(async_loop.AsyncModalOperatorMixin,
         projects = list(reduce_properties(projects_user['_items'])) + \
                    list(reduce_properties(projects_shared['_items']))
 
-        preferences().project.available_projects = projects
+        def proj_sort_key(project):
+            return project.get('name')
+
+        preferences().project.available_projects = sorted(projects, key=proj_sort_key)
 
         self.quit()
 
@@ -659,6 +686,7 @@ def register():
     bpy.utils.register_class(SyncStatusProperties)
     bpy.utils.register_class(PILLAR_OT_subscribe)
     bpy.utils.register_class(PILLAR_OT_projects)
+    bpy.utils.register_class(PILLAR_OT_project_open_in_browser)
     bpy.utils.register_class(PILLAR_PT_image_custom_properties)
 
     addon_prefs = preferences()
@@ -693,6 +721,7 @@ def unregister():
     bpy.utils.unregister_class(SyncStatusProperties)
     bpy.utils.unregister_class(PILLAR_OT_subscribe)
     bpy.utils.unregister_class(PILLAR_OT_projects)
+    bpy.utils.unregister_class(PILLAR_OT_project_open_in_browser)
     bpy.utils.unregister_class(PILLAR_PT_image_custom_properties)
 
     del WindowManager.last_blender_cloud_location

blender_cloud/flamenco/__init__.py

@@ -20,16 +20,29 @@
 
 The preferences are managed blender.py, the rest of the Flamenco-specific stuff is here.
 """
+
 import functools
 import logging
+import os
 from pathlib import Path, PurePath
 import typing
 
+if "bpy" in locals():
+    import importlib
+
+    try:
+        bam_interface = importlib.reload(bam_interface)
+        sdk = importlib.reload(sdk)
+    except NameError:
+        from . import bam_interface, sdk
+else:
+    from . import bam_interface, sdk
+
 import bpy
 from bpy.types import AddonPreferences, Operator, WindowManager, Scene, PropertyGroup
 from bpy.props import StringProperty, EnumProperty, PointerProperty, BoolProperty, IntProperty
 
-from .. import async_loop, pillar
+from .. import async_loop, pillar, project_specific
 from ..utils import pyside_cache, redraw
 
 log = logging.getLogger(__name__)
@@ -54,7 +67,9 @@ class FlamencoManagerGroup(PropertyGroup):
     manager = EnumProperty(
         items=available_managers,
         name='Flamenco Manager',
-        description='Which Flamenco Manager to use for jobs')
+        description='Which Flamenco Manager to use for jobs',
+        update=project_specific.store,
+    )
 
     status = EnumProperty(
         items=[
@@ -136,9 +151,20 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
     log = logging.getLogger('%s.FLAMENCO_OT_render' % __name__)
 
     async def async_execute(self, context):
+        # Refuse to start if the file hasn't been saved. It's okay if
+        # it's dirty, but we do need a filename and a location.
+        if not os.path.exists(context.blend_data.filepath):
+            self.report({'ERROR'}, 'Please save your Blend file before using '
+                                   'the Blender Cloud addon.')
+            self.quit()
+            return
+
         if not await self.authenticate(context):
             return
 
+        import pillarsdk.exceptions
+        from .sdk import Manager
+        from ..pillar import pillar_call
         from ..blender import preferences
 
         scene = context.scene
@@ -160,15 +186,28 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
         if not outfile:
             return
 
-        # Create the job at Flamenco Server.
+        # Fetch Manager for doing path replacement.
+        self.log.info('Going to fetch manager %s', self.user_id)
         prefs = preferences()
 
+        manager_id = prefs.flamenco_manager.manager
+        try:
+            manager = await pillar_call(Manager.find, manager_id)
+        except pillarsdk.exceptions.ResourceNotFound:
+            self.report({'ERROR'}, 'Manager %s not found, refresh your managers in '
+                                   'the Blender Cloud add-on settings.' % manager_id)
+            self.quit()
+            return
+
+        # Create the job at Flamenco Server.
         context.window_manager.flamenco_status = 'COMMUNICATING'
+
+        frame_range = scene.flamenco_render_frame_range.strip() or scene_frame_range(context)
         settings = {'blender_cmd': '{blender}',
                     'chunk_size': scene.flamenco_render_fchunk_size,
-                    'filepath': str(outfile),
+                    'filepath': manager.replace_path(outfile),
-                    'frames': scene.flamenco_render_frame_range,
+                    'frames': frame_range,
-                    'render_output': str(render_output),
+                    'render_output': manager.replace_path(render_output),
                     }
 
         # Add extra settings specific to the job type
@@ -188,7 +227,7 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
         try:
             job_info = await create_job(self.user_id,
                                         prefs.project.project,
-                                        prefs.flamenco_manager.manager,
+                                        manager_id,
                                         scene.flamenco_render_job_type,
                                         settings,
                                         'Render %s' % filepath.name,
@@ -287,7 +326,6 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
 
         from datetime import datetime
         from ..blender import preferences
-        from . import bam_interface
 
         prefs = preferences()
 
@@ -300,6 +338,8 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
         outdir = Path(prefs.flamenco_job_file_path) / unique_dir
         outfile = outdir / filepath.name
 
+        exclusion_filter = prefs.flamenco_exclude_filter or None
+
         try:
             outdir.mkdir(parents=True)
         except Exception as ex:
@@ -309,7 +349,7 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
             return None, []
 
         try:
-            missing_sources = await bam_interface.bam_copy(filepath, outfile)
+            missing_sources = await bam_interface.bam_copy(filepath, outfile, exclusion_filter)
         except bam_interface.CommandExecutionError as ex:
             self.log.exception('Unable to execute BAM pack')
             self.report({'ERROR'}, 'Unable to execute BAM pack: %s' % ex)
@@ -319,6 +359,13 @@ class FLAMENCO_OT_render(async_loop.AsyncModalOperatorMixin,
         return outfile, missing_sources
 
 
+def scene_frame_range(context) -> str:
+    """Returns the frame range string for the current scene."""
+
+    s = context.scene
+    return '%i-%i' % (s.frame_start, s.frame_end)
+
+
 class FLAMENCO_OT_scene_to_frame_range(FlamencoPollMixin, Operator):
     """Sets the scene frame range as the Flamenco render frame range."""
     bl_idname = 'flamenco.scene_to_frame_range'
@@ -326,8 +373,7 @@ class FLAMENCO_OT_scene_to_frame_range(FlamencoPollMixin, Operator):
     bl_description = __doc__.rstrip('.')
 
     def execute(self, context):
-        s = context.scene
+        context.scene.flamenco_render_frame_range = scene_frame_range(context)
-        s.flamenco_render_frame_range = '%i-%i' % (s.frame_start, s.frame_end)
         return {'FINISHED'}
 
 
@@ -343,14 +389,15 @@ class FLAMENCO_OT_copy_files(Operator,
 
     async def async_execute(self, context):
         from pathlib import Path
-        from . import bam_interface
         from ..blender import preferences
 
         context.window_manager.flamenco_status = 'PACKING'
+        exclusion_filter = preferences().flamenco_exclude_filter or None
 
         missing_sources = await bam_interface.bam_copy(
             Path(context.blend_data.filepath),
             Path(preferences().flamenco_job_file_path),
+            exclusion_filter
         )
 
         if missing_sources:
@@ -407,6 +454,30 @@ class FLAMENCO_OT_explore_file_path(FlamencoPollMixin,
         return {'FINISHED'}
 
 
+class FLAMENCO_OT_enable_output_path_override(Operator):
+    """Enables the 'override output path' setting."""
+
+    bl_idname = 'flamenco.enable_output_path_override'
+    bl_label = 'Enable Overriding of Output Path'
+    bl_description = 'Click to specify a non-default Output Path for this particular job'
+
+    def execute(self, context):
+        context.scene.flamenco_do_override_output_path = True
+        return {'FINISHED'}
+
+
+class FLAMENCO_OT_disable_output_path_override(Operator):
+    """Disables the 'override output path' setting."""
+
+    bl_idname = 'flamenco.disable_output_path_override'
+    bl_label = 'disable Overriding of Output Path'
+    bl_description = 'Click to use the default Output Path'
+
+    def execute(self, context):
+        context.scene.flamenco_do_override_output_path = False
+        return {'FINISHED'}
+
+
 async def create_job(user_id: str,
                      project_id: str,
                      manager_id: str,
@@ -461,6 +532,7 @@ def _render_output_path(
         flamenco_job_output_path: str,
         render_image_format: str,
         flamenco_render_frame_range: str,
+        include_rel_path: bool = True,
 ) -> typing.Optional[PurePath]:
     """Cached version of render_output_path()
 
@@ -475,12 +547,17 @@ def _render_output_path(
         return None
 
     try:
-        proj_rel = blend_filepath.parent.relative_to(project_path)
+        blend_abspath = blend_filepath.resolve().absolute()
+    except FileNotFoundError:
+        # Path.resolve() will raise a FileNotFoundError if the path doesn't exist.
+        return None
+
+    try:
+        proj_rel = blend_abspath.parent.relative_to(project_path)
     except ValueError:
         return None
 
-    rel_parts = proj_rel.parts[flamenco_job_output_strip_components:]
+    output_top = PurePath(flamenco_job_output_path)
-    output_top = Path(flamenco_job_output_path)
 
     # Strip off '.flamenco' too; we use 'xxx.flamenco.blend' as job file, but
     # don't want to have all the output paths ending in '.flamenco'.
@@ -488,7 +565,11 @@ def _render_output_path(
     if stem.endswith('.flamenco'):
         stem = stem[:-9]
 
+    if include_rel_path:
+        rel_parts = proj_rel.parts[flamenco_job_output_strip_components:]
         dir_components = output_top.joinpath(*rel_parts) / stem
+    else:
+        dir_components = output_top
 
     # Blender will have to append the file extensions by itself.
     if is_image_type(render_image_format):
@@ -513,13 +594,19 @@ def render_output_path(context, filepath: Path = None) -> typing.Optional[PurePa
     if filepath is None:
         filepath = Path(context.blend_data.filepath)
 
+    if scene.flamenco_do_override_output_path:
+        job_output_path = scene.flamenco_override_output_path
+    else:
+        job_output_path = prefs.flamenco_job_output_path
+
     return _render_output_path(
-        prefs.attract_project_local_path,
+        prefs.cloud_project_local_path,
         filepath,
         prefs.flamenco_job_output_strip_components,
-        prefs.flamenco_job_output_path,
+        job_output_path,
         scene.render.image_settings.file_format,
         scene.flamenco_render_frame_range,
+        include_rel_path=not scene.flamenco_do_override_output_path,
     )
 
 
@@ -553,8 +640,9 @@ class FLAMENCO_PT_render(bpy.types.Panel, FlamencoPollMixin):
         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)
+        paths_layout = layout.column(align=True)
-        labeled_row = readonly_stuff.split(0.25, align=True)
+
+        labeled_row = paths_layout.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)
@@ -562,19 +650,33 @@ class FLAMENCO_PT_render(bpy.types.Panel, FlamencoPollMixin):
                                       text='', icon='DISK_DRIVE')
         props.path = prefs.flamenco_job_file_path
 
-        labeled_row = readonly_stuff.split(0.25, align=True)
+        render_output = render_output_path(context)
+        if render_output is None:
+            paths_layout.label('Unable to render with Flamenco, outside of project directory.')
+        else:
+            labeled_row = paths_layout.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:
+            if context.scene.flamenco_do_override_output_path:
-            prop_btn_row.label('Unable to render with Flamenco, outside of project directory.')
+                prop_btn_row.prop(context.scene, 'flamenco_override_output_path', text='')
+                op = FLAMENCO_OT_disable_output_path_override.bl_idname
+                icon = 'X'
             else:
                 prop_btn_row.label(str(render_output))
+                op = FLAMENCO_OT_enable_output_path_override.bl_idname
+                icon = 'GREASEPENCIL'
+            prop_btn_row.operator(op, icon=icon, text='')
+
             props = prop_btn_row.operator(FLAMENCO_OT_explore_file_path.bl_idname,
                                           text='', icon='DISK_DRIVE')
             props.path = str(render_output.parent)
 
+            if context.scene.flamenco_do_override_output_path:
+                labeled_row = paths_layout.split(0.25, align=True)
+                labeled_row.label('Effective Output Path:')
+                labeled_row.label(str(render_output))
+
             flamenco_status = context.window_manager.flamenco_status
             if flamenco_status == 'IDLE':
                 layout.operator(FLAMENCO_OT_render.bl_idname,
@@ -594,6 +696,7 @@ def activate():
     global flamenco_is_active
     log.info('Activating Flamenco')
     flamenco_is_active = True
+    _render_output_path.cache_clear()
 
 
 def deactivate():
@@ -602,6 +705,23 @@ def deactivate():
     global flamenco_is_active
     log.info('Deactivating Flamenco')
     flamenco_is_active = False
+    _render_output_path.cache_clear()
+
+
+def flamenco_do_override_output_path_updated(scene, context):
+    """Set the override paths to the default, if not yet set."""
+
+    # Only set a default when enabling the override.
+    if not scene.flamenco_do_override_output_path:
+        return
+
+    # Don't overwrite existing setting.
+    if scene.flamenco_override_output_path:
+        return
+
+    from ..blender import preferences
+    scene.flamenco_override_output_path = preferences().flamenco_job_output_path
+    log.info('Setting Override Output Path to %s', scene.flamenco_override_output_path)
 
 
 def register():
@@ -613,6 +733,8 @@ def register():
     bpy.utils.register_class(FLAMENCO_OT_scene_to_frame_range)
     bpy.utils.register_class(FLAMENCO_OT_copy_files)
     bpy.utils.register_class(FLAMENCO_OT_explore_file_path)
+    bpy.utils.register_class(FLAMENCO_OT_enable_output_path_override)
+    bpy.utils.register_class(FLAMENCO_OT_disable_output_path_override)
     bpy.utils.register_class(FLAMENCO_PT_render)
 
     scene = bpy.types.Scene
@@ -650,6 +772,19 @@ def register():
         description='Higher numbers mean higher priority'
     )
 
+    scene.flamenco_do_override_output_path = BoolProperty(
+        name='Override Output Path for this Job',
+        description='When enabled, allows you to specify a non-default Output path '
+                    'for this particular job',
+        default=False,
+        update=flamenco_do_override_output_path_updated
+    )
+    scene.flamenco_override_output_path = StringProperty(
+        name='Override Output Path',
+        description='Path where to store output files, should be accessible for Workers',
+        subtype='DIR_PATH',
+        default='')
+
     bpy.types.WindowManager.flamenco_status = EnumProperty(
         items=[
             ('IDLE', 'IDLE', 'Not doing anything.'),
@@ -686,6 +821,14 @@ def unregister():
         del bpy.types.Scene.flamenco_render_job_priority
     except AttributeError:
         pass
+    try:
+        del bpy.types.Scene.flamenco_do_override_output_path
+    except AttributeError:
+        pass
+    try:
+        del bpy.types.Scene.flamenco_override_output_path
+    except AttributeError:
+        pass
     try:
         del bpy.types.WindowManager.flamenco_status
     except AttributeError:

blender_cloud/flamenco/bam_interface.py

@@ -14,7 +14,30 @@ class CommandExecutionError(Exception):
     pass
 
 
-async def bam_copy(base_blendfile: Path, target_blendfile: Path) -> typing.List[Path]:
+def wheel_pythonpath_278() -> str:
+    """Returns the value of a PYTHONPATH environment variable needed to run BAM from its wheel file.
+
+    Workaround for Blender 2.78c not having io_blend_utils.pythonpath()
+    """
+
+    import os
+    from ..wheels import wheel_filename
+
+    # Find the wheel to run.
+    wheelpath = wheel_filename('blender_bam')
+
+    log.info('Using wheel %s to run BAM-Pack', wheelpath)
+
+    # Update the PYTHONPATH to include that wheel.
+    existing_pypath = os.environ.get('PYTHONPATH', '')
+    if existing_pypath:
+        return os.pathsep.join((existing_pypath, wheelpath))
+
+    return wheelpath
+
+
+async def bam_copy(base_blendfile: Path, target_blendfile: Path,
+                   exclusion_filter: str) -> typing.List[Path]:
     """Uses BAM to copy the given file and dependencies to the target blendfile.
 
     Due to the way blendfile_pack.py is programmed/structured, we cannot import it
@@ -27,6 +50,7 @@ async def bam_copy(base_blendfile: Path, target_blendfile: Path) -> typing.List[
     """
 
     import asyncio
+    import os
     import shlex
     import subprocess
 
@@ -41,12 +65,29 @@ async def bam_copy(base_blendfile: Path, target_blendfile: Path) -> typing.List[
         '--mode', 'FILE',
     ]
 
+    if exclusion_filter:
+        args.extend(['--exclude', exclusion_filter])
+
     cmd_to_log = ' '.join(shlex.quote(s) for s in args)
     log.info('Executing %s', cmd_to_log)
 
+    # Workaround for Blender 2.78c not having io_blend_utils.pythonpath()
+    if hasattr(io_blend_utils, 'pythonpath'):
+        pythonpath = io_blend_utils.pythonpath()
+    else:
+        pythonpath = wheel_pythonpath_278()
+
+    env = {
+        'PYTHONPATH': pythonpath,
+        # Needed on Windows because http://bugs.python.org/issue8557
+        'PATH': os.environ['PATH'],
+    }
+    if 'SYSTEMROOT' in os.environ:  # Windows http://bugs.python.org/issue20614
+        env['SYSTEMROOT'] = os.environ['SYSTEMROOT']
+
     proc = await asyncio.create_subprocess_exec(
         *args,
-        env={'PYTHONPATH': io_blend_utils.pythonpath()},
+        env=env,
         stdin=subprocess.DEVNULL,
         stdout=subprocess.PIPE,
         stderr=subprocess.STDOUT,

blender_cloud/flamenco/sdk.py

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

blender_cloud/image_sharing.py

@@ -112,6 +112,10 @@ class PILLAR_OT_image_share(pillar.PillarOperatorMixin,
     async def async_execute(self, context):
         """Entry point of the asynchronous operator."""
 
+        # We don't want to influence what is included in the screen shot.
+        if self.target == 'SCREENSHOT':
+            print('Blender Cloud add-on is communicating with Blender Cloud')
+        else:
             self.report({'INFO'}, 'Communicating with Blender Cloud')
 
         try:
@@ -120,9 +124,8 @@ class PILLAR_OT_image_share(pillar.PillarOperatorMixin,
                 db_user = await self.check_credentials(context, REQUIRES_ROLES_FOR_IMAGE_SHARING)
                 self.user_id = db_user['_id']
                 self.log.debug('Found user ID: %s', self.user_id)
-            except pillar.NotSubscribedToCloudError:
+            except pillar.NotSubscribedToCloudError as ex:
-                self.log.exception('User not subscribed to cloud.')
+                self._log_subscription_needed(can_renew=ex.can_renew)
-                self.report({'ERROR'}, 'Please subscribe to the Blender Cloud.')
                 self._state = 'QUIT'
                 return
             except pillar.UserNotLoggedInError:

blender_cloud/pillar.py

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

blender_cloud/project_specific.py

@@ -0,0 +1,101 @@
+"""Handle saving and loading project-specific settings."""
+
+import logging
+
+# Names of BlenderCloudPreferences properties that are both project-specific
+# and simple enough to store directly in a dict.
+PROJECT_SPECIFIC_SIMPLE_PROPS = (
+    'cloud_project_local_path',
+    'flamenco_exclude_filter',
+    'flamenco_job_file_path',
+    'flamenco_job_output_path',
+    'flamenco_job_output_strip_components'
+)
+
+log = logging.getLogger(__name__)
+project_settings_loading = False
+
+
+def handle_project_update(_=None, _2=None):
+    """Handles changing projects, which may cause extensions to be disabled/enabled.
+
+    Ignores arguments so that it can be used as property update callback.
+    """
+
+    from .blender import preferences, project_extensions
+
+    global project_settings_loading
+    project_settings_loading = True
+    try:
+        prefs = preferences()
+        project_id = prefs.project.project
+        log.info('Updating internal state to reflect extensions enabled on current project %s.',
+                 project_id)
+
+        project_extensions.cache_clear()
+
+        from blender_cloud import attract, flamenco
+        attract.deactivate()
+        flamenco.deactivate()
+
+        enabled_for = project_extensions(project_id)
+        log.info('Project extensions: %s', enabled_for)
+        if 'attract' in enabled_for:
+            attract.activate()
+        if 'flamenco' in enabled_for:
+            flamenco.activate()
+
+        # Load project-specific settings from the last time we visited this project.
+        ps = prefs.get('project_settings', {}).get(project_id, {})
+        if not ps:
+            log.debug('no project-specific settings are available, not touching options')
+            return
+
+        if log.isEnabledFor(logging.DEBUG):
+            from pprint import pformat
+            log.debug('loading project-specific settings:\n%s', pformat(ps.to_dict()))
+
+        for name in PROJECT_SPECIFIC_SIMPLE_PROPS:
+            if name in ps and hasattr(prefs, name):
+                setattr(prefs, name, ps[name])
+        if ps.get('flamenco_manager'):
+            prefs.flamenco_manager.manager = ps['flamenco_manager']
+            log.debug('setting flamenco manager to %s', ps['flamenco_manager'])
+
+    finally:
+        project_settings_loading = False
+
+
+def store(_=None, _2=None):
+    """Remember project-specific settings as soon as one of them changes.
+
+    Ignores arguments so that it can be used as property update callback.
+
+    No-op when project_settings_loading=True, to prevent saving project-
+    specific settings while they are actually being loaded.
+    """
+    from .blender import preferences
+
+    global project_settings_loading
+    if project_settings_loading:
+        return
+
+    prefs = preferences()
+    project_id = prefs.project.project
+    all_settings = prefs.get('project_settings', {})
+    ps = all_settings.get(project_id, {})
+
+    for name in PROJECT_SPECIFIC_SIMPLE_PROPS:
+        ps[name] = getattr(prefs, name)
+    ps['flamenco_manager'] = prefs.flamenco_manager.manager
+
+    if log.isEnabledFor(logging.DEBUG):
+        from pprint import pformat
+        if hasattr(ps, 'to_dict'):
+            ps_to_log = ps.to_dict()
+        else:
+            ps_to_log = ps
+        log.debug('saving project-specific settings:\n%s', pformat(ps_to_log))
+
+    all_settings[project_id] = ps
+    prefs['project_settings'] = all_settings

blender_cloud/settings_sync.py

@@ -284,9 +284,8 @@ class PILLAR_OT_sync(pillar.PillarOperatorMixin,
                 db_user = await self.check_credentials(context, REQUIRES_ROLES_FOR_SYNC)
                 self.user_id = db_user['_id']
                 log.debug('Found user ID: %s', self.user_id)
-            except pillar.NotSubscribedToCloudError:
+            except pillar.NotSubscribedToCloudError as ex:
-                self.log.exception('User not subscribed to cloud.')
+                self._log_subscription_needed(can_renew=ex.can_renew)
-                self.bss_report({'SUBSCRIBE'}, 'Please subscribe to the Blender Cloud.')
                 self._state = 'QUIT'
                 return
             except pillar.UserNotLoggedInError:

blender_cloud/texture_browser.py

@@ -76,8 +76,8 @@ class MenuItem:
     icon_margin_y = 4
     text_margin_x = 6
 
-    text_height = 16
+    text_size = 12
-    text_width = 72
+    text_size_small = 10
 
     DEFAULT_ICONS = {
         'FOLDER': os.path.join(library_icons_path, 'folder.png'),
@@ -214,12 +214,32 @@ class MenuItem:
 
         # draw some text
         font_id = 0
-        blf.position(font_id,
+        text_dpi = bpy.context.user_preferences.system.dpi
-                     self.x + self.icon_margin_x + ICON_WIDTH + self.text_margin_x,
+        text_x = self.x + self.icon_margin_x + ICON_WIDTH + self.text_margin_x
-                     self.y + ICON_HEIGHT * 0.5 - 0.25 * self.text_height, 0)
+        text_y = self.y + ICON_HEIGHT * 0.5 - 0.25 * self.text_size
-        blf.size(font_id, self.text_height, self.text_width)
+        blf.position(font_id, text_x, text_y, 0)
+        blf.size(font_id, self.text_size, text_dpi)
         blf.draw(font_id, self.label_text)
 
+        # Draw the components of the texture (i.e. which map types are available)
+        try:
+            node_files = self.node.properties.files
+        except AttributeError:
+            # Happens for nodes that don't have .properties.files.
+            node_files = None
+        if not node_files:
+            return
+
+        map_types = {f.map_type for f in node_files if f.map_type}
+        map_types.discard('color')  # all textures have colour
+        if not map_types:
+            return
+
+        bgl.glColor4f(1.0, 1.0, 1.0, 0.5)
+        blf.size(font_id, self.text_size_small, text_dpi)
+        blf.position(font_id, text_x, self.y + 0.5 * self.text_size_small, 0)
+        blf.draw(font_id, ', '.join(sorted(map_types)))
+
     def hits(self, mouse_x: int, mouse_y: int) -> bool:
         return self.x < mouse_x < self.x + self.width and self.y < mouse_y < self.y + self.height
 
@@ -311,8 +331,8 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
             self.mouse_y = event.mouse_y
 
         left_mouse_release = event.type == 'LEFTMOUSE' and event.value == 'RELEASE'
-        if self._state == 'PLEASE_SUBSCRIBE' and left_mouse_release:
+        if left_mouse_release and self._state in {'PLEASE_SUBSCRIBE', 'PLEASE_RENEW'}:
-            self.open_browser_subscribe()
+            self.open_browser_subscribe(renew=self._state == 'PLEASE_RENEW')
             self._finish(context)
             return {'FINISHED'}
 
@@ -365,9 +385,9 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
 
         try:
             db_user = await self.check_credentials(context, REQUIRED_ROLES_FOR_TEXTURE_BROWSER)
-        except pillar.NotSubscribedToCloudError:
+        except pillar.NotSubscribedToCloudError as ex:
-            self.log.info('User not subscribed to Blender Cloud.')
+            self._log_subscription_needed(can_renew=ex.can_renew, level='INFO')
-            self._show_subscribe_screen()
+            self._show_subscribe_screen(can_renew=ex.can_renew)
             return None
 
         if db_user is None:
@@ -375,10 +395,14 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
 
         await self.async_download_previews()
 
-    def _show_subscribe_screen(self):
+    def _show_subscribe_screen(self, *, can_renew: bool):
         """Shows the "You need to subscribe" screen."""
 
+        if can_renew:
+            self._state = 'PLEASE_RENEW'
+        else:
             self._state = 'PLEASE_SUBSCRIBE'
+
         bpy.context.window.cursor_set('HAND')
 
     def descend_node(self, menu_item: MenuItem):
@@ -457,7 +481,7 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
 
         return menu_item
 
-    def update_menu_item(self, node, *args) -> MenuItem:
+    def update_menu_item(self, node, *args):
         node_uuid = node['_id']
 
         # Just make this thread-safe to be on the safe side.
@@ -538,6 +562,7 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
             self.add_menu_item(node, None, 'SPINNER', texture_node['name'])
 
         def thumbnail_loaded(node, file_desc, thumb_path):
+            self.log.debug('Node %s thumbnail loaded', node['_id'])
             self.update_menu_item(node, file_desc, thumb_path)
 
         await pillar.fetch_texture_thumbs(node_uuid, 's', directory,
@@ -547,6 +572,7 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
 
     def browse_assets(self):
         self.log.debug('Browsing assets at %r', self.current_path)
+        bpy.context.window_manager.last_blender_cloud_location = str(self.current_path)
         self._new_async_task(self.async_download_previews())
 
     def draw_menu(self, context):
@@ -559,6 +585,7 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
             'DOWNLOADING_TEXTURE': self._draw_downloading,
             'EXCEPTION': self._draw_exception,
             'PLEASE_SUBSCRIBE': self._draw_subscribe,
+            'PLEASE_RENEW': self._draw_renew,
         }
 
         if self._state in drawers:
@@ -726,6 +753,11 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
                                   'Click to subscribe to the Blender Cloud',
                                   (0.0, 0.0, 0.2, 0.6))
 
+    def _draw_renew(self, context):
+        self._draw_text_on_colour(context,
+                                  'Click to renew your Blender Cloud subscription',
+                                  (0.0, 0.0, 0.2, 0.6))
+
     def get_clicked(self) -> MenuItem:
 
         for item in self.current_display_content:
@@ -806,11 +838,11 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
                                                      future=signalling_future))
         self.async_task.add_done_callback(texture_download_completed)
 
-    def open_browser_subscribe(self):
+    def open_browser_subscribe(self, *, renew: bool):
         import webbrowser
 
-        webbrowser.open_new_tab('https://cloud.blender.org/join')
+        url = 'renew' if renew else 'join'
-
+        webbrowser.open_new_tab('https://cloud.blender.org/%s' % url)
         self.report({'INFO'}, 'We just started a browser for you.')
 
     def _scroll_smooth(self):
@@ -865,9 +897,8 @@ class PILLAR_OT_switch_hdri(pillar.PillarOperatorMixin,
             try:
                 db_user = await self.check_credentials(context, REQUIRED_ROLES_FOR_TEXTURE_BROWSER)
                 user_id = db_user['_id']
-            except pillar.NotSubscribedToCloudError:
+            except pillar.NotSubscribedToCloudError as ex:
-                self.log.exception('User not subscribed to cloud.')
+                self._log_subscription_needed(can_renew=ex.can_renew)
-                self.report({'ERROR'}, 'Please subscribe to the Blender Cloud.')
                 self._state = 'QUIT'
                 return
             except pillar.UserNotLoggedInError:

blender_cloud/wheels/__init__.py

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

requirements.txt

@@ -3,13 +3,15 @@
 lockfile==0.12.2
 pillarsdk==1.6.1
 wheel==0.29.0
+blender-bam==1.1.7
 
 # Secondary requirements:
-cffi==1.6.0
+asn1crypto==0.24.0
-cryptography==1.3.1
+cffi==1.11.2
-idna==2.1
+cryptography==2.1.4
+idna==2.6
 pyasn1==0.1.9
-pycparser==2.14
+pycparser==2.18
-pyOpenSSL==16.0.0
+pyOpenSSL==17.5.0
 requests==2.10.0
-six==1.10.0
+six==1.11.0

setup.py

@@ -101,6 +101,11 @@ class BuildWheels(Command):
             log.info('Downloading Pillar Python SDK wheel')
             self.download_wheel(requirements['pillarsdk'])
 
+        # Download BAM from pypi. This is required for compatibility with Blender 2.78.
+        if not list(self.wheels_path.glob('blender_bam*.whl')):
+            log.info('Downloading BAM wheel')
+            self.download_wheel(requirements['blender-bam'])
+
         # Build CacheControl.
         if not list(self.wheels_path.glob('CacheControl*.whl')):
             log.info('Building CacheControl in %s', self.cachecontrol_path)
@@ -227,11 +232,11 @@ setup(
               'wheels': BuildWheels},
     name='blender_cloud',
     description='The Blender Cloud addon allows browsing the Blender Cloud from Blender.',
-    version='1.6.2',
+    version='1.8.0',
     author='Sybren A. Stüvel',
     author_email='sybren@stuvel.eu',
     packages=find_packages('.'),
-    data_files=[('blender_cloud', ['README.md', 'README-flamenco.md']),
+    data_files=[('blender_cloud', ['README.md', 'README-flamenco.md', 'CHANGELOG.md']),
                 ('blender_cloud/icons', glob.glob('blender_cloud/icons/*'))],
     scripts=[],
     url='https://developer.blender.org/diffusion/BCA/',

tests/test_path_replacement.py

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

update_version.sh

@@ -1,15 +1,19 @@
 #!/bin/bash
 
-if [ -z "$1" ]; then
+VERSION="${1/version-}"
+
+if [ -z "$VERSION" ]; then
     echo "Usage: $0 new-version" >&2
     exit 1
 fi
 
-BL_INFO_VER=$(echo "$1" | sed 's/\./, /g')
+BL_INFO_VER=$(echo "$VERSION" | sed 's/\./, /g')
 
-sed "s/version='[^']*'/version='$1'/" -i setup.py
+sed "s/version='[^']*'/version='$VERSION'/" -i setup.py
 sed "s/'version': ([^)]*)/'version': ($BL_INFO_VER)/" -i blender_cloud/__init__.py
 
 git diff
 echo
-echo "Don't forget to commit!"
+echo "Don't forget to commit and tag:"
+echo git commit -m \'Bumped version to $VERSION\' setup.py blender_cloud/__init__.py
+echo git tag -a version-$VERSION -m \'Tagged version $VERSION\'