holobench 1.40.1__py3-none-any.whl → 1.42.0__py3-none-any.whl

bencher/results/bench_result.py

@@ -1,49 +1,129 @@
 from __future__ import annotations
-from typing import List
+from typing import List, Optional, Any
 import panel as pn
+from param import Parameter
 
 from bencher.results.bench_result_base import EmptyContainer
 from bencher.results.video_summary import VideoSummaryResult
-from bencher.results.panel_result import PanelResult
-from bencher.results.plotly_result import PlotlyResult
-from bencher.results.holoview_result import HoloviewResult
-from bencher.results.hvplot_result import HvplotResult
+from bencher.results.video_result import VideoResult
+from bencher.results.volume_result import VolumeResult
+from bencher.results.holoview_results.holoview_result import HoloviewResult
+
+# Updated imports for distribution result classes
+from bencher.results.holoview_results.distribution_result.box_whisker_result import BoxWhiskerResult
+from bencher.results.holoview_results.distribution_result.violin_result import ViolinResult
+from bencher.results.holoview_results.scatter_result import ScatterResult
+from bencher.results.holoview_results.distribution_result.scatter_jitter_result import (
+    ScatterJitterResult,
+)
+from bencher.results.holoview_results.bar_result import BarResult
+from bencher.results.holoview_results.line_result import LineResult
+from bencher.results.holoview_results.curve_result import CurveResult
+from bencher.results.holoview_results.heatmap_result import HeatmapResult
+from bencher.results.holoview_results.surface_result import SurfaceResult
+from bencher.results.histogram_result import HistogramResult
+from bencher.results.optuna_result import OptunaResult
 from bencher.results.dataset_result import DataSetResult
 from bencher.utils import listify
 
 
-class BenchResult(PlotlyResult, HoloviewResult, HvplotResult, VideoSummaryResult, DataSetResult):  # noqa pylint: disable=too-many-ancestors
+class BenchResult(
+    VolumeResult,
+    BoxWhiskerResult,
+    ViolinResult,
+    ScatterJitterResult,
+    ScatterResult,
+    LineResult,
+    BarResult,
+    HeatmapResult,
+    CurveResult,
+    SurfaceResult,
+    HoloviewResult,
+    HistogramResult,
+    VideoSummaryResult,
+    DataSetResult,
+    OptunaResult,
+):  # noqa pylint: disable=too-many-ancestors
     """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)
+        """Initialize a BenchResult instance.
+
+        Args:
+            bench_cfg: The benchmark configuration object containing settings and result data
+        """
+        VolumeResult.__init__(self, bench_cfg)
         HoloviewResult.__init__(self, bench_cfg)
         # DataSetResult.__init__(self.bench_cfg)
 
+    @classmethod
+    def from_existing(cls, original: BenchResult) -> BenchResult:
+        new_instance = cls(original.bench_cfg)
+        new_instance.ds = original.ds
+        new_instance.bench_cfg = original.bench_cfg
+        new_instance.plt_cnt_cfg = original.plt_cnt_cfg
+        return new_instance
+
+    def to(
+        self,
+        result_type: BenchResult,
+        result_var: Optional[Parameter] = None,
+        override: bool = True,
+        **kwargs: Any,
+    ) -> BenchResult:
+        """Return the current instance of BenchResult.
+
+        Returns:
+            BenchResult: The current instance of the benchmark result
+        """
+        result_instance = result_type(self.bench_cfg)
+        result_instance.ds = self.ds
+        result_instance.plt_cnt_cfg = self.plt_cnt_cfg
+        result_instance.dataset_list = self.dataset_list
+        return result_instance.to_plot(result_var=result_var, override=override, **kwargs)
+
     @staticmethod
-    def default_plot_callbacks():
+    def default_plot_callbacks() -> List[callable]:
+        """Get the default list of plot callback functions.
+
+        These callbacks are used by default in the to_auto method if no specific
+        plot list is provided.
+
+        Returns:
+            List[callable]: A list of plotting callback functions
+        """
         return [
             # VideoSummaryResult.to_video_summary, #quite expensive so not turned on by default
-            HoloviewResult.to_bar,
-            HoloviewResult.to_scatter_jitter,
-            HoloviewResult.to_curve,
-            HoloviewResult.to_line,
-            HoloviewResult.to_heatmap,
-            HvplotResult.to_histogram,
-            PlotlyResult.to_volume,
+            BarResult.to_plot,
+            BoxWhiskerResult.to_plot,
+            # ViolinResult.to_violin,
+            # ScatterJitterResult.to_plot,
+            CurveResult.to_plot,
+            LineResult.to_plot,
+            HeatmapResult.to_plot,
+            HistogramResult.to_plot,
+            VolumeResult.to_plot,
             # PanelResult.to_video,
-            PanelResult.to_panes,
+            VideoResult.to_panes,
         ]
 
     @staticmethod
-    def plotly_callbacks():
-        return [HoloviewResult.to_surface, PlotlyResult.to_volume]
+    def plotly_callbacks() -> List[callable]:
+        """Get the list of Plotly-specific callback functions.
+
+        Returns:
+            List[callable]: A list of Plotly-based visualization callback functions
+        """
+        return [SurfaceResult.to_surface, VolumeResult.to_volume]
 
     def plot(self) -> pn.panel:
-        """Plots the benchresult using the plot callbacks defined by the bench run
+        """Plots the benchresult using the plot callbacks defined by the bench run.
+
+        This method uses the plot_callbacks defined in the bench_cfg to generate
+        plots for the benchmark results.
 
         Returns:
-             pn.panel: A panel representation of the results
+             pn.panel: A panel representation of the results, or None if no plot_callbacks defined
         """
         if self.bench_cfg.plot_callbacks is not None:
             return pn.Column(*[cb(self) for cb in self.bench_cfg.plot_callbacks])
@@ -53,8 +133,22 @@ class BenchResult(PlotlyResult, HoloviewResult, HvplotResult, VideoSummaryResult
         self,
         plot_list: List[callable] = None,
         remove_plots: List[callable] = None,
+        default_container=pn.Column,
+        override: bool = False,  # false so that plots that are not supported are not shown
         **kwargs,
     ) -> List[pn.panel]:
+        """Automatically generate plots based on the provided plot callbacks.
+
+        Args:
+            plot_list (List[callable], optional): List of plot callback functions to use. Defaults to None.
+            remove_plots (List[callable], optional): List of plot callback functions to exclude. Defaults to None.
+            default_container (type, optional): Default container type for the plots. Defaults to pn.Column.
+            override (bool, optional): Whether to override unsupported plots. Defaults to False.
+            **kwargs: Additional keyword arguments for plot configuration.
+
+        Returns:
+            List[pn.panel]: A list of panel objects containing the generated plots.
+        """
         self.plt_cnt_cfg.print_debug = False
         plot_list = listify(plot_list)
         remove_plots = listify(remove_plots)
@@ -67,12 +161,12 @@ class BenchResult(PlotlyResult, HoloviewResult, HvplotResult, VideoSummaryResult
 
         kwargs = self.set_plot_size(**kwargs)
 
-        row = EmptyContainer(pn.Row())
+        row = EmptyContainer(default_container())
         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))
+            row.append(plot_callback(self, override=override, **kwargs))
 
         self.plt_cnt_cfg.print_debug = True
         if len(row.pane) == 0:
@@ -82,15 +176,14 @@ class BenchResult(PlotlyResult, HoloviewResult, HvplotResult, VideoSummaryResult
         return row.pane
 
     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
+        """Given the dataset result of a benchmark run, automatically deduce 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
+            **kwargs: Additional keyword arguments for plot configuration.
 
         Returns:
-            pn.pane: A panel containing plot results
+            pn.panel: 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))

bencher/results/bench_result_base.py

@@ -6,6 +6,8 @@ from param import Parameter
 import holoviews as hv
 from functools import partial
 import panel as pn
+import numpy as np
+from textwrap import wrap
 
 from bencher.utils import int_to_col, color_tuple_to_css, callable_name
 
@@ -14,7 +16,6 @@ from bencher.variables.inputs import with_level
 
 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.plotting.plot_filter import VarRange, PlotFilter
 from bencher.utils import listify
@@ -25,6 +26,13 @@ from bencher.results.composable_container.composable_container_panel import (
     ComposableContainerPanel,
 )
 
+from collections import defaultdict
+
+import pandas as pd
+
+from bencher.bench_cfg import BenchCfg
+from bencher.plotting.plt_cnt_cfg import PltCntCfg
+
 # todo add plugins
 # https://gist.github.com/dorneanu/cce1cd6711969d581873a88e0257e312
 # https://kaleidoescape.github.io/decorated-plugins/
@@ -52,7 +60,87 @@ class EmptyContainer:
         return self.pane if len(self.pane) > 0 else None
 
 
-class BenchResultBase(OptunaResult):
+def convert_dataset_bool_dims_to_str(dataset: xr.Dataset) -> xr.Dataset:
+    """Given a dataarray that contains boolean coordinates, convert them to strings so that holoviews loads the data properly
+
+    Args:
+        dataarray (xr.DataArray): dataarray with boolean coordinates
+
+    Returns:
+        xr.DataArray: dataarray with boolean coordinates converted to strings
+    """
+    bool_coords = {}
+    for c in dataset.coords:
+        if dataset.coords[c].dtype == bool:
+            bool_coords[c] = [str(vals) for vals in dataset.coords[c].values]
+
+    if len(bool_coords) > 0:
+        return dataset.assign_coords(bool_coords)
+    return dataset
+
+
+class BenchResultBase:
+    def __init__(self, bench_cfg: BenchCfg) -> None:
+        self.bench_cfg = bench_cfg
+        # self.wrap_long_time_labels(bench_cfg)  # todo remove
+        self.ds = xr.Dataset()
+        self.object_index = []
+        self.hmaps = defaultdict(dict)
+        self.result_hmaps = bench_cfg.result_hmaps
+        self.studies = []
+        self.plt_cnt_cfg = PltCntCfg()
+        self.plot_inputs = []
+        self.dataset_list = []
+
+        # self.width=600/
+        # self.height=600
+
+        #   bench_res.objects.append(rv)
+        # bench_res.reference_index = len(bench_res.objects)
+
+    def to_xarray(self) -> xr.Dataset:
+        return self.ds
+
+    def setup_object_index(self):
+        self.object_index = []
+
+    def to_pandas(self, reset_index=True) -> pd.DataFrame:
+        """Get the xarray results as a pandas dataframe
+
+        Returns:
+            pd.DataFrame: The xarray results array as a pandas dataframe
+        """
+        ds = self.to_xarray().to_dataframe()
+        return ds.reset_index() if reset_index else ds
+
+    def wrap_long_time_labels(self, bench_cfg):
+        """Takes a benchCfg and wraps any index labels that are too long to be plotted easily
+
+        Args:
+            bench_cfg (BenchCfg):
+
+        Returns:
+            BenchCfg: updated config with wrapped labels
+        """
+        if bench_cfg.over_time:
+            if self.ds.coords["over_time"].dtype == np.datetime64:
+                # plotly catastrophically fails to plot anything with the default long string representation of time, so convert to a shorter time representation
+                self.ds.coords["over_time"] = [
+                    pd.to_datetime(t).strftime("%d-%m-%y %H-%M-%S")
+                    for t in self.ds.coords["over_time"].values
+                ]
+                # wrap very long time event labels because otherwise the graphs are unreadable
+            if bench_cfg.time_event is not None:
+                self.ds.coords["over_time"] = [
+                    "\n".join(wrap(t, 20)) for t in self.ds.coords["over_time"].values
+                ]
+        return bench_cfg
+
+    def post_setup(self):
+        self.plt_cnt_cfg = PltCntCfg.generate_plt_cnt_cfg(self.bench_cfg)
+        self.bench_cfg = self.wrap_long_time_labels(self.bench_cfg)
+        self.ds = convert_dataset_bool_dims_to_str(self.ds)
+
     def result_samples(self) -> int:
         """The number of samples in the results dataframe"""
         return self.ds.count()
@@ -80,7 +168,7 @@ class BenchResultBase(OptunaResult):
     def to_dataset(
         self,
         reduce: ReduceType = ReduceType.AUTO,
-        result_var: ResultVar = None,
+        result_var: ResultVar | str = None,
         level: int = None,
     ) -> xr.Dataset:
         """Generate a summarised xarray dataset.
@@ -97,7 +185,15 @@ class BenchResultBase(OptunaResult):
         ds_out = self.ds.copy()
 
         if result_var is not None:
-            ds_out = ds_out[result_var.name].to_dataset(name=result_var.name)
+            if isinstance(result_var, Parameter):
+                var_name = result_var.name
+            elif isinstance(result_var, str):
+                var_name = result_var
+            else:
+                raise TypeError(
+                    f"Unsupported type for result_var: {type(result_var)}. Expected Parameter or str."
+                )
+            ds_out = ds_out[var_name].to_dataset(name=var_name)
 
         def rename_ds(dataset: xr.Dataset, suffix: str):
             # var_name =
@@ -219,9 +315,6 @@ class BenchResultBase(OptunaResult):
     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:
@@ -321,7 +414,7 @@ class BenchResultBase(OptunaResult):
         **kwargs,
     ) -> Optional[pn.Row]:
         if hv_dataset is None:
-            hv_dataset = self.to_hv_dataset()
+            hv_dataset = self.to_hv_dataset(reduce=reduce)
 
         if pane_collection is None:
             pane_collection = pn.Row()
@@ -333,7 +426,7 @@ class BenchResultBase(OptunaResult):
             if result_types is None or isinstance(rv, result_types):
                 row.append(
                     self.to_panes_multi_panel(
-                        self.to_hv_dataset(reduce=reduce, result_var=rv),
+                        hv_dataset,
                         rv,
                         plot_callback=partial(plot_callback, **kwargs),
                         target_dimension=target_dimension,
@@ -362,7 +455,7 @@ class BenchResultBase(OptunaResult):
         pane_collection: pn.pane = None,
         override=False,
         **kwargs,
-    ):
+    ) -> Optional[pn.panel]:
         plot_filter = PlotFilter(
             float_range=float_range,
             cat_range=cat_range,
@@ -558,3 +651,19 @@ class BenchResultBase(OptunaResult):
 
     def to_description(self, width: int = 800) -> pn.pane.Markdown:
         return self.bench_cfg.to_description(width)
+
+    def set_plot_size(self, **kwargs) -> dict:
+        if "width" not in kwargs:
+            if self.bench_cfg.plot_size is not None:
+                kwargs["width"] = self.bench_cfg.plot_size
+            # specific width overrides general size
+            if self.bench_cfg.plot_width is not None:
+                kwargs["width"] = self.bench_cfg.plot_width
+
+        if "height" not in kwargs:
+            if self.bench_cfg.plot_size is not None:
+                kwargs["height"] = self.bench_cfg.plot_size
+            # specific height overrides general size
+            if self.bench_cfg.plot_height is not None:
+                kwargs["height"] = self.bench_cfg.plot_height
+        return kwargs

bencher/results/composable_container/composable_container_video.py

@@ -3,7 +3,7 @@ import numpy as np
 from copy import deepcopy
 from pathlib import Path
 from dataclasses import dataclass
-from moviepy.editor import (
+from moviepy import (
     ImageClip,
     CompositeVideoClip,
     clips_array,
@@ -11,22 +11,43 @@ from moviepy.editor import (
     VideoClip,
     VideoFileClip,
 )
-from moviepy.video.fx.margin import margin
 
 from bencher.results.composable_container.composable_container_base import (
     ComposableContainerBase,
     ComposeType,
 )
 from bencher.video_writer import VideoWriter
+from moviepy import vfx
 
 
 @dataclass()
 class RenderCfg:
+    """Configuration class for video rendering options.
+
+    This class controls how videos and images are composed and rendered together.
+    It provides options for timing, layout, appearance, and labeling of the output.
+
+    Attributes:
+        compose_method (ComposeType): Method to compose multiple clips (sequence, right, down, overlay).
+            Defaults to ComposeType.sequence.
+        var_name (str, optional): Variable name for labeling. Defaults to None.
+        var_value (str, optional): Variable value for labeling. Defaults to None.
+        background_col (tuple[int, int, int]): RGB color for background. Defaults to white (255, 255, 255).
+        duration (float): Target duration for the composed video in seconds. Defaults to 10.0.
+        default_duration (float): Fallback duration when duration is None. Defaults to 10.0.
+        duration_target (bool): If True, tries to match target duration while respecting frame
+            duration constraints. If False, uses exact duration. Defaults to True.
+        min_frame_duration (float): Minimum duration for each frame in seconds. Defaults to 1/30.
+        max_frame_duration (float): Maximum duration for each frame in seconds. Defaults to 2.0.
+        margin (int): Margin size in pixels to add around clips. Defaults to 0.
+    """
+
     compose_method: ComposeType = ComposeType.sequence
     var_name: str = None
     var_value: str = None
     background_col: tuple[int, int, int] = (255, 255, 255)
     duration: float = 10.0
+    default_duration: float = 10.0
     duration_target: bool = True
     min_frame_duration: float = 1.0 / 30
     max_frame_duration: float = 2.0
@@ -69,7 +90,9 @@ class ComposableContainerVideo(ComposableContainerBase):
     def calculate_duration(self, frames, render_cfg: RenderCfg):
         if render_cfg.duration_target:
             # calculate duration based on fps constraints
-            duration = 10.0 if render_cfg.duration is None else render_cfg.duration
+            duration = (
+                render_cfg.default_duration if render_cfg.duration is None else render_cfg.duration
+            )
             frame_duration = duration / frames
             if render_cfg.min_frame_duration is not None:
                 frame_duration = max(frame_duration, render_cfg.min_frame_duration)
@@ -77,7 +100,10 @@ class ComposableContainerVideo(ComposableContainerBase):
                 frame_duration = min(frame_duration, render_cfg.max_frame_duration)
             duration = frame_duration * frames
         else:
-            duration = render_cfg.duration
+            if render_cfg.duration is None:
+                duration = render_cfg.default_duration
+            else:
+                duration = render_cfg.duration
             frame_duration = duration / float(frames)
 
         print("max_frame_duration", render_cfg.max_frame_duration)
@@ -111,8 +137,8 @@ class ComposableContainerVideo(ComposableContainerBase):
             case ComposeType.right | ComposeType.down:
                 for i in range(len(self.container)):
                     self.container[i] = self.extend_clip(self.container[i], max_duration)
-                    self.container[i] = margin(
-                        self.container[i], top=render_cfg.margin, color=render_cfg.background_col
+                    self.container[i] = self.container[i].with_effects(
+                        [vfx.Margin(top=render_cfg.margin, color=render_cfg.background_col)]
                     )
 
                 if render_cfg.compose_method == ComposeType.right:
@@ -126,13 +152,14 @@ class ComposableContainerVideo(ComposableContainerBase):
                 out = concatenate_videoclips(
                     self.container, bg_color=render_cfg.background_col, method="compose"
                 )
-            # case ComposeType.overlay:
-            #     for i in range(len(self.container)):
-            #         self.container[i].alpha = 1./len(self.container)
-            #     out = CompositeVideoClip(self.container, bg_color=render_cfg.background_col)
-            #     # out.duration = fps
+            case ComposeType.overlay:
+                for i in range(len(self.container)):
+                    self.container[i] = self.container[i].with_opacity(1.0 / len(self.container))
+                out = CompositeVideoClip(self.container, bg_color=render_cfg.background_col)
             case _:
-                raise RuntimeError("This compose type is not supported")
+                raise RuntimeError(
+                    f"This compose type is not supported: {render_cfg.compose_method}"
+                )
 
         label = self.label_formatter(render_cfg.var_name, render_cfg.var_value)
         if label is not None: