holobench 1.3.5__py3-none-any.whl → 1.23.0__py3-none-any.whl

bencher/plotting/plot_filter.py

@@ -1,110 +0,0 @@
-from __future__ import annotations
-from typing import Optional
-from dataclasses import dataclass
-from bencher.plotting.plt_cnt_cfg import PltCntCfg
-import panel as pn
-
-
-class VarRange:
-    """A VarRange represents the bounded and unbounded ranges of integers.  This class is used to define filters for various variable types.  For example by defining cat_var = VarRange(0,0), calling matches(0) will return true, but any other integer will not match.  You can also have unbounded ranges for example VarRange(2,None) will match to 2,3,4... up to infinity. for By default the lower and upper bounds are set to -1 so so that no matter what value is passsed to matches() will return false.  Matches only takes 0 and positive integers."""
-
-    def __init__(self, lower_bound: int = 0, upper_bound: int = -1) -> None:
-        """
-        Args:
-            lower_bound (int, optional): The smallest acceptable value to matches(). Passing None will result in a lower bound of 0 (as matches only accepts positive integers). Defaults to 0.
-            upper_bound (int, optional): The largest acceptable value to matches().  Passing None will result in no upper bound. Defaults to -1 which results in a range with no matches.
-        """
-        self.lower_bound = lower_bound
-        self.upper_bound = upper_bound
-
-    def matches(self, val: int) -> bool:
-        """Checks that a value is within the variable range.  lower_bound and upper_bound are inclusive (lower_bound<=val<=upper_bound )
-
-        Args:
-            val (int): A positive integer representing a number of items
-
-        Returns:
-            bool: True if the items is within the range, False otherwise.
-
-        Raises:
-            ValueError: If val < 0
-        """
-        if val < 0:
-            raise ValueError("val must be >= 0")
-        if self.lower_bound is not None:
-            lower_match = val >= self.lower_bound
-        else:
-            lower_match = True
-
-        if self.upper_bound is not None:
-            upper_match = val <= self.upper_bound
-        else:
-            upper_match = True
-
-        return lower_match and upper_match
-
-    def matches_info(self, val, name):
-        match = self.matches(val)
-        info = f"{name}\t{match}\t{self.lower_bound}>= {val} <={self.upper_bound}"
-        return match, info
-
-    def __str__(self) -> str:
-        return f"VarRange(lower_bound={self.lower_bound}, upper_bound={self.upper_bound})"
-
-
-@dataclass
-class PlotFilter:
-    """A class for representing the types of results a plot is able to represent."""
-
-    float_range: VarRange = VarRange()
-    cat_range: VarRange = VarRange()
-    vector_len: VarRange = VarRange(1, 1)
-    result_vars: VarRange = VarRange(1, 1)
-    panel_range: VarRange = VarRange(0, 0)
-    repeats_range: VarRange = VarRange(1, None)
-    input_range: VarRange = VarRange(1, None)
-
-    def matches_result(self, plt_cnt_cfg: PltCntCfg, plot_name: str) -> PlotMatchesResult:
-        """Checks if the result data signature matches the type of data the plot is able to display."""
-        return PlotMatchesResult(self, plt_cnt_cfg, plot_name)
-
-
-# @dataclass
-class PlotMatchesResult:
-    """Stores information about which properites match the requirements of a particular plotter"""
-
-    def __init__(self, plot_filter: PlotFilter, plt_cnt_cfg: PltCntCfg, plot_name: str):
-        match_info = []
-        matches = []
-
-        match_candidates = [
-            (plot_filter.float_range, plt_cnt_cfg.float_cnt, "float"),
-            (plot_filter.cat_range, plt_cnt_cfg.cat_cnt, "cat"),
-            (plot_filter.vector_len, plt_cnt_cfg.vector_len, "vec"),
-            (plot_filter.result_vars, plt_cnt_cfg.result_vars, "results"),
-            (plot_filter.panel_range, plt_cnt_cfg.panel_cnt, "panels"),
-            (plot_filter.repeats_range, plt_cnt_cfg.repeats, "repeats"),
-            (plot_filter.input_range, plt_cnt_cfg.inputs_cnt, "inputs"),
-        ]
-
-        for m, cnt, name in match_candidates:
-            match, info = m.matches_info(cnt, name)
-            matches.append(match)
-            if not match:
-                match_info.append(info)
-
-        self.overall = all(matches)
-
-        match_info.insert(0, f"plot {plot_name} matches: {self.overall}")
-        self.matches_info = "\n".join(match_info).strip()
-        self.plt_cnt_cfg = plt_cnt_cfg
-
-        if self.plt_cnt_cfg.print_debug:
-            print(f"checking {plot_name} result: {self.overall}")
-            if not self.overall:
-                print(self.matches_info)
-
-    def to_panel(self, **kwargs) -> Optional[pn.pane.Markdown]:
-        if self.plt_cnt_cfg.print_debug:
-            return pn.pane.Markdown(self.matches_info, **kwargs)
-        return None

bencher/plotting/plt_cnt_cfg.py

@@ -1,74 +0,0 @@
-from __future__ import annotations
-import param
-from bencher.bench_cfg import BenchCfg
-from bencher.variables.results import PANEL_TYPES
-
-from bencher.variables.inputs import IntSweep, FloatSweep, BoolSweep, EnumSweep, StringSweep
-from bencher.variables.time import TimeSnapshot
-
-
-class PltCntCfg(param.Parameterized):
-    """Plot Count Config"""
-
-    float_vars = param.List(doc="A list of float vars in order of plotting, x then y")
-    float_cnt = param.Integer(0, doc="The number of float variables to plot")
-    cat_vars = param.List(doc="A list of categorical values to plot in order hue,row,col")
-    cat_cnt = param.Integer(0, doc="The number of cat variables")
-    vector_len = param.Integer(1, doc="The vector length of the return variable , scalars = len 1")
-    result_vars = param.Integer(1, doc="The number result variables to plot")  # todo remove
-    panel_vars = param.List(doc="A list of panel results")
-    panel_cnt = param.Integer(0, doc="Number of results reprented as panel panes")
-    repeats = param.Integer(0, doc="The number of repeat samples")
-    inputs_cnt = param.Integer(0, doc="The number of repeat samples")
-
-    print_debug = param.Boolean(
-        True, doc="Print debug information about why a filter matches this config or not"
-    )
-
-    @staticmethod
-    def generate_plt_cnt_cfg(
-        bench_cfg: BenchCfg,
-    ) -> PltCntCfg:
-        """Given a BenchCfg work out how many float and cat variables there are and store in a PltCntCfg class
-
-        Args:
-            bench_cfg (BenchCfg): See BenchCfg definition
-
-        Raises:
-            ValueError: If no plotting procedure could be automatically detected
-
-        Returns:
-            PltCntCfg: see PltCntCfg definition
-        """
-        plt_cnt_cfg = PltCntCfg()
-        # plt_cnt_cfg.float_vars = deepcopy(bench_cfg.iv_time)
-
-        plt_cnt_cfg.cat_vars = []
-        plt_cnt_cfg.float_vars = []
-
-        for iv in bench_cfg.input_vars:
-            if isinstance(iv, (IntSweep, FloatSweep, TimeSnapshot)):
-                # if "IntSweep" in typestr or "FloatSweep" in typestr:
-                plt_cnt_cfg.float_vars.append(iv)
-                type_allocated = True
-            if isinstance(iv, (EnumSweep, BoolSweep, StringSweep)):
-                # if "EnumSweep" in typestr or "BoolSweep" in typestr or "StringSweep" in typestr:
-                plt_cnt_cfg.cat_vars.append(iv)
-                type_allocated = True
-
-            if not type_allocated:
-                raise ValueError(f"No rule for type {type(iv)}")
-
-        for rv in bench_cfg.result_vars:
-            if isinstance(rv, PANEL_TYPES):
-                plt_cnt_cfg.panel_vars.append(rv)
-
-        plt_cnt_cfg.float_cnt = len(plt_cnt_cfg.float_vars)
-        plt_cnt_cfg.cat_cnt = len(plt_cnt_cfg.cat_vars)
-        plt_cnt_cfg.panel_cnt = len(plt_cnt_cfg.panel_vars)
-        plt_cnt_cfg.repeats = bench_cfg.repeats
-        plt_cnt_cfg.inputs_cnt = len(bench_cfg.input_vars)
-        return plt_cnt_cfg
-
-    def __str__(self):
-        return f"float_cnt: {self.float_cnt}\ncat_cnt: {self.cat_cnt} \npanel_cnt: {self.panel_cnt}\nvector_len: {self.vector_len}"

bencher/results/bench_result.py

@@ -1,80 +0,0 @@
-from __future__ import annotations
-from typing import List
-import panel as pn
-
-from bencher.results.panel_result import PanelResult
-from bencher.results.plotly_result import PlotlyResult
-from bencher.results.holoview_result import HoloviewResult
-from bencher.results.bench_result_base import EmptyContainer
-
-
-class BenchResult(PlotlyResult, HoloviewResult):
-
-    """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:
-        PlotlyResult.__init__(self, bench_cfg)
-        HoloviewResult.__init__(self, bench_cfg)
-
-    @staticmethod
-    def default_plot_callbacks():
-        return [
-            HoloviewResult.to_bar,
-            HoloviewResult.to_scatter_jitter,
-            HoloviewResult.to_curve,
-            HoloviewResult.to_line,
-            HoloviewResult.to_heatmap,
-            PlotlyResult.to_volume,
-            PanelResult.to_video,
-            PanelResult.to_panes,
-        ]
-
-    @staticmethod
-    def plotly_callbacks():
-        return [HoloviewResult.to_surface, PlotlyResult.to_volume]
-
-    def to_auto(
-        self,
-        plot_list: List[callable] = None,
-        remove_plots: List[callable] = None,
-        **kwargs,
-    ) -> List[pn.panel]:
-        self.plt_cnt_cfg.print_debug = False
-
-        if plot_list is None:
-            plot_list = BenchResult.default_plot_callbacks()
-        if remove_plots is not None:
-            for p in remove_plots:
-                plot_list.remove(p)
-
-        kwargs = self.set_plot_size(**kwargs)
-
-        row = EmptyContainer(pn.Row())
-        for plot_callback in plot_list:
-            if self.plt_cnt_cfg.print_debug:
-                print(f"checking: {plot_callback.__name__}")
-            # the callbacks are passed from the static class definition, so self needs to be passed before the plotting callback can be called
-            row.append(plot_callback(self, **kwargs))
-
-        self.plt_cnt_cfg.print_debug = True
-        if len(row.pane) == 0:
-            row.append(
-                pn.pane.Markdown("No Plotters are able to represent these results", **kwargs)
-            )
-        return row.pane
-
-    def to_auto_plots(self, **kwargs) -> List[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:
-            bench_cfg (BenchCfg): Information on how the benchmark was sampled and the resulting data
-
-        Returns:
-            pn.pane: A panel containing plot results
-        """
-
-        plot_cols = pn.Column()
-        plot_cols.append(self.to_sweep_summary(name="Plots View"))
-        plot_cols.append(self.to_auto(**kwargs))
-        plot_cols.append(self.bench_cfg.to_post_description())
-        return plot_cols

bencher/results/bench_result_base.py

@@ -1,405 +0,0 @@
-import logging
-from typing import List, Any, Tuple, Optional
-from enum import Enum, auto
-import xarray as xr
-from param import Parameter
-import holoviews as hv
-from functools import partial
-from bencher.utils import int_to_col, color_tuple_to_css, callable_name
-
-from bencher.variables.parametrised_sweep import ParametrizedSweep
-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
-
-
-# todo add plugins
-# https://gist.github.com/dorneanu/cce1cd6711969d581873a88e0257e312
-# https://kaleidoescape.github.io/decorated-plugins/
-
-
-class ReduceType(Enum):
-    AUTO = auto()  # automatically determine the best way to reduce the dataset
-    SQUEEZE = auto()  # remove any dimensions of length 1
-    REDUCE = auto()  # get the mean and std dev of the the "repeat" dimension
-    NONE = auto()  # don't reduce
-
-
-class EmptyContainer:
-    """A wrapper for list like containers that only appends if the item is not None"""
-
-    def __init__(self, pane) -> None:
-        self.pane = pane
-
-    def append(self, child):
-        if child is not None:
-            self.pane.append(child)
-
-    def get(self):
-        return self.pane if len(self.pane) > 0 else None
-
-
-class BenchResultBase(OptunaResult):
-    def result_samples(self) -> int:
-        """The number of samples in the results dataframe"""
-        return self.ds.count()
-
-    def to_hv_dataset(
-        self, reduce: ReduceType = ReduceType.AUTO, result_var: ResultVar = None
-    ) -> hv.Dataset:
-        """Generate a holoviews dataset from the xarray dataset.
-
-        Args:
-            reduce (ReduceType, optional): Optionally perform reduce options on the dataset.  By default the returned dataset will calculate the mean and standard devation over the "repeat" dimension so that the dataset plays nicely with most of the holoviews plot types.  Reduce.Sqeeze is used if there is only 1 repeat and you want the "reduce" variable removed from the dataset. ReduceType.None returns an unaltered dataset. Defaults to ReduceType.AUTO.
-
-        Returns:
-            hv.Dataset: results in the form of a holoviews dataset
-        """
-
-        if reduce == ReduceType.NONE:
-            kdims = [i.name for i in self.bench_cfg.all_vars]
-            return hv.Dataset(self.to_dataset(reduce, result_var), kdims=kdims)
-        return hv.Dataset(self.to_dataset(reduce, result_var))
-
-    def to_dataset(
-        self, reduce: ReduceType = ReduceType.AUTO, result_var: ResultVar = None
-    ) -> xr.Dataset:
-        """Generate a summarised xarray dataset.
-
-        Args:
-            reduce (ReduceType, optional): Optionally perform reduce options on the dataset.  By default the returned dataset will calculate the mean and standard devation over the "repeat" dimension so that the dataset plays nicely with most of the holoviews plot types.  Reduce.Sqeeze is used if there is only 1 repeat and you want the "reduce" variable removed from the dataset. ReduceType.None returns an unaltered dataset. Defaults to ReduceType.AUTO.
-
-        Returns:
-            xr.Dataset: results in the form of an xarray dataset
-        """
-        if reduce == ReduceType.AUTO:
-            reduce = ReduceType.REDUCE if self.bench_cfg.repeats > 1 else ReduceType.SQUEEZE
-
-        ds = self.ds if result_var is None else self.ds[result_var.name]
-
-        match (reduce):
-            case ReduceType.REDUCE:
-                ds_reduce_mean = ds.mean(dim="repeat", keep_attrs=True)
-                ds_reduce_std = ds.std(dim="repeat", keep_attrs=True)
-
-                for v in ds_reduce_mean.data_vars:
-                    ds_reduce_mean[f"{v}_std"] = ds_reduce_std[v]
-                return ds_reduce_mean
-            case ReduceType.SQUEEZE:
-                return ds.squeeze(drop=True)
-            case _:
-                return ds
-
-    def get_optimal_vec(
-        self,
-        result_var: ParametrizedSweep,
-        input_vars: List[ParametrizedSweep],
-    ) -> List[Any]:
-        """Get the optimal values from the sweep as a vector.
-
-        Args:
-            result_var (bch.ParametrizedSweep): Optimal values of this result variable
-            input_vars (List[bch.ParametrizedSweep]): Define which input vars values are returned in the vector
-
-        Returns:
-            List[Any]: A vector of optimal values for the desired input vector
-        """
-
-        da = self.get_optimal_value_indices(result_var)
-        output = []
-        for iv in input_vars:
-            if da.coords[iv.name].values.size == 1:
-                # https://stackoverflow.com/questions/773030/why-are-0d-arrays-in-numpy-not-considered-scalar
-                # use [()] to convert from a 0d numpy array to a scalar
-                output.append(da.coords[iv.name].values[()])
-            else:
-                logging.warning(f"values size: {da.coords[iv.name].values.size}")
-                output.append(max(da.coords[iv.name].values[()]))
-            logging.info(f"Maximum value of {iv.name}: {output[-1]}")
-        return output
-
-    def get_optimal_value_indices(self, result_var: ParametrizedSweep) -> xr.DataArray:
-        """Get an xarray mask of the values with the best values found during a parameter sweep
-
-        Args:
-            result_var (bch.ParametrizedSweep): Optimal value of this result variable
-
-        Returns:
-            xr.DataArray: xarray mask of optimal values
-        """
-        result_da = self.ds[result_var.name]
-        if result_var.direction == OptDir.maximize:
-            opt_val = result_da.max()
-        else:
-            opt_val = result_da.min()
-        indicies = result_da.where(result_da == opt_val, drop=True).squeeze()
-        logging.info(f"optimal value of {result_var.name}: {opt_val.values}")
-        return indicies
-
-    def get_optimal_inputs(
-        self,
-        result_var: ParametrizedSweep,
-        keep_existing_consts: bool = True,
-        as_dict: bool = False,
-    ) -> Tuple[ParametrizedSweep, Any] | dict[ParametrizedSweep, Any]:
-        """Get a list of tuples of optimal variable names and value pairs, that can be fed in as constant values to subsequent parameter sweeps
-
-        Args:
-            result_var (bch.ParametrizedSweep): Optimal values of this result variable
-            keep_existing_consts (bool): Include any const values that were defined as part of the parameter sweep
-            as_dict (bool): return value as a dictionary
-
-        Returns:
-            Tuple[bch.ParametrizedSweep, Any]|[ParametrizedSweep, Any]: Tuples of variable name and optimal values
-        """
-        da = self.get_optimal_value_indices(result_var)
-        if keep_existing_consts:
-            output = deepcopy(self.bench_cfg.const_vars)
-        else:
-            output = []
-
-        for iv in self.bench_cfg.input_vars:
-            # assert da.coords[iv.name].values.size == (1,)
-            if da.coords[iv.name].values.size == 1:
-                # https://stackoverflow.com/questions/773030/why-are-0d-arrays-in-numpy-not-considered-scalar
-                # use [()] to convert from a 0d numpy array to a scalar
-                output.append((iv, da.coords[iv.name].values[()]))
-            else:
-                logging.warning(f"values size: {da.coords[iv.name].values.size}")
-                output.append((iv, max(da.coords[iv.name].values[()])))
-
-            logging.info(f"Maximum value of {iv.name}: {output[-1][1]}")
-        if as_dict:
-            return dict(output)
-        return output
-
-    def describe_sweep(self):
-        return self.bench_cfg.describe_sweep()
-
-    def get_best_holomap(self, name: str = None):
-        return self.get_hmap(name)[self.get_best_trial_params(True)]
-
-    def get_hmap(self, name: str = None):
-        try:
-            if name is None:
-                name = self.result_hmaps[0].name
-            if name in self.hmaps:
-                return self.hmaps[name]
-        except Exception as e:
-            raise RuntimeError(
-                "You are trying to plot a holomap result but it is not in the result_vars list.  Add the holomap to the result_vars list"
-            ) from e
-        return None
-
-    def to_plot_title(self) -> str:
-        if len(self.bench_cfg.input_vars) > 0 and len(self.bench_cfg.result_vars) > 0:
-            return f"{self.bench_cfg.result_vars[0].name} vs {self.bench_cfg.input_vars[0].name}"
-        return ""
-
-    def title_from_ds(self, dataset: xr.Dataset, result_var: Parameter, **kwargs):
-        if "title" in kwargs:
-            return kwargs["title"]
-
-        if isinstance(dataset, xr.DataArray):
-            tit = [dataset.name]
-            for d in dataset.dims:
-                tit.append(d)
-        else:
-            tit = [result_var.name]
-            tit.extend(list(dataset.sizes))
-
-        return " vs ".join(tit)
-
-    def get_results_var_list(self, result_var: ParametrizedSweep = None) -> List[ResultVar]:
-        return self.bench_cfg.result_vars if result_var is None else [result_var]
-
-    def map_plots(
-        self,
-        plot_callback: callable,
-        result_var: ParametrizedSweep = None,
-        row: EmptyContainer = None,
-    ) -> Optional[pn.Row]:
-        if row is None:
-            row = EmptyContainer(pn.Row(name=self.to_plot_title()))
-        for rv in self.get_results_var_list(result_var):
-            row.append(plot_callback(rv))
-        return row.get()
-
-    def map_plot_panes(
-        self,
-        plot_callback: callable,
-        hv_dataset: hv.Dataset = None,
-        target_dimension: int = 2,
-        result_var: ResultVar = None,
-        result_types=None,
-        **kwargs,
-    ) -> Optional[pn.Row]:
-        if hv_dataset is None:
-            hv_dataset = self.to_hv_dataset()
-        row = EmptyContainer(pn.Row())
-
-        # kwargs= self.set_plot_size(**kwargs)
-        for rv in self.get_results_var_list(result_var):
-            if result_types is None or isinstance(rv, result_types):
-                row.append(
-                    self.to_panes_multi_panel(
-                        hv_dataset,
-                        rv,
-                        plot_callback=partial(plot_callback, **kwargs),
-                        target_dimension=target_dimension,
-                    )
-                )
-        return row.get()
-
-    def filter(
-        self,
-        plot_callback: callable,
-        plot_filter=None,
-        float_range: VarRange = VarRange(0, None),
-        cat_range: VarRange = VarRange(0, None),
-        vector_len: VarRange = VarRange(1, 1),
-        result_vars: VarRange = VarRange(1, 1),
-        panel_range: VarRange = VarRange(0, 0),
-        repeats_range: VarRange = VarRange(1, None),
-        input_range: VarRange = VarRange(1, None),
-        reduce: ReduceType = ReduceType.AUTO,
-        target_dimension: int = 2,
-        result_var: ResultVar = None,
-        result_types=None,
-        **kwargs,
-    ):
-        plot_filter = PlotFilter(
-            float_range=float_range,
-            cat_range=cat_range,
-            vector_len=vector_len,
-            result_vars=result_vars,
-            panel_range=panel_range,
-            repeats_range=repeats_range,
-            input_range=input_range,
-        )
-        matches_res = plot_filter.matches_result(self.plt_cnt_cfg, callable_name(plot_callback))
-        if matches_res.overall:
-            return self.map_plot_panes(
-                plot_callback=plot_callback,
-                hv_dataset=self.to_hv_dataset(reduce=reduce),
-                target_dimension=target_dimension,
-                result_var=result_var,
-                result_types=result_types,
-                **kwargs,
-            )
-        return matches_res.to_panel()
-
-    def to_panes_multi_panel(
-        self,
-        hv_dataset: hv.Dataset,
-        result_var: ResultVar,
-        plot_callback: callable = None,
-        target_dimension: int = 1,
-        **kwargs,
-    ):
-        dims = len(hv_dataset.dimensions())
-        if target_dimension is None:
-            target_dimension = dims
-        return self._to_panes_da(
-            hv_dataset.data,
-            plot_callback=plot_callback,
-            target_dimension=target_dimension,
-            horizontal=dims <= target_dimension + 1,
-            result_var=result_var,
-            **kwargs,
-        )
-
-    def _to_panes_da(
-        self,
-        dataset: xr.Dataset,
-        plot_callback=pn.pane.panel,
-        target_dimension=1,
-        horizontal=False,
-        result_var=None,
-        **kwargs,
-    ) -> pn.panel:
-        # todo, when dealing with time and repeats, add feature to allow custom order of dimension recursion
-        ##todo remove recursion
-        num_dims = len(dataset.sizes)
-        # print(f"num_dims: {num_dims}, horizontal: {horizontal}, target: {target_dimension}")
-        dims = list(d for d in dataset.sizes)
-
-        time_dim_delta = 0
-        if self.bench_cfg.over_time:
-            time_dim_delta = 0
-
-        if num_dims > (target_dimension + time_dim_delta) and num_dims != 0:
-            dim_sel = 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)
-            )
-
-            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}"
-
-                panes = self._to_panes_da(
-                    sliced,
-                    plot_callback=plot_callback,
-                    target_dimension=target_dimension,
-                    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)
-                inner_container.append(panes)
-                outer_container.append(inner_container)
-                # outer_container.append(pn.Row(inner_container, align="center"))
-            for c in outer_container:
-                c[0].width = max_len * 7
-        else:
-            return plot_callback(dataset=dataset, result_var=result_var, **kwargs)
-
-        return outer_container
-
-    # MAPPING TO LOWER LEVEL BENCHCFG functions so they are available at a top level.
-    def to_sweep_summary(self, **kwargs):
-        return self.bench_cfg.to_sweep_summary(**kwargs)
-
-    def to_title(self, panel_name: str = None) -> pn.pane.Markdown:
-        return self.bench_cfg.to_title(panel_name)
-
-    def to_description(self, width: int = 800) -> pn.pane.Markdown:
-        return self.bench_cfg.to_description(width)