Support scope_prefix parameter in link_views_by_dict (#325)

* Support scope_prefix parameter in link_views_by_dict

* Lint

* Remove unused import

* Exports

* Coverage

* Version bump

Author: keller-mark

.coveragerc_omit

@@ -6,6 +6,7 @@ omit =
     vitessce/widget.py
     vitessce/wrappers.py
     vitessce/repr.py
+    vitessce/utils.py
     vitessce/data_utils/anndata.py
     vitessce/data_utils/ome.py
     vitessce/data_utils/entities.py

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vitessce"
-version = "3.2.2"
+version = "3.2.3"
 authors = [
   { name="Mark Keller", email="[email protected]" },
 ]

tests/test_config.py

@@ -1402,3 +1402,115 @@ def test_config_link_views_by_dict():
         ],
         "initStrategy": "auto"
     }
+
+
+def test_config_link_views_by_dict_with_scope_prefix():
+    vc = VitessceConfig(schema_version="1.0.16", name="My config")
+    dataset = vc.add_dataset(name="My dataset")
+
+    spatial_view = vc.add_view('spatial', dataset=dataset)
+    lc_view = vc.add_view('layerController', dataset=dataset)
+
+    vc.link_views_by_dict([spatial_view, lc_view], {
+        'spatialImageLayer': CL([
+            {
+                'spatialLayerOpacity': 1,
+                'spatialImageChannel': CL([
+                    {
+                        'spatialTargetC': 0,
+                        'spatialChannelColor': [255, 0, 0],
+                    },
+                    {
+                        'spatialTargetC': 1,
+                        'spatialChannelColor': [0, 255, 0],
+                    },
+                ]),
+            },
+        ])
+    }, scope_prefix="SOME_PREFIX_")
+
+    vc_dict = vc.to_dict()
+
+    assert vc_dict == {
+        "version": "1.0.16",
+        "name": "My config",
+        "description": "",
+        "datasets": [
+            {
+                "uid": "A",
+                "name": "My dataset",
+                "files": []
+            }
+        ],
+        "coordinationSpace": {
+            "dataset": {
+                "A": "A"
+            },
+            "spatialImageLayer": {
+                "SOME_PREFIX_0": "__dummy__"
+            },
+            "spatialLayerOpacity": {
+                "SOME_PREFIX_0": 1,
+            },
+            "spatialImageChannel": {
+                "SOME_PREFIX_0": "__dummy__",
+                "SOME_PREFIX_1": "__dummy__"
+            },
+            "spatialTargetC": {
+                "SOME_PREFIX_0": 0,
+                "SOME_PREFIX_1": 1
+            },
+            "spatialChannelColor": {
+                "SOME_PREFIX_0": [255, 0, 0],
+                "SOME_PREFIX_1": [0, 255, 0],
+            },
+            "metaCoordinationScopes": {
+                "SOME_PREFIX_0": {
+                    "spatialImageLayer": ["SOME_PREFIX_0"]
+                }
+            },
+            "metaCoordinationScopesBy": {
+                "SOME_PREFIX_0": {
+                    "spatialImageLayer": {
+                        "spatialLayerOpacity": {
+                            "SOME_PREFIX_0": "SOME_PREFIX_0"
+                        },
+                        "spatialImageChannel": {
+                            "SOME_PREFIX_0": ["SOME_PREFIX_0", "SOME_PREFIX_1"]
+                        }
+                    },
+                    "spatialImageChannel": {
+                        "spatialTargetC": {
+                            "SOME_PREFIX_0": "SOME_PREFIX_0",
+                            "SOME_PREFIX_1": "SOME_PREFIX_1"
+                        },
+                        "spatialChannelColor": {
+                            "SOME_PREFIX_0": "SOME_PREFIX_0",
+                            "SOME_PREFIX_1": "SOME_PREFIX_1"
+                        }
+                    }
+                }
+            }
+        },
+        "layout": [
+            {
+                "component": "spatial",
+                "coordinationScopes": {
+                    "dataset": "A",
+                    "metaCoordinationScopes": ["SOME_PREFIX_0"],
+                    "metaCoordinationScopesBy": ["SOME_PREFIX_0"]
+                },
+                "x": 0, "y": 0, "w": 1, "h": 1
+            },
+            {
+                "component": "layerController",
+                "coordinationScopes": {
+                    "dataset": "A",
+                    "metaCoordinationScopes": ["SOME_PREFIX_0"],
+                    "metaCoordinationScopesBy": ["SOME_PREFIX_0"]
+                },
+                "x": 0, "y": 0, "w": 1, "h": 1
+            }
+        ],
+        "initStrategy": "auto"
+    }

vitessce/__init__.py

@@ -10,6 +10,11 @@
     CoordinationLevel,
 )
 
+from .utils import (
+    get_initial_coordination_scope_prefix,
+    get_initial_coordination_scope_name,
+)
+
 from .repr import make_repr
 
 from .constants import (

vitessce/config.py

@@ -12,6 +12,7 @@
 )
 
 from .repr import make_repr, make_params_repr
+from .utils import create_prefixed_get_next_scope_numeric
 
 
 def _get_next_scope(prev_scopes):
@@ -862,6 +863,8 @@ def __init__(self, schema_version, name=None, description=None, base_dir=None):
             "initStrategy": "auto"
         }
 
+        self.get_next_scope = _get_next_scope
+
         if name is None:
             self.config["name"] = ""
         else:
@@ -926,7 +929,7 @@ def add_dataset(self, name="", uid=None, files=None, objs=None):
                 )
             )
         """
-        uid = uid if uid is not None else _get_next_scope(
+        uid = uid if uid is not None else self.get_next_scope(
             [d.dataset['uid'] for d in self.config["datasets"]])
         assert isinstance(uid, str)
         vcd = VitessceConfigDataset(uid, name, base_dir=self.base_dir)
@@ -1099,7 +1102,7 @@ def add_coordination(self, *c_types):
             prev_scopes = list(self.config["coordinationSpace"][c_type_str].keys(
             )) if c_type_str in self.config["coordinationSpace"].keys() else []
             scope = VitessceConfigCoordinationScope(
-                c_type_str, _get_next_scope(prev_scopes))
+                c_type_str, self.get_next_scope(prev_scopes))
             if scope.c_type not in self.config["coordinationSpace"]:
                 self.config["coordinationSpace"][scope.c_type] = {}
             self.config["coordinationSpace"][scope.c_type][scope.c_scope] = scope
@@ -1138,8 +1141,8 @@ def add_meta_coordination(self):
         prev_meta_by_scopes = self.config["coordinationSpace"].get(ct.META_COORDINATION_SCOPES_BY.value, {}).keys()
 
         meta_container = VitessceConfigMetaCoordinationScope(
-            _get_next_scope(prev_meta_scopes),
-            _get_next_scope(prev_meta_by_scopes),
+            self.get_next_scope(prev_meta_scopes),
+            self.get_next_scope(prev_meta_by_scopes),
         )
         if ct.META_COORDINATION_SCOPES.value not in self.config["coordinationSpace"]:
             self.config["coordinationSpace"][ct.META_COORDINATION_SCOPES.value] = {}
@@ -1256,6 +1259,8 @@ def add_coordination_by_dict(self, input_val):
         """
         def process_level(level):
             result = {}
+            if level is None:
+                return result
             for c_type, next_level_or_initial_value in level.items():
                 c_type_str = norm_enum(c_type, ct)
                 # Check if value of object is instanceof CoordinationLevel
@@ -1295,7 +1300,7 @@ def map_func(next_el):
         output_val = process_level(input_val)
         return output_val
 
-    def link_views_by_dict(self, views, input_val, meta=True):
+    def link_views_by_dict(self, views, input_val, meta=True, scope_prefix=None):
         """
         A convenience function for setting up multi-level and meta-coordination scopes across a set of views.
 
@@ -1322,6 +1327,8 @@ def link_views_by_dict(self, views, input_val, meta=True):
                 ct.SPATIAL_TARGET_Y: 0,
             })
         """
+        if scope_prefix:
+            self.get_next_scope = create_prefixed_get_next_scope_numeric(scope_prefix)
         scopes = self.add_coordination_by_dict(input_val)
         if meta:
             meta_scope = self.add_meta_coordination()
@@ -1332,7 +1339,8 @@ def link_views_by_dict(self, views, input_val, meta=True):
         else:
             for view in views:
                 view.use_coordination_by_dict(scopes)
-
+        if scope_prefix:
+            self.get_next_scope = _get_next_scope
         return self
 
     def set_coordination_value(self, c_type, c_scope, c_value):

vitessce/utils.py

@@ -0,0 +1,35 @@
+def get_next_scope_numeric(prev_scopes):
+    next_scope_int = 0
+    next_scope_str = None
+
+    while True:
+        next_scope_str = str(next_scope_int)
+        if next_scope_str not in prev_scopes:
+            break
+        next_scope_int += 1
+    return next_scope_str
+
+
+def create_prefixed_get_next_scope_numeric(prefix):
+
+    def inner_get_next_scope(prev_scopes):
+        next_scope_int = 0
+        next_scope_str = None
+
+        while True:
+            next_scope_str = f"{prefix}{next_scope_int}"
+            if next_scope_str not in prev_scopes:
+                break
+            next_scope_int += 1
+        return next_scope_str
+
+    return inner_get_next_scope
+
+
+def get_initial_coordination_scope_prefix(dataset_uid, data_type):
+    return f"init_{dataset_uid}_{data_type}_"
+
+
+def get_initial_coordination_scope_name(dataset_uid, data_type, i=None):
+    prefix = get_initial_coordination_scope_prefix(dataset_uid, data_type)
+    return f"{prefix}{0 if i is None else i}"