Merge Context Manager + Work Files (Fix #412)

avalon/fusion/workio.py

@@ -39,11 +39,10 @@ def current_file():
     return current_filepath
 
 
-def work_root():
-    from avalon import Session
+def work_root(session):
 
-    work_dir = Session["AVALON_WORKDIR"]
-    scene_dir = Session.get("AVALON_SCENEDIR")
+    work_dir = session["AVALON_WORKDIR"]
+    scene_dir = session.get("AVALON_SCENEDIR")
     if scene_dir:
         return os.path.join(work_dir, scene_dir)
     else:

avalon/houdini/workio.py

@@ -48,11 +48,10 @@ def current_file():
     return current_filepath
 
 
-def work_root():
-    from avalon import Session
+def work_root(session):
 
-    work_dir = Session["AVALON_WORKDIR"]
-    scene_dir = Session.get("AVALON_SCENEDIR")
+    work_dir = session["AVALON_WORKDIR"]
+    scene_dir = session.get("AVALON_SCENEDIR")
     if scene_dir:
         return os.path.join(work_dir, scene_dir)
     else:

avalon/maya/workio.py

@@ -30,10 +30,27 @@ def current_file():
     return current_filepath
 
 
-def work_root():
-
-    # Base the root on the current Maya workspace.
-    return os.path.join(
-        cmds.workspace(query=True, rootDirectory=True),
-        cmds.workspace(fileRuleEntry="scene")
-    )
+def work_root(session):
+    work_dir = session["AVALON_WORKDIR"]
+    scene_dir = None
+
+    # Query scene file rule from workspace.mel if it exists in WORKDIR
+    workspace_mel = os.path.join(work_dir, "workspace.mel")
+    if os.path.exists(workspace_mel):
+        scene_rule = 'workspace -fr "scene" '
+        # We need to use builtins as `open` is overridden by the workio API
+        open_file = __builtins__["open"]
+        with open_file(workspace_mel, "r") as f:
+            for line in f:
+                if line.strip().startswith(scene_rule):
+                    remainder = line[len(scene_rule):]      # == "rule";
+                    scene_dir = remainder.split('"')[1]     # == rule
+    else:
+        # We can't query a workspace that does not exist
+        # so we return similar to what we do in other hosts.
+        scene_dir = session.get("AVALON_SCENEDIR")
+
+    if scene_dir:
+        return os.path.join(work_dir, scene_dir)
+    else:
+        return work_dir

avalon/nuke/workio.py

@@ -42,6 +42,11 @@ def current_file():
     return os.path.normpath(current_file).replace("\\", "/")
 
 
-def work_root():
-    from avalon import Session
-    return os.path.normpath(Session["AVALON_WORKDIR"]).replace("\\", "/")
+def work_root(session):
+
+    if scene_dir:
+        path = os.path.join(work_dir, scene_dir)
+    else:
+        path = work_dir
+
+    return os.path.normpath(path).replace("\\", "/")

avalon/pipeline.py

@@ -926,61 +926,103 @@ def get_representation_context(representation):
     return context
 
 
-def update_current_task(task=None, asset=None, app=None):
-    """Update active Session to a new task work area.
+def compute_session_changes(session, task=None, asset=None, app=None):
+    """Compute the changes for a Session object on asset, task or app switch
 
-    This updates the live Session to a different `asset`, `task` or `app`.
+    This does *NOT* update the Session object, but returns the changes
+    required for a valid update of the Session.
 
     Args:
-        task (str): The task to set.
-        asset (str): The asset to set.
-        app (str): The app to set.
+        session (dict): The initial session to compute changes to.
+            This is required for computing the full Work Directory, as that
+            also depends on the values that haven't changed.
+        task (str, Optional): Name of task to switch to.
+        asset (str or dict, Optional): Name of asset to switch to.
+            You can also directly provide the Asset dictionary as returned
+            from the database to avoid an additional query. (optimization)
+        app (str, Optional): Name of app to switch to.
 
     Returns:
-        dict: The changed key, values in the current Session.
+        dict: The required changes in the Session dictionary.
 
     """
 
-    mapping = {
-        "AVALON_ASSET": asset,
-        "AVALON_TASK": task,
-        "AVALON_APP": app,
-    }
-    changed = {key: value for key, value in mapping.items() if value}
-    if not changed:
-        return
+    changes = dict()
 
-    # Update silo when asset changed
-    if "AVALON_ASSET" in changed:
-        asset_document = io.find_one({"name": changed["AVALON_ASSET"],
-                                      "type": "asset"})
-        assert asset_document, "Asset must exist"
-        changed["AVALON_SILO"] = asset_document["silo"]
+    # If no changes, return directly
+    if not any([task, asset, app]):
+        return changes
+
+    if task:
+        changes["AVALON_TASK"] = task
+
+    if app:
+        changes["AVALON_APP"] = app
+
+    # Update silo and hierarchy when asset changed
+    if asset:
+        if isinstance(asset, dict):
+            # Assume database document
+            asset_document = asset
+            asset = asset["name"]
+        else:
+            asset_document = io.find_one({"name": asset,
+                                          "type": "asset"})
+            assert asset_document, "Asset must exist"
+
+        changes["AVALON_ASSET"] = asset
+
+        # Update silo
+        changes["AVALON_SILO"] = asset_document["silo"]
+
+        # Update hierarchy
+        parents = asset_document['data'].get('parents', [])
+        hierarchy = ""
+        if len(parents) > 0:
+            hierarchy = os.path.sep.join(parents)
+        changes['AVALON_HIERARCHY'] = hierarchy
 
     # Compute work directory (with the temporary changed session so far)
     project = io.find_one({"type": "project"},
                           projection={"config.template.work": True})
     template = project["config"]["template"]["work"]
-    _session = Session.copy()
-    _session.update(changed)
-    changed["AVALON_WORKDIR"] = _format_work_template(template, _session)
+    _session = session.copy()
+    _session.update(changes)
+    changes["AVALON_WORKDIR"] = _format_work_template(template, _session)
+
+    return changes
+
+
+def update_current_task(task=None, asset=None, app=None):
+    """Update active Session to a new task work area.
+
+    This updates the live Session to a different `asset`, `task` or `app`.
+
+    Args:
+        task (str): The task to set.
+        asset (str): The asset to set.
+        app (str): The app to set.
+
+    Returns:
+        dict: The changed key, values in the current Session.
+
+    """
 
-    parents = asset_document['data'].get('parents', [])
-    hierarchy = ""
-    if len(parents) > 0:
-        hierarchy = os.path.sep.join(parents)
-    changed['AVALON_HIERARCHY'] = hierarchy
+    changes = compute_session_changes(Session,
+                                      task=task,
+                                      asset=asset,
+                                      app=app)
 
     # Update the full session in one go to avoid half updates
-    Session.update(changed)
+    Session.update(changes)
 
     # Update the environment
-    os.environ.update(changed)
+    os.environ.update(changes)
 
     # Emit session change
-    emit("taskChanged", changed.copy())
+    emit("taskChanged", changes.copy())
 
-    return changed
+    return changes
 
 
 def _format_work_template(template, session=None):

avalon/tools/widgets.py

@@ -120,6 +120,11 @@ def get_active_asset(self):
         current = self.view.currentIndex()
         return current.data(self.model.ObjectIdRole)
 
+    def get_active_asset_document(self):
+        """Return the asset id the current asset."""
+        current = self.view.currentIndex()
+        return current.data(self.model.DocumentRole)
+
     def get_active_index(self):
         return self.view.currentIndex()