holobench 1.41.0__py3-none-any.whl → 1.43.0__py3-none-any.whl

bencher/plotting/plot_filter.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 from typing import Optional
 from dataclasses import dataclass
 from bencher.plotting.plt_cnt_cfg import PltCntCfg
+import logging
 import panel as pn
 
 
@@ -43,9 +44,20 @@ class VarRange:
 
         return lower_match and upper_match
 
-    def matches_info(self, val, name):
+    def matches_info(self, val: int, name: str) -> tuple[bool, str]:
+        """Get matching info for a value with a descriptive name.
+
+        Args:
+            val (int): A positive integer to check against the range
+            name (str): A descriptive name for the value being checked, used in the output string
+
+        Returns:
+            tuple[bool, str]: A tuple containing:
+                - bool: True if the value matches the range, False otherwise
+                - str: A formatted string describing the match result
+        """
         match = self.matches(val)
-        info = f"{name}\t{match}\t{self.lower_bound}>= {val} <={self.upper_bound}"
+        info = f"{name}\t{self.lower_bound}>= {val} <={self.upper_bound} is {match}"
         return match, info
 
     def __str__(self) -> str:
@@ -65,13 +77,21 @@ class PlotFilter:
     input_range: VarRange = VarRange(1, None)
 
     def matches_result(
-        self, plt_cnt_cfg: PltCntCfg, plot_name: str, override: bool = False
+        self, plt_cnt_cfg: PltCntCfg, plot_name: str, override: bool
     ) -> PlotMatchesResult:
-        """Checks if the result data signature matches the type of data the plot is able to display."""
+        """Checks if the result data signature matches the type of data the plot is able to display.
+
+        Args:
+            plt_cnt_cfg (PltCntCfg): Configuration containing counts of different plot elements
+            plot_name (str): Name of the plot being checked
+            override (bool): Whether to override filter matching rules
+
+        Returns:
+            PlotMatchesResult: Object containing match results and information
+        """
         return PlotMatchesResult(self, plt_cnt_cfg, plot_name, override)
 
 
-# @dataclass
 class PlotMatchesResult:
     """Stores information about which properties match the requirements of a particular plotter"""
 
@@ -80,12 +100,20 @@ class PlotMatchesResult:
         plot_filter: PlotFilter,
         plt_cnt_cfg: PltCntCfg,
         plot_name: str,
-        override: bool = False,
-    ):
-        match_info = []
-        matches = []
+        override: bool,
+    ) -> None:
+        """Initialize a PlotMatchesResult with filter matching information.
 
-        match_candidates = [
+        Args:
+            plot_filter (PlotFilter): The filter defining acceptable ranges for plot properties
+            plt_cnt_cfg (PltCntCfg): Configuration containing counts of different plot elements
+            plot_name (str): Name of the plot being checked
+            override (bool): Whether to override filter matching rules
+        """
+        match_info: list[str] = []
+        matches: list[bool] = []
+
+        match_candidates: list[tuple[VarRange, int, str]] = [
             (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"),
@@ -99,7 +127,7 @@ class PlotMatchesResult:
             match, info = m.matches_info(cnt, name)
             matches.append(match)
             if not match:
-                match_info.append(info)
+                match_info.append(f"\t{info}")
         if override:
             match_info.append(f"override: {override}")
             self.overall = True
@@ -107,15 +135,22 @@ class PlotMatchesResult:
             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
+        self.matches_info: str = "\n".join(match_info).strip()
+        self.plt_cnt_cfg: PltCntCfg = 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)
+        # if self.plt_cnt_cfg.print_debug:
+        logging.info(self.matches_info)
 
     def to_panel(self, **kwargs) -> Optional[pn.pane.Markdown]:
+        """Convert match information to a Panel Markdown pane if debug mode is enabled.
+
+        Args:
+            **kwargs: Additional keyword arguments to pass to the Panel Markdown constructor
+
+        Returns:
+            Optional[pn.pane.Markdown]: A Markdown pane containing match information if in debug mode,
+                                        None otherwise
+        """
         if self.plt_cnt_cfg.print_debug:
             return pn.pane.Markdown(self.matches_info, **kwargs)
         return None

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])
@@ -54,8 +134,21 @@ class BenchResult(PlotlyResult, HoloviewResult, HvplotResult, VideoSummaryResult
         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)
@@ -73,7 +166,7 @@ class BenchResult(PlotlyResult, HoloviewResult, HvplotResult, VideoSummaryResult
             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:
@@ -83,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:
@@ -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