holobench 1.5.0__tar.gz → 1.7.0__tar.gz

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

@@ -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 → 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.5.0 → holobench-1.7.0}/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

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

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

{holobench-1.5.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
 
@@ -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)

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

{holobench-1.5.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.5.0 → holobench-1.7.0}/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

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

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

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

{holobench-1.5.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)