holobench 1.6.0__tar.gz → 1.7.0__tar.gz

{holobench-1.6.0 → holobench-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: holobench
-Version: 1.6.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

{holobench-1.6.0 → holobench-1.7.0}/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

{holobench-1.6.0 → holobench-1.7.0}/bencher/bench_report.py

@@ -48,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:

{holobench-1.6.0 → holobench-1.7.0}/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
 
@@ -171,6 +172,10 @@ class Bench(BenchPlotServer):
         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
@@ -243,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.
 
@@ -257,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
 
@@ -369,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,
@@ -381,6 +394,7 @@ class Bench(BenchPlotServer):
             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)
 
@@ -443,6 +457,7 @@ class Bench(BenchPlotServer):
 
         if bench_cfg.auto_plot:
             self.report.append_result(bench_res)
+
         self.results.append(bench_res)
         return bench_res
 

{holobench-1.6.0 → holobench-1.7.0}/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()

{holobench-1.6.0 → holobench-1.7.0}/bencher/results/bench_result.py

@@ -35,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,
@@ -67,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:

{holobench-1.6.0 → holobench-1.7.0}/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):

holobench-1.7.0/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

holobench-1.7.0/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)

holobench-1.7.0/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)

holobench-1.7.0/bencher/results/panel_result.py

@@ -0,0 +1,32 @@
+from typing import Optional
+from functools import partial
+import panel as pn
+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 (
+    PANEL_TYPES,
+)
+
+
+class PanelResult(BenchResultBase):
+    def to_video(self, result_var: Parameter = None, **kwargs):
+        vc = VideoControls()
+        return pn.Column(
+            vc.video_controls(),
+            self.to_panes(result_var=result_var, container=vc.video_container, **kwargs),
+        )
+
+    def to_panes(
+        self, result_var: Parameter = None, target_dimension: int = 0, container=None, **kwargs
+    ) -> Optional[pn.pane.panel]:
+        if container is None:
+            container = pn.pane.panel
+        return self.map_plot_panes(
+            partial(self.ds_to_container, container=container),
+            hv_dataset=self.to_hv_dataset(ReduceType.SQUEEZE),
+            target_dimension=target_dimension,
+            result_var=result_var,
+            result_types=PANEL_TYPES,
+            **kwargs,
+        )

holobench-1.7.0/bencher/results/video_summary.py

@@ -0,0 +1,198 @@
+from bencher.utils import params_to_str
+from typing import Optional, List
+import itertools
+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
+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):
+    def to_video_summary(
+        self,
+        result_var: Parameter = None,
+        input_order: List[str] = None,
+        reverse: bool = True,
+        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),
+        )
+        matches_res = plot_filter.matches_result(
+            self.plt_cnt_cfg, callable_name(self.to_video_summary_ds)
+        )
+
+        # video_controls = VideoControls()
+        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_summary_ds(ds, rv, input_order, reverse, **kwargs))
+            return row
+        return matches_res.to_panel()
+
+    def to_video_summary_ds(
+        self,
+        dataset: xr.Dataset,
+        result_var: Parameter,
+        input_order: List[str] = None,
+        reverse: bool = True,
+        video_controls: VideoControls = None,
+        **kwargs,
+    ):
+        vr = VideoWriter()
+        da = dataset[result_var.name]
+
+        if input_order is None:
+            input_order = list(da.dims)
+        else:
+            input_order = params_to_str(input_order)
+        if reverse:
+            input_order = list(reversed(input_order))
+
+        inputs_produc = [da.coords[i].values for i in input_order]
+
+        for index in itertools.product(*inputs_produc):
+            lookup = dict(zip(input_order, index))
+            val = da.loc[lookup].item()
+            index = listify(index)
+            for i in range(len(index)):
+                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)))
+            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)

{holobench-1.6.0 → holobench-1.7.0}/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,24 +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")
-            return self.filename
+            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])
+        if clip is not None:
             clip.write_videofile(self.filename)
             return self.filename
         return None
-        # clip = ImageSequenceClip(self.image_files, fps=fps, with_mask=False)
+
+    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.6.0 → holobench-1.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "holobench"
-version = "1.6.0"
+version = "1.7.0"
 
 authors = [{ name = "Austin Gregg-Smith", email = "blooop@gmail.com" }]
 description = "A package for benchmarking the performance of arbitrary functions"

holobench-1.6.0/bencher/results/panel_result.py

@@ -1,63 +0,0 @@
-from typing import Optional, Any
-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,
-)
-
-
-class PanelResult(BenchResultBase):
-    def to_video(self, result_var: Parameter = None, **kwargs):
-        vc = VideoControls()
-        return pn.Column(
-            vc.video_controls(),
-            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]:
-        if container is None:
-            container = pn.pane.panel
-        return self.map_plot_panes(
-            partial(self.ds_to_container, container=container),
-            hv_dataset=self.to_hv_dataset(ReduceType.SQUEEZE),
-            target_dimension=target_dimension,
-            result_var=result_var,
-            result_types=PANEL_TYPES,
-            **kwargs,
-        )

holobench-1.6.0/bencher/results/video_summary.py

@@ -1,81 +0,0 @@
-from bencher.utils import params_to_str
-from typing import Optional, List
-import itertools
-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
-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
-
-
-class VideoSummaryResult(BenchResultBase):
-    def to_video_summary(
-        self,
-        result_var: Parameter = None,
-        input_order: List[str] = None,
-        reverse: bool = True,
-        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),
-        )
-        matches_res = plot_filter.matches_result(
-            self.plt_cnt_cfg, callable_name(self.to_video_summary_ds)
-        )
-
-        # video_controls = VideoControls()
-        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_summary_ds(ds, rv, input_order, reverse, **kwargs))
-            return row
-        return matches_res.to_panel()
-
-    def to_video_summary_ds(
-        self,
-        dataset: xr.Dataset,
-        result_var: Parameter,
-        input_order: List[str] = None,
-        reverse: bool = True,
-        video_controls: VideoControls = None,
-        **kwargs,
-    ):
-        vr = VideoWriter()
-        da = dataset[result_var.name]
-
-        if input_order is None:
-            input_order = list(da.dims)
-        else:
-            input_order = params_to_str(input_order)
-        if reverse:
-            input_order = list(reversed(input_order))
-
-        inputs_produc = [da.coords[i].values for i in input_order]
-
-        for index in itertools.product(*inputs_produc):
-            lookup = dict(zip(input_order, index))
-            val = da.loc[lookup].item()
-            index = listify(index)
-            for i in range(len(index)):
-                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)))
-            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