holobench 1.28.1__tar.gz → 1.29.0__tar.gz

{holobench-1.28.1/holobench.egg-info → holobench-1.29.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: holobench
-Version: 1.28.1
+Version: 1.29.0
 Summary: A package for benchmarking the performance of arbitrary functions
 Author-email: Austin Gregg-Smith <blooop@gmail.com>
 Project-URL: Repository, https://github.com/dyson-ai/bencher

{holobench-1.28.1 → holobench-1.29.0}/bencher/__init__.py

@@ -19,6 +19,7 @@ from .variables.results import (
     ResultReference,
     ResultVolume,
     OptDir,
+    ResultDataSet,
     curve,
 )
 

{holobench-1.28.1 → holobench-1.29.0}/bencher/bencher.py

@@ -30,6 +30,7 @@ from bencher.variables.results import (
     ResultString,
     ResultContainer,
     ResultReference,
+    ResultDataSet,
 )
 from bencher.results.bench_result import BenchResult
 from bencher.variables.parametrised_sweep import ParametrizedSweep
@@ -612,12 +613,13 @@ class Bench(BenchPlotServer):
         )
         # xarray stores K N-dimensional arrays of data.  Each array is named and in this case we have a nd array for each result variable
         data_vars = {}
+        dataset_list = []
 
         for rv in bench_cfg.result_vars:
             if isinstance(rv, ResultVar):
                 result_data = np.full(dims_cfg.dims_size, np.nan, dtype=float)
                 data_vars[rv.name] = (dims_cfg.dims_name, result_data)
-            if isinstance(rv, ResultReference):
+            if isinstance(rv, (ResultReference, ResultDataSet)):
                 result_data = np.full(dims_cfg.dims_size, -1, dtype=int)
                 data_vars[rv.name] = (dims_cfg.dims_name, result_data)
             if isinstance(
@@ -625,6 +627,7 @@ class Bench(BenchPlotServer):
             ):
                 result_data = np.full(dims_cfg.dims_size, "NAN", dtype=object)
                 data_vars[rv.name] = (dims_cfg.dims_name, result_data)
+
             elif type(rv) == ResultVec:
                 for i in range(rv.size):
                     result_data = np.full(dims_cfg.dims_size, np.nan)
@@ -633,6 +636,7 @@ class Bench(BenchPlotServer):
         bench_res = BenchResult(bench_cfg)
         bench_res.ds = xr.Dataset(data_vars=data_vars, coords=dims_cfg.coords)
         bench_res.ds_dynamic = self.ds_dynamic
+        bench_res.dataset_list = dataset_list
         bench_res.setup_object_index()
 
         return bench_res, function_inputs, dims_cfg.dims_name
@@ -770,6 +774,13 @@ class Bench(BenchPlotServer):
                     ),
                 ):
                     set_xarray_multidim(bench_res.ds[rv.name], worker_job.index_tuple, result_value)
+                elif isinstance(rv, ResultDataSet):
+                    bench_res.dataset_list.append(result_value)
+                    set_xarray_multidim(
+                        bench_res.ds[rv.name],
+                        worker_job.index_tuple,
+                        len(bench_res.dataset_list) - 1,
+                    )
                 elif isinstance(rv, ResultReference):
                     bench_res.object_index.append(result_value)
                     set_xarray_multidim(
@@ -777,6 +788,7 @@ class Bench(BenchPlotServer):
                         worker_job.index_tuple,
                         len(bench_res.object_index) - 1,
                     )
+
                 elif isinstance(rv, ResultVec):
                     if isinstance(result_value, (list, np.ndarray)):
                         if len(result_value) == rv.size:

holobench-1.29.0/bencher/example/example_dataframe.py

@@ -0,0 +1,48 @@
+import bencher as bch
+
+import xarray as xr
+import numpy as np
+import holoviews as hv
+
+
+class ExampleMergeDataset(bch.ParametrizedSweep):
+
+    value = bch.FloatSweep(default=0, bounds=[0, 10])
+    repeats_x = bch.IntSweep(default=2, bounds=[2, 4])
+    # repeats_y = bch.IntSweep(default=2, bounds=[2, 4])
+
+    result_df = bch.ResultDataSet()
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+        # First, create a DataArray from the vector
+        vector = [v + self.value for v in range(1, self.repeats_x)]
+        data_array = xr.DataArray(vector, dims=["index"], coords={"index": np.arange(len(vector))})
+        # Convert the DataArray to a Dataset
+        result_df = xr.Dataset({"result_df": data_array})
+        self.result_df = bch.ResultDataSet(result_df.to_pandas())
+        return super().__call__(**kwargs)
+
+
+def example_dataset(run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None):
+    bench = ExampleMergeDataset().to_bench(run_cfg, report)
+    res = bench.plot_sweep(input_vars=["value"], const_vars=dict(repeats_x=4))
+    # bench.report.append(res.to_panes(target_dimension=1))
+    # bench.report.append(res.to_panes(target_dimension=2))
+    # bench.reprt.append(res.to_video_grid
+    #                             # bch.BenchResult.to_video_grid,
+    #     target_duration=0.06,
+    #     compose_method_list=[
+    #         bch.ComposeType.right,
+    #         bch.ComposeType.right,
+    #         bch.ComposeType.sequence,
+    #     ],
+    # )
+    # bench.report.append(res.to_panes(container=hv.Bars,target_dimension=1))
+    # bench.report.append(res.to_panes(container=hv.Curve))
+    bench.report.append(res.to_dataset1(container=hv.Curve))
+    return bench
+
+
+if __name__ == "__main__":
+    example_dataset().report.show()

{holobench-1.28.1 → holobench-1.29.0}/bencher/example/example_image.py

@@ -121,14 +121,12 @@ if __name__ == "__main__":
 
         # res = bench.sweep(input_vars=["sides", "radius"])
 
-        # bench.report.append(res.to_heatmap(target_dimension=3))
-
         bench.plot_sweep(input_vars=["sides"])
         bench.plot_sweep(input_vars=["sides", "color"])
 
-        bench.plot_sweep(input_vars=["sides", "radius"])
-
-        # bench.report.append(res.to_line(target_dimension=1))
+        res = bench.plot_sweep(input_vars=["sides", "radius"])
+        bench.report.append(res.to_heatmap(target_dimension=3))
+        bench.report.append(res.to_line(target_dimension=1))
 
         return bench
 
@@ -148,8 +146,8 @@ if __name__ == "__main__":
     # ex_run_cfg.debug = True
     # ex_run_cfg.repeats = 2
     ex_run_cfg.level = 4
-    example_image_vid(ex_run_cfg).report.show()
-    # simple().report.show()
+    # example_image_vid(ex_run_cfg).report.show()
+    simple().report.show()
 
     # example_image_vid_sequential(ex_run_cfg).report.show()
     # example_image(ex_run_cfg).report.show()

holobench-1.29.0/bencher/example/example_image1.py

@@ -0,0 +1,81 @@
+import bencher as bch
+import numpy as np
+import math
+import matplotlib.pyplot as plt
+
+
+def polygon_points(radius: float, sides: int, start_angle: float):
+    points = []
+    for ang in np.linspace(0, 360, sides + 1):
+        angle = math.radians(start_angle + ang)
+        points.append(([math.sin(angle) * radius, math.cos(angle) * radius]))
+    return points
+
+
+class BenchPolygons(bch.ParametrizedSweep):
+    sides = bch.IntSweep(default=3, bounds=(3, 7))
+    radius = bch.FloatSweep(default=1, bounds=(0.2, 1))
+    linewidth = bch.FloatSweep(default=1, bounds=(1, 10))
+    linestyle = bch.StringSweep(["solid", "dashed", "dotted"])
+    color = bch.StringSweep(["red", "green", "blue"])
+    start_angle = bch.FloatSweep(default=0, bounds=[0, 360])
+    polygon = bch.ResultImage()
+    polygon_small = bch.ResultImage()
+
+    area = bch.ResultVar()
+    side_length = bch.ResultVar()
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+        points = polygon_points(self.radius, self.sides, self.start_angle)
+        # self.hmap = hv.Curve(points)
+        self.polygon = self.points_to_polygon_png(points, bch.gen_image_path("polygon"), dpi=30)
+        self.polygon_small = self.points_to_polygon_png(
+            points, bch.gen_image_path("polygon"), dpi=10
+        )
+
+        self.side_length = 2 * self.radius * math.sin(math.pi / self.sides)
+        self.area = (self.sides * self.side_length**2) / (4 * math.tan(math.pi / self.sides))
+        return super().__call__()
+
+    def points_to_polygon_png(self, points: list[float], filename: str, dpi):
+        """Draw a closed polygon and save to png"""
+        fig = plt.figure(frameon=False)
+        ax = plt.Axes(fig, [0.0, 0.0, 1.0, 1.0], frameon=False)
+        ax.set_axis_off()
+        ax.plot(
+            [p[0] for p in points],
+            [p[1] for p in points],
+            linewidth=self.linewidth,
+            linestyle=self.linestyle,
+            color=self.color,
+        )
+        ax.set_xlim(-1, 1)
+        ax.set_ylim(-1, 1)
+
+        ax.set_aspect("equal")
+        fig.add_axes(ax)
+        fig.savefig(filename, dpi=dpi)
+
+        return filename
+
+
+def example_image_vid_sequential1(
+    run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None
+) -> bch.Bench:
+    bench = BenchPolygons().to_bench(run_cfg, report)
+    res = bench.plot_sweep(input_vars=["sides"])
+
+    bench.report.append(res.to_panes(zip_results=True))
+
+    return bench
+
+
+if __name__ == "__main__":
+
+    ex_run_cfg = bch.BenchRunCfg()
+    ex_run_cfg.use_sample_cache = True
+    ex_run_cfg.overwrite_sample_cache = True
+    ex_run_cfg.level = 3
+
+    example_image_vid_sequential1(ex_run_cfg).report.show()

{holobench-1.28.1 → holobench-1.29.0}/bencher/results/bench_result.py

@@ -7,15 +7,17 @@ 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.dataset_result import DataSetResult
 from bencher.utils import listify
 
 
-class BenchResult(PlotlyResult, HoloviewResult, VideoSummaryResult):
+class BenchResult(PlotlyResult, HoloviewResult, VideoSummaryResult, DataSetResult):
     """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)
+        # DataSetResult.__init__(self.bench_cfg)
 
     @staticmethod
     def default_plot_callbacks():

{holobench-1.28.1 → holobench-1.29.0}/bencher/results/bench_result_base.py

@@ -19,9 +19,7 @@ from bencher.variables.results import ResultVar
 from bencher.plotting.plot_filter import VarRange, PlotFilter
 from bencher.utils import listify
 
-from bencher.variables.results import (
-    ResultReference,
-)
+from bencher.variables.results import ResultReference, ResultDataSet
 
 from bencher.results.composable_container.composable_container_panel import ComposableContainerPanel
 
@@ -242,6 +240,46 @@ class BenchResultBase(OptunaResult):
             row.append(plot_callback(rv))
         return row.get()
 
+    @staticmethod
+    def zip_results1D(args):  # pragma: no cover
+        first_el = [a[0] for a in args]
+        out = pn.Column()
+        for a in zip(*first_el):
+            row = pn.Row()
+            row.append(a[0])
+            for a1 in range(1, len(a[1])):
+                row.append(a[a1][1])
+            out.append(row)
+        return out
+
+    @staticmethod
+    def zip_results1D1(panel_list):  # pragma: no cover
+        container_args = {"styles": {}}
+        container_args["styles"]["border-bottom"] = f"{2}px solid grey"
+        print(panel_list)
+        out = pn.Column()
+        for a in zip(*panel_list):
+            row = pn.Row(**container_args)
+            row.append(a[0][0])
+            for a1 in range(0, len(a)):
+                row.append(a[a1][1])
+            out.append(row)
+        return out
+
+    @staticmethod
+    def zip_results1D2(panel_list):  # pragma: no cover
+        if panel_list is not None:
+            print(panel_list)
+            primary = panel_list[0]
+            secondary = panel_list[1:]
+            for i in range(len(primary)):
+                print(type(primary[i]))
+                if isinstance(primary[i], (pn.Column, pn.Row)):
+                    for j in range(len(secondary)):
+                        primary[i].append(secondary[j][i][1])
+            return primary
+        return panel_list
+
     def map_plot_panes(
         self,
         plot_callback: callable,
@@ -250,6 +288,7 @@ class BenchResultBase(OptunaResult):
         result_var: ResultVar = None,
         result_types=None,
         pane_collection: pn.pane = None,
+        zip_results=False,
         **kwargs,
     ) -> Optional[pn.Row]:
         if hv_dataset is None:
@@ -271,6 +310,9 @@ class BenchResultBase(OptunaResult):
                         target_dimension=target_dimension,
                     )
                 )
+
+        if zip_results:
+            return self.zip_results1D2(row.get())
         return row.get()
 
     def filter(
@@ -405,10 +447,17 @@ class BenchResultBase(OptunaResult):
             return da_ds.values.squeeze().item()
         return da.expand_dims(dim).values[0]
 
-    def ds_to_container(
+    def ds_to_container(  # pylint: disable=too-many-return-statements
         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, ResultDataSet):
+            ref = self.dataset_list[val]
+            if ref is not None:
+                if container is not None:
+                    return container(ref.obj)
+                return ref.obj
+            return None
         if isinstance(result_var, ResultReference):
             ref = self.object_index[val]
             if ref is not None:

{holobench-1.28.1 → holobench-1.29.0}/bencher/results/composable_container/composable_container_base.py

@@ -10,7 +10,7 @@ class ComposeType(StrEnum):
     right = auto()  # append the container to the right (creates a row)
     down = auto()  # append the container below (creates a column)
     sequence = auto()  # display the container after (in time)
-    # overlay = auto()  # overlay on top of the current container (alpha blending)
+    overlay = auto()  # overlay on top of the current container (alpha blending)
 
     def flip(self):
         match self:

holobench-1.29.0/bencher/results/composable_container/composable_container_dataframe.py

@@ -0,0 +1,52 @@
+from dataclasses import dataclass
+import panel as pn
+import xarray as xr
+from bencher.results.composable_container.composable_container_base import ComposableContainerBase
+from bencher.results.composable_container.composable_container_base import ComposeType
+
+
+@dataclass(kw_only=True)
+class ComposableContainerDataset(ComposableContainerBase):
+    name: str = None
+    var_name: str = None
+    var_value: str = None
+    width: int = None
+    background_col: str = None
+    horizontal: bool = True
+
+    def __post_init__(
+        self,
+    ) -> None:
+        container_args = {
+            "name": self.name,
+            "styles": {},
+        }
+
+        if self.width is not None:
+            container_args["styles"]["border-bottom"] = f"{self.width}px solid grey"
+        if self.background_col is not None:
+            container_args["styles"]["background"] = self.background_col
+
+        if self.horizontal:
+            self.container = pn.Column(**container_args)
+            align = ("center", "center")
+        else:
+            self.container = pn.Row(**container_args)
+            align = ("end", "center")
+
+        label = self.label_formatter(self.var_name, self.var_value)
+        if label is not None:
+            self.label_len = len(label)
+            side = pn.pane.Markdown(label, align=align)
+            self.append(side)
+
+    def render(self, **kwargs):  # pylint: disable=unused-argument
+        match self.compose_method:
+            case ComposeType.right:
+                return xr.concat(self.container, 0)
+            case ComposeType.down:
+                return xr.concat(self.container, 1)
+            case ComposeType.sequence:
+                return xr.concat(self.container, 2)
+            # case ComposeType.overlay:
+            # return xr.Dataset.mean()

holobench-1.29.0/bencher/results/dataset_result.py

@@ -0,0 +1,227 @@
+from typing import Optional
+import panel as pn
+from param import Parameter
+from bencher.results.bench_result_base import BenchResultBase, ReduceType
+
+
+from functools import partial
+import holoviews as hv
+from bencher.variables.results import (
+    PANEL_TYPES,
+)
+
+
+class DataSetResult(BenchResultBase):
+    def to_dataset1(
+        self,
+        result_var: Parameter = None,
+        hv_dataset=None,
+        target_dimension: int = 0,
+        container=None,
+        level: int = None,
+        **kwargs,
+    ) -> Optional[pn.pane.panel]:
+        if hv_dataset is None:
+            hv_dataset = self.to_hv_dataset(ReduceType.SQUEEZE, level=level)
+        elif not isinstance(hv_dataset, hv.Dataset):
+            hv_dataset = hv.Dataset(hv_dataset)
+        return self.map_plot_panes(
+            partial(self.ds_to_container, container=container),
+            hv_dataset=hv_dataset,
+            target_dimension=target_dimension,
+            result_var=result_var,
+            result_types=PANEL_TYPES,
+            **kwargs,
+        )
+
+
+# class DataSetResult(BenchResultBase):
+
+#     def to_datatset(
+#         self,
+#         result_var: Parameter = None,
+#         result_types=(ResultDataSet,),
+#         pane_collection: pn.pane = None,
+#         time_sequence_dimension=0,
+#         target_duration: float = None,
+#         **kwargs,
+#     ) -> Optional[pn.panel]:
+#         """Returns the results compiled into a video
+
+#         Args:
+#             result_var (Parameter, optional): The result var to plot. Defaults to None.
+#             result_types (tuple, optional): The types of result var to convert to video. Defaults to (ResultDataSet,).
+#             collection (pn.pane, optional): If there are multiple results, use this collection to stack them. Defaults to pn.Row().
+
+#         Returns:
+#             Optional[pn.panel]: a panel pane with a video of all results concatenated together
+#         """
+#         plot_filter = PlotFilter(
+#             float_range=VarRange(0, None),
+#             cat_range=VarRange(0, None),
+#             panel_range=VarRange(1, None),
+#             input_range=VarRange(0, None),
+#         )
+#         matches_res = plot_filter.matches_result(
+#             self.plt_cnt_cfg, callable_name(self.to_video_grid_ds)
+#         )
+
+#         if pane_collection is None:
+#             pane_collection = pn.Row()
+
+#         if matches_res.overall:
+#             ds = self.to_dataset(ReduceType.SQUEEZE)
+#             for rv in self.get_results_var_list(result_var):
+#                 if isinstance(rv, result_types):
+#                     pane_collection.append(
+#                         self.to_video_grid_ds(
+#                             ds,
+#                             rv,
+#                             time_sequence_dimension=time_sequence_dimension,
+#                             target_duration=target_duration,
+#                             **kwargs,
+#                         )
+#                     )
+#             return pane_collection
+#         return matches_res.to_panel()
+
+#     def to_video_grid_ds(
+#         self,
+#         dataset: xr.Dataset,
+#         result_var: Parameter,
+#         reverse=True,
+#         time_sequence_dimension=0,
+#         video_controls: VideoControls = None,
+#         target_duration: float = None,
+#         **kwargs,
+#     ):
+#         cvc = self._to_video_panes_ds(
+#             dataset,
+#             self.plot_cb,
+#             target_dimension=0,
+#             horizontal=True,
+#             compose_method=ComposeType.right,
+#             time_sequence_dimension=time_sequence_dimension,
+#             result_var=result_var,
+#             final=True,
+#             reverse=reverse,
+#             target_duration=target_duration,
+#             **kwargs,
+#         )
+
+#         filename = VideoWriter().write_video_raw(cvc)
+
+#         if filename is not None:
+#             if video_controls is None:
+#                 video_controls = VideoControls()
+#             return video_controls.video_container(
+#                 filename, width=kwargs.get("width", None), height=kwargs.get("height", None)
+#             )
+#         return None
+
+#     def plot_cb(self, dataset, result_var, **kwargs):
+#         val = self.ds_to_container(dataset, result_var, container=None, **kwargs)
+#         return val
+
+#     def dataset_to_compose_list(
+#         self,
+#         dataset: xr.Dataset,
+#         first_compose_method: ComposeType = ComposeType.down,
+#         time_sequence_dimension: int = 0,
+#     ) -> List[ComposeType]:
+#         """ "Given a dataset, chose an order for composing the results.  By default will flip between right and down and the last dimension will be a time sequence.
+
+#         Args:
+#             dataset (xr.Dataset): the dataset to render
+#             first_compose_method (ComposeType, optional): the direction of the first composition method. Defaults to ComposeType.right.
+#             time_sequence_dimension (int, optional): The dimension to start time sequencing instead of composing in space. Defaults to 0.
+
+#         Returns:
+#             List[ComposeType]: A list of composition methods for composing the dataset result
+#         """
+
+#         num_dims = len(dataset.sizes)
+#         if time_sequence_dimension == -1:  # use time sequence for everything
+#             compose_method_list = [ComposeType.sequence] * (num_dims + 1)
+#         else:
+#             compose_method_list = [first_compose_method]
+#             compose_method_list.extend(
+#                 ComposeType.flip(compose_method_list[-1]) for _ in range(num_dims - 1)
+#             )
+#             compose_method_list.append(ComposeType.sequence)
+
+#             for i in range(min(len(compose_method_list), time_sequence_dimension + 1)):
+#                 compose_method_list[i] = ComposeType.sequence
+
+#         return compose_method_list
+
+#     def _to_video_panes_ds(
+#         self,
+#         dataset: xr.Dataset,
+#         plot_callback: callable = None,
+#         target_dimension=0,
+#         compose_method=ComposeType.right,
+#         compose_method_list=None,
+#         result_var=None,
+#         time_sequence_dimension=0,
+#         root_dimensions=None,
+#         reverse=False,
+#         target_duration: float = None,
+#         **kwargs,
+#     ) -> pn.panel:
+#         num_dims = len(dataset.sizes)
+#         dims = list(d for d in dataset.sizes)
+#         if reverse:
+#             dims = list(reversed(dims))
+
+#         if root_dimensions is None:
+#             root_dimensions = num_dims
+
+#         if compose_method_list is None:
+#             compose_method_list = self.dataset_to_compose_list(
+#                 dataset, compose_method, time_sequence_dimension=time_sequence_dimension
+#             )
+
+#             # print(compose_method_list)
+
+#         compose_method_list_pop = deepcopy(compose_method_list)
+#         if len(compose_method_list_pop) > 1:
+#             compose_method = compose_method_list_pop.pop()
+
+#         if num_dims > (target_dimension) and num_dims != 0:
+#             selected_dim = dims[-1]
+#             outer_container = ComposableContainerVideo()
+#             for i in range(dataset.sizes[selected_dim]):
+#                 sliced = dataset.isel({selected_dim: i})
+#                 label_val = sliced.coords[selected_dim].values.item()
+#                 inner_container = ComposableContainerVideo()
+
+#                 panes = self._to_video_panes_ds(
+#                     sliced,
+#                     plot_callback=plot_callback,
+#                     target_dimension=target_dimension,
+#                     compose_method_list=compose_method_list_pop,
+#                     result_var=result_var,
+#                     root_dimensions=root_dimensions,
+#                     time_sequence_dimension=time_sequence_dimension,
+#                 )
+#                 inner_container.append(panes)
+
+#                 rendered = inner_container.render(
+#                     RenderCfg(
+#                         var_name=selected_dim,
+#                         var_value=label_val,
+#                         compose_method=compose_method,
+#                         duration=target_duration,
+#                     )
+#                 )
+#                 outer_container.append(rendered)
+#             return outer_container.render(
+#                 RenderCfg(
+#                     compose_method=compose_method,
+#                     duration=target_duration,
+#                     background_col=color_tuple_to_255(int_to_col(num_dims - 2, 0.05, 1.0)),
+#                     # background_col= (255,0,0),
+#                 )
+#             )
+#         return plot_callback(dataset=dataset, result_var=result_var, **kwargs)

{holobench-1.28.1 → holobench-1.29.0}/bencher/results/optuna_result.py

@@ -63,6 +63,7 @@ class OptunaResult:
         self.studies = []
         self.plt_cnt_cfg = PltCntCfg()
         self.plot_inputs = []
+        self.dataset_list = []
 
         # self.width=600/
         # self.height=600

{holobench-1.28.1 → holobench-1.29.0}/bencher/variables/parametrised_sweep.py

@@ -3,7 +3,7 @@ from typing import List, Tuple, Any
 from param import Parameter, Parameterized
 import holoviews as hv
 import panel as pn
-
+from copy import deepcopy
 
 from bencher.utils import make_namedtuple, hash_sha1
 from bencher.variables.results import ALL_RESULT_TYPES, ResultHmap
@@ -127,7 +127,7 @@ class ParametrizedSweep(Parameterized):
         inp = cls.get_inputs_only()
         defaults = {}
         for i in inp:
-            defaults[i.name] = i.default
+            defaults[i.name] = deepcopy(i.default)
 
         for k, v in kwargs.items():
             defaults[k] = v

{holobench-1.28.1 → holobench-1.29.0}/bencher/variables/results.py

@@ -186,6 +186,25 @@ class ResultReference(param.Parameter):
         return hash_sha1(self)
 
 
+class ResultDataSet(param.Parameter):
+    __slots__ = ["units", "obj"]
+
+    def __init__(
+        self,
+        obj: Any = None,
+        default: Any = None,
+        units: str = "dataset",
+        **params,
+    ):
+        super().__init__(default=default, **params)
+        self.units = units
+        self.obj = obj
+
+    def hash_persistent(self) -> str:
+        """A hash function that avoids the PYTHONHASHSEED 'feature' which returns a different hash value each time the program is run"""
+        return hash_sha1(self)
+
+
 class ResultVolume(param.Parameter):
     __slots__ = ["units", "obj"]
 
@@ -199,7 +218,15 @@ class ResultVolume(param.Parameter):
         return hash_sha1(self)
 
 
-PANEL_TYPES = (ResultPath, ResultImage, ResultVideo, ResultContainer, ResultString, ResultReference)
+PANEL_TYPES = (
+    ResultPath,
+    ResultImage,
+    ResultVideo,
+    ResultContainer,
+    ResultString,
+    ResultReference,
+    ResultDataSet,
+)
 
 ALL_RESULT_TYPES = (
     ResultVar,
@@ -210,5 +237,6 @@ ALL_RESULT_TYPES = (
     ResultImage,
     ResultString,
     ResultContainer,
+    ResultDataSet,
     ResultReference,
 )

{holobench-1.28.1 → holobench-1.29.0/holobench.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: holobench
-Version: 1.28.1
+Version: 1.29.0
 Summary: A package for benchmarking the performance of arbitrary functions
 Author-email: Austin Gregg-Smith <blooop@gmail.com>
 Project-URL: Repository, https://github.com/dyson-ai/bencher

{holobench-1.28.1 → holobench-1.29.0}/holobench.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ bencher/example/example_composable_container2.py
 bencher/example/example_consts.py
 bencher/example/example_custom_sweep.py
 bencher/example/example_custom_sweep2.py
+bencher/example/example_dataframe.py
 bencher/example/example_docs.py
 bencher/example/example_filepath.py
 bencher/example/example_float3D.py
@@ -37,6 +38,7 @@ bencher/example/example_holosweep.py
 bencher/example/example_holosweep_objects.py
 bencher/example/example_holosweep_tap.py
 bencher/example/example_image.py
+bencher/example/example_image1.py
 bencher/example/example_levels.py
 bencher/example/example_levels2.py
 bencher/example/example_pareto.py
@@ -74,6 +76,7 @@ bencher/plotting/plt_cnt_cfg.py
 bencher/results/__init__.py
 bencher/results/bench_result.py
 bencher/results/bench_result_base.py
+bencher/results/dataset_result.py
 bencher/results/float_formatter.py
 bencher/results/holoview_result.py
 bencher/results/optuna_result.py
@@ -83,6 +86,7 @@ bencher/results/video_result.py
 bencher/results/video_summary.py
 bencher/results/composable_container/__init__.py
 bencher/results/composable_container/composable_container_base.py
+bencher/results/composable_container/composable_container_dataframe.py
 bencher/results/composable_container/composable_container_panel.py
 bencher/results/composable_container/composable_container_video.py
 bencher/variables/__init__.py

{holobench-1.28.1 → holobench-1.29.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "holobench"
-version = "1.28.1"
+version = "1.29.0"
 
 authors = [{ name = "Austin Gregg-Smith", email = "blooop@gmail.com" }]
 description = "A package for benchmarking the performance of arbitrary functions"
@@ -72,6 +72,7 @@ py310 = ["py310", "test"]
 py311 = ["py311", "test"]
 
 [tool.pixi.tasks]
+success = "echo Success"
 format = "black ."
 check-clean-workspace = "git diff --exit-code"
 ruff-lint = "ruff check . --fix"

{holobench-1.28.1 → holobench-1.29.0}/test/test_bench_examples.py

@@ -17,6 +17,7 @@ from bencher.example.example_workflow import example_floats2D_workflow, example_
 from bencher.example.example_holosweep import example_holosweep
 from bencher.example.example_holosweep_tap import example_holosweep_tap
 
+from bencher.example.example_dataframe import example_dataset
 from bencher.example.optuna.example_optuna import optuna_rastrigin
 from bencher.example.example_sample_cache import example_sample_cache
 from bencher.example.example_strings import example_strings
@@ -95,6 +96,9 @@ class TestBenchExamples(unittest.TestCase):
     def test_example_float3D(self) -> None:
         self.examples_asserts(example_floats3D(self.create_run_cfg()))
 
+    def test_example_dataset(self) -> None:
+        self.examples_asserts(example_dataset(self.create_run_cfg()))
+
     def test_example_custom_sweep(self) -> None:
         self.examples_asserts(example_custom_sweep(self.create_run_cfg()))