holobench 1.40.0__tar.gz → 1.41.0__tar.gz

holobench-1.41.0/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.3.10]
+
+Before changelogs

{holobench-1.40.0 → holobench-1.41.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: holobench
-Version: 1.40.0
+Version: 1.41.0
 Summary: A package for benchmarking the performance of arbitrary functions
 Project-URL: Repository, https://github.com/dyson-ai/bencher
 Project-URL: Home, https://github.com/dyson-ai/bencher
@@ -12,28 +12,24 @@ Requires-Python: <3.13,>=3.10
 Requires-Dist: diskcache<=5.6.3,>=5.6
 Requires-Dist: holoviews<=1.20.0,>=1.15
 Requires-Dist: hvplot<=0.10.0,>=0.8
-Requires-Dist: matplotlib<=3.10.0,>=3.6.3
-Requires-Dist: moviepy-fix-codec
-Requires-Dist: numpy<=2.2.2,>=1.0
-Requires-Dist: optuna<=4.2.0,>=3.2
+Requires-Dist: moviepy<=2.1.2,>=2.1.2
+Requires-Dist: numpy<=2.2.3,>=1.0
+Requires-Dist: optuna<=4.2.1,>=3.2
 Requires-Dist: pandas<=2.2.3,>=2.0
-Requires-Dist: panel<=1.6.0,>=1.3.6
+Requires-Dist: panel<=1.6.1,>=1.3.6
 Requires-Dist: param<=2.2.0,>=1.13.0
 Requires-Dist: plotly<=6.0.0,>=5.15
 Requires-Dist: scikit-learn<=1.6.1,>=1.2
-Requires-Dist: scoop<=0.7.2.0,>=0.7.0
-Requires-Dist: sortedcontainers<=2.4,>=2.4
-Requires-Dist: str2bool<=1.1,>=1.1
 Requires-Dist: strenum<=0.4.15,>=0.4.0
 Requires-Dist: xarray<=2025.1.2,>=2023.7
 Provides-Extra: rerun
 Requires-Dist: flask; extra == 'rerun'
 Requires-Dist: flask-cors; extra == 'rerun'
 Requires-Dist: rerun-notebook; extra == 'rerun'
-Requires-Dist: rerun-sdk==0.21.0; extra == 'rerun'
+Requires-Dist: rerun-sdk==0.22.0; extra == 'rerun'
 Provides-Extra: test
-Requires-Dist: coverage<=7.6.10,>=7.5.4; extra == 'test'
-Requires-Dist: hypothesis<=6.124.9,>=6.104.2; extra == 'test'
+Requires-Dist: coverage<=7.6.12,>=7.5.4; extra == 'test'
+Requires-Dist: hypothesis<=6.125.3,>=6.104.2; extra == 'test'
 Requires-Dist: ipykernel; extra == 'test'
 Requires-Dist: jupyter-bokeh; extra == 'test'
 Requires-Dist: nbformat; extra == 'test'
@@ -42,7 +38,7 @@ Requires-Dist: pre-commit<=4.1.0; extra == 'test'
 Requires-Dist: pylint<=3.3.4,>=3.2.5; extra == 'test'
 Requires-Dist: pytest-cov<=6.0.0,>=4.1; extra == 'test'
 Requires-Dist: pytest<=8.3.4,>=7.4; extra == 'test'
-Requires-Dist: ruff<=0.9.4,>=0.5.0; extra == 'test'
+Requires-Dist: ruff<=0.9.6,>=0.5.0; extra == 'test'
 Description-Content-Type: text/markdown
 
 # Bencher

{holobench-1.40.0 → holobench-1.41.0}/bencher/bench_cfg.py

@@ -6,17 +6,14 @@ import logging
 from typing import List
 
 import param
-from str2bool import str2bool
 import panel as pn
-
+from datetime import datetime
 
 from bencher.variables.sweep_base import hash_sha1, describe_variable
 from bencher.variables.time import TimeSnapshot, TimeEvent
 from bencher.variables.results import OptDir
 from bencher.job import Executors
-from datetime import datetime
-
-# from bencher.results.bench_result import BenchResult
+from bencher.results.laxtex_result import to_latex
 
 
 class BenchPlotSrvCfg(param.Parameterized):
@@ -199,11 +196,8 @@ class BenchRunCfg(BenchPlotSrvCfg):
 
         parser.add_argument(
             "--nightly",
-            type=lambda b: bool(str2bool(b)),
-            nargs="?",
-            const=False,
-            default=False,
-            help="turn on nightly benchmarking",
+            action="store_true",
+            help="Turn on nightly benchmarking",
         )
 
         parser.add_argument(
@@ -344,13 +338,32 @@ class BenchCfg(BenchRunCfg):
     def inputs_as_str(self) -> List[str]:
         return [i.name for i in self.input_vars]
 
-    def describe_sweep(self, width: int = 800, accordion=True) -> pn.pane.Markdown:
+    def to_latex(self):
+        return to_latex(self)
+
+    def describe_sweep(self, width: int = 800, accordion=True) -> pn.pane.Markdown | pn.Column:
         """Produce a markdown summary of the sweep settings"""
 
+        latex = self.to_latex()
         desc = pn.pane.Markdown(self.describe_benchmark(), width=width)
         if accordion:
-            return pn.Accordion(("Data Collection Parameters", desc))
-        return desc
+            desc = pn.Accordion(("Expand Full Data Collection Parameters", desc))
+
+        sentence = self.sweep_sentence()
+        if latex is not None:
+            return pn.Column(sentence, latex, desc)
+        return pn.Column(sentence, latex, desc)
+
+    def sweep_sentence(self):
+        inputs = " by ".join([iv.name for iv in self.all_vars])
+
+        all_vars_lens = [len(iv.values()) for iv in reversed(self.all_vars)]
+        if len(all_vars_lens) == 1:
+            all_vars_lens.append(1)
+        result_sizes = "x".join([str(iv) for iv in all_vars_lens])
+        results = ", ".join([rv.name for rv in self.result_vars])
+
+        return f"Sweeping {inputs} to generate a {result_sizes} result dataframe containing {results}. "
 
     def describe_benchmark(self) -> str:
         """Generate a string summary of the inputs and results from a BenchCfg

{holobench-1.40.0 → holobench-1.41.0}/bencher/caching.py

@@ -3,9 +3,6 @@ from diskcache import Cache
 from bencher.variables.parametrised_sweep import ParametrizedSweep
 from bencher.utils import hash_sha1
 import logging
-from sortedcontainers import SortedDict
-
-# from job import job,JobCache,JobFunctionCache
 
 
 class CachedParams(ParametrizedSweep):
@@ -20,7 +17,7 @@ class CachedParams(ParametrizedSweep):
             self.cache.clear()
 
     def kwargs_to_hash_key(self, **kwargs):
-        return tuple(SortedDict(kwargs).items())
+        return tuple(sorted(kwargs.items(), key=lambda item: str(item[0])))
 
     def in_cache(self, **kwargs):
         self.update_params_from_kwargs(**kwargs)

holobench-1.41.0/bencher/example/example_composable_container_image.py

@@ -0,0 +1,60 @@
+import bencher as bch
+
+from bencher.example.example_image import BenchPolygons
+
+
+class BenchComposableContainerImage(BenchPolygons):
+    compose_method = bch.EnumSweep(bch.ComposeType)
+    labels = bch.BoolSweep()
+    num_frames = bch.IntSweep(default=5, bounds=[1, 100])
+
+    polygon_vid = bch.ResultVideo()
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+        var_name = None
+        var_value = None
+
+        if self.labels:
+            var_name = "sides"
+            var_value = self.sides
+        vr = bch.ComposableContainerVideo()
+        for i in range(self.num_frames):
+            res = super().__call__(start_angle=i)
+            print(res)
+            vr.append(res["polygon"])
+        self.polygon_vid = vr.to_video(
+            bch.RenderCfg(
+                compose_method=self.compose_method,
+                var_name=var_name,
+                var_value=var_value,
+                max_frame_duration=1.0 / 20.0,
+            )
+        )
+        return self.get_results_values_as_dict()
+
+
+def example_composable_container_image(
+    run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None
+) -> bch.Bench:
+    bench = BenchComposableContainerImage().to_bench(run_cfg, report)
+    # bench.add_plot_callback(bch.BenchResult.to_panes)
+    # bench.add_plot_callback(bch.BenchResult.to_video_grid, result_types=(bch.ResultVideo))
+    # bench.add_plot_callback(bch.BenchResult.to_video_summary, result_types=(bch.ResultVideo))
+    # bench.plot_sweep(input_vars=["compose_method", "labels"])
+
+    bench.plot_sweep(input_vars=["compose_method"])
+
+    # bench.compose_
+    # bench.plot_sweep(
+    # input_vars=[bch.p("num_frames", [2, 8, 20])],
+    # const_vars=dict(compose_method=bch.ComposeType.sequence),
+    # )
+
+    return bench
+
+
+if __name__ == "__main__":
+    ex_run_cfg = bch.BenchRunCfg()
+    ex_composable_image = example_composable_container_image(ex_run_cfg)
+    ex_composable_image.report.show()

holobench-1.41.0/bencher/example/example_composable_container_video.py

@@ -0,0 +1,49 @@
+import bencher as bch
+from bencher.example.example_composable_container_image import BenchComposableContainerImage
+
+
+class BenchComposableContainerVideo(bch.ParametrizedSweep):
+    unequal_length = bch.BoolSweep()
+    compose_method = bch.EnumSweep(bch.ComposeType)
+    labels = bch.BoolSweep()
+    polygon_vid = bch.ResultVideo()
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+        vr = bch.ComposableContainerVideo()
+        for i in range(3, 5):
+            num_frames = i * 10 if self.unequal_length else 5
+            res = BenchComposableContainerImage().__call__(
+                compose_method=bch.ComposeType.sequence, sides=i, num_frames=num_frames
+            )
+            vr.append(res["polygon_vid"])
+
+        self.polygon_vid = vr.to_video(bch.RenderCfg(compose_method=kwargs.get("compose_method")))
+        return self.get_results_values_as_dict()
+
+
+def example_composable_container_video(
+    run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None
+) -> bch.Bench:
+    bench = BenchComposableContainerVideo().to_bench(run_cfg, report)
+
+    bench.result_vars = ["polygon_vid"]
+    bench.add_plot_callback(bch.BenchResult.to_panes)
+    bench.add_plot_callback(bch.BenchResult.to_video_grid, result_types=(bch.ResultVideo))
+    bench.add_plot_callback(bch.BenchResult.to_video_summary, result_types=(bch.ResultVideo))
+    bench.plot_sweep(input_vars=["compose_method", "labels"], const_vars=dict(unequal_length=True))
+
+    res = bench.plot_sweep(
+        input_vars=[],
+        const_vars=dict(unequal_length=False, compose_method=bch.ComposeType.sequence),
+        plot_callbacks=False,
+    )
+
+    bench.report.append(res.to_video_grid())
+
+    return bench
+
+
+if __name__ == "__main__":
+    ex_run_cfg = bch.BenchRunCfg()
+    example_composable_container_video(ex_run_cfg).report.show()

{holobench-1.40.0 → holobench-1.41.0}/bencher/example/example_image.py

@@ -1,7 +1,7 @@
 import bencher as bch
 import numpy as np
 import math
-import matplotlib.pyplot as plt
+from PIL import Image, ImageDraw
 
 
 def polygon_points(radius: float, sides: int, start_angle: float):
@@ -16,7 +16,6 @@ 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()
@@ -26,33 +25,30 @@ class BenchPolygons(bch.ParametrizedSweep):
     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"))
+        filepath = bch.gen_image_path("polygon")
+        self.polygon = self.points_to_polygon_png(points, filepath)
+        # Verify filepath is being returned
+        assert isinstance(self.polygon, str), f"Expected string filepath, got {type(self.polygon)}"
 
         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):
-        """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)
+        """Draw a closed polygon and save to png using PIL"""
+        size = 300
+        img = Image.new("RGBA", (size, size), (0, 0, 0, 0))
+        draw = ImageDraw.Draw(img)
+
+        # Scale points to image size (from [-1,1] to [0,size])
+        scaled_points = [(((p[0] + 1) * size / 2), ((1 - p[1]) * size / 2)) for p in points]
 
-        ax.set_aspect("equal")
-        fig.add_axes(ax)
-        fig.savefig(filename, dpi=30)
+        # Draw polygon outline
+        draw.line(scaled_points, fill=self.color, width=int(self.linewidth))
 
-        return filename
+        img.save(filename, "PNG")
+        # Explicitly return the filename string
+        return str(filename)
 
 
 def example_image(run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None) -> bch.Bench:

{holobench-1.40.0 → holobench-1.41.0}/bencher/example/example_image1.py

@@ -1,7 +1,7 @@
 import bencher as bch
 import numpy as np
 import math
-import matplotlib.pyplot as plt
+from PIL import Image, ImageDraw
 
 
 def polygon_points(radius: float, sides: int, start_angle: float):
@@ -28,36 +28,32 @@ class BenchPolygons(bch.ParametrizedSweep):
     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)
+        filepath = bch.gen_image_path("polygon")
+        self.polygon = self.points_to_polygon_png(points, filepath, dpi=30)
         self.polygon_small = self.points_to_polygon_png(
             points, bch.gen_image_path("polygon"), dpi=10
         )
+        # Verify filepaths are being returned
+        assert isinstance(self.polygon, str), f"Expected string filepath, got {type(self.polygon)}"
+        assert isinstance(self.polygon_small, str), (
+            f"Expected string filepath, got {type(self.polygon_small)}"
+        )
 
         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)
+        """Draw a closed polygon and save to png using PIL"""
+        size = int(100 * (dpi / 30))
+        img = Image.new("RGBA", (size, size), (0, 0, 0, 0))
+        draw = ImageDraw.Draw(img)
 
-        ax.set_aspect("equal")
-        fig.add_axes(ax)
-        fig.savefig(filename, dpi=dpi)
+        scaled_points = [(((p[0] + 1) * size / 2), ((1 - p[1]) * size / 2)) for p in points]
+        draw.line(scaled_points, fill=self.color, width=int(self.linewidth))
 
-        return filename
+        img.save(filename, "PNG")
+        return str(filename)
 
 
 def example_image_vid_sequential1(

{holobench-1.40.0 → holobench-1.41.0}/bencher/example/example_video.py

@@ -1,9 +1,24 @@
 import bencher as bch
 import numpy as np
-import matplotlib.pyplot as plt
+from PIL import Image
+import colorcet as cc
+import numpy.typing as npt
+
+
+def apply_colormap(data: npt.NDArray) -> npt.NDArray:
+    """Apply a perceptually uniform colormap to the data"""
+    # Normalize data to [0, 1]
+    normalized = (data - data.min()) / (data.max() - data.min())
+    # Convert hex colors to RGB values using numpy's frombuffer
+    colors = np.array(
+        [np.frombuffer(bytes.fromhex(c.lstrip("#")), dtype=np.uint8) for c in cc.rainbow]
+    )
+    # Map normalized values to colormap indices
+    indices = (normalized * (len(colors) - 1)).astype(int)
+    # Create RGB array from the colormap
+    return colors[indices]
 
 
-# code from https://ipython-books.github.io/124-simulating-a-partial-differential-equation-reaction-diffusion-systems-and-turing-patterns/
 class TuringPattern(bch.ParametrizedSweep):
     alpha = bch.FloatSweep(default=2.8e-4, bounds=(2e-4, 5e-3))
     beta = bch.FloatSweep(default=5e-3, bounds=(1e-3, 9e-3))
@@ -17,6 +32,7 @@ class TuringPattern(bch.ParametrizedSweep):
     video = bch.ResultVideo()
     score = bch.ResultVar()
     img = bch.ResultImage()
+    img_extracted = bch.ResultImage()
 
     def laplacian(self, Z, dx):
         Ztop = Z[0:-2, 1:-1]
@@ -49,28 +65,28 @@ class TuringPattern(bch.ParametrizedSweep):
     def __call__(self, **kwargs):
         self.update_params_from_kwargs(**kwargs)
 
-        n = int(self.time / self.dt)  # number of iterations
-        dx = 2.0 / self.size  # space step
+        n = int(self.time / self.dt)
+        dx = 2.0 / self.size
 
         U = np.random.rand(self.size, self.size)
         V = np.random.rand(self.size, self.size)
 
-        fig, ax = plt.subplots(frameon=False, figsize=(2, 2))
-        fig.set_tight_layout(True)
-        ax.set_axis_off()
         vid_writer = bch.VideoWriter()
         for i in range(n):
             self.update(U, V, dx)
             if i % 500 == 0:
-                ax.imshow(U)
-                fig.canvas.draw()
-                rgb = np.array(fig.canvas.renderer.buffer_rgba())
-                vid_writer.append(rgb)
-
-        self.img = bch.add_image(rgb)
-
+                # Apply colormap to create RGB image
+                rgb = apply_colormap(U)
+                # Create PIL image with alpha channel
+                img = Image.fromarray(rgb, "RGB").convert("RGBA")
+                img = img.resize((200, 200), Image.Resampling.LANCZOS)
+                rgb_alpha = np.array(img)
+                vid_writer.append(rgb_alpha)
+
+        self.img = bch.add_image(rgb_alpha)
         self.video = vid_writer.write()
-
+        self.img_extracted = bch.video_writer.VideoWriter.extract_frame(self.video)
+        print("img path", self.img_extracted)
         self.score = self.alpha + self.beta
         return super().__call__()
 
@@ -109,8 +125,8 @@ def example_video_tap(
 if __name__ == "__main__":
     run_cfg_ex = bch.BenchRunCfg()
     run_cfg_ex.level = 2
-    run_cfg_ex.cache_samples = True
-    run_cfg_ex.only_hash_tag = True
+    # run_cfg_ex.cache_samples = True
+    # run_cfg_ex.only_hash_tag = True
 
     # example_video(run_cfg_ex).report.show()
     example_video_tap(run_cfg_ex).report.show()

{holobench-1.40.0 → holobench-1.41.0}/bencher/example/experimental/example_hvplot_explorer.py

@@ -1,6 +1,5 @@
 # THIS IS NOT A WORKING EXAMPLE YET
 # pylint: disable=duplicate-code
-import hvplot
 import bencher as bch
 from bencher import ExampleBenchCfgIn, ExampleBenchCfgOut, bench_function
 
@@ -35,5 +34,5 @@ if __name__ == "__main__":
         ),
     )
 
-    hvexplorer = hvplot.explorer(bench_out.get_dataframe())
-    hvexplorer.show()
+    bench.report.append(bench_out.to_explorer())
+    bench.report.show()

holobench-1.41.0/bencher/example/inputs_1D/example_1_float_2_cat_repeats.py

@@ -0,0 +1,12 @@
+import bencher as bch
+from bencher.example.meta.example_meta import BenchableObject
+
+run_cfg = bch.BenchRunCfg()
+run_cfg.repeats = 20
+run_cfg.level = 4
+bench = BenchableObject().to_bench(run_cfg)
+res = bench.plot_sweep(
+    input_vars=["float1", "noisy", "noise_distribution"], result_vars=["distance", "sample_noise"]
+)
+
+bench.report.show()

{holobench-1.40.0 → holobench-1.41.0}/bencher/example/meta/generate_examples.py

@@ -49,6 +49,8 @@ if __name__ == "__main__":
         "/workspaces/bencher/bencher/example/inputs_1D/example_1_in_2_out_repeats.py", "1D"
     )
 
-    convert_example_to_jupyter_notebook(
-        "/workspaces/bencher/bencher/example/example_simple_float.py", "1D"
-    )
+    # todo, enable
+    # convert_example_to_jupyter_notebook(
+    #     "/workspaces/bencher/bencher/example/example_composable_container_video.py",
+    #     "Media",
+    # )

{holobench-1.40.0 → holobench-1.41.0}/bencher/example/meta/generate_meta.py

@@ -39,7 +39,7 @@ class BenchMetaGen(bch.ParametrizedSweep):
         inputs_vars_float = [
             "float1",
             "float2",
-            "float3",
+            bch.p("float3", max_level=3),
             "sigma",
         ]
 
@@ -107,10 +107,9 @@ def example_meta(run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None
         description="""## All Combinations of Variable Sweeps and Resulting Plots
 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]),
+            bch.p("float_vars", [0, 1]),
             "categorical_vars",
             bch.p("sample_with_repeats", [1, 20]),
-            # "sample_over_time",
         ],
         const_vars=[
             # BenchMeta.param.float_vars.with_const(1),
@@ -119,6 +118,31 @@ This uses bencher to display all the combinations of plots bencher is able to pr
             # BenchMeta.param.sample_over_time.with_const(True),
         ],
     )
+    bench.plot_sweep(
+        title="Meta Bench",
+        description="""## All Combinations of Variable Sweeps and Resulting Plots
+This uses bencher to display all the combinations of plots bencher is able to produce""",
+        input_vars=[
+            bch.p("float_vars", [2, 3]),
+            "categorical_vars",
+        ],
+    )
+
+    #     bench.plot_sweep(
+    #         title="Meta Bench",
+    #         description="""## All Combinations of Variable Sweeps and Resulting Plots
+    # This uses bencher to display all the combinations of plots bencher is able to produce""",
+    #         input_vars=[
+    #             bch.p("float_vars", [2, 3]),
+    #             "categorical_vars",
+    #         ],
+    #         const_vars=[
+    #             dict(level=3)
+    #             # BenchMeta.param.sample_with_repeats.with_const(2),
+    #             # BenchMeta.param.categorical_vars.with_const(2),
+    #             # BenchMeta.param.sample_over_time.with_const(True),
+    #         ],
+    #     )
 
     return bench
 

{holobench-1.40.0 → holobench-1.41.0}/bencher/job.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 from typing import Callable
-from sortedcontainers import SortedDict
 import logging
 from diskcache import Cache
 from concurrent.futures import Future, ProcessPoolExecutor
@@ -11,7 +10,6 @@ from enum import auto
 try:
     from scoop import futures as scoop_future_executor
 except ImportError as e:
-    logging.warning(e.msg)
     scoop_future_executor = None
 
 
@@ -23,7 +21,7 @@ class Job:
         self.function = function
         self.job_args = job_args
         if job_key is None:
-            self.job_key = hash_sha1(tuple(SortedDict(self.job_args).items()))
+            self.job_key = hash_sha1(tuple(sorted(self.job_args.items())))
         else:
             self.job_key = job_key
         self.tag = tag

{holobench-1.40.0 → holobench-1.41.0}/bencher/results/bench_result.py

@@ -53,6 +53,7 @@ class BenchResult(PlotlyResult, HoloviewResult, HvplotResult, VideoSummaryResult
         self,
         plot_list: List[callable] = None,
         remove_plots: List[callable] = None,
+        default_container=pn.Column,
         **kwargs,
     ) -> List[pn.panel]:
         self.plt_cnt_cfg.print_debug = False
@@ -67,7 +68,7 @@ class BenchResult(PlotlyResult, HoloviewResult, HvplotResult, VideoSummaryResult
 
         kwargs = self.set_plot_size(**kwargs)
 
-        row = EmptyContainer(pn.Row())
+        row = EmptyContainer(default_container())
         for plot_callback in plot_list:
             if self.plt_cnt_cfg.print_debug:
                 print(f"checking: {plot_callback.__name__}")

{holobench-1.40.0 → holobench-1.41.0}/bencher/results/bench_result_base.py

@@ -321,7 +321,7 @@ class BenchResultBase(OptunaResult):
         **kwargs,
     ) -> Optional[pn.Row]:
         if hv_dataset is None:
-            hv_dataset = self.to_hv_dataset()
+            hv_dataset = self.to_hv_dataset(reduce=reduce)
 
         if pane_collection is None:
             pane_collection = pn.Row()
@@ -333,7 +333,7 @@ class BenchResultBase(OptunaResult):
             if result_types is None or isinstance(rv, result_types):
                 row.append(
                     self.to_panes_multi_panel(
-                        self.to_hv_dataset(reduce=reduce, result_var=rv),
+                        hv_dataset,
                         rv,
                         plot_callback=partial(plot_callback, **kwargs),
                         target_dimension=target_dimension,