holobench 1.28.1__py3-none-any.whl → 1.30.2__py3-none-any.whl

bencher/__init__.py

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

bencher/bench_cfg.py

@@ -69,7 +69,7 @@ class BenchRunCfg(BenchPlotSrvCfg):
 
     serve_pandas_flat: bool = param.Boolean(
         True,
-        doc="Serve a flattend pandas summary on the results webpage.  If you have a large dataset consider setting this to false if the page loading is slow",
+        doc="Serve a flattened pandas summary on the results webpage.  If you have a large dataset consider setting this to false if the page loading is slow",
     )
 
     serve_xarray: bool = param.Boolean(
@@ -78,7 +78,7 @@ class BenchRunCfg(BenchPlotSrvCfg):
     )
 
     auto_plot: bool = param.Boolean(
-        True, doc=" Automaticlly dedeuce the best type of plot for the results."
+        True, doc=" Automatically dedeuce the best type of plot for the results."
     )
 
     raise_duplicate_exception: bool = param.Boolean(False, doc=" Used to debug unique plot names.")
@@ -131,13 +131,13 @@ class BenchRunCfg(BenchPlotSrvCfg):
 
     render_plotly = param.Boolean(
         True,
-        doc="Plotly and Bokeh don't play nicely together, so by default pre-render plotly figures to a non dynamic version so that bokeh plots correctly.  If you want interactive 3D graphs, set this to true but be aware that your 2D interactive graphs will probalby stop working.",
+        doc="Plotly and Bokeh don't play nicely together, so by default pre-render plotly figures to a non dynamic version so that bokeh plots correctly.  If you want interactive 3D graphs, set this to true but be aware that your 2D interactive graphs will probably stop working.",
     )
 
     level = param.Integer(
         default=0,
         bounds=[0, 12],
-        doc="The level parameter is a method of defining the number samples to sweep over in a variable agnostic way, i.e you don't need to specficy the number of samples for each variable as they are calculated dynamically from the sampling level.  See example_level.py for more information.",
+        doc="The level parameter is a method of defining the number samples to sweep over in a variable agnostic way, i.e you don't need to specify the number of samples for each variable as they are calculated dynamically from the sampling level.  See example_level.py for more information.",
     )
 
     run_tag = param.String(
@@ -163,10 +163,10 @@ class BenchRunCfg(BenchPlotSrvCfg):
     plot_size = param.Integer(default=None, doc="Sets the width and height of the plot")
     plot_width = param.Integer(
         default=None,
-        doc="Sets with width of the plots, this will ovverride the plot_size parameter",
+        doc="Sets with width of the plots, this will override the plot_size parameter",
     )
     plot_height = param.Integer(
-        default=None, doc="Sets the height of the plot, this will ovverride the plot_size parameter"
+        default=None, doc="Sets the height of the plot, this will override the plot_size parameter"
     )
 
     @staticmethod
@@ -291,7 +291,7 @@ class BenchCfg(BenchRunCfg):
 
     tag: str = param.String(
         "",
-        doc="Use tags to group different benchmarks together. By default benchmarks are considered distinct from eachother and are identified by the hash of their name and inputs, constants and results and tag, but you can optionally change the hash value to only depend on the tag.  This way you can have multiple unrelated benchmarks share values with eachother based only on the tag value.",
+        doc="Use tags to group different benchmarks together. By default benchmarks are considered distinct from each other and are identified by the hash of their name and inputs, constants and results and tag, but you can optionally change the hash value to only depend on the tag.  This way you can have multiple unrelated benchmarks share values with each other based only on the tag value.",
     )
 
     hash_value: str = param.String(
@@ -311,10 +311,10 @@ class BenchCfg(BenchRunCfg):
         self.iv_repeat = None
 
     def hash_persistent(self, include_repeats) -> str:
-        """override the default hash function becuase the default hash function does not return the same value for the same inputs.  It references internal variables that are unique per instance of BenchCfg
+        """override the default hash function because the default hash function does not return the same value for the same inputs.  It references internal variables that are unique per instance of BenchCfg
 
         Args:
-            include_repeats (bool) : by default include repeats as part of the hash execpt with using the sample cache
+            include_repeats (bool) : by default include repeats as part of the hash except with using the sample cache
         """
 
         if include_repeats:

bencher/bench_plot_server.py

@@ -84,7 +84,7 @@ class BenchPlotServer:
         Args:
             bench_cfg (BenchCfg): benchmark results
             plots_instance (List[pn.panel]): list of panel objects to display
-            port (int): use a fixed port to lauch the server
+            port (int): use a fixed port to launch the server
         """
 
         # suppress verbose tornado and bokeh output

bencher/bench_runner.py

@@ -85,7 +85,7 @@ class BenchRunner:
             run_cfg (BenchRunCfg, optional): benchmark run configuration. Defaults to None.
             publish (bool, optional): Publish the results to git, requires a publish url to be set up. Defaults to False.
             debug (bool, optional): _description_. Defaults to False.
-            show (bool, optional): show the results in the local web browswer. Defaults to False.
+            show (bool, optional): show the results in the local web browser. Defaults to False.
             save (bool, optional): save the results to disk in index.html. Defaults to False.
             grouped (bool, optional): Produce a single html page with all the benchmarks included. Defaults to True.
             use_cache (bool, optional): Use the sample cache to reused previous results. Defaults to True.

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
@@ -177,7 +178,7 @@ class Bench(BenchPlotServer):
         self.plot = True
 
     def add_plot_callback(self, callback: Callable[[BenchResult], pn.panel], **kwargs) -> None:
-        """Add a plotting callback that will be called on any result produced when calling a sweep funciton.  You can pass additional arguments to the plotting function with kwargs.  e.g.  add_plot_callback(bch.BenchResult.to_video_grid,)
+        """Add a plotting callback that will be called on any result produced when calling a sweep function.  You can pass additional arguments to the plotting function with kwargs.  e.g.  add_plot_callback(bch.BenchResult.to_video_grid,)
 
         Args:
             callback (Callable[[BenchResult], pn.panel]): _description_
@@ -497,7 +498,7 @@ class Bench(BenchPlotServer):
         """check that a variable is a subclass of param
 
         Args:
-            variable (param.Parameter): the varible to check
+            variable (param.Parameter): the variable to check
             var_type (str): a string representation of the variable type for better error messages
 
         Raises:
@@ -559,7 +560,7 @@ class Bench(BenchPlotServer):
         """Load historical data from a cache if over_time=true
 
         Args:
-            ds (xr.Dataset): Freshly calcuated data
+            ds (xr.Dataset): Freshly calculated data
             bench_cfg_hash (int): Hash of the input variables used to generate the data
             clear_history (bool): Optionally clear the history
 
@@ -592,7 +593,7 @@ class Bench(BenchPlotServer):
             time_src (datetime | str): a representation of the sample time
 
         Returns:
-            tuple[BenchResult, List, List]: bench_result, function intputs, dimension names
+            tuple[BenchResult, List, List]: bench_result, function inputs, dimension names
         """
 
         if time_src is None:
@@ -610,14 +611,15 @@ class Bench(BenchPlotServer):
         function_inputs = list(
             zip(product(*dims_cfg.dim_ranges_index), product(*dims_cfg.dim_ranges))
         )
-        # 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
+        # xarray stores K N-dimensional arrays of data.  Each array is named and in this case we have an 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,7 +627,8 @@ 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:
+
+            elif type(rv) is ResultVec:
                 for i in range(rv.size):
                     result_data = np.full(dims_cfg.dims_size, np.nan)
                     data_vars[rv.index_name(i)] = (dims_cfg.dims_name, result_data)
@@ -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:
@@ -818,14 +830,14 @@ class Bench(BenchPlotServer):
 
         Args:
             bench_cfg (BenchCfg):
-            input_var (ParametrizedSweep): The varible to extract metadata from
+            input_var (ParametrizedSweep): The variable to extract metadata from
         """
 
         for rv in bench_res.bench_cfg.result_vars:
-            if type(rv) == ResultVar:
+            if type(rv) is ResultVar:
                 bench_res.ds[rv.name].attrs["units"] = rv.units
                 bench_res.ds[rv.name].attrs["long_name"] = rv.name
-            elif type(rv) == ResultVec:
+            elif type(rv) is ResultVec:
                 for i in range(rv.size):
                     bench_res.ds[rv.index_name(i)].attrs["units"] = rv.units
                     bench_res.ds[rv.index_name(i)].attrs["long_name"] = rv.name
@@ -840,7 +852,7 @@ class Bench(BenchPlotServer):
             dsvar.attrs["description"] = input_var.__doc__
 
     def report_results(self, bench_cfg: BenchCfg, print_xarray: bool, print_pandas: bool):
-        """Optionally display the caculated benchmark data as either as pandas, xarray or plot
+        """Optionally display the calculated benchmark data as either as pandas, xarray or plot
 
         Args:
             bench_cfg (BenchCfg):

bencher/example/benchmark_data.py

@@ -1,6 +1,6 @@
 """This file contains an example of how to define benchmarking parameters sweeps. Categorical values are defined as enums and passed to EnumSweep classes, other types of sweeps are defined by their respective classes.
 
-You can define a subclass which contains an input configuration which can be passed to a function in a type safe way. You can combine the subclass with a higher level class which contains more configuation parameters.  This is to help manage the complexity of large configuration/parameter spaces. 
+You can define a subclass which contains an input configuration which can be passed to a function in a type safe way. You can combine the subclass with a higher level class which contains more configuration parameters.  This is to help manage the complexity of large configuration/parameter spaces.
 """
 
 import math

bencher/example/example_categorical.py

@@ -86,7 +86,7 @@ def example_categorical(
         ],
         title="Categorical 3D Example Over Time",
         result_vars=[ExampleBenchCfgOut.param.out_sin],
-        description="""Lastly, what if you want to track these distributions over time? Set over_time=True and bencher will cache and display historical resuts alongside the latest result.  Use clear_history=True to clear that cache.""",
+        description="""Lastly, what if you want to track these distributions over time? Set over_time=True and bencher will cache and display historical results alongside the latest result.  Use clear_history=True to clear that cache.""",
         post_description="The output shows faceted line plot with confidence intervals for the mean value over time.",
         run_cfg=run_cfg,
     )

bencher/example/example_custom_sweep.py

@@ -23,7 +23,7 @@ class Square(bch.ParametrizedSweep):
 def example_custom_sweep(
     run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
 ) -> bch.Bench:
-    """This example shows how to define a custom set of value to sample from intead of a uniform sweep
+    """This example shows how to define a custom set of value to sample from instead of a uniform sweep
 
     Args:
         run_cfg (BenchRunCfg): configuration of how to perform the param sweep

bencher/example/example_custom_sweep2.py

@@ -17,7 +17,7 @@ class Square(bch.ParametrizedSweep):
 def example_custom_sweep2(
     run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None
 ) -> bch.Bench:
-    """This example shows how to define a custom set of value to sample from intead of a uniform sweep
+    """This example shows how to define a custom set of value to sample from instead of a uniform sweep
 
     Args:
         run_cfg (BenchRunCfg): configuration of how to perform the param sweep

bencher/example/example_dataframe.py

@@ -0,0 +1,47 @@
+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()

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()

bencher/example/example_image1.py

@@ -0,0 +1,80 @@
+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()

bencher/example/example_levels.py

@@ -81,7 +81,7 @@ def run_levels_1D(bench: bch.Bench) -> bch.Bench:
     bench.report.append(row)
 
     bench.report.append_markdown(
-        "Level 1 returns a single point at the lower bound of the parameter. Level 2 uses the uppper and lower bounds of the parameter. All subsequent levels are created by adding a sample between each previously calculated sample to ensure that all previous values can be reused while retaining an equal sample spacing.  The following plots show the sample points as circles and the corresponding plot of a sin function sampled at that level.",
+        "Level 1 returns a single point at the lower bound of the parameter. Level 2 uses the upper and lower bounds of the parameter. All subsequent levels are created by adding a sample between each previously calculated sample to ensure that all previous values can be reused while retaining an equal sample spacing.  The following plots show the sample points as circles and the corresponding plot of a sin function sampled at that level.",
         width=600,
     )
 

bencher/example/example_levels2.py

@@ -15,7 +15,7 @@ class Square(bch.ParametrizedSweep):
 
 
 def example_levels2(run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None) -> bch.Bench:
-    """This example shows how to define a custom set of value to sample from intead of a uniform sweep
+    """This example shows how to define a custom set of value to sample from instead of a uniform sweep
 
     Args:
         run_cfg (BenchRunCfg): configuration of how to perform the param sweep

bencher/example/example_pareto.py

@@ -29,7 +29,7 @@ def example_pareto(
 
     res = bench.plot_sweep(
         title="Pareto Optimisation with Optuna",
-        description="This example shows how to plot the pareto front of the tradeoff between multiple criteria.  When multiple result variable are defined, and use_optuna=True a pareto plot and the relative importance of each input variable on the output criteria is plotted. A summary of the points on the pareto front is printed as well.  You can use the pareto plot to decide the how to trade off one objective for another.  Pareto plots are suppored for 2D and 3D.  If you have more than 3 result variables the first 3 are selected for the pareto plot.  Plotting 4D surfaces is left as an exercise to the reader",
+        description="This example shows how to plot the pareto front of the tradeoff between multiple criteria.  When multiple result variable are defined, and use_optuna=True a pareto plot and the relative importance of each input variable on the output criteria is plotted. A summary of the points on the pareto front is printed as well.  You can use the pareto plot to decide the how to trade off one objective for another.  Pareto plots are supported for 2D and 3D.  If you have more than 3 result variables the first 3 are selected for the pareto plot.  Plotting 4D surfaces is left as an exercise to the reader",
         input_vars=[
             ExampleBenchCfgIn.param.theta,
             ExampleBenchCfgIn.param.offset,

bencher/example/example_sample_cache_context.py

@@ -82,7 +82,7 @@ def example_cache_context() -> bch.Bench:
         tag="example_tag1",
     )
 
-    # these values have not been calcuated before so there should be 1 fn call
+    # these values have not been calculated before so there should be 1 fn call
     assert_call_counts(bencher, run_cfg, wrapper_calls=1, fn_calls=1, cache_calls=0)
 
     # now create a new benchmark that calculates the values of the previous two benchmarks. The tag is the same so those values will be loaded from the cache instead of getting calculated again
@@ -106,7 +106,7 @@ def example_cache_context() -> bch.Bench:
         tag="example_tag2",
     )
 
-    # Both calls are calcuated becuase the tag is different so they don't hit the cache
+    # Both calls are calculated because the tag is different so they don't hit the cache
     assert_call_counts(bencher, run_cfg, wrapper_calls=2, fn_calls=2, cache_calls=0)
 
     return bencher

bencher/example/example_simple.py

@@ -12,7 +12,7 @@ from strenum import StrEnum
 import bencher as bch
 
 
-# define a class with the output variables you want to benchmark. It must inherit from ParametrizedSweep (which inherits from param.Parametrized). Param is a python library that allows you to track metadata about parameters.  I would recommend reading at least the intro: https://param.holoviz.org/.  I have extended param with some extra metadata such is the units of the variable so that it can automaticaly be plotted.
+# define a class with the output variables you want to benchmark. It must inherit from ParametrizedSweep (which inherits from param.Parametrized). Param is a python library that allows you to track metadata about parameters.  I would recommend reading at least the intro: https://param.holoviz.org/.  I have extended param with some extra metadata such is the units of the variable so that it can automatically be plotted.
 class OutputCfg(bch.ParametrizedSweep):
     """A class for defining what variables the benchmark function returns and metadata on those variables"""
 
@@ -41,7 +41,7 @@ class InputCfg(bch.ParametrizedSweep):
     # The variables must be defined as one of the Sweep types, i.e, FloatSweep, IntSweep, EnumSweep from bencher.bench_vars
     # theta = FloatSweep(default=0, bounds=[0, math.pi], doc="Input angle", units="rad", samples=30)
 
-    # Define sweep variables by passing in an enum class name. The first element of the enum is the default by convention, but you can overrride the default in the constructor
+    # Define sweep variables by passing in an enum class name. The first element of the enum is the default by convention, but you can override the default in the constructor
     algo_setting_enum = bch.EnumSweep(AlgoSetting, default=AlgoSetting.poor)
 
     # In this case there are no units so its marked as unitless or ul. You can define how many evenly distributed samples to sample the parameter with
@@ -66,7 +66,7 @@ class InputCfg(bch.ParametrizedSweep):
 
         match cfg.algo_setting_enum:
             case AlgoSetting.noisy:
-                # add some random noise to the output.  When your algorith has noisy output it often is an indication that something is not quite right.  The graphs should show that you want to avoid the "noisy" setting in your algorithm
+                # add some random noise to the output.  When your algorithm has noisy output it often is an indication that something is not quite right.  The graphs should show that you want to avoid the "noisy" setting in your algorithm
                 output.accuracy += random.uniform(-10, 10)
             case AlgoSetting.optimum:
                 output.accuracy += 30  # This is the setting with the best performance, and characterising that is is the goal of the benchmarking
@@ -122,9 +122,9 @@ if __name__ == "__main__":
         result_vars=[OutputCfg.param.accuracy],
         const_vars=[(InputCfg.param.algo_setting_float, 1.33)],
         title="Simple example 1D sweep over time",
-        description="""Once you have found the optimal settings for your algorithm you want to make sure that the performance is not lost over time.  You can set variables to a constant value and in this case the float value is set to its optimum value.  The first time this function is run only the results from sweeping the categorical value is plotted (the same as example 1), but the second time it is run a graph the values over time is shown. [Run the code again if you don't see a graph over time]. If the graphs over time shows long term changes (not just noise), it indicate there is another external factor that is affecting your performace over time, i.e. dependencies changing, physical degradation of equipment, an unnoticed bug from a pull request etc...
+        description="""Once you have found the optimal settings for your algorithm you want to make sure that the performance is not lost over time.  You can set variables to a constant value and in this case the float value is set to its optimum value.  The first time this function is run only the results from sweeping the categorical value is plotted (the same as example 1), but the second time it is run a graph the values over time is shown. [Run the code again if you don't see a graph over time]. If the graphs over time shows long term changes (not just noise), it indicate there is another external factor that is affecting your performance over time, i.e. dependencies changing, physical degradation of equipment, an unnoticed bug from a pull request etc...
 
-        This shows the basic features of bencher.  These examples are purposefully simplified to demonstrate its features in isolation and don't reeally show the real advantages of bencher.  If you only have a few inputs and outputs its not that complicated to throw together some plots of performance.  The power of bencher is that when you have a system with many moving parts that all interact with eachother, teasing apart those influences becomes much harder because the parameter spaces combine quite quickly into a high dimensional mess. Bencher makes it easier to experiment with different combination of inputs to gain an intuition of the system performance. Bencher can plot up to 6D input natively and you can add custom plots if you have exotic data types or state spaces [WIP]. 
+        This shows the basic features of bencher.  These examples are purposefully simplified to demonstrate its features in isolation and don't reeally show the real advantages of bencher.  If you only have a few inputs and outputs its not that complicated to throw together some plots of performance.  The power of bencher is that when you have a system with many moving parts that all interact with each other, teasing apart those influences becomes much harder because the parameter spaces combine quite quickly into a high dimensional mess. Bencher makes it easier to experiment with different combination of inputs to gain an intuition of the system performance. Bencher can plot up to 6D input natively and you can add custom plots if you have exotic data types or state spaces [WIP]. 
         """,
         post_description="",
         run_cfg=bch.BenchRunCfg(repeats=10, over_time=True, clear_history=False),

bencher/example/meta/example_meta.py

@@ -149,7 +149,7 @@ def example_meta(
     bench.plot_sweep(
         title="Meta Bench",
         description="""## All Combinations of Variable Sweeps and Resulting Plots
-This uses bencher to display all the combinatios of plots bencher is able to produce""",
+This uses bencher to display all the combinations of plots bencher is able to produce""",
         input_vars=[
             bch.p("float_vars", [0, 1, 2, 3]),
             BenchMeta.param.categorical_vars,

bencher/example/shelved/example_kwargs.py

@@ -10,7 +10,7 @@
 #     trig_func: str = "sin",
 #     **kwargs,  # pylint: disable=unused-argument
 # ) -> dict:
-#     """All the other examples use classes and parameters to define the inputs and outputs to the function. However it makes the code less flexible when integrating with other systems, so this example shows a more basic interface that accepts and returns dictionaries.  The classes still need to be defined however because that is how the sweep and plotting settings are calcuated"""
+#     """All the other examples use classes and parameters to define the inputs and outputs to the function. However it makes the code less flexible when integrating with other systems, so this example shows a more basic interface that accepts and returns dictionaries.  The classes still need to be defined however because that is how the sweep and plotting settings are calculated"""
 #     output = {}
 
 #     if trig_func == "sin":

bencher/plotting/plot_filter.py

@@ -6,7 +6,7 @@ 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."""
+    """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 passed to matches() will return false.  Matches only takes 0 and positive integers."""
 
     def __init__(self, lower_bound: int = 0, upper_bound: int = -1) -> None:
         """
@@ -71,7 +71,7 @@ class PlotFilter:
 
 # @dataclass
 class PlotMatchesResult:
-    """Stores information about which properites match the requirements of a particular plotter"""
+    """Stores information about which properties match the requirements of a particular plotter"""
 
     def __init__(self, plot_filter: PlotFilter, plt_cnt_cfg: PltCntCfg, plot_name: str):
         match_info = []

bencher/plotting/plt_cnt_cfg.py

@@ -3,7 +3,13 @@ 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.inputs import (
+    IntSweep,
+    FloatSweep,
+    BoolSweep,
+    EnumSweep,
+    StringSweep,
+)
 from bencher.variables.time import TimeSnapshot
 
 
@@ -17,12 +23,13 @@ class PltCntCfg(param.Parameterized):
     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")
+    panel_cnt = param.Integer(0, doc="Number of results represent 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"
+        True,
+        doc="Print debug information about why a filter matches this config or not",
     )
 
     @staticmethod

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():