Add get_display to get AnnotationDisplay (#46)

examples/Basics.ipynb

@@ -380,7 +380,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "annotator.delete_annotation('deadcafe', annotator.df.index[0]) # Example of deleting multiple annotations"
+    "annotator.delete_annotation(['deadcafe', annotator.df.index[0]]) # Example of deleting multiple annotations"
    ]
   },
   {

holonote/annotate/annotator.py

@@ -690,7 +690,7 @@ def __init__(self, spec: dict, **params):
         The spec argument must be an element or a dictionary of kdim dtypes
         """
 
-        self._elements = {}
+        self._displays = {}
 
         super().__init__(
             spec if isinstance(spec, dict) else self._infer_kdim_dtypes(spec),
@@ -712,28 +712,31 @@ def _create_annotation_element(self, element_key: tuple[str, ...]) -> Annotation
                 raise ValueError(msg)
         return AnnotationDisplay(self, kdims=list(element_key))
 
-    def get_element(self, kdims: tuple[str, ...] | str) -> AnnotationDisplay:
-        element_key = (kdims,) if isinstance(kdims, str) else tuple(map(str, kdims))
-        if element_key not in self._elements:
-            self._elements[element_key] = self._create_annotation_element(element_key)
-        return self._elements[element_key]
+    def get_element(self, *kdims: str | hv.Dimension) -> hv.DynamicMap:
+        return self.get_display(*kdims).element
+
+    def get_display(self, *kdims: str | hv.Dimension) -> AnnotationDisplay:
+        element_key = tuple(map(str, kdims))
+        if element_key not in self._displays:
+            self._displays[element_key] = self._create_annotation_element(element_key)
+        return self._displays[element_key]
 
     def __mul__(self, other: hv.Element) -> hv.Overlay:
-        return other * self.get_element(other.kdims).element
+        return other * self.get_element(*other.kdims)
 
     def __rmul__(self, other: hv.Element) -> hv.Overlay:
         return self.__mul__(other)
 
     def refresh(self, clear=False) -> None:
-        for v in self._elements.values():
+        for v in self._displays.values():
             hv.streams.Stream.trigger([v._annotation_count_stream])
             if clear:
                 v.clear_indicated_region()
             v.show_region()
 
     def set_annotation_table(self, annotation_table):
         self.select_by_index()
-        for v in self._elements.values():
+        for v in self._displays.values():
             v.select_by_index()
         self.clear_regions()
         super().set_annotation_table(annotation_table)
@@ -770,7 +773,7 @@ def delete_annotations(self, *indices):
     def select_by_index(self, *inds):
         "Set the selection state by the indices i.e. primary key values"
 
-        for v in self._elements.values():
+        for v in self._displays.values():
             if not v.selection_enabled:
                 inds = ()
 
@@ -799,7 +802,7 @@ def selection_enabled(self) -> bool:
 
     @selection_enabled.setter
     def selection_enabled(self, enabled: bool) -> None:
-        for v in self._elements.values():
+        for v in self._displays.values():
             v.selection_enabled = enabled
 
         if not enabled:
@@ -811,5 +814,5 @@ def editable_enabled(self) -> bool:
 
     @editable_enabled.setter
     def editable_enabled(self, enabled: bool) -> None:
-        for v in self._elements.values():
+        for v in self._displays.values():
             v.editable_enabled = enabled

holonote/tests/test_annotators_element.py

@@ -5,27 +5,26 @@
 bk_renderer = hv.renderer("bokeh")
 
 
-def _get_element(annotator, kdims=None) -> hv.Element:
+def _get_display(annotator, kdims=None) -> hv.Element:
     if kdims is None:
-        kdims = next(iter(annotator._elements.keys()))
+        kdims = next(iter(annotator._displays))
     kdims = (kdims,) if isinstance(kdims, str) else tuple(kdims)
-    element = annotator._elements[kdims]
-    return element
+    return annotator.get_display(*kdims)
 
 
 def get_region_editor_data(
     annotator,
     element_type,
     kdims=None,
 ):
-    el = _get_element(annotator, kdims).region_editor()
+    el = _get_display(annotator, kdims).region_editor()
     for e in el.last.traverse():
         if isinstance(e, element_type):
             return e.data
 
 
 def get_indicators_data(annotator, element_type, kdims=None):
-    return _get_element(annotator, kdims).static_indicators.data
+    return _get_display(annotator, kdims).static_indicators.data
 
 
 def test_set_regions_range1d(annotator_range1d, element_range1d) -> None:
@@ -149,21 +148,21 @@ def test_editable_enabled(annotator_range1d, element_range1d):
     annotator_range1d * element_range1d
 
     annotator_range1d.editable_enabled = False
-    for element in annotator_range1d._elements.values():
-        assert not element.editable_enabled
+    for display in annotator_range1d._displays.values():
+        assert not display.editable_enabled
 
     annotator_range1d.editable_enabled = True
-    for element in annotator_range1d._elements.values():
-        assert element.editable_enabled
+    for display in annotator_range1d._displays.values():
+        assert display.editable_enabled
 
 
 def test_selection_enabled(annotator_range1d, element_range1d):
     annotator_range1d * element_range1d
 
     annotator_range1d.selection_enabled = False
-    for element in annotator_range1d._elements.values():
-        assert not element.selection_enabled
+    for display in annotator_range1d._displays.values():
+        assert not display.selection_enabled
 
     annotator_range1d.selection_enabled = True
-    for element in annotator_range1d._elements.values():
-        assert element.selection_enabled
+    for display in annotator_range1d._displays.values():
+        assert display.selection_enabled