holobench 1.9.0__tar.gz → 1.11.0__tar.gz

{holobench-1.9.0 → holobench-1.11.0}/PKG-INFO

@@ -1,23 +1,23 @@
 Metadata-Version: 2.1
 Name: holobench
-Version: 1.9.0
+Version: 1.11.0
 Summary: A package for benchmarking the performance of arbitrary functions
 Author-email: Austin Gregg-Smith <blooop@gmail.com>
 Description-Content-Type: text/markdown
-Requires-Dist: holoviews>=1.15,<=1.18.1
-Requires-Dist: numpy>=1.0,<=1.26.3
-Requires-Dist: param>=1.13.0,<=2.0.2
+Requires-Dist: holoviews>=1.15,<=1.18.3
+Requires-Dist: numpy>=1.0,<=1.26.4
+Requires-Dist: param>=1.13.0,<=2.1.0
 Requires-Dist: hvplot>=0.8,<=0.9.2
-Requires-Dist: matplotlib>=3.6.3,<=3.8.2
-Requires-Dist: panel>=1.3.6,<=1.3.8
+Requires-Dist: matplotlib>=3.6.3,<=3.8.3
+Requires-Dist: panel>=1.3.6,<=1.4.0
 Requires-Dist: diskcache>=5.6,<=5.6.3
-Requires-Dist: optuna>=3.2,<=3.5.0
-Requires-Dist: xarray>=2023.7,<=2024.1.1
-Requires-Dist: plotly>=5.15,<=5.18.0
+Requires-Dist: optuna>=3.2,<=3.6.1
+Requires-Dist: xarray>=2023.7,<=2024.3.0
+Requires-Dist: plotly>=5.15,<=5.20.0
 Requires-Dist: sortedcontainers>=2.4,<=2.4
-Requires-Dist: pandas>=2.0,<=2.2.0
+Requires-Dist: pandas>=2.0,<=2.2.1
 Requires-Dist: strenum>=0.4.0,<=0.4.15
-Requires-Dist: scikit-learn>=1.2,<=1.4.0
+Requires-Dist: scikit-learn>=1.2,<=1.4.1.post1
 Requires-Dist: str2bool>=1.1,<=1.1
 Requires-Dist: scoop>=0.7.0,<=0.7.2.0
 Requires-Dist: moviepy>=1.0.3,<=1.0.3
@@ -25,8 +25,8 @@ Requires-Dist: black>=23,<=24.1.1 ; extra == "test"
 Requires-Dist: pylint>=2.16,<=3.0.3 ; extra == "test"
 Requires-Dist: pytest-cov>=4.1,<=4.1 ; extra == "test"
 Requires-Dist: pytest>=7.4,<=8.0.0 ; extra == "test"
-Requires-Dist: hypothesis>=6.82,<=6.97.4 ; extra == "test"
-Requires-Dist: ruff>=0.0.280,<=0.1.15 ; extra == "test"
+Requires-Dist: hypothesis>=6.82,<=6.97.1 ; extra == "test"
+Requires-Dist: ruff>=0.0.280,<=0.1.14 ; extra == "test"
 Requires-Dist: coverage>=7.2.7,<=7.4.1 ; extra == "test"
 Project-URL: Documentation, https://bencher.readthedocs.io/en/latest/
 Project-URL: Home, https://github.com/dyson-ai/bencher

{holobench-1.9.0 → holobench-1.11.0}/bencher/__init__.py

@@ -39,3 +39,4 @@ from .results.holoview_result import ReduceType, HoloviewResult
 from .bench_report import BenchReport
 from .job import Executors
 from .video_writer import VideoWriter, add_image
+from .class_enum import ClassEnum, ExampleEnum

{holobench-1.9.0 → holobench-1.11.0}/bencher/bench_cfg.py

@@ -38,10 +38,6 @@ class BenchRunCfg(BenchPlotSrvCfg):
         doc="If true each time the function is called it will plot a timeseries of historical and the latest result.",
     )
 
-    debug: bool = param.Boolean(
-        False, doc="Debug the sampling faster by reducing the dimension sampling resolution"
-    )
-
     use_optuna: bool = param.Boolean(False, doc="show optuna plots")
 
     summarise_constant_inputs = param.Boolean(
@@ -333,7 +329,6 @@ class BenchCfg(BenchRunCfg):
                 hash_sha1(str(self.title)),
                 hash_sha1(self.over_time),
                 repeats_hash,
-                hash_sha1(self.debug),
                 hash_sha1(self.tag),
             )
         )
@@ -364,16 +359,16 @@ class BenchCfg(BenchRunCfg):
 
         benchmark_sampling_str.append("Input Variables:")
         for iv in self.input_vars:
-            benchmark_sampling_str.extend(describe_variable(iv, self.debug, True))
+            benchmark_sampling_str.extend(describe_variable(iv, True))
 
         if self.const_vars and (self.summarise_constant_inputs):
             benchmark_sampling_str.append("\nConstants:")
             for cv in self.const_vars:
-                benchmark_sampling_str.extend(describe_variable(cv[0], False, False, cv[1]))
+                benchmark_sampling_str.extend(describe_variable(cv[0], False, cv[1]))
 
         benchmark_sampling_str.append("\nResult Variables:")
         for rv in self.result_vars:
-            benchmark_sampling_str.extend(describe_variable(rv, self.debug, False))
+            benchmark_sampling_str.extend(describe_variable(rv, False))
 
         print_meta = True
         # if len(self.meta_vars) == 1:
@@ -394,7 +389,7 @@ class BenchCfg(BenchRunCfg):
             benchmark_sampling_str.append(f"    parallel: {self.executor}")
 
             for mv in self.meta_vars:
-                benchmark_sampling_str.extend(describe_variable(mv, self.debug, True))
+                benchmark_sampling_str.extend(describe_variable(mv, True))
 
         benchmark_sampling_str.append("```")
 
@@ -455,7 +450,7 @@ class DimsCfg:
         self.dims_name = [i.name for i in bench_cfg.all_vars]
 
         self.dim_ranges = []
-        self.dim_ranges = [i.values(bench_cfg.debug) for i in bench_cfg.all_vars]
+        self.dim_ranges = [i.values() for i in bench_cfg.all_vars]
         self.dims_size = [len(p) for p in self.dim_ranges]
         self.dim_ranges_index = [list(range(i)) for i in self.dims_size]
         self.dim_ranges_str = [f"{s}\n" for s in self.dim_ranges]

{holobench-1.9.0 → holobench-1.11.0}/bencher/bencher.py

@@ -573,7 +573,7 @@ class Bench(BenchPlotServer):
         # bench_cfg.all_vars = [ bench_cfg.iv_repeat] +bench_cfg.input_vars + bench_cfg.iv_time
 
         for i in bench_cfg.all_vars:
-            logging.info(i.sampling_str(bench_cfg.debug))
+            logging.info(i.sampling_str())
 
         dims_cfg = DimsCfg(bench_cfg)
         function_inputs = list(
@@ -631,7 +631,6 @@ class Bench(BenchPlotServer):
             default=repeats,
             bounds=[1, repeats],
             samples=repeats,
-            samples_debug=2 if repeats > 2 else 1,
             units="repeats",
             doc="The number of times a sample was measured",
         )

holobench-1.11.0/bencher/class_enum.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+from strenum import StrEnum
+from typing import Any
+import importlib
+from abc import abstractmethod
+from dataclasses import dataclass
+from enum import auto
+
+
+class ClassEnum(StrEnum):
+    """A ClassEnum is a pattern to make it easier to create factory a factory method that converts from an enum to a corresponding class.  Subclasses should implement to_class(enum_instance:EnumType) which takes an enum returns the corresponding instance of that class."""
+
+    @classmethod
+    def to_class_generic(cls, module_import: str, class_name: str) -> Any:
+        """Create an instance of the class referred to by this enum
+
+        Returns:
+            Any: instance of the class
+        """
+
+        class_def = getattr(importlib.import_module(module_import), class_name)
+        return class_def()
+
+    @classmethod
+    @abstractmethod
+    def to_class(cls, enum_val: ClassEnum) -> Any:
+        """Subclasses should overrides this method to take  an enum returns the corresponding instance of that class."""
+        raise NotImplementedError()
+
+
+@dataclass
+class BaseClass:
+    baseclassname: str = "class0"
+
+
+@dataclass
+class Class1(BaseClass):
+    classname: str = "class1"
+
+
+@dataclass
+class Class2(BaseClass):
+    classname: str = "class2"
+
+
+class ExampleEnum(ClassEnum):
+    Class1 = auto()
+    Class2 = auto()
+
+    @classmethod
+    def to_class(cls, enum_val: ExampleEnum) -> BaseClass:
+        return cls.to_class_generic("bencher.class_enum", enum_val)

{holobench-1.9.0 → holobench-1.11.0}/bencher/example/example_holosweep.py

@@ -41,12 +41,11 @@ class PlotFunctions(bch.ParametrizedSweep):
 
     compute_fn = bch.EnumSweep(Function)
 
+    # RESULT VARS
     fn_output = bch.ResultVar(units="v", doc="sin of theta with some noise")
-
     out_sum = bch.ResultVar(units="v", doc="The sum")
-
-    hmap = bch.ResultReference()
-    hmap1 = bch.ResultHmap()
+    ref = bch.ResultReference()
+    holomap = bch.ResultHmap()
 
     def __call__(self, plot=True, **kwargs) -> dict:
         self.update_params_from_kwargs(**kwargs)
@@ -56,8 +55,8 @@ class PlotFunctions(bch.ParametrizedSweep):
             0, noise
         )
 
-        self.hmap1 = self.plot_holo(plot)
-        self.hmap = bch.ResultReference(self.hmap1)
+        self.holomap = self.plot_holo(plot)
+        self.ref = bch.ResultReference(self.ref)
 
         return self.get_results_values_as_dict()
 
@@ -73,17 +72,11 @@ class PlotFunctions(bch.ParametrizedSweep):
 def example_holosweep(
     run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
 ) -> bch.Bench:
-    wv = PlotFunctions()
-
-    # run_cfg.use_optuna = True
-
-    bench = bch.Bench("waves", wv, run_cfg=run_cfg, report=report)
+    bench = PlotFunctions().to_bench(run_cfg, report)
 
     bench.plot_sweep(
-        "phase",
-        input_vars=[PlotFunctions.param.theta, PlotFunctions.param.freq],
-        result_vars=[PlotFunctions.param.fn_output, PlotFunctions.param.hmap],
-        # result_vars=[PlotFunctions.param.hmap],
+        input_vars=["theta", "freq"],
+        result_vars=["fn_output", "holomap"],
     )
 
     # print("best", res.get_best_trial_params(True))
@@ -99,6 +92,7 @@ def example_holosweep(
 
 
 if __name__ == "__main__":
+    PlotFunctions().to_gui()
     bench_run = bch.BenchRunner("bench_runner_test")
     bench_run.add_run(example_holosweep)
-    bench_run.run(level=3, show=True, use_cache=False)
+    bench_run.run(level=6, show=True, use_cache=False)

{holobench-1.9.0 → holobench-1.11.0}/bencher/example/example_holosweep_tap.py

@@ -120,7 +120,7 @@ def example_holosweep_tap_slider(
 
     heatmap = res.to_heatmap().opts(tools=["hover", "tap"])
     posxy = hv.streams.Tap(source=heatmap, x=0, y=0)
-    sld1 = wv.param.phase.as_slider(run_cfg.debug)
+    sld1 = wv.param.phase.as_slider()
 
     def tap_plot(x, y):
         print(x, y)

{holobench-1.9.0 → holobench-1.11.0}/bencher/example/example_image.py

@@ -82,7 +82,7 @@ def example_image_vid(
 ) -> bch.Bench:
     bench = BenchPolygons().to_bench(run_cfg, report)
     bench.add_plot_callback(bch.BenchResult.to_sweep_summary)
-    bench.add_plot_callback(bch.BenchResult.to_video_grid)
+    bench.add_plot_callback(bch.BenchResult.to_video_grid, target_duration=1)
     bench.plot_sweep(input_vars=["sides"])
     bench.plot_sweep(input_vars=["radius", "sides"])
     bench.plot_sweep(input_vars=["radius", "sides", "linewidth"])
@@ -108,6 +108,6 @@ 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()
+    example_image_vid(ex_run_cfg).report.show()
     # example_image_vid_sequential(ex_run_cfg).report.show()
-    example_image(ex_run_cfg).report.show()
+    # example_image(ex_run_cfg).report.show()

{holobench-1.9.0 → holobench-1.11.0}/bencher/example/example_levels.py

@@ -37,7 +37,7 @@ class RunWithLevel(bch.ParametrizedSweep):
 
         self.level_samples = int(
             pow(
-                len(bch.FloatSweep(bounds=[0, 1]).with_level(self.level).values(False)),
+                len(bch.FloatSweep(bounds=[0, 1]).with_level(self.level).values()),
                 self.dimensions,
             )
         )

{holobench-1.9.0 → holobench-1.11.0}/bencher/job.py

@@ -80,7 +80,8 @@ class FutureCache:
         size_limit: int = int(20e9),  # 20 GB
         use_cache=True,
     ):
-        self.executor = Executors.factory(executor)
+        self.executor_type = executor
+        self.executor = None
         if use_cache:
             self.cache = Cache(f"cachedir/{cache_name}", tag_index=tag_index, size_limit=size_limit)
             logging.info(f"cache dir: {self.cache.directory}")
@@ -110,6 +111,9 @@ class FutureCache:
 
         self.worker_fn_call_count += 1
 
+        if self.executor_type is not Executors.SERIAL:
+            if self.executor is None:
+                self.executor = Executors.factory(self.executor_type)
         if self.executor is not None:
             self.overwrite_msg(job, " starting parallel job...")
             return JobFuture(
@@ -148,9 +152,7 @@ class FutureCache:
             self.cache.close()
         if self.executor:
             self.executor.shutdown()
-
-    # def __del__(self):
-    #     self.close()
+            self.executor = None
 
     def stats(self) -> str:
         logging.info(f"job calls: {self.worker_wrapper_call_count}")

{holobench-1.9.0 → holobench-1.11.0}/bencher/optuna_conversions.py

@@ -30,7 +30,7 @@ def optuna_grid_search(bench_cfg: BenchCfg) -> optuna.Study:
     """
     search_space = {}
     for iv in bench_cfg.all_vars:
-        search_space[iv.name] = iv.values(bench_cfg.debug)
+        search_space[iv.name] = iv.values()
     directions = []
     for rv in bench_cfg.optuna_targets(True):
         directions.append(rv.direction)

{holobench-1.9.0 → holobench-1.11.0}/bencher/results/bench_result_base.py

@@ -249,11 +249,16 @@ class BenchResultBase(OptunaResult):
         target_dimension: int = 2,
         result_var: ResultVar = None,
         result_types=None,
+        pane_collection: pn.pane = None,
         **kwargs,
     ) -> Optional[pn.Row]:
         if hv_dataset is None:
             hv_dataset = self.to_hv_dataset()
-        row = EmptyContainer(pn.Row())
+
+        if pane_collection is None:
+            pane_collection = pn.Row()
+
+        row = EmptyContainer(pane_collection)
 
         # kwargs= self.set_plot_size(**kwargs)
         for rv in self.get_results_var_list(result_var):
@@ -283,6 +288,7 @@ class BenchResultBase(OptunaResult):
         target_dimension: int = 2,
         result_var: ResultVar = None,
         result_types=None,
+        pane_collection: pn.pane = None,
         **kwargs,
     ):
         plot_filter = PlotFilter(
@@ -302,6 +308,7 @@ class BenchResultBase(OptunaResult):
                 target_dimension=target_dimension,
                 result_var=result_var,
                 result_types=result_types,
+                pane_collection=pane_collection,
                 **kwargs,
             )
         return matches_res.to_panel()
@@ -372,9 +379,7 @@ class BenchResultBase(OptunaResult):
                     horizontal=len(sliced.sizes) <= target_dimension + 1,
                     result_var=result_var,
                 )
-
-                if inner_container.label_len > max_len:
-                    max_len = inner_container.label_len
+                max_len = max(max_len, inner_container.label_len)
                 inner_container.append(panes)
                 outer_container.append(inner_container.container)
             for c in outer_container.container:

{holobench-1.9.0 → holobench-1.11.0}/bencher/results/composable_container/composable_container_video.py

@@ -19,12 +19,13 @@ class ComposableContainerVideo(ComposableContainerBase):
         var_value: str = None,
         background_col: tuple[3] = (255, 255, 255),
         horizontal: bool = True,
+        target_duration: float = None,
     ) -> None:
         super().__init__(horizontal)
         self.name = name
         self.container = []
         self.background_col = background_col
-        self.target_duration = 10.0
+        self.target_duration = 10 if target_duration is None else target_duration
         self.var_name = var_name
 
         self.label = self.label_formatter(var_name, var_value)

{holobench-1.9.0 → holobench-1.11.0}/bencher/results/holoview_result.py

@@ -465,7 +465,7 @@ class HoloviewResult(PanelResult):
 
         kdims = []
         for i in self.bench_cfg.input_vars + [self.bench_cfg.iv_repeat]:
-            kdims.append(i.as_dim(compute_values=True, debug=self.bench_cfg.debug))
+            kdims.append(i.as_dim(compute_values=True))
 
         return hv.DynamicMap(cb, kdims=kdims)
 
@@ -510,7 +510,7 @@ class HoloviewResult(PanelResult):
             result_vars=VarRange(1, 1),
         ).matches_result(self.plt_cnt_cfg, "to_surface_hv")
         if matches_res.overall:
-            # xr_cfg = plot_float_cnt_2(self.plt_cnt_cfg, result_var, self.bench_cfg.debug)
+            # xr_cfg = plot_float_cnt_2(self.plt_cnt_cfg, result_var)
 
             # TODO a warning suggests setting this parameter, but it does not seem to help as expected, leaving here to fix in the future
             # hv.config.image_rtol = 1.0

{holobench-1.9.0 → holobench-1.11.0}/bencher/results/video_summary.py

@@ -74,7 +74,8 @@ class VideoSummaryResult(BenchResultBase):
             label = ", ".join(f"{a[0]}={a[1]}" for a in list(zip(input_order, index)))
             if val is not None:
                 vr.append_file(val, label)
-        fn = vr.write_png()
+        fn = vr.write_png(**kwargs)
+        kwargs.pop("target_duration", None)
         if fn is not None:
             if video_controls is None:
                 video_controls = VideoControls()
@@ -87,8 +88,19 @@ class VideoSummaryResult(BenchResultBase):
         self,
         result_var: Parameter = None,
         result_types=(ResultImage,),
+        pane_collection: pn.pane = 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 (ResultImage,).
+            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),
@@ -98,13 +110,16 @@ class VideoSummaryResult(BenchResultBase):
         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)
-            row = pn.Row()
             for rv in self.get_results_var_list(result_var):
                 if isinstance(rv, result_types):
-                    row.append(self.to_video_grid_ds(ds, rv, **kwargs))
-            return row
+                    pane_collection.append(self.to_video_grid_ds(ds, rv, **kwargs))
+            return pane_collection
         return matches_res.to_panel()
 
     def to_video_grid_ds(
@@ -113,6 +128,7 @@ class VideoSummaryResult(BenchResultBase):
         result_var: Parameter,
         reverse=True,
         video_controls: VideoControls = None,
+        target_duration: float = None,
         **kwargs,
     ):
         vr = VideoWriter()
@@ -125,6 +141,7 @@ class VideoSummaryResult(BenchResultBase):
             result_var=result_var,
             final=True,
             reverse=reverse,
+            target_duration=target_duration,
             **kwargs,
         )
 
@@ -150,6 +167,7 @@ class VideoSummaryResult(BenchResultBase):
         result_var=None,
         final=False,
         reverse=False,
+        target_duration: float = None,
         **kwargs,
     ) -> pn.panel:
         num_dims = len(dataset.sizes)
@@ -168,6 +186,7 @@ class VideoSummaryResult(BenchResultBase):
                 name=" vs ".join(dims),
                 background_col=dim_color,
                 horizontal=horizontal,
+                target_duration=target_duration,
                 # var_name=selected_dim,
                 # var_value=label_val,
             )
@@ -180,6 +199,7 @@ class VideoSummaryResult(BenchResultBase):
                     var_name=selected_dim,
                     var_value=label_val,
                     horizontal=horizontal,
+                    target_duration=target_duration,
                 )
                 panes = self._to_video_panes_ds(
                     sliced,
@@ -190,9 +210,7 @@ class VideoSummaryResult(BenchResultBase):
                 )
                 inner_container.append(panes)
 
-                if inner_container.label_len > max_len:
-                    max_len = inner_container.label_len
-
+                max_len = max(max_len, inner_container.label_len)
                 rendered = inner_container.render()
                 outer_container.append(rendered)
             return outer_container.render(concatenate=final)

{holobench-1.9.0 → holobench-1.11.0}/bencher/variables/inputs.py

@@ -11,7 +11,7 @@ class SweepSelector(Selector, SweepBase):
 
     __slots__ = shared_slots
 
-    def __init__(self, units: str = "ul", samples: int = None, samples_debug: int = 2, **params):
+    def __init__(self, units: str = "ul", samples: int = None, **params):
         SweepBase.__init__(self)
         Selector.__init__(self, **params)
 
@@ -20,24 +20,20 @@ class SweepSelector(Selector, SweepBase):
             self.samples = len(self.objects)
         else:
             self.samples = samples
-        self.samples_debug = min(self.samples, samples_debug)
 
-    def values(self, debug=False) -> List[Any]:
+    def values(self) -> List[Any]:
         """return all the values for a parameter sweep.  If debug is true return a reduced list"""
-        return self.indices_to_samples(self.samples_debug if debug else self.samples, self.objects)
+        return self.indices_to_samples(self.samples, self.objects)
 
 
 class BoolSweep(SweepSelector):
     """A class to reprsent a parameter sweep of bools"""
 
-    def __init__(
-        self, units: str = "ul", samples: int = None, samples_debug: int = 2, default=True, **params
-    ):
+    def __init__(self, units: str = "ul", samples: int = None, default=True, **params):
         SweepSelector.__init__(
             self,
             units=units,
             samples=samples,
-            samples_debug=samples_debug,
             default=default,
             objects=[True, False] if default else [False, True],
             **params,
@@ -52,7 +48,6 @@ class StringSweep(SweepSelector):
         string_list: List[str],
         units: str = "",
         samples: int = None,
-        samples_debug: int = 2,
         **params,
     ):
         SweepSelector.__init__(
@@ -61,7 +56,6 @@ class StringSweep(SweepSelector):
             instantiate=True,
             units=units,
             samples=samples,
-            samples_debug=samples_debug,
             **params,
         )
 
@@ -71,9 +65,7 @@ class EnumSweep(SweepSelector):
 
     __slots__ = shared_slots
 
-    def __init__(
-        self, enum_type: Enum | List[Enum], units=" ", samples=None, samples_debug=2, **params
-    ):
+    def __init__(self, enum_type: Enum | List[Enum], units=" ", samples=None, **params):
         # The enum can either be an Enum type or a list of enums
         list_of_enums = isinstance(enum_type, list)
         selector_list = enum_type if list_of_enums else list(enum_type)
@@ -83,7 +75,6 @@ class EnumSweep(SweepSelector):
             instantiate=True,
             units=units,
             samples=samples,
-            samples_debug=samples_debug,
             **params,
         )
         if not list_of_enums:  # Grab the docs from the enum type def
@@ -95,12 +86,11 @@ class IntSweep(Integer, SweepBase):
 
     __slots__ = shared_slots + ["sample_values"]
 
-    def __init__(self, units="ul", samples=None, samples_debug=2, sample_values=None, **params):
+    def __init__(self, units="ul", samples=None, sample_values=None, **params):
         SweepBase.__init__(self)
         Integer.__init__(self, **params)
 
         self.units = units
-        self.samples_debug = samples_debug
 
         if sample_values is None:
             if samples is None:
@@ -116,7 +106,7 @@ class IntSweep(Integer, SweepBase):
             if "default" not in params:
                 self.default = sample_values[0]
 
-    def values(self, debug=False) -> List[int]:
+    def values(self) -> List[int]:
         """return all the values for a parameter sweep.  If debug is true return the  list"""
         sample_values = (
             self.sample_values
@@ -124,7 +114,7 @@ class IntSweep(Integer, SweepBase):
             else list(range(int(self.bounds[0]), int(self.bounds[1] + 1)))
         )
 
-        return self.indices_to_samples(self.samples_debug if debug else self.samples, sample_values)
+        return self.indices_to_samples(self.samples, sample_values)
 
     ###THESE ARE COPIES OF INTEGER VALIDATION BUT ALSO ALLOW NUMPY INT TYPES
     def _validate_value(self, val, allow_None):
@@ -152,14 +142,11 @@ class FloatSweep(Number, SweepBase):
 
     __slots__ = shared_slots + ["sample_values"]
 
-    def __init__(
-        self, units="ul", samples=10, samples_debug=2, sample_values=None, step=None, **params
-    ):
+    def __init__(self, units="ul", samples=10, sample_values=None, step=None, **params):
         SweepBase.__init__(self)
         Number.__init__(self, step=step, **params)
 
         self.units = units
-        self.samples_debug = samples_debug
 
         self.sample_values = sample_values
 
@@ -170,20 +157,14 @@ class FloatSweep(Number, SweepBase):
             if "default" not in params:
                 self.default = sample_values[0]
 
-    def values(self, debug=False) -> List[float]:
+    def values(self) -> List[float]:
         """return all the values for a parameter sweep.  If debug is true return a reduced list"""
-        samps = self.samples_debug if debug else self.samples
+        samps = self.samples
         if self.sample_values is None:
             if self.step is None:
                 return np.linspace(self.bounds[0], self.bounds[1], samps)
 
             return np.arange(self.bounds[0], self.bounds[1], self.step)
-        if debug:
-            indices = [
-                int(i)
-                for i in np.linspace(0, len(self.sample_values) - 1, self.samples_debug, dtype=int)
-            ]
-            return [self.sample_values[i] for i in indices]
         return self.sample_values
 
 

{holobench-1.9.0 → holobench-1.11.0}/bencher/variables/parametrised_sweep.py

@@ -153,7 +153,7 @@ class ParametrizedSweep(Parameterized):
 
     @classmethod
     def get_results_only(cls) -> List[Parameter]:
-        """Return a list of input parameters
+        """Return a list of result parameters
 
         Returns:
             List[param.Parameter]: A list of result parameters
@@ -175,16 +175,19 @@ class ParametrizedSweep(Parameterized):
         return [iv.as_dim(compute_values) for iv in inputs]
 
     def to_dynamic_map(
-        self,
-        callback=None,
-        name=None,
-        remove_dims: str | List[str] = None,
+        self, callback=None, name=None, remove_dims: str | List[str] = None, result_var: str = None
     ) -> hv.DynamicMap:
         if callback is None:
             callback = self.__call__
 
+        if result_var is None:
+            result_vars = self.get_input_and_results().results
+            for k, rv in result_vars.items():
+                if isinstance(rv, ResultHmap):
+                    result_var = k
+
         def callback_wrapper(**kwargs):
-            return callback(**kwargs)["hmap"]
+            return callback(**kwargs)[result_var]
 
         return hv.DynamicMap(
             callback=callback_wrapper,
@@ -192,9 +195,9 @@ class ParametrizedSweep(Parameterized):
             name=name,
         ).opts(shared_axes=False, framewise=True, width=1000, height=1000)
 
-    def to_gui(self):  # pragma: no cover
+    def to_gui(self, result_var: str = None, **kwargs):  # pragma: no cover
         main = pn.Row(
-            self.to_dynamic_map(),
+            self.to_dynamic_map(result_var=result_var, **kwargs),
         )
         main.show()
 

{holobench-1.9.0 → holobench-1.11.0}/bencher/variables/results.py

@@ -1,5 +1,5 @@
 from enum import auto
-from typing import List, Callable, Any
+from typing import List, Callable, Any, Optional
 
 import panel as pn
 import param
@@ -87,8 +87,16 @@ class ResultHmap(param.Parameter):
         return hash_sha1(self)
 
 
-def curve(x_vals: List[float], y_vals: List[float], x_name: str, y_name: str, **kwargs) -> hv.Curve:
-    return hv.Curve(zip(x_vals, y_vals), kdims=[x_name], vdims=[y_name], label=y_name, **kwargs)
+def curve(
+    x_vals: List[float],
+    y_vals: List[float],
+    x_name: str,
+    y_name: str,
+    label: Optional[str] = None,
+    **kwargs,
+) -> hv.Curve:
+    label = label or y_name
+    return hv.Curve(zip(x_vals, y_vals), kdims=[x_name], vdims=[y_name], label=label, **kwargs)
 
 
 class PathResult(param.Filename):

{holobench-1.9.0 → holobench-1.11.0}/bencher/variables/sweep_base.py

@@ -11,12 +11,10 @@ from bencher.utils import hash_sha1
 
 # slots that are shared across all Sweep classes
 # param and slots don't work easily with multiple inheritance so define here
-shared_slots = ["units", "samples", "samples_debug"]
+shared_slots = ["units", "samples"]
 
 
-def describe_variable(
-    v: Parameterized, debug: bool, include_samples: bool, value=None
-) -> List[str]:
+def describe_variable(v: Parameterized, include_samples: bool, value=None) -> List[str]:
     """Generate a string description of a variable
 
     Args:
@@ -32,8 +30,8 @@ def describe_variable(
     sampling_str.append(f"{v.name}:")
     if include_samples:
         # sampling_str.append(f"{indent}{v.sampling_str(debug)}")
-        sampling_str.append(f"{indent}number of samples: {len(v.values(debug))}")
-        sampling_str.append(f"{indent}sample values: {[str(v) for v in v.values(debug)]}")
+        sampling_str.append(f"{indent}number of samples: {len(v.values())}")
+        sampling_str.append(f"{indent}sample values: {[str(v) for v in v.values()]}")
 
     if value is not None:
         sampling_str.append(f"{indent}value: {value}")
@@ -51,15 +49,14 @@ class SweepBase(param.Parameter):
     # def __init__(self, **params):
     # super().__init__(**params)
     # self.units = ""
-    # slots = ["units", "samples", "samples_debug"]
+    # slots = ["units", "samples"]
     # __slots__ = shared_slots
 
-    def values(self, debug: bool) -> List[Any]:
+    def values(
+        self,
+    ) -> List[Any]:
         """All sweep classes must implement this method. This generates sample values from based on the parameters bounds and sample number.
 
-        Args:
-            debug (bool): Return a reduced set of samples to enable fast debugging of a data generation and plotting pipeline. Ideally when debug is true, 2 samples will be returned
-
         Returns:
             List[Any]: A list of samples from the variable
         """
@@ -67,22 +64,16 @@ class SweepBase(param.Parameter):
 
     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.units, self.samples, self.samples_debug)  # pylint: disable=no-member
-        )
-
-    def sampling_str(self, debug=False) -> str:
-        """Generate a string representation of the of the sampling procedure
+        return hash_sha1((self.units, self.samples))  # pylint: disable=no-member
 
-        Args:
-            debug (bool): If true then self.samples_debug is used
-        """
+    def sampling_str(self) -> str:
+        """Generate a string representation of the of the sampling procedure"""
 
-        samples = self.values(debug)
+        samples = self.values()
         object_str = ",".join([str(i) for i in samples])
         return f"Taking {len(samples)} samples from {self.name} with values: [{object_str}]"
 
-    def as_slider(self, debug=False) -> pn.widgets.slider.DiscreteSlider:
+    def as_slider(self) -> pn.widgets.slider.DiscreteSlider:
         """given a sweep variable (self), return the range of values as a panel slider
 
         Args:
@@ -91,9 +82,9 @@ class SweepBase(param.Parameter):
         Returns:
             pn.widgets.slider.DiscreteSlider: A panel slider with the values() of the sweep variable
         """
-        return pn.widgets.slider.DiscreteSlider(name=self.name, options=list(self.values(debug)))
+        return pn.widgets.slider.DiscreteSlider(name=self.name, options=list(self.values()))
 
-    def as_dim(self, compute_values=False, debug=False) -> hv.Dimension:
+    def as_dim(self, compute_values=False) -> hv.Dimension:
         """Takes a sweep variable and turns it into a holoview dimension
 
         Returns:
@@ -102,22 +93,26 @@ class SweepBase(param.Parameter):
         name_tuple = (self.name, self.name)
 
         params = {}
-        if hasattr(self, "bounds"):
+        if hasattr(self, "bounds") and self.bounds is not None:
             if compute_values:
-                params["values"] = self.values(debug)
+                params["values"] = self.values()
                 # params["range"] = tuple(self.bounds)
             else:
                 params["range"] = tuple(self.bounds)
                 params["default"] = self.default
 
         else:
-            params["values"] = self.values(debug)
+            params["values"] = self.values()
             params["default"] = self.default
 
         if hasattr(self, "step"):
             params["step"] = getattr(self, "step")
 
-        return hv.Dimension(name_tuple, unit=self.units, **params)  # pylint: disable=no-member
+        # TODO investigate why this stopped working after a holoviews update
+        # if hasattr(self, "units"):
+        # params["unit"] = getattr(self, "units")
+
+        return hv.Dimension(name_tuple, **params)
 
     def indices_to_samples(self, desires_num_samples, sample_values):
         indices = [

{holobench-1.9.0 → holobench-1.11.0}/bencher/variables/time.py

@@ -11,7 +11,7 @@ class TimeBase(SweepBase, Selector):
 
     __slots__ = shared_slots
 
-    def values(self, debug=False) -> List[str]:
+    def values(self) -> List[str]:
         """return all the values for a parameter sweep.  If debug is true return a reduced list"""
         # print(self.sampling_str(debug))
         return self.objects
@@ -27,7 +27,6 @@ class TimeSnapshot(TimeBase):
         datetime_src: datetime | str,
         units: str = "time",
         samples: int = None,
-        samples_debug: int = 2,
         **params,
     ):
         if isinstance(datetime_src, str):
@@ -44,7 +43,6 @@ class TimeSnapshot(TimeBase):
             self.samples = len(self.objects)
         else:
             self.samples = samples
-        self.samples_debug = min(self.samples, samples_debug)
 
 
 class TimeEvent(TimeBase):
@@ -57,7 +55,6 @@ class TimeEvent(TimeBase):
         time_event: str,
         units: str = "event",
         samples: int = None,
-        samples_debug: int = 2,
         **params,
     ):
         TimeBase.__init__(
@@ -71,4 +68,3 @@ class TimeEvent(TimeBase):
             self.samples = len(self.objects)
         else:
             self.samples = samples
-        self.samples_debug = min(self.samples, samples_debug)

{holobench-1.9.0 → holobench-1.11.0}/bencher/video_writer.py

@@ -79,7 +79,8 @@ class VideoWriter:
         else:
             self.image_files.append(filepath)
 
-    def to_images_sequence(self, images, target_duration: float = 10.0, frame_time=None):
+    def to_images_sequence(self, images, target_duration: float = 10.0, frame_time=None, **kwargs):
+        target_duration = kwargs.pop("target_duration", target_duration)
         if isinstance(images, list) and len(images) > 0:
             if frame_time is None:
                 fps = len(images) / target_duration
@@ -90,10 +91,10 @@ class VideoWriter:
             return ImageSequenceClip(images, fps=fps, with_mask=False)
         return None
 
-    def write_png(self):
+    def write_png(self, **kwargs):
         clip = None
         if len(self.image_files) > 0:
-            clip = self.to_images_sequence(self.image_files)
+            clip = self.to_images_sequence(self.image_files, **kwargs)
         if len(self.video_files) > 0:
             clip = concatenate_videoclips([VideoFileClip(f) for f in self.video_files])
         if clip is not None:

{holobench-1.9.0 → holobench-1.11.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "holobench"
-version = "1.9.0"
+version = "1.11.0"
 
 authors = [{ name = "Austin Gregg-Smith", email = "blooop@gmail.com" }]
 description = "A package for benchmarking the performance of arbitrary functions"
@@ -11,20 +11,20 @@ readme = "README.md"
 
 
 dependencies = [
-  "holoviews>=1.15,<=1.18.1",
-  "numpy>=1.0,<=1.26.3",
-  "param>=1.13.0,<=2.0.2",
+  "holoviews>=1.15,<=1.18.3",
+  "numpy>=1.0,<=1.26.4",
+  "param>=1.13.0,<=2.1.0",
   "hvplot>=0.8,<=0.9.2",
-  "matplotlib>=3.6.3,<=3.8.2",
-  "panel>=1.3.6,<=1.3.8",
+  "matplotlib>=3.6.3,<=3.8.3",
+  "panel>=1.3.6,<=1.4.0",
   "diskcache>=5.6,<=5.6.3",
-  "optuna>=3.2,<=3.5.0",
-  "xarray>=2023.7,<=2024.1.1",
-  "plotly>=5.15,<=5.18.0",
+  "optuna>=3.2,<=3.6.1",
+  "xarray>=2023.7,<=2024.3.0",
+  "plotly>=5.15,<=5.20.0",
   "sortedcontainers>=2.4,<=2.4",
-  "pandas>=2.0,<=2.2.0",
+  "pandas>=2.0,<=2.2.1",
   "strenum>=0.4.0,<=0.4.15",
-  "scikit-learn>=1.2,<=1.4.0",
+  "scikit-learn>=1.2,<=1.4.1.post1",
   "str2bool>=1.1,<=1.1",
   "scoop>=0.7.0,<=0.7.2.0",
   "moviepy>=1.0.3,<=1.0.3",
@@ -36,8 +36,8 @@ test = [
   "pylint>=2.16,<=3.0.3",
   "pytest-cov>=4.1,<=4.1",
   "pytest>=7.4,<=8.0.0",
-  "hypothesis>=6.82,<=6.97.4",
-  "ruff>=0.0.280,<=0.1.15",
+  "hypothesis>=6.82,<=6.97.1",
+  "ruff>=0.0.280,<=0.1.14",
   "coverage>=7.2.7,<=7.4.1",
 ]
 
@@ -74,7 +74,7 @@ line-length = 100
 [tool.ruff]
 # Never enforce `E501` (line length violations).
 #"F841" will auto remove unused variables which is annoying during development, pylint catches this anyway
-ignore = ["E501", "E902", "F841"]
+lint.ignore = ["E501", "E902", "F841"]
 
 
 # Same as Black.
@@ -83,10 +83,10 @@ line-length = 100
 target-version = "py310"
 
 # Allow unused variables when underscore-prefixed.
-dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+lint.dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
 
 # Ignore `E402` (import violations) in all `__init__.py` files, and in `path/to/file.py`.
-[tool.ruff.per-file-ignores]
+[tool.ruff.lint.per-file-ignores]
 "__init__.py" = ["E402", "F401"]