holobench 1.5.0__py2.py3-none-any.whl → 1.7.0__py2.py3-none-any.whl

bencher/bench_cfg.py

@@ -303,6 +303,11 @@ class BenchCfg(BenchRunCfg):
         doc="store the hash value of the config to avoid having to hash multiple times",
     )
 
+    plot_callbacks = param.List(
+        None,
+        doc="A callable that takes a BenchResult and returns panel representation of the results",
+    )
+
     def __init__(self, **params):
         super().__init__(**params)
         self.plot_lib = None

bencher/bench_plot_server.py

@@ -1,4 +1,5 @@
 """A server for display plots of benchmark results"""
+
 import logging
 import os
 from typing import List, Tuple

bencher/bench_report.py

@@ -3,7 +3,8 @@ from typing import Callable
 import os
 import panel as pn
 from pathlib import Path
-import shutil
+import tempfile
+
 from threading import Thread
 
 from bencher.results.bench_result import BenchResult
@@ -47,7 +48,7 @@ class BenchReport(BenchPlotServer):
         self.pane.append(col)
 
     def append_result(self, bench_res: BenchResult) -> None:
-        self.append_tab(bench_res.to_auto_plots(), bench_res.bench_cfg.title)
+        self.append_tab(bench_res.plot(), bench_res.bench_cfg.title)
 
     def append_tab(self, pane: pn.panel, name: str = None) -> None:
         if pane is not None:
@@ -137,24 +138,23 @@ class BenchReport(BenchPlotServer):
 
         remote, publish_url = remote_callback(branch_name)
 
-        directory = "tmpgit"
-        report_path = self.save(directory, filename="index.html", in_html_folder=False)
-        logging.info(f"created report at: {report_path.absolute()}")
+        with tempfile.TemporaryDirectory() as td:
+            directory = td
+            report_path = self.save(directory, filename="index.html", in_html_folder=False)
+            logging.info(f"created report at: {report_path.absolute()}")
 
-        cd_dir = f"cd {directory} &&"
+            cd_dir = f"cd {directory} &&"
 
-        os.system(f"{cd_dir} git init")
-        os.system(f"{cd_dir} git checkout -b {branch_name}")
-        os.system(f"{cd_dir} git add index.html")
-        os.system(f'{cd_dir} git commit -m "publish {branch_name}"')
-        os.system(f"{cd_dir} git remote add origin {remote}")
-        os.system(f"{cd_dir} git push --set-upstream origin {branch_name} -f")
+            os.system(f"{cd_dir} git init")
+            os.system(f"{cd_dir} git checkout -b {branch_name}")
+            os.system(f"{cd_dir} git add index.html")
+            os.system(f'{cd_dir} git commit -m "publish {branch_name}"')
+            os.system(f"{cd_dir} git remote add origin {remote}")
+            os.system(f"{cd_dir} git push --set-upstream origin {branch_name} -f")
 
         logging.info("Published report @")
         logging.info(publish_url)
 
-        shutil.rmtree(directory)
-
         return publish_url
 
 

bencher/bench_runner.py

@@ -103,7 +103,7 @@ class BenchRunner:
         for r in range(1, repeats + 1):
             for lvl in range(min_level, max_level + 1):
                 if grouped:
-                    report_level = BenchReport(self.name)
+                    report_level = BenchReport(f"{self.name}_{run_cfg.run_tag}")
 
                 for bch_fn in self.bench_fns:
                     run_lvl = deepcopy(run_cfg)

bencher/bencher.py

@@ -10,6 +10,7 @@ import xarray as xr
 from diskcache import Cache
 from contextlib import suppress
 from functools import partial
+import panel as pn
 
 from bencher.worker_job import WorkerJob
 
@@ -165,6 +166,17 @@ class Bench(BenchPlotServer):
 
         self.cache_size = int(100e9)  # default to 100gb
 
+        # self.bench_cfg = BenchCfg()
+
+        # Maybe put this in SweepCfg
+        self.input_vars = None
+        self.result_vars = None
+        self.const_vars = None
+        self.plot_callbacks = []
+
+    def add_plot_callback(self, callback: Callable[[BenchResult], pn.panel]) -> None:
+        self.plot_callbacks.append(callback)
+
     def set_worker(self, worker: Callable, worker_input_cfg: ParametrizedSweep = None) -> None:
         """Set the benchmark worker function and optionally the type the worker expects
 
@@ -188,34 +200,6 @@ class Bench(BenchPlotServer):
             logging.info(f"setting worker {worker}")
         self.worker_input_cfg = worker_input_cfg
 
-    def sweep(
-        self,
-        input_vars: List[ParametrizedSweep] = None,
-        result_vars: List[ParametrizedSweep] = None,
-        const_vars: List[ParametrizedSweep] = None,
-        time_src: datetime = None,
-        description: str = None,
-        post_description: str = None,
-        pass_repeat: bool = False,
-        tag: str = "",
-        run_cfg: BenchRunCfg = None,
-        plot: bool = False,
-    ) -> BenchResult:
-        title = "Sweeping " + " vs ".join(params_to_str(input_vars))
-        return self.plot_sweep(
-            title,
-            input_vars=input_vars,
-            result_vars=result_vars,
-            const_vars=const_vars,
-            time_src=time_src,
-            description=description,
-            post_description=post_description,
-            pass_repeat=pass_repeat,
-            tag=tag,
-            run_cfg=run_cfg,
-            plot=plot,
-        )
-
     def sweep_sequential(
         self,
         title="",
@@ -264,6 +248,7 @@ class Bench(BenchPlotServer):
         tag: str = "",
         run_cfg: BenchRunCfg = None,
         plot: bool = True,
+        plot_callbacks=None,
     ) -> BenchResult:
         """The all in 1 function benchmarker and results plotter.
 
@@ -278,7 +263,8 @@ class Bench(BenchPlotServer):
             pass_repeat (bool,optional) By default do not pass the kwarg 'repeat' to the benchmark function.  Set to true if
             you want the benchmark function to be passed the repeat number
             tag (str,optional): Use tags to group different benchmarks together.
-            run_cfg: (BenchRunCfg, optional): A config for storing how the benchmarks and run and plotted
+            run_cfg: (BenchRunCfg, optional): A config for storing how the benchmarks and run
+            plot_callbacks: A list of plot callbacks to clal on the results
         Raises:
             ValueError: If a result variable is not set
 
@@ -291,18 +277,27 @@ class Bench(BenchPlotServer):
                 logging.info(
                     "No input variables passed, using all param variables in bench class as inputs"
                 )
-                input_vars = self.worker_class_instance.get_inputs_only()
+                if self.input_vars is None:
+                    input_vars = self.worker_class_instance.get_inputs_only()
+                else:
+                    input_vars = self.input_vars
                 for i in input_vars:
                     logging.info(f"input var: {i.name}")
             if result_vars is None:
                 logging.info(
                     "No results variables passed, using all result variables in bench class:"
                 )
-                result_vars = self.worker_class_instance.get_results_only()
+                if self.result_vars is None:
+                    result_vars = self.worker_class_instance.get_results_only()
+                else:
+                    result_vars = self.result_vars
                 for r in result_vars:
                     logging.info(f"result var: {r.name}")
             if const_vars is None:
-                const_vars = self.worker_class_instance.get_input_defaults()
+                if self.const_vars is None:
+                    const_vars = self.worker_class_instance.get_input_defaults()
+                else:
+                    const_vars = self.const_vars
         else:
             if input_vars is None:
                 input_vars = []
@@ -381,6 +376,12 @@ class Bench(BenchPlotServer):
                 "## Results Description\nPlease set post_description to explain these results"
             )
 
+        if plot_callbacks is None:
+            if len(self.plot_callbacks) == 0:
+                plot_callbacks = [BenchResult.to_auto_plots]
+            else:
+                plot_callbacks = self.plot_callbacks
+
         bench_cfg = BenchCfg(
             input_vars=input_vars,
             result_vars=result_vars_only,
@@ -392,7 +393,14 @@ class Bench(BenchPlotServer):
             title=title,
             pass_repeat=pass_repeat,
             tag=run_cfg.run_tag + tag,
+            auto_plot=plot,
+            plot_callbacks=plot_callbacks,
         )
+        return self.run_sweep(bench_cfg, run_cfg, time_src)
+
+    def run_sweep(
+        self, bench_cfg: BenchCfg, run_cfg: BenchRunCfg, time_src: datetime
+    ) -> BenchResult:
         print("tag", bench_cfg.tag)
 
         bench_cfg.param.update(run_cfg.param.values())
@@ -447,8 +455,9 @@ class Bench(BenchPlotServer):
 
         bench_res.post_setup()
 
-        if plot and bench_res.bench_cfg.auto_plot:
+        if bench_cfg.auto_plot:
             self.report.append_result(bench_res)
+
         self.results.append(bench_res)
         return bench_res
 
@@ -799,3 +808,7 @@ class Bench(BenchPlotServer):
 
     def get_result(self, index: int = -1) -> BenchResult:
         return self.results[index]
+
+    def publish(self, remote_callback: Callable) -> str:
+        branch_name = f"{self.bench_name}_{self.run_cfg.run_tag}"
+        return self.report.publish(remote_callback, branch_name=branch_name)

bencher/example/example_float_cat.py

@@ -1,4 +1,5 @@
 """Example of how to perform a parameter sweep for categorical variables"""
+
 import bencher as bch
 
 

bencher/example/example_image.py

@@ -44,7 +44,7 @@ class BenchPolygons(bch.ParametrizedSweep):
 
         ax.set_aspect("equal")
         fig.add_axes(ax)
-        fig.savefig(filename, dpi=50)
+        fig.savefig(filename, dpi=30)
 
         return filename
 
@@ -54,24 +54,9 @@ def example_image(
 ) -> bch.Bench:
     bench = bch.Bench("polygons", BenchPolygons(), run_cfg=run_cfg, report=report)
 
-    for s in [
-        [BenchPolygons.param.sides],
-        [BenchPolygons.param.sides, BenchPolygons.param.linewidth],
-        [BenchPolygons.param.sides, BenchPolygons.param.linewidth, BenchPolygons.param.linestyle],
-        [
-            BenchPolygons.param.sides,
-            BenchPolygons.param.linewidth,
-            BenchPolygons.param.linestyle,
-            BenchPolygons.param.color,
-        ],
-        [
-            BenchPolygons.param.sides,
-            BenchPolygons.param.linewidth,
-            BenchPolygons.param.linestyle,
-            BenchPolygons.param.color,
-            BenchPolygons.param.radius,
-        ],
-    ]:
+    sweep_vars = ["sides", "radius", "linewidth", "color"]
+    for i in range(1, len(sweep_vars)):
+        s = sweep_vars[:i]
         bench.plot_sweep(
             f"Polygons Sweeping {len(s)} Parameters",
             input_vars=s,
@@ -81,24 +66,26 @@ def example_image(
     return bench
 
 
-if __name__ == "__main__":
+def example_image_vid(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    bench = BenchPolygons().to_bench(run_cfg, report)
+    bench.add_plot_callback(bch.BenchResult.to_sweep_summary)
+    bench.add_plot_callback(bch.BenchResult.to_video_grid)
+    bench.plot_sweep(input_vars=["sides"])
+    bench.plot_sweep(input_vars=["sides", "radius"])
+    return bench
 
-    def example_image_vid(
-        run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
-    ) -> bch.Bench:
-        bench = BenchPolygons().to_bench(run_cfg, report)
-        bench.plot_sweep(input_vars=["sides", "radius", "color"], plot=True)
-        return bench
+
+if __name__ == "__main__":
 
     def example_image_vid_sequential(
         run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
     ) -> bch.Bench:
         bench = BenchPolygons().to_bench(run_cfg, report)
-        res_list = bench.sweep_sequential(
-            input_vars=["radius", "sides", "linewidth", "color"], group_size=3
-        )
-        for r in res_list:
-            bench.report.append(r.to_video_summary())
+        bench.add_plot_callback(bch.BenchResult.to_title)
+        bench.add_plot_callback(bch.BenchResult.to_video_grid)
+        bench.sweep_sequential(input_vars=["radius", "sides", "linewidth", "color"], group_size=1)
         return bench
 
     # def example_image_pairs()

bencher/example/example_simple_bool.py

@@ -1,4 +1,5 @@
 """This file has some examples for how to perform basic benchmarking parameter sweeps"""
+
 import bencher as bch
 
 # All the examples will be using the data structures and benchmark function defined in this file

bencher/example/example_simple_cat.py

@@ -1,4 +1,5 @@
 """This file has some examples for how to perform basic benchmarking parameter sweeps"""
+
 # pylint: disable=duplicate-code
 
 import bencher as bch

bencher/example/example_time_event.py

@@ -1,4 +1,5 @@
 """This file has some examples for how to perform basic benchmarking parameter sweeps"""
+
 # pylint: disable=duplicate-code
 
 import bencher as bch

bencher/results/bench_result.py

@@ -11,7 +11,6 @@ from bencher.utils import listify
 
 
 class BenchResult(PlotlyResult, HoloviewResult, VideoSummaryResult):
-
     """Contains the results of the benchmark and has methods to cast the results to various datatypes and graphical representations"""
 
     def __init__(self, bench_cfg) -> None:
@@ -36,6 +35,14 @@ class BenchResult(PlotlyResult, HoloviewResult, VideoSummaryResult):
     def plotly_callbacks():
         return [HoloviewResult.to_surface, PlotlyResult.to_volume]
 
+    def plot(self) -> pn.panel:
+        """Plots the benchresult using the plot callbacks defined by the bench run
+
+        Returns:
+             pn.panel: A panel representation of the results
+        """
+        return pn.Column(*[cb(self) for cb in self.bench_cfg.plot_callbacks])
+
     def to_auto(
         self,
         plot_list: List[callable] = None,
@@ -68,7 +75,7 @@ class BenchResult(PlotlyResult, HoloviewResult, VideoSummaryResult):
             )
         return row.pane
 
-    def to_auto_plots(self, **kwargs) -> List[pn.panel]:
+    def to_auto_plots(self, **kwargs) -> pn.panel:
         """Given the dataset result of a benchmark run, automatically dedeuce how to plot the data based on the types of variables that were sampled
 
         Args:

bencher/results/bench_result_base.py

@@ -5,6 +5,8 @@ import xarray as xr
 from param import Parameter
 import holoviews as hv
 from functools import partial
+import panel as pn
+
 from bencher.utils import int_to_col, color_tuple_to_css, callable_name
 
 from bencher.variables.parametrised_sweep import ParametrizedSweep
@@ -12,10 +14,13 @@ from bencher.variables.results import OptDir
 from copy import deepcopy
 from bencher.results.optuna_result import OptunaResult
 from bencher.variables.results import ResultVar
-from bencher.results.float_formatter import FormatFloat
 from bencher.plotting.plot_filter import VarRange, PlotFilter
-import panel as pn
 
+from bencher.variables.results import (
+    ResultReference,
+)
+
+from bencher.results.composable_container.composable_container_panel import ComposableContainerPanel
 
 # todo add plugins
 # https://gist.github.com/dorneanu/cce1cd6711969d581873a88e0257e312
@@ -333,29 +338,24 @@ class BenchResultBase(OptunaResult):
             time_dim_delta = 0
 
         if num_dims > (target_dimension + time_dim_delta) and num_dims != 0:
-            dim_sel = dims[-1]
+            selected_dim = dims[-1]
             # print(f"selected dim {dim_sel}")
-
             dim_color = color_tuple_to_css(int_to_col(num_dims - 2, 0.05, 1.0))
 
-            background_col = dim_color
-            name = " vs ".join(dims)
-
-            container_args = {"name": name, "styles": {"background": background_col}}
-            outer_container = (
-                pn.Row(**container_args) if horizontal else pn.Column(**container_args)
+            outer_container = ComposableContainerPanel(
+                name=" vs ".join(dims), background_col=dim_color, horizontal=not horizontal
             )
-
             max_len = 0
-
-            for i in range(dataset.sizes[dim_sel]):
-                sliced = dataset.isel({dim_sel: i})
-
-                lable_val = sliced.coords[dim_sel].values.item()
-                if isinstance(lable_val, (int, float)):
-                    lable_val = FormatFloat()(lable_val)
-
-                label = f"{dim_sel}={lable_val}"
+            for i in range(dataset.sizes[selected_dim]):
+                sliced = dataset.isel({selected_dim: i})
+                label_val = sliced.coords[selected_dim].values.item()
+                inner_container = ComposableContainerPanel(
+                    outer_container.name,
+                    width=num_dims - target_dimension,
+                    var_name=selected_dim,
+                    var_value=label_val,
+                    horizontal=horizontal,
+                )
 
                 panes = self._to_panes_da(
                     sliced,
@@ -364,35 +364,46 @@ class BenchResultBase(OptunaResult):
                     horizontal=len(sliced.sizes) <= target_dimension + 1,
                     result_var=result_var,
                 )
-                width = num_dims - target_dimension
-
-                container_args = {
-                    "name": name,
-                    "styles": {"border-bottom": f"{width}px solid grey"},
-                }
-
-                if horizontal:
-                    inner_container = pn.Column(**container_args)
-                    align = ("center", "center")
-                else:
-                    inner_container = pn.Row(**container_args)
-                    align = ("end", "center")
-
-                label_len = len(label)
-                if label_len > max_len:
-                    max_len = label_len
-                side = pn.pane.Markdown(label, align=align)
-
-                inner_container.append(side)
+
+                if inner_container.label_len > max_len:
+                    max_len = inner_container.label_len
                 inner_container.append(panes)
-                outer_container.append(inner_container)
-                # outer_container.append(pn.Row(inner_container, align="center"))
-            for c in outer_container:
+                outer_container.append(inner_container.container)
+            for c in outer_container.container:
                 c[0].width = max_len * 7
         else:
             return plot_callback(dataset=dataset, result_var=result_var, **kwargs)
 
-        return outer_container
+        return outer_container.container
+
+    def zero_dim_da_to_val(self, da_ds: xr.DataArray | xr.Dataset) -> Any:
+        # todo this is really horrible, need to improve
+        dim = None
+        if isinstance(da_ds, xr.Dataset):
+            dim = list(da_ds.keys())[0]
+            da = da_ds[dim]
+        else:
+            da = da_ds
+
+        for k in da.coords.keys():
+            dim = k
+            break
+        if dim is None:
+            return da_ds.values.squeeze().item()
+        return da.expand_dims(dim).values[0]
+
+    def ds_to_container(
+        self, dataset: xr.Dataset, result_var: Parameter, container, **kwargs
+    ) -> Any:
+        val = self.zero_dim_da_to_val(dataset[result_var.name])
+        if isinstance(result_var, ResultReference):
+            ref = self.object_index[val]
+            val = ref.obj
+            if ref.container is not None:
+                return ref.container(val, **kwargs)
+        if container is not None:
+            return container(val, styles={"background": "white"}, **kwargs)
+        return val
 
     # MAPPING TO LOWER LEVEL BENCHCFG functions so they are available at a top level.
     def to_sweep_summary(self, **kwargs):

bencher/results/composable_container/composable_container_base.py

@@ -0,0 +1,58 @@
+from enum import Enum, auto
+from typing import Any
+from bencher.results.float_formatter import FormatFloat
+
+
+# TODO enable these options
+class ComposeType(Enum):
+    right = auto()  # append the container to the right (creates a row)
+    down = auto()  # append the container below (creates a column)
+    overlay = auto()  # overlay on top of the current container (alpha blending)
+    sequence = auto()  # display the container after (in time)
+
+
+class ComposableContainerBase:
+    """A base class for renderer backends.  A composable renderr"""
+
+    @staticmethod
+    def label_formatter(var_name: str, var_value: int | float | str) -> str:
+        """Take a variable name and values and return a pretty version with approximate fixed width
+
+        Args:
+            var_name (str): The name of the variable, usually a dimension
+            var_value (int | float | str): The value of the dimension
+
+        Returns:
+            str: Pretty string representation with fixed width
+        """
+
+        if isinstance(var_value, (int, float)):
+            var_value = FormatFloat()(var_value)
+        if var_name is not None and var_value is not None:
+            return f"{var_name}={var_value}"
+        if var_name is not None:
+            return f"{var_name}"
+        if var_value is not None:
+            return f"{var_value}"
+        return None
+
+    def __init__(self, horizontal: bool = True) -> None:
+        self.horizontal: bool = horizontal
+        self.compose_method = ComposeType.right
+        self.container = []
+
+    def append(self, obj: Any) -> None:
+        """Add an object to the container.  The relationship between the objects is defined by the ComposeType
+
+        Args:
+            obj (Any): Object to add to the container
+        """
+        self.container.append(obj)
+
+    def render(self):
+        """Return a representation of the container that can be composed with other render() results. This function can also be used to defer layout and rending options until all the information about the container content is known.  You may need to ovverride this method depending on the container. See composable_container_video as an example.
+
+        Returns:
+            Any: Visual representation of the container that can be combined with other containers
+        """
+        return self.container

bencher/results/composable_container/composable_container_panel.py

@@ -0,0 +1,40 @@
+import panel as pn
+from bencher.results.composable_container.composable_container_base import ComposableContainerBase
+
+
+class ComposableContainerPanel(ComposableContainerBase):
+    def __init__(
+        self,
+        name: str = None,
+        var_name: str = None,
+        var_value: str = None,
+        width: int = None,
+        background_col: str = None,
+        horizontal: bool = True,
+    ) -> None:
+        super().__init__(horizontal)
+
+        container_args = {
+            "name": name,
+            "styles": {},
+        }
+
+        self.name = name
+
+        if width is not None:
+            container_args["styles"]["border-bottom"] = f"{width}px solid grey"
+        if background_col is not None:
+            container_args["styles"]["background"] = background_col
+
+        if horizontal:
+            self.container = pn.Column(**container_args)
+            align = ("center", "center")
+        else:
+            self.container = pn.Row(**container_args)
+            align = ("end", "center")
+
+        label = self.label_formatter(var_name, var_value)
+        if label is not None:
+            self.label_len = len(label)
+            side = pn.pane.Markdown(label, align=align)
+            self.append(side)

bencher/results/composable_container/composable_container_video.py

@@ -0,0 +1,54 @@
+import numpy as np
+from moviepy.editor import (
+    ImageClip,
+    CompositeVideoClip,
+    clips_array,
+    concatenate_videoclips,
+    VideoClip,
+)
+
+from bencher.results.composable_container.composable_container_base import ComposableContainerBase
+from bencher.video_writer import VideoWriter
+
+
+class ComposableContainerVideo(ComposableContainerBase):
+    def __init__(
+        self,
+        name: str = None,
+        var_name: str = None,
+        var_value: str = None,
+        background_col: tuple[3] = (255, 255, 255),
+        horizontal: bool = True,
+    ) -> None:
+        super().__init__(horizontal)
+        self.name = name
+        self.container = []
+        self.background_col = background_col
+
+        self.label = self.label_formatter(var_name, var_value)
+        if self.label is not None:
+            self.label_len = len(self.label)
+
+    def append(self, obj: VideoClip | str) -> None:
+        if isinstance(obj, VideoClip):
+            self.container.append(obj)
+        else:
+            if self.label is not None:
+                img_obj = np.array(VideoWriter.label_image(obj, self.label))
+            else:
+                img_obj = obj
+            self.container.append(ImageClip(img_obj, duration=1.0))
+
+    def render(self, concatenate: bool = False) -> CompositeVideoClip:
+        if concatenate:
+            return concatenate_videoclips(self.container)
+        if self.horizontal:
+            # if self.label is not None:
+            #     width =  self.label_len*6
+            #     img = VideoWriter.create_label(self.label, width=width)
+            #     side = ImageClip(np.array(img), duration=1.0)
+            #     self.container.insert(0, side)
+            clips = [self.container]
+        else:
+            clips = [[c] for c in self.container]
+        return clips_array(clips, bg_color=self.background_col)

bencher/results/panel_result.py

@@ -1,12 +1,10 @@
-from typing import Optional, Any
+from typing import Optional
 from functools import partial
 import panel as pn
-import xarray as xr
 from param import Parameter
 from bencher.results.bench_result_base import BenchResultBase, ReduceType
 from bencher.results.video_result import VideoControls
 from bencher.variables.results import (
-    ResultReference,
     PANEL_TYPES,
 )
 
@@ -19,35 +17,6 @@ class PanelResult(BenchResultBase):
             self.to_panes(result_var=result_var, container=vc.video_container, **kwargs),
         )
 
-    def zero_dim_da_to_val(self, da_ds: xr.DataArray | xr.Dataset) -> Any:
-        # todo this is really horrible, need to improve
-        dim = None
-        if isinstance(da_ds, xr.Dataset):
-            dim = list(da_ds.keys())[0]
-            da = da_ds[dim]
-        else:
-            da = da_ds
-
-        for k in da.coords.keys():
-            dim = k
-            break
-        if dim is None:
-            return da_ds.values.squeeze().item()
-        return da.expand_dims(dim).values[0]
-
-    def ds_to_container(
-        self, dataset: xr.Dataset, result_var: Parameter, container, **kwargs
-    ) -> Any:
-        val = self.zero_dim_da_to_val(dataset[result_var.name])
-        if isinstance(result_var, ResultReference):
-            ref = self.object_index[val]
-            val = ref.obj
-            if ref.container is not None:
-                return ref.container(val, **kwargs)
-        if container is not None:
-            return container(val, styles={"background": "white"}, **kwargs)
-        return val
-
     def to_panes(
         self, result_var: Parameter = None, target_dimension: int = 0, container=None, **kwargs
     ) -> Optional[pn.pane.panel]:

bencher/results/video_summary.py

@@ -5,12 +5,14 @@ import panel as pn
 import xarray as xr
 from param import Parameter
 from bencher.results.bench_result_base import BenchResultBase, ReduceType
-from bencher.variables.results import ResultImage, ResultVideo
+from bencher.variables.results import ResultImage
 from bencher.plotting.plot_filter import VarRange, PlotFilter
 from bencher.utils import callable_name, listify
 from bencher.video_writer import VideoWriter
 from bencher.results.float_formatter import FormatFloat
 from bencher.results.video_result import VideoControls
+from bencher.utils import int_to_col
+from bencher.results.composable_container.composable_container_video import ComposableContainerVideo
 
 
 class VideoSummaryResult(BenchResultBase):
@@ -19,6 +21,7 @@ class VideoSummaryResult(BenchResultBase):
         result_var: Parameter = None,
         input_order: List[str] = None,
         reverse: bool = True,
+        result_types=(ResultImage,),
         **kwargs,
     ) -> Optional[pn.panel]:
         plot_filter = PlotFilter(
@@ -35,7 +38,7 @@ class VideoSummaryResult(BenchResultBase):
             ds = self.to_dataset(ReduceType.SQUEEZE)
             row = pn.Row()
             for rv in self.get_results_var_list(result_var):
-                if isinstance(rv, (ResultImage, ResultVideo)):
+                if isinstance(rv, result_types):
                     row.append(self.to_video_summary_ds(ds, rv, input_order, reverse, **kwargs))
             return row
         return matches_res.to_panel()
@@ -69,9 +72,127 @@ class VideoSummaryResult(BenchResultBase):
                 if isinstance(index[i], (int, float)):
                     index[i] = FormatFloat()(index[i])
             label = ", ".join(f"{a[0]}={a[1]}" for a in list(zip(input_order, index)))
-            vr.append_file(val, label)
-        vr.write_png()
-        if video_controls is None:
-            video_controls = VideoControls()
-        vid = video_controls.video_container(vr.filename, **kwargs)
-        return vid
+            if val is not None:
+                vr.append_file(val, label)
+        fn = vr.write_png()
+        if fn is not None:
+            if video_controls is None:
+                video_controls = VideoControls()
+            vid = video_controls.video_container(fn, **kwargs)
+            return vid
+
+        return None
+
+    def to_video_grid(
+        self,
+        result_var: Parameter = None,
+        result_types=(ResultImage,),
+        **kwargs,
+    ) -> Optional[pn.panel]:
+        plot_filter = PlotFilter(
+            float_range=VarRange(0, None),
+            cat_range=VarRange(0, None),
+            panel_range=VarRange(1, None),
+            input_range=VarRange(1, None),
+        )
+        matches_res = plot_filter.matches_result(
+            self.plt_cnt_cfg, callable_name(self.to_video_grid_ds)
+        )
+        if matches_res.overall:
+            ds = self.to_dataset(ReduceType.SQUEEZE)
+            row = pn.Row()
+            for rv in self.get_results_var_list(result_var):
+                if isinstance(rv, result_types):
+                    row.append(self.to_video_grid_ds(ds, rv, **kwargs))
+            return row
+        return matches_res.to_panel()
+
+    def to_video_grid_ds(
+        self,
+        dataset: xr.Dataset,
+        result_var: Parameter,
+        reverse=True,
+        video_controls: VideoControls = None,
+        **kwargs,
+    ):
+        vr = VideoWriter()
+
+        cvc = self._to_video_panes_ds(
+            dataset,
+            self.plot_cb,
+            target_dimension=0,
+            horizontal=True,
+            result_var=result_var,
+            final=True,
+            reverse=reverse,
+            **kwargs,
+        )
+
+        fn = vr.write_video_raw(cvc)
+
+        if fn is not None:
+            if video_controls is None:
+                video_controls = VideoControls()
+            vid = video_controls.video_container(fn, **kwargs)
+            return vid
+        return None
+
+    def plot_cb(self, dataset, result_var, **kwargs):
+        val = self.ds_to_container(dataset, result_var, container=None, **kwargs)
+        # print(val)
+        return val
+
+    def _to_video_panes_ds(
+        self,
+        dataset: xr.Dataset,
+        plot_callback: callable = None,
+        target_dimension=0,
+        horizontal=False,
+        result_var=None,
+        final=False,
+        reverse=False,
+        **kwargs,
+    ) -> pn.panel:
+        num_dims = len(dataset.sizes)
+        dims = list(d for d in dataset.sizes)
+        if reverse:
+            dims = list(reversed(dims))
+
+        if num_dims > (target_dimension) and num_dims != 0:
+            selected_dim = dims[-1]
+            # print(f"selected dim {selected_dim}")
+            dim_color = int_to_col(num_dims - 2, 0.05, 1.0)
+
+            outer_container = ComposableContainerVideo(
+                name=" vs ".join(dims),
+                background_col=dim_color,
+                horizontal=horizontal,
+                # var_name=selected_dim,
+                # var_value=label_val,
+            )
+            max_len = 0
+            for i in range(dataset.sizes[selected_dim]):
+                sliced = dataset.isel({selected_dim: i})
+                label_val = sliced.coords[selected_dim].values.item()
+                inner_container = ComposableContainerVideo(
+                    outer_container.name,
+                    var_name=selected_dim,
+                    var_value=label_val,
+                    horizontal=horizontal,
+                )
+                panes = self._to_video_panes_ds(
+                    sliced,
+                    plot_callback=plot_callback,
+                    target_dimension=target_dimension,
+                    horizontal=len(sliced.sizes) <= target_dimension + 1,
+                    result_var=result_var,
+                )
+                inner_container.append(panes)
+
+                if inner_container.label_len > max_len:
+                    max_len = inner_container.label_len
+
+                rendered = inner_container.render()
+                outer_container.append(rendered)
+            return outer_container.render(concatenate=final)
+        return plot_callback(dataset=dataset, result_var=result_var, **kwargs)

bencher/utils.py

@@ -132,11 +132,11 @@ def gen_path(filename, folder, suffix):
     return f"{path.absolute().as_posix()}/{filename}_{uuid4()}{suffix}"
 
 
-def gen_video_path(video_name: str, extension: str = ".webm") -> str:
+def gen_video_path(video_name: str = "vid", extension: str = ".webm") -> str:
     return gen_path(video_name, "vid", extension)
 
 
-def gen_image_path(image_name: str, filetype=".png") -> str:
+def gen_image_path(image_name: str = "img", filetype=".png") -> str:
     return gen_path(image_name, "img", filetype)
 
 

bencher/variables/parametrised_sweep.py

@@ -125,15 +125,32 @@ class ParametrizedSweep(Parameterized):
         return item.name != p_name
 
     @classmethod
-    def get_input_defaults(cls, override_defaults: List = None) -> List[Tuple[Parameter, Any]]:
+    def get_input_defaults(
+        cls,
+        override_defaults: List = None,
+    ) -> List[Tuple[Parameter, Any]]:
         inp = cls.get_inputs_only()
         if override_defaults is None:
             override_defaults = []
         assert isinstance(override_defaults, list)
+
         for p in override_defaults:
             inp = filter(partial(ParametrizedSweep.filter_fn, p_name=p[0].name), inp)
+
         return override_defaults + [[i, i.default] for i in inp]
 
+    @classmethod
+    def get_input_defaults_override(cls, **kwargs) -> dict[str, Any]:
+        inp = cls.get_inputs_only()
+        defaults = {}
+        for i in inp:
+            defaults[i.name] = i.default
+
+        for k, v in kwargs.items():
+            defaults[k] = v
+
+        return defaults
+
     @classmethod
     def get_results_only(cls) -> List[Parameter]:
         """Return a list of input parameters

bencher/video_writer.py

@@ -2,10 +2,16 @@ import numpy as np
 import moviepy.video.io.ImageSequenceClip
 from pathlib import Path
 from .utils import gen_video_path, gen_image_path
+
 import moviepy
-from moviepy.editor import VideoFileClip, ImageClip, ImageSequenceClip
+from moviepy.editor import (
+    VideoFileClip,
+    ImageClip,
+    ImageSequenceClip,
+    clips_array,
+    concatenate_videoclips,
+)
 from PIL import Image, ImageDraw
-from moviepy.editor import clips_array, concatenate_videoclips
 
 
 class VideoWriter:
@@ -18,21 +24,26 @@ class VideoWriter:
     def append(self, img):
         self.images.append(img)
 
-    def write(self, bitrate: int = 1500) -> str:
-        # todo
-        # if len(self.images[0.shape) == 2:
-        #     for i in range(len(self.images)):
-        #         self.images[i] = np.expand_dims(self.images[i], 2)
-
+    def write(self, bitrate: int = 2000) -> str:
         clip = moviepy.video.io.ImageSequenceClip.ImageSequenceClip(
             self.images, fps=30, with_mask=False, load_images=True
         )
-        clip.write_videofile(self.filename, bitrate=f"{bitrate}k", logger=None)
+        self.write_video_raw(clip, bitrate=bitrate)
         return self.filename
 
-    def create_label(self, label, width, height=20):
+    @staticmethod
+    def create_label(label, width, height=20):
         new_img = Image.new("RGB", (width, height), (255, 255, 255))
-        ImageDraw.Draw(new_img).text((0, 0), label, (0, 0, 0))
+        # ImageDraw.Draw(new_img).text((width/2, 0), label, (0, 0, 0),align="center",achor="ms")
+        ImageDraw.Draw(new_img).text((width / 2.0, 0), label, (0, 0, 0), anchor="mt")
+
+        return new_img
+
+    @staticmethod
+    def label_image(path: Path, label, padding=20) -> Path:
+        image = Image.open(path)
+        new_img = VideoWriter.create_label(label, image.size[0], image.size[1] + padding)
+        new_img.paste(image, (0, padding))
         return new_img
 
     def append_file(self, filepath, label=None):
@@ -66,21 +77,34 @@ class VideoWriter:
         else:
             self.image_files.append(filepath)
 
-    def write_png(self, bitrate: int = 1500, target_duration: float = 10.0, frame_time=None):
-        if frame_time is None:
-            fps = len(self.image_files) / target_duration
-            fps = max(fps, 1)  # never slower that 1 seconds per frame
-            fps = min(fps, 30)
-        else:
-            fps = 1.0 / frame_time
+    def to_images_sequence(self, images, target_duration: float = 10.0, frame_time=None):
+        if isinstance(images, list) and len(images) > 0:
+            if frame_time is None:
+                fps = len(images) / target_duration
+                fps = max(fps, 1)  # never slower that 1 seconds per frame
+                fps = min(fps, 30)
+            else:
+                fps = 1.0 / frame_time
+            return ImageSequenceClip(images, fps=fps, with_mask=False)
+        return None
 
+    def write_png(self):
+        clip = None
         if len(self.image_files) > 0:
-            clip = ImageSequenceClip(self.image_files, fps=fps, with_mask=False)
-            clip.write_videofile(self.filename, bitrate=f"{bitrate}k", logger=None)
+            clip = self.to_images_sequence(self.image_files)
         if len(self.video_files) > 0:
             clip = concatenate_videoclips([VideoFileClip(f) for f in self.video_files])
-            clip.write_videofile(self.filename, logger=None)
-            # clip = ImageSequenceClip(self.image_files, fps=fps, with_mask=False)
+        if clip is not None:
+            clip.write_videofile(self.filename)
+            return self.filename
+        return None
+
+    def write_video_raw(
+        self, video_clip: moviepy.video.VideoClip, bitrate: int = 2000, fps: int = 30
+    ) -> str:
+        video_clip.write_videofile(self.filename, codec="libvpx", bitrate=f"{bitrate}k", fps=fps)
+        video_clip.close()
+        return self.filename
 
 
 def add_image(np_array: np.ndarray, name: str = "img"):

{holobench-1.5.0.dist-info → holobench-1.7.0.dist-info}/METADATA

@@ -1,33 +1,33 @@
 Metadata-Version: 2.1
 Name: holobench
-Version: 1.5.0
+Version: 1.7.0
 Summary: A package for benchmarking the performance of arbitrary functions
 Author-email: Austin Gregg-Smith <blooop@gmail.com>
 Description-Content-Type: text/markdown
 Requires-Dist: holoviews>=1.15,<=1.18.1
-Requires-Dist: numpy>=1.0,<=1.26.2
-Requires-Dist: param>=1.13.0,<=2.0.1
-Requires-Dist: hvplot>=0.8,<=0.9.1
+Requires-Dist: numpy>=1.0,<=1.26.3
+Requires-Dist: param>=1.13.0,<=2.0.2
+Requires-Dist: hvplot>=0.8,<=0.9.2
 Requires-Dist: matplotlib>=3.6.3,<=3.8.2
-Requires-Dist: panel>=1.3.6,<=1.3.6
+Requires-Dist: panel>=1.3.6,<=1.3.8
 Requires-Dist: diskcache>=5.6,<=5.6.3
 Requires-Dist: optuna>=3.2,<=3.5.0
-Requires-Dist: xarray>=2023.7,<=2023.12.0
+Requires-Dist: xarray>=2023.7,<=2024.1.1
 Requires-Dist: plotly>=5.15,<=5.18.0
 Requires-Dist: sortedcontainers>=2.4,<=2.4
-Requires-Dist: pandas>=2.0,<=2.1.4
+Requires-Dist: pandas>=2.0,<=2.2.0
 Requires-Dist: strenum>=0.4.0,<=0.4.15
-Requires-Dist: scikit-learn>=1.2,<=1.3.2
+Requires-Dist: scikit-learn>=1.2,<=1.4.0
 Requires-Dist: str2bool>=1.1,<=1.1
 Requires-Dist: scoop>=0.7.0,<=0.7.2.0
 Requires-Dist: moviepy>=1.0.3,<=1.0.3
-Requires-Dist: black>=23,<=23.12.1 ; extra == "test"
+Requires-Dist: black>=23,<=24.1.1 ; extra == "test"
 Requires-Dist: pylint>=2.16,<=3.0.3 ; extra == "test"
 Requires-Dist: pytest-cov>=4.1,<=4.1 ; extra == "test"
-Requires-Dist: pytest>=7.4,<=7.4.4 ; extra == "test"
-Requires-Dist: hypothesis>=6.82,<=6.92.2 ; extra == "test"
-Requires-Dist: ruff>=0.0.280,<=0.1.9 ; extra == "test"
-Requires-Dist: coverage>=7.2.7,<=7.4.0 ; extra == "test"
+Requires-Dist: pytest>=7.4,<=8.0.0 ; extra == "test"
+Requires-Dist: hypothesis>=6.82,<=6.97.4 ; extra == "test"
+Requires-Dist: ruff>=0.0.280,<=0.1.15 ; extra == "test"
+Requires-Dist: coverage>=7.2.7,<=7.4.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.5.0.dist-info → holobench-1.7.0.dist-info}/RECORD

@@ -1,14 +1,14 @@
 bencher/__init__.py,sha256=lw9moEkY3rb3kQVS3_SM9L0LsOAXRSM1JUJ_mm16tMQ,1236
-bencher/bench_cfg.py,sha256=0dIF_JrvWYiugNDi28wh_8a8ejm99cnw3RrlMIDI2Ww,18714
-bencher/bench_plot_server.py,sha256=HnW6XpmARweMCd-koqzu1lxuj0gA4_fP-72D3Yfy-0M,4087
-bencher/bench_report.py,sha256=b9jLksrXzBhSmvI7KetO1i0hsHknE7qk4b4k0MGGtNw,10484
-bencher/bench_runner.py,sha256=TLJGn-NO4BBBZMG8W5E6u7IPyij67Yk3S4B29ONClnk,6049
-bencher/bencher.py,sha256=R9bvH_97T2qY7atwT38r2lDFzXSxr4ODfLxFGGVQNfM,31884
+bencher/bench_cfg.py,sha256=IUhAhjpn_RkBTHonWN7deye_gYLgvTHszSGtcHj4MJY,18867
+bencher/bench_plot_server.py,sha256=ZePbN9lKMQggONYMBW0CJm9saLjmxtdeAEs6eiei_8g,4088
+bencher/bench_report.py,sha256=jh3T_q9KByZDeMPMf0KNJojZukxRzkfaYGeuWQU8MKM,10528
+bencher/bench_runner.py,sha256=AE1V0zGOxhe6qByFbb-V60GUugg3vQzyUxFK8Z1yc6Y,6072
+bencher/bencher.py,sha256=GZBRPT3BsA-Iv9I0lRl8QgOJnAee8fnPa94vcyRvzxs,32438
 bencher/caching.py,sha256=AusaNrzGGlj5m6zcwcqnTn55Mam2mQdF--oqelO806M,1627
 bencher/job.py,sha256=Q2zpia95Ibukk8EeFq5IBbpo2PMRe7o5keelJCJlGnI,5927
 bencher/optuna_conversions.py,sha256=9nLVPAydSQ8PyJlyhzs__Em6_Rx8l8Ld94UNJZxy6cY,5303
-bencher/utils.py,sha256=d8kkFpXXUF4d-Khdggdma95c5iT8fj-ZmHnE_mBpUqs,5520
-bencher/video_writer.py,sha256=1BVebcaIuUO6gJ-XMKSdFmhz5xbdAmhHNXIN084urDE,3725
+bencher/utils.py,sha256=QwK8uqt5RhYJc5A3zsHiuBxx7CHOa1YxwDNA6QBzCz4,5536
+bencher/video_writer.py,sha256=TiNpx5MteVzZLf0jUfZoSQrhvvTCUTewRkHGod9IOnE,4286
 bencher/worker_job.py,sha256=FREi0yWQACFmH86R1j-LH72tALEFkKhLDmmoGQY9Jh4,1571
 bencher/example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bencher/example/benchmark_data.py,sha256=D9yUg_KKtqqEkAiLceodDwsv6sh7xEFWZNp6P6Y3pj4,6989
@@ -17,23 +17,23 @@ bencher/example/example_categorical.py,sha256=3BeOQN58nCGx6xzB0YvkgaBFInzJ5L3XsI
 bencher/example/example_custom_sweep.py,sha256=-y8mYuXYD91j8kcCEe9c6Gx6g1dK-bvHM9sbXqHL2gA,1916
 bencher/example/example_docs.py,sha256=aUi33O543JBPoOGlpHaY2eA74GR7cHH_6-hcC8xf3z0,1174
 bencher/example/example_float3D.py,sha256=pwi3YlDad3NL4IrfMK2V5yV1CRpqfmUO-zUnGmVYxDs,3425
-bencher/example/example_float_cat.py,sha256=RZiKEACZyGDnubxhaUcabI43AYvm3h7qt0SCUp5Yuso,3810
+bencher/example/example_float_cat.py,sha256=7f1xL5Rjn2Iy5TaVrvTafFiPZZU-KHQ6TvW6HyVrCMo,3811
 bencher/example/example_floats.py,sha256=HcQgfwldTVeFBmBTMtZ0yRy17ZJ4cfJeI_t8TxY2iOI,4269
 bencher/example/example_floats2D.py,sha256=D0kljoUCinMKCEW-Zg-cQ8sYu_yPCZqzKJ9tRtt-Ono,3697
 bencher/example/example_holosweep.py,sha256=d9g5aWCAUb7FMZahb4t3xNs344EshPhA-8-K6K1SBXg,3180
 bencher/example/example_holosweep_objects.py,sha256=vHuAtkM1VrJelHOazn_SJfzxNywKyaMzN-DE8W7Ricc,3228
 bencher/example/example_holosweep_tap.py,sha256=3ayQ0bTj_XWP_92ifQJAhe1whwPAj_xWHPkzC7fvqAY,4540
-bencher/example/example_image.py,sha256=bsV2OYP2e_e8iXza-Xv94EAIG-W6L-hwJ047athOvoQ,3792
+bencher/example/example_image.py,sha256=87op1Z-VW-ypZOWjWUxDvJYJ9-MyELvb3_QW3sWkg5o,3410
 bencher/example/example_levels.py,sha256=rpSNB571yfMnT7iO66Ds-DPGHWzOTM9FLMNfSetJdHY,6896
 bencher/example/example_pareto.py,sha256=yyAg8Vb-5sgsS6LkYKT7T5Evcfg69FlCqCakUippSmU,2687
 bencher/example/example_sample_cache.py,sha256=7gf1BJ63VAgdqNuNXkbL9-jeTeC3kXA_PY9yG3ulTz0,4200
 bencher/example/example_sample_cache_context.py,sha256=IAUBbL78QM20R8evaq7L8I-xPxFDFykF1Gk1y2Ru1W0,4063
 bencher/example/example_simple.py,sha256=Nn2ixNx29jbgvwH2K5vDGhSFcqKLMNaP1occPxhHoU0,11703
-bencher/example/example_simple_bool.py,sha256=36KMSHyXZhzS1cp2TZnDLn7-GpShLdQ7mycuT0M3le8,1247
-bencher/example/example_simple_cat.py,sha256=YFccE84g37U2M3ByWYIcGNLXWdW_ktJbbZvGL0D6oHA,1759
+bencher/example/example_simple_bool.py,sha256=GZ6pyj8FaQV9gNxaqAmX6c5XWtMvKosezAbSADEl0G0,1248
+bencher/example/example_simple_cat.py,sha256=XsV_75Jk3phVPI4om3q0vn1POfREb3CGRm9Kq1tL-OA,1760
 bencher/example/example_simple_float.py,sha256=X4vsH0F4fZAoO0EKB1xIzFMY0f0Wyk8LV2plPlSEsbI,1323
 bencher/example/example_strings.py,sha256=BdsEZgLT9mOxLkBKNHz2XpPwwe4SzNTdjnY1WVlOmNM,1570
-bencher/example/example_time_event.py,sha256=y1vpK7UDrObEu0Z1x3e4OQzvGCQ7pF5GZvpKLegMbYk,2158
+bencher/example/example_time_event.py,sha256=e6R-a6ZPe-ePiWoNvN3YuSQK-Y2HOGntsjCm_SPon28,2159
 bencher/example/example_video.py,sha256=IJGgRHmpeppOKwhSkDHDJVuHw32yBJiBpbKaI34soHI,3742
 bencher/example/example_workflow.py,sha256=00QnUuViMfX_PqzqkXmg1wPX6yAq7IS7mCL_RFKwrMM,6806
 bencher/example/experimental/example_bokeh_plotly.py,sha256=3jUKh8eKIAlpklKnp8UopIHhUDw1A0_5CwjeyTzbi7o,846
@@ -57,20 +57,24 @@ 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=gKhMTCZ1V-hrkqwFRSE7c0Hswa7lD87RAi8gWzq32C4,3088
-bencher/results/bench_result_base.py,sha256=ZDm2DDngsg0QRglbaQlSMRpuxGHpoiiruAMGL1VuXso,15770
+bencher/results/bench_result.py,sha256=9whs_FNftl3rfB7oGzwSbF_-kxRK5U2gvnwpvSRc9qQ,3366
+bencher/results/bench_result_base.py,sha256=ymR99Fvnmbsw6Qn24wPP1gesofjATKwKX_FcpCT9ZWU,16257
 bencher/results/float_formatter.py,sha256=sX6HNCyaXdHDxC8ybVUHwCJ3qOKbPUkBOplVIHtKWjM,1746
 bencher/results/holoview_result.py,sha256=nfXYTaGQkXwLqJ_gEB3TYJxHfKAQCN1E60D9Tfbkxos,22254
 bencher/results/optuna_result.py,sha256=jtsWJGdCS0L98EzxTxXU_AyarCL5CkXRLOVuSvs048M,13437
-bencher/results/panel_result.py,sha256=wJAIrmOocXlRzsYRIuA7G4BQSvcvNkq_LIYtKyrqZ2w,2175
+bencher/results/panel_result.py,sha256=ZHTkobAYHHsYYvQqLafba8g3rbT255hKO7u9A_oMBhM,1115
 bencher/results/plotly_result.py,sha256=wkgfL38qJp6RviekXBYpNPeU4HCf0nbtKDAhu5QZhUg,2132
 bencher/results/video_result.py,sha256=E3fAxXctRVxiRyamadpKCMXanM5TTqw1tEYICS2LDLs,1146
-bencher/results/video_summary.py,sha256=r6C8y5sehoXpMHKutyVhYBFPPzvN7UZMNAMwm7fhEnM,2780
+bencher/results/video_summary.py,sha256=2oYxPDjFknDg16OOm8hhr29_TyMNbBh3v8R2EuRoQQg,6875
+bencher/results/composable_container/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bencher/results/composable_container/composable_container_base.py,sha256=u5bSXD0yuKSwvr2z3cWF1FijQqpr-pciPm86JxhLmJo,2323
+bencher/results/composable_container/composable_container_panel.py,sha256=A56-MaaaId_VBMFhvM7Jtfh8_3PeKNxlEnOKU49IsW8,1221
+bencher/results/composable_container/composable_container_video.py,sha256=yxvVTnK86O9kW2vIfSSv83zpSobVtFOB0-7tbcusbWA,1847
 bencher/variables/inputs.py,sha256=XtUko3qNYB1xk7fwM9teVGRU0MNCW673n2teGtoyFGU,6393
-bencher/variables/parametrised_sweep.py,sha256=5yCsyzpyrWUfZSCNxnLPSAAay9YntCRb-UMoXTmsBOc,7037
+bencher/variables/parametrised_sweep.py,sha256=sqi5JPzloZ7f6fiZZwOFMa3AQnFWkfjYXQy7OWSask0,7361
 bencher/variables/results.py,sha256=QCn7IZd4RwcRcDCp6DQp8w0wBMnHzluyw-Hu19Jg7Ig,6028
 bencher/variables/sweep_base.py,sha256=I1LEeG1y5Jsw0a-Ik03t0tSzcfENht2GmBECJ3KNs28,6559
 bencher/variables/time.py,sha256=Le7s8_oUYJD4wCqwQw-a_FRDpYQOi8CqMbGYsBF07jg,2860
-holobench-1.5.0.dist-info/WHEEL,sha256=Sgu64hAMa6g5FdzHxXv9Xdse9yxpGGMeagVtPMWpJQY,99
-holobench-1.5.0.dist-info/METADATA,sha256=UkkQraH7uxRtV_qXQAepbLeY9sk7s6PMWGol96ahBvs,5110
-holobench-1.5.0.dist-info/RECORD,,
+holobench-1.7.0.dist-info/WHEEL,sha256=Sgu64hAMa6g5FdzHxXv9Xdse9yxpGGMeagVtPMWpJQY,99
+holobench-1.7.0.dist-info/METADATA,sha256=AL1TkmzE02fT5sl6xlhwdALAElXC8CeHyrir-8VF8oQ,5109
+holobench-1.7.0.dist-info/RECORD,,