holobench 1.13.0__py2.py3-none-any.whl → 1.16.0__py2.py3-none-any.whl

bencher/bench_cfg.py

@@ -344,9 +344,13 @@ class BenchCfg(BenchRunCfg):
     def inputs_as_str(self) -> List[str]:
         return [i.name for i in self.input_vars]
 
-    def describe_sweep(self, width: int = 800) -> pn.pane.Markdown:
+    def describe_sweep(self, width: int = 800, accordion=True) -> pn.pane.Markdown:
         """Produce a markdown summary of the sweep settings"""
-        return pn.pane.Markdown(self.describe_benchmark(), width=width)
+
+        desc = pn.pane.Markdown(self.describe_benchmark(), width=width)
+        if accordion:
+            return pn.Accordion(("Data Collection Parameters", desc))
+        return desc
 
     def describe_benchmark(self) -> str:
         """Generate a string summary of the inputs and results from a BenchCfg
@@ -427,7 +431,7 @@ class BenchCfg(BenchRunCfg):
         if self.description is not None and description:
             col.append(self.to_description())
         if describe_sweep:
-            col.append(pn.Accordion(("Data Collection Parameters", self.describe_sweep())))
+            col.append(self.describe_sweep())
         if results_suffix:
             col.append(pn.pane.Markdown("## Results:"))
         return col

bencher/example/example_image.py

@@ -19,7 +19,7 @@ class BenchPolygons(bch.ParametrizedSweep):
     color = bch.StringSweep(["red", "green", "blue"])
     polygon = bch.ResultImage()
     area = bch.ResultVar()
-    # hmap = bch.ResultHmap()
+    side_length = bch.ResultVar()
 
     def __call__(self, **kwargs):
         self.update_params_from_kwargs(**kwargs)
@@ -27,6 +27,9 @@ class BenchPolygons(bch.ParametrizedSweep):
         # self.hmap = hv.Curve(points)
         self.polygon = self.points_to_polygon_png(points, bch.gen_image_path("polygon"))
         self.area = self.radius * self.sides
+
+        self.side_length = 2 * self.radius * math.sin(math.pi / self.sides)
+        self.area = (self.sides * self.side_length**2) / (4 * math.tan(math.pi / self.sides))
         return super().__call__()
 
     def points_to_polygon_png(self, points: list[float], filename: str):
@@ -74,6 +77,8 @@ def example_image(
             f"Polygons Sweeping {len(s)} Parameters",
             input_vars=s,
         )
+        bench.report.append(bench.get_result().to_panes())
+
     return bench
 
 
@@ -92,6 +97,24 @@ def example_image_vid(
 
 if __name__ == "__main__":
 
+    def simple():
+        bench = BenchPolygons().to_bench(bch.BenchRunCfg(level=4))
+
+        # bench.plot_sweep(input_vars=["sides","color","radius"])
+
+        # res = bench.sweep(input_vars=["sides", "radius"])
+
+        # bench.report.append(res.to_heatmap(target_dimension=3))
+
+        bench.plot_sweep(input_vars=["sides"])
+        bench.plot_sweep(input_vars=["sides", "color"])
+
+        bench.plot_sweep(input_vars=["sides", "radius"])
+
+        # bench.report.append(res.to_line(target_dimension=1))
+
+        return bench
+
     def example_image_vid_sequential(
         run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
     ) -> bch.Bench:
@@ -108,6 +131,8 @@ if __name__ == "__main__":
     # ex_run_cfg.debug = True
     # ex_run_cfg.repeats = 2
     ex_run_cfg.level = 4
-    example_image_vid(ex_run_cfg).report.show()
+    # example_image_vid(ex_run_cfg).report.show()
+    simple().report.show()
+
     # example_image_vid_sequential(ex_run_cfg).report.show()
     # example_image(ex_run_cfg).report.show()

bencher/example/example_video.py

@@ -16,6 +16,7 @@ class TuringPattern(bch.ParametrizedSweep):
 
     video = bch.ResultVideo()
     score = bch.ResultVar()
+    img = bch.ResultImage()
 
     def laplacian(self, Z, dx):
         Ztop = Z[0:-2, 1:-1]
@@ -66,6 +67,8 @@ class TuringPattern(bch.ParametrizedSweep):
                 rgb = np.array(fig.canvas.renderer.buffer_rgba())
                 vid_writer.append(rgb)
 
+        self.img = bch.add_image(rgb)
+
         self.video = vid_writer.write()
 
         self.score = self.alpha + self.beta
@@ -92,12 +95,25 @@ def example_video(
 def example_video_tap(
     run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
 ) -> bch.Bench:  # pragma: no cover
-    bench = TuringPattern().to_bench(run_cfg=run_cfg, report=report)
-    bench.plot_sweep(
+    tp = TuringPattern()
+
+    # run_cfg.use_sample_cache = False
+    # run_cfg.use_optuna = True
+    run_cfg.auto_plot = False
+    run_cfg.run_tag = "3"
+    bench = tp.to_bench(run_cfg=run_cfg, report=report)
+
+    res = bench.plot_sweep(
+        "phase",
         input_vars=["alpha", "beta"],
         # result_vars=["video","score"],
+        # result_vars=["score"],
+        run_cfg=run_cfg,
     )
 
+    bench.report.append(res.describe_sweep())
+    bench.report.append(res.to_heatmap())
+
     return bench
 
 
@@ -105,6 +121,7 @@ if __name__ == "__main__":
     run_cfg_ex = bch.BenchRunCfg()
     run_cfg_ex.level = 2
     run_cfg_ex.use_sample_cache = True
+    run_cfg_ex.only_hash_tag = True
 
     # example_video(run_cfg_ex).report.show()
     example_video_tap(run_cfg_ex).report.show()

bencher/results/bench_result.py

@@ -20,7 +20,7 @@ class BenchResult(PlotlyResult, HoloviewResult, VideoSummaryResult):
     @staticmethod
     def default_plot_callbacks():
         return [
-            VideoSummaryResult.to_video_summary,
+            # VideoSummaryResult.to_video_summary, #quite expensive so not turned on by default
             HoloviewResult.to_bar,
             HoloviewResult.to_scatter_jitter,
             HoloviewResult.to_curve,

bencher/results/bench_result_base.py

@@ -17,13 +17,13 @@ from copy import deepcopy
 from bencher.results.optuna_result import OptunaResult
 from bencher.variables.results import ResultVar
 from bencher.plotting.plot_filter import VarRange, PlotFilter
+from bencher.utils import listify
 
 from bencher.variables.results import (
     ResultReference,
 )
 
 from bencher.results.composable_container.composable_container_panel import ComposableContainerPanel
-from bencher.utils import listify
 
 # todo add plugins
 # https://gist.github.com/dorneanu/cce1cd6711969d581873a88e0257e312
@@ -228,7 +228,7 @@ class BenchResultBase(OptunaResult):
         return " vs ".join(tit)
 
     def get_results_var_list(self, result_var: ParametrizedSweep = None) -> List[ResultVar]:
-        return self.bench_cfg.result_vars if result_var is None else [result_var]
+        return self.bench_cfg.result_vars if result_var is None else listify(result_var)
 
     def map_plots(
         self,

bencher/results/holoview_result.py

@@ -8,12 +8,12 @@ from functools import partial
 import hvplot.xarray  # noqa pylint: disable=duplicate-code,unused-import
 import xarray as xr
 
-from bencher.utils import hmap_canonical_input, get_nearest_coords, get_nearest_coords1D
+from bencher.utils import hmap_canonical_input, get_nearest_coords, get_nearest_coords1D, listify
 from bencher.results.panel_result import PanelResult
 from bencher.results.bench_result_base import ReduceType
 
 from bencher.plotting.plot_filter import PlotFilter, VarRange
-from bencher.variables.results import ResultVar
+from bencher.variables.results import ResultVar, ResultImage, ResultVideo
 
 
 hv.extension("bokeh", "plotly")
@@ -85,6 +85,7 @@ class HoloviewResult(PanelResult):
             float_range=VarRange(0, 0),
             cat_range=VarRange(0, None),
             repeats_range=VarRange(1, 1),
+            panel_range=VarRange(0, None),
             reduce=ReduceType.SQUEEZE,
             target_dimension=2,
             result_var=result_var,
@@ -124,15 +125,34 @@ class HoloviewResult(PanelResult):
             **kwargs,
         )
 
-    def to_line(self, result_var: Parameter = None, **kwargs) -> Optional[pn.panel]:
+    def to_line(
+        self,
+        result_var: Parameter = None,
+        tap_var=None,
+        tap_container: pn.pane.panel = None,
+        target_dimension=2,
+        **kwargs,
+    ) -> Optional[pn.panel]:
+        if tap_var is None:
+            tap_var = self.plt_cnt_cfg.panel_vars
+        elif not isinstance(tap_var, list):
+            tap_var = [tap_var]
+
+        if len(tap_var) == 0 or self.plt_cnt_cfg.inputs_cnt > 1:
+            heatmap_cb = self.to_line_ds
+        else:
+            heatmap_cb = partial(
+                self.to_line_tap_ds, result_var_plots=tap_var, container=tap_container
+            )
+
         return self.filter(
-            self.to_line_ds,
+            heatmap_cb,
             float_range=VarRange(1, 1),
             cat_range=VarRange(0, None),
             repeats_range=VarRange(1, 1),
             panel_range=VarRange(0, None),
             reduce=ReduceType.SQUEEZE,
-            target_dimension=2,
+            target_dimension=target_dimension,
             result_var=result_var,
             result_types=(ResultVar),
             **kwargs,
@@ -140,7 +160,6 @@ class HoloviewResult(PanelResult):
 
     def to_line_ds(self, dataset: xr.Dataset, result_var: Parameter, **kwargs):
         x = self.plt_cnt_cfg.float_vars[0].name
-        # y = self.plt_cnt_cfg.result_vars[0].name
         by = None
         if self.plt_cnt_cfg.cat_cnt >= 1:
             by = self.plt_cnt_cfg.cat_vars[0].name
@@ -178,22 +197,28 @@ class HoloviewResult(PanelResult):
         self,
         result_var: Parameter = None,
         tap_var=None,
-        tap_container=None,
+        tap_container: pn.pane.panel = None,
         target_dimension=2,
         **kwargs,
     ) -> Optional[pn.panel]:
         if tap_var is None:
+            tap_var = self.plt_cnt_cfg.panel_vars
+        elif not isinstance(tap_var, list):
+            tap_var = [tap_var]
+
+        if len(tap_var) == 0:
             heatmap_cb = self.to_heatmap_ds
         else:
             heatmap_cb = partial(
-                self.to_heatmap_container_tap_ds, result_var_plot=tap_var, container=tap_container
+                self.to_heatmap_container_tap_ds, result_var_plots=tap_var, container=tap_container
             )
 
         return self.filter(
             heatmap_cb,
-            float_range=VarRange(2, None),
+            float_range=VarRange(0, None),
             cat_range=VarRange(0, None),
-            input_range=VarRange(1, None),
+            input_range=VarRange(2, None),
+            panel_range=VarRange(0, None),
             target_dimension=target_dimension,
             result_var=result_var,
             result_types=(ResultVar),
@@ -204,56 +229,180 @@ class HoloviewResult(PanelResult):
         self, dataset: xr.Dataset, result_var: Parameter, **kwargs
     ) -> Optional[hv.HeatMap]:
         if len(dataset.dims) >= 2:
-            x = self.plt_cnt_cfg.float_vars[0].name
-            y = self.plt_cnt_cfg.float_vars[1].name
+            x = self.bench_cfg.input_vars[0].name
+            y = self.bench_cfg.input_vars[1].name
             C = result_var.name
             title = f"Heatmap of {result_var.name}"
             time_args = self.time_widget(title)
             return dataset.hvplot.heatmap(x=x, y=y, C=C, cmap="plasma", **time_args, **kwargs)
         return None
 
+    def result_var_to_container(self, result_var):
+        if isinstance(result_var, ResultImage):
+            return pn.pane.PNG
+        return pn.pane.Video if isinstance(result_var, ResultVideo) else pn.pane.panel
+
+    def setup_results_and_containers(self, result_var_plots, container, **kwargs):
+        result_var_plots = listify(result_var_plots)
+        if container is None:
+            containers = [self.result_var_to_container(rv) for rv in result_var_plots]
+        else:
+            containers = listify(container)
+
+        cont_instances = [c(**kwargs) for c in containers]
+        return result_var_plots, cont_instances
+
     def to_heatmap_container_tap_ds(
         self,
         dataset: xr.Dataset,
         result_var: Parameter,
-        result_var_plot: Parameter,
-        container: pn.pane.panel = pn.pane.panel,
+        result_var_plots: List[Parameter] = None,
+        container: pn.pane.panel = None,
         **kwargs,
     ) -> pn.Row:
-        htmap = self.to_heatmap_ds(dataset, result_var).opts(tools=["hover", "tap"], **kwargs)
-        htmap_posxy = hv.streams.Tap(source=htmap, x=0, y=0)
-
-        container_instance = container(**kwargs)
+        htmap = self.to_heatmap_ds(dataset, result_var).opts(tools=["hover"], **kwargs)
+        result_var_plots, cont_instances = self.setup_results_and_containers(
+            result_var_plots, container
+        )
         title = pn.pane.Markdown("Selected: None")
 
-        def tap_plot(x, y):  # pragma: no cover
-            x_nearest = get_nearest_coords1D(
+        state = dict(x=None, y=None, update=False)
+
+        def tap_plot_heatmap(x, y):  # pragma: no cover
+            # print(f"moved {x}{y}")
+            x_nearest_new = get_nearest_coords1D(
                 x, dataset.coords[self.bench_cfg.input_vars[0].name].data
             )
-            y_nearest = get_nearest_coords1D(
+            y_nearest_new = get_nearest_coords1D(
                 y, dataset.coords[self.bench_cfg.input_vars[1].name].data
             )
-            kdims = {}
-            kdims[self.bench_cfg.input_vars[0].name] = x_nearest
-            kdims[self.bench_cfg.input_vars[1].name] = y_nearest
-
-            if hasattr(htmap, "current_key"):
-                for d, k in zip(htmap.kdims, htmap.current_key):
-                    kdims[d.name] = k
-
-            ds = dataset[result_var_plot.name]
-            val = ds.sel(**kdims)
-            item = self.zero_dim_da_to_val(val)
-            title.object = "Selected: " + ", ".join([f"{k}:{v}" for k, v in kdims.items()])
-            container_instance.object = item
-            if hasattr(container, "autoplay"):  # container is a video, set to autoplay
-                container_instance.paused = False
-                container_instance.time = 0
-                container_instance.loop = True
-                container_instance.autoplay = True
-
-        htmap_posxy.add_subscriber(tap_plot)
-        bound_plot = pn.Column(title, container_instance)
+
+            # xv = self.bench_cfg.input_vars[0].name
+            # yv = self.bench_cfg.input_vars[1].name
+            # nearest = get_nearest_coords(dataset, **{xv: x, yv: y})
+            # print(nearest)
+            # print(x_nearest_new,y_nearest_new)
+
+            if x_nearest_new != state["x"]:
+                state["x"] = x_nearest_new
+                state["update"] = True
+            if y_nearest_new != state["y"]:
+                state["y"] = y_nearest_new
+                state["update"] = True
+
+            if state["update"]:
+                kdims = {}
+                kdims[self.bench_cfg.input_vars[0].name] = state["x"]
+                kdims[self.bench_cfg.input_vars[1].name] = state["y"]
+
+                if hasattr(htmap, "current_key"):
+                    for d, k in zip(htmap.kdims, htmap.current_key):
+                        kdims[d.name] = k
+                for rv, cont in zip(result_var_plots, cont_instances):
+                    ds = dataset[rv.name]
+                    val = ds.sel(**kdims)
+                    item = self.zero_dim_da_to_val(val)
+                    title.object = "Selected: " + ", ".join([f"{k}:{v}" for k, v in kdims.items()])
+                    cont.object = item
+                    if hasattr(cont, "autoplay"):  # container is a video, set to autoplay
+                        cont.paused = False
+                        cont.time = 0
+                        cont.loop = True
+                        cont.autoplay = True
+                state["update"] = False
+
+        def on_exit(x, y):  # pragma: no cover # pylint: disable=unused-argument
+            state["update"] = True
+
+        htmap_posxy = hv.streams.PointerXY(source=htmap)
+        htmap_posxy.add_subscriber(tap_plot_heatmap)
+        ls = hv.streams.MouseLeave(source=htmap)
+        ls.add_subscriber(on_exit)
+
+        bound_plot = pn.Column(title, *cont_instances)
+        return pn.Row(htmap, bound_plot)
+
+    def to_line_tap_ds(
+        self,
+        dataset: xr.Dataset,
+        result_var: Parameter,
+        result_var_plots: List[Parameter] = None,
+        container: pn.pane.panel = pn.pane.panel,
+        **kwargs,
+    ) -> pn.Row:
+        htmap = self.to_line_ds(dataset, result_var).opts(tools=["hover"], **kwargs)
+        result_var_plots, cont_instances = self.setup_results_and_containers(
+            result_var_plots, container
+        )
+        title = pn.pane.Markdown("Selected: None")
+
+        state = dict(x=None, y=None, update=False)
+
+        def tap_plot_line(x, y):  # pragma: no cover
+            # print(f"{x},{y}")
+            # print(dataset)
+
+            # xv = self.bench_cfg.input_vars[0].name
+            # yv = self.bench_cfg.input_vars[1].name
+
+            # x_nearest_new = get_nearest_coords1D(
+            #     x, dataset.coords[self.bench_cfg.input_vars[0].name].data
+            # )
+            # y_nearest_new = get_nearest_coords1D(
+            #     y, dataset.coords[self.bench_cfg.input_vars[1].name].data
+            # )
+
+            # kwargs = {xv: x, yv: y}
+
+            # nearest = get_nearest_coords(dataset, **kwargs)
+            # print(nearest)
+
+            x_nearest_new = get_nearest_coords1D(
+                x, dataset.coords[self.bench_cfg.input_vars[0].name].data
+            )
+
+            if x_nearest_new != state["x"]:
+                state["x"] = x_nearest_new
+                state["update"] = True
+
+            if self.plt_cnt_cfg.inputs_cnt > 1:
+                y_nearest_new = get_nearest_coords1D(
+                    y, dataset.coords[self.bench_cfg.input_vars[1].name].data
+                )
+                if y_nearest_new != state["y"]:
+                    state["y"] = y_nearest_new
+                    state["update"] = True
+
+            if state["update"]:
+                kdims = {}
+                kdims[self.bench_cfg.input_vars[0].name] = state["x"]
+                if self.plt_cnt_cfg.inputs_cnt > 1:
+                    kdims[self.bench_cfg.input_vars[1].name] = state["y"]
+
+                if hasattr(htmap, "current_key"):
+                    for d, k in zip(htmap.kdims, htmap.current_key):
+                        kdims[d.name] = k
+                for rv, cont in zip(result_var_plots, cont_instances):
+                    ds = dataset[rv.name]
+                    val = ds.sel(**kdims)
+                    item = self.zero_dim_da_to_val(val)
+                    title.object = "Selected: " + ", ".join([f"{k}:{v}" for k, v in kdims.items()])
+                    cont.object = item
+                    if hasattr(cont, "autoplay"):  # container is a video, set to autoplay
+                        cont.paused = False
+                        cont.time = 0
+                        cont.loop = True
+                        cont.autoplay = True
+                state["update"] = False
+
+        def on_exit(x, y):  # pragma: no cover # pylint: disable=unused-argument
+            state["update"] = True
+
+        htmap_posxy = hv.streams.PointerXY(source=htmap)
+        htmap_posxy.add_subscriber(tap_plot_line)
+        ls = hv.streams.MouseLeave(source=htmap)
+        ls.add_subscriber(on_exit)
+        bound_plot = pn.Column(title, *cont_instances)
         return pn.Row(htmap, bound_plot)
 
     def to_error_bar(self) -> hv.Bars:

bencher/utils.py

@@ -61,6 +61,9 @@ def get_nearest_coords(dataset: xr.Dataset, collapse_list=False, **kwargs) -> di
 def get_nearest_coords1D(val: Any, coords) -> Any:
     if isinstance(val, (int, float)):
         return min(coords, key=lambda x_: abs(x_ - val))
+    for i in coords:
+        if val == i:
+            return i
     return val
 
 

{holobench-1.13.0.dist-info → holobench-1.16.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: holobench
-Version: 1.13.0
+Version: 1.16.0
 Summary: A package for benchmarking the performance of arbitrary functions
 Author-email: Austin Gregg-Smith <blooop@gmail.com>
 Description-Content-Type: text/markdown
@@ -25,9 +25,9 @@ Requires-Dist: black>=23,<=24.4.2 ; extra == "test"
 Requires-Dist: pylint>=2.16,<=3.1.0 ; extra == "test"
 Requires-Dist: pytest-cov>=4.1,<=5.0.0 ; extra == "test"
 Requires-Dist: pytest>=7.4,<=8.2.0 ; extra == "test"
-Requires-Dist: hypothesis>=6.82,<=6.100.2 ; extra == "test"
-Requires-Dist: ruff>=0.0.280,<=0.4.2 ; extra == "test"
-Requires-Dist: coverage>=7.2.7,<=7.5.0 ; extra == "test"
+Requires-Dist: hypothesis>=6.82,<=6.101.0 ; extra == "test"
+Requires-Dist: ruff>=0.0.280,<=0.4.4 ; extra == "test"
+Requires-Dist: coverage>=7.2.7,<=7.5.1 ; extra == "test"
 Project-URL: Documentation, https://bencher.readthedocs.io/en/latest/
 Project-URL: Home, https://github.com/dyson-ai/bencher
 Project-URL: Repository, https://github.com/dyson-ai/bencher

{holobench-1.13.0.dist-info → holobench-1.16.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 bencher/__init__.py,sha256=tScVYfGMeh2G84wMdglc16lZy5MNtRS13Qqv-7Cf1O4,1283
-bencher/bench_cfg.py,sha256=9Vnm_TUKTweywLE_csLwe_h9cDga2POBDywoFqe3e3k,18637
+bencher/bench_cfg.py,sha256=xbgycmg8v0vbt4AjGXBivs-7EcQuopLtm0R-DLiI-l8,18720
 bencher/bench_plot_server.py,sha256=ZePbN9lKMQggONYMBW0CJm9saLjmxtdeAEs6eiei_8g,4088
 bencher/bench_report.py,sha256=jh3T_q9KByZDeMPMf0KNJojZukxRzkfaYGeuWQU8MKM,10528
 bencher/bench_runner.py,sha256=F4DN1YSFXnUAGO17tJ6DZDyEu7QBgvTyqn8G_iCd36c,6165
@@ -8,7 +8,7 @@ bencher/caching.py,sha256=AusaNrzGGlj5m6zcwcqnTn55Mam2mQdF--oqelO806M,1627
 bencher/class_enum.py,sha256=kYHW9qKkKcNdwaXizZL-fTptS_DUEGv4c88yCehk3gc,1492
 bencher/job.py,sha256=swa0VwrZf41v7qNjreVDIYUU6r_dfuLipPZbg_w5x7c,6089
 bencher/optuna_conversions.py,sha256=DAa1DBXJ5EvTGiPyzuDTovQSjKVpMZ2sdwEXThlXJVU,5288
-bencher/utils.py,sha256=qcbqBXTy9vH-PQbT1Hbdb81kAofTjnq-_A3bXvpJIvo,5595
+bencher/utils.py,sha256=sF7m8qLC-5gP8VdTa0yG8NVnpzkMVFOfKszV5IqQI2o,5658
 bencher/video_writer.py,sha256=v0yXr7PV0rYWTWqVWBZkXFD3N_ExrZHHHkbEXcXK5bc,4512
 bencher/worker_job.py,sha256=FREi0yWQACFmH86R1j-LH72tALEFkKhLDmmoGQY9Jh4,1571
 bencher/example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -24,7 +24,7 @@ bencher/example/example_floats2D.py,sha256=D0kljoUCinMKCEW-Zg-cQ8sYu_yPCZqzKJ9tR
 bencher/example/example_holosweep.py,sha256=lxH0Z_waInGIH5AtGQi4zwPAZRI_uN0DbsJhI9iSF7Q,3017
 bencher/example/example_holosweep_objects.py,sha256=vHuAtkM1VrJelHOazn_SJfzxNywKyaMzN-DE8W7Ricc,3228
 bencher/example/example_holosweep_tap.py,sha256=NYXofWGV9GaBN72Q3kKPT5lKJ-slYZH5VzTAavUu23w,4527
-bencher/example/example_image.py,sha256=_DS4UFok_aPCCEKspTi3qxnIYj9JR27GV9j3rhe9js8,3875
+bencher/example/example_image.py,sha256=5Tb6iu_AhkqzF4j96KgjNvnznu_zgF3vORSu3sYUCUo,4669
 bencher/example/example_levels.py,sha256=s-UfXXp8qj5U0Gx5KyMqj--nn1Ke0NtHVLSSJYIPaYY,6891
 bencher/example/example_pareto.py,sha256=yyAg8Vb-5sgsS6LkYKT7T5Evcfg69FlCqCakUippSmU,2687
 bencher/example/example_sample_cache.py,sha256=7gf1BJ63VAgdqNuNXkbL9-jeTeC3kXA_PY9yG3ulTz0,4200
@@ -35,7 +35,7 @@ bencher/example/example_simple_cat.py,sha256=XsV_75Jk3phVPI4om3q0vn1POfREb3CGRm9
 bencher/example/example_simple_float.py,sha256=X4vsH0F4fZAoO0EKB1xIzFMY0f0Wyk8LV2plPlSEsbI,1323
 bencher/example/example_strings.py,sha256=BdsEZgLT9mOxLkBKNHz2XpPwwe4SzNTdjnY1WVlOmNM,1570
 bencher/example/example_time_event.py,sha256=e6R-a6ZPe-ePiWoNvN3YuSQK-Y2HOGntsjCm_SPon28,2159
-bencher/example/example_video.py,sha256=IJGgRHmpeppOKwhSkDHDJVuHw32yBJiBpbKaI34soHI,3742
+bencher/example/example_video.py,sha256=2d7GPjBXxGmNpHTMHVGqV4j8EVk7Yz---GM6WVxJpfo,4156
 bencher/example/example_workflow.py,sha256=00QnUuViMfX_PqzqkXmg1wPX6yAq7IS7mCL_RFKwrMM,6806
 bencher/example/experimental/example_bokeh_plotly.py,sha256=3jUKh8eKIAlpklKnp8UopIHhUDw1A0_5CwjeyTzbi7o,846
 bencher/example/experimental/example_hover_ex.py,sha256=qszw4FkIfqQkVviPSpmUoFOoi6PGotGbsc7Ojyx8EtU,1052
@@ -58,10 +58,10 @@ bencher/plotting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 bencher/plotting/plot_filter.py,sha256=Zff02hEcRffiqDEoXUHVZQJK5kW4HbMxe2GYCrxI8jg,4688
 bencher/plotting/plt_cnt_cfg.py,sha256=BkiAsgHm35Mqb5OsjULGVK0Q6pGZ0WSsJxxwSOrbaQs,3124
 bencher/results/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bencher/results/bench_result.py,sha256=bxYm80avpfCMJr4bS94smkFSYbxvniXMJpXDEm2noHA,3444
-bencher/results/bench_result_base.py,sha256=5V4n_lbgF19mud8h7wIxc_vg7nr3ZeWaj6AK0E7KmLg,18713
+bencher/results/bench_result.py,sha256=JoXfAQ2dkoVt2mBM0Hp5V0843CWcSCuBfR817VhLVx0,3491
+bencher/results/bench_result_base.py,sha256=qkH2hLgr6QAlCuQ3_FpqGXqBrurNwJocvoRwdQiI9Gs,18720
 bencher/results/float_formatter.py,sha256=sX6HNCyaXdHDxC8ybVUHwCJ3qOKbPUkBOplVIHtKWjM,1746
-bencher/results/holoview_result.py,sha256=MAwDjT6ggChzgHyb2ri21pp3Ak2Z7SYczTEMvSqL3as,22247
+bencher/results/holoview_result.py,sha256=X-eSz2XzYGfr_vfX0ZgM7LCxszlyETC5TorHlRyQdHY,27993
 bencher/results/optuna_result.py,sha256=jtsWJGdCS0L98EzxTxXU_AyarCL5CkXRLOVuSvs048M,13437
 bencher/results/panel_result.py,sha256=vzZaXhGurbKex50hrSksdTh7tBIAGvcDN9l1OBulWDQ,1403
 bencher/results/plotly_result.py,sha256=wkgfL38qJp6RviekXBYpNPeU4HCf0nbtKDAhu5QZhUg,2132
@@ -76,6 +76,6 @@ bencher/variables/parametrised_sweep.py,sha256=OSEVTYzsN2ayc0BQAN0lC441z5UDUy2kc
 bencher/variables/results.py,sha256=8i5qYWZ4KILWL1qT07mLIssUQXDKEx6CnXPgFZJB8jw,6121
 bencher/variables/sweep_base.py,sha256=cOybffErb3_QUsCfiZa0mlVy9tGDueqiElZmc363apE,6258
 bencher/variables/time.py,sha256=Up1VOTwoOi-HchRlCh-K1PRR8FvhZyNqLDUODa0erHA,2659
-holobench-1.13.0.dist-info/WHEEL,sha256=Sgu64hAMa6g5FdzHxXv9Xdse9yxpGGMeagVtPMWpJQY,99
-holobench-1.13.0.dist-info/METADATA,sha256=K3Kr2pXOl_1faFEnmoNg86ag8BZKvJCdLjQ7FiGbF3A,5112
-holobench-1.13.0.dist-info/RECORD,,
+holobench-1.16.0.dist-info/WHEEL,sha256=Sgu64hAMa6g5FdzHxXv9Xdse9yxpGGMeagVtPMWpJQY,99
+holobench-1.16.0.dist-info/METADATA,sha256=CPVcm2N_YjGRZ0FyYelMLWe28GQ9RhzqS7GaatvSo_w,5112
+holobench-1.16.0.dist-info/RECORD,,