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

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

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

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)

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

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

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:

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(

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

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

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

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",
+    # )

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
 

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

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__}")

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,

bencher/results/composable_container/composable_container_video.py

@@ -3,7 +3,7 @@ import numpy as np
 from copy import deepcopy
 from pathlib import Path
 from dataclasses import dataclass
-from moviepy.editor import (
+from moviepy import (
     ImageClip,
     CompositeVideoClip,
     clips_array,
@@ -11,22 +11,43 @@ from moviepy.editor import (
     VideoClip,
     VideoFileClip,
 )
-from moviepy.video.fx.margin import margin
 
 from bencher.results.composable_container.composable_container_base import (
     ComposableContainerBase,
     ComposeType,
 )
 from bencher.video_writer import VideoWriter
+from moviepy import vfx
 
 
 @dataclass()
 class RenderCfg:
+    """Configuration class for video rendering options.
+
+    This class controls how videos and images are composed and rendered together.
+    It provides options for timing, layout, appearance, and labeling of the output.
+
+    Attributes:
+        compose_method (ComposeType): Method to compose multiple clips (sequence, right, down, overlay).
+            Defaults to ComposeType.sequence.
+        var_name (str, optional): Variable name for labeling. Defaults to None.
+        var_value (str, optional): Variable value for labeling. Defaults to None.
+        background_col (tuple[int, int, int]): RGB color for background. Defaults to white (255, 255, 255).
+        duration (float): Target duration for the composed video in seconds. Defaults to 10.0.
+        default_duration (float): Fallback duration when duration is None. Defaults to 10.0.
+        duration_target (bool): If True, tries to match target duration while respecting frame
+            duration constraints. If False, uses exact duration. Defaults to True.
+        min_frame_duration (float): Minimum duration for each frame in seconds. Defaults to 1/30.
+        max_frame_duration (float): Maximum duration for each frame in seconds. Defaults to 2.0.
+        margin (int): Margin size in pixels to add around clips. Defaults to 0.
+    """
+
     compose_method: ComposeType = ComposeType.sequence
     var_name: str = None
     var_value: str = None
     background_col: tuple[int, int, int] = (255, 255, 255)
     duration: float = 10.0
+    default_duration: float = 10.0
     duration_target: bool = True
     min_frame_duration: float = 1.0 / 30
     max_frame_duration: float = 2.0
@@ -69,7 +90,9 @@ class ComposableContainerVideo(ComposableContainerBase):
     def calculate_duration(self, frames, render_cfg: RenderCfg):
         if render_cfg.duration_target:
             # calculate duration based on fps constraints
-            duration = 10.0 if render_cfg.duration is None else render_cfg.duration
+            duration = (
+                render_cfg.default_duration if render_cfg.duration is None else render_cfg.duration
+            )
             frame_duration = duration / frames
             if render_cfg.min_frame_duration is not None:
                 frame_duration = max(frame_duration, render_cfg.min_frame_duration)
@@ -77,7 +100,10 @@ class ComposableContainerVideo(ComposableContainerBase):
                 frame_duration = min(frame_duration, render_cfg.max_frame_duration)
             duration = frame_duration * frames
         else:
-            duration = render_cfg.duration
+            if render_cfg.duration is None:
+                duration = render_cfg.default_duration
+            else:
+                duration = render_cfg.duration
             frame_duration = duration / float(frames)
 
         print("max_frame_duration", render_cfg.max_frame_duration)
@@ -111,8 +137,8 @@ class ComposableContainerVideo(ComposableContainerBase):
             case ComposeType.right | ComposeType.down:
                 for i in range(len(self.container)):
                     self.container[i] = self.extend_clip(self.container[i], max_duration)
-                    self.container[i] = margin(
-                        self.container[i], top=render_cfg.margin, color=render_cfg.background_col
+                    self.container[i] = self.container[i].with_effects(
+                        [vfx.Margin(top=render_cfg.margin, color=render_cfg.background_col)]
                     )
 
                 if render_cfg.compose_method == ComposeType.right:
@@ -126,13 +152,14 @@ class ComposableContainerVideo(ComposableContainerBase):
                 out = concatenate_videoclips(
                     self.container, bg_color=render_cfg.background_col, method="compose"
                 )
-            # case ComposeType.overlay:
-            #     for i in range(len(self.container)):
-            #         self.container[i].alpha = 1./len(self.container)
-            #     out = CompositeVideoClip(self.container, bg_color=render_cfg.background_col)
-            #     # out.duration = fps
+            case ComposeType.overlay:
+                for i in range(len(self.container)):
+                    self.container[i] = self.container[i].with_opacity(1.0 / len(self.container))
+                out = CompositeVideoClip(self.container, bg_color=render_cfg.background_col)
             case _:
-                raise RuntimeError("This compose type is not supported")
+                raise RuntimeError(
+                    f"This compose type is not supported: {render_cfg.compose_method}"
+                )
 
         label = self.label_formatter(render_cfg.var_name, render_cfg.var_value)
         if label is not None:

bencher/results/holoview_result.py

@@ -154,14 +154,14 @@ class HoloviewResult(PanelResult):
             tap_var = [tap_var]
 
         if len(tap_var) == 0 or self.plt_cnt_cfg.inputs_cnt > 1 or not use_tap:
-            heatmap_cb = self.to_line_ds
+            line_cb = self.to_line_ds
         else:
-            heatmap_cb = partial(
+            line_cb = partial(
                 self.to_line_tap_ds, result_var_plots=tap_var, container=tap_container
             )
 
         return self.filter(
-            heatmap_cb,
+            line_cb,
             float_range=VarRange(1, 1),
             cat_range=VarRange(0, None),
             repeats_range=VarRange(1, 1),
@@ -202,17 +202,26 @@ class HoloviewResult(PanelResult):
     ) -> Optional[hv.Curve]:
         hvds = hv.Dataset(dataset)
         title = self.title_from_ds(dataset, result_var, **kwargs)
-
-        # print(result_var.name, dataset)
+        # print(result_var.name)
+        # print( dataset)
         pt = hv.Overlay()
         # find pairs of {var_name} {var_name}_std to plot the line and their spreads.
-        for var in dataset.data_vars:
-            if not var.endswith("_std"):
-                std_var = f"{var}_std"
-                pt *= hvds.to(hv.Curve, vdims=var, label=var).opts(title=title, **kwargs)
-                # Only create a Spread if the matching _std variable exists
-                if std_var in dataset.data_vars:
-                    pt *= hvds.to(hv.Spread, vdims=[var, std_var])
+        var = result_var.name
+        std_var = f"{var}_std"
+
+        pt *= hvds.to(hv.Curve, vdims=var, label=var).opts(title=title, **kwargs)
+        # Only create a Spread if the matching _std variable exists
+        if std_var in dataset.data_vars:
+            pt *= hvds.to(hv.Spread, vdims=[var, std_var])
+
+        # for var in dataset.data_vars:
+        #     print(var)
+        #     if not var.endswith("_std"):
+        #         std_var = f"{var}_std"
+        #         pt *= hvds.to(hv.Curve, vdims=var, label=var).opts(title=title, **kwargs)
+        #         #Only create a Spread if the matching _std variable exists
+        #         if std_var in dataset.data_vars:
+        #             pt *= hvds.to(hv.Spread, vdims=[var, std_var])
 
         return pt.opts(legend_position="right")
 

bencher/results/laxtex_result.py

@@ -0,0 +1,67 @@
+import panel as pn
+from panel.pane import LaTeX
+from typing import Optional, List, Any
+
+pn.extension("mathjax")
+
+
+def latex_text(text: str) -> str:
+    """Convert text to LaTeX text format, replacing underscores with spaces."""
+    return r"\text{" + text.replace("_", " ") + r"} \\"
+
+
+def format_values_list(values: List[Any], max_display: int = 5) -> List[Any]:
+    """Format a list of values, showing ellipsis if too long."""
+    if len(values) <= max_display:
+        return values
+    return [values[i] for i in [0, 1, 0, -2, -1]]
+
+
+def create_matrix_array(values: List[Any]) -> str:
+    """Create a LaTeX matrix array from values."""
+    displayed_vals = format_values_list(values)
+    if len(values) > 5:
+        displayed_vals[2] = "⋮"
+    return r"\\ ".join([str(val) for val in displayed_vals])
+
+
+def input_var_to_latex(input_var) -> str:
+    """Convert input variable to LaTeX format."""
+    vals = input_var.values()
+    latex_str = r"\begin{array}{c}"
+    latex_str += latex_text(input_var.name)
+    latex_str += f"{len(vals)}" + r"\times1 \\"
+    latex_str += r"\left[ \begin{array}{c}"
+    latex_str += create_matrix_array(vals)
+    latex_str += r"\end{array} \right] \end{array}"
+    return latex_str
+
+
+def result_var_to_latex(bench_cfg) -> str:
+    """Convert result variables to LaTeX format."""
+    sizes = [str(len(i.values())) for i in bench_cfg.all_vars]
+    if len(sizes) == 1:
+        sizes.insert(0, "1")
+
+    latex_str = r"\begin{array}{c}"
+    latex_str += r"\times".join(reversed(sizes)) + r"\\ of \\"
+    latex_str += r" \left[\begin{array}{cc}"
+    latex_str += "".join(latex_text(rv.name) for rv in bench_cfg.result_vars)
+    latex_str += r"\end{array} \right]\end{array}"
+    return latex_str
+
+
+def to_latex(bench_cfg) -> Optional[pn.pane.LaTeX]:
+    """Convert benchmark configuration to LaTeX visualization.
+
+    Returns None if there are no variables to display.
+    """
+    if not bench_cfg.all_vars:
+        return None
+
+    latex_str = r"\[" + r"\bigtimes".join(input_var_to_latex(iv) for iv in bench_cfg.all_vars)
+    latex_str += r"\rightarrow\quad"
+    latex_str += result_var_to_latex(bench_cfg)
+    latex_str += r"\]"
+
+    return LaTeX(latex_str.replace("_", r"\;"))

bencher/utils.py

@@ -1,6 +1,5 @@
 from collections import namedtuple
 import xarray as xr
-from sortedcontainers import SortedDict
 import hashlib
 import re
 import math
@@ -27,9 +26,7 @@ def hmap_canonical_input(dic: dict) -> tuple:
     Returns:
         tuple: values of the dictionary always in the same order and hashable
     """
-
-    function_input = SortedDict(dic)
-    return tuple(function_input.values())
+    return tuple(value for _, value in sorted(dic.items()))
 
 
 def make_namedtuple(class_name: str, **fields) -> namedtuple:

bencher/video_writer.py

@@ -1,9 +1,8 @@
 import numpy as np
 import moviepy.video.io.ImageSequenceClip
+import moviepy.video.io.VideoFileClip
 from pathlib import Path
 from .utils import gen_video_path, gen_image_path
-
-import moviepy
 from PIL import Image, ImageDraw
 
 
@@ -46,6 +45,16 @@ class VideoWriter:
         new_img.paste(image, (0, padding))
         return new_img
 
+    @staticmethod
+    def convert_to_compatible_format(video_path: str) -> str:
+        new_path = Path(video_path)
+        new_path = new_path.with_name(f"{new_path.stem}_fixed{new_path.suffix}").as_posix()
+        vw = VideoWriter()
+        vw.filename = new_path
+        with moviepy.video.io.VideoFileClip.VideoFileClip(video_path) as vid:
+            vw.write_video_raw(vid)
+        return new_path
+
     def write_video_raw(self, video_clip: moviepy.video.VideoClip, fps: int = 30) -> str:
         video_clip.write_videofile(
             self.filename,
@@ -59,6 +68,32 @@ class VideoWriter:
         video_clip.close()
         return self.filename
 
+    @staticmethod
+    def extract_frame(video_path: str, time: float = None, output_path: str = None) -> str:
+        """Extract a frame from a video at a specific time.
+
+        Args:
+            video_path: Path to the video file
+            time: Time in seconds to extract frame. If None, uses last frame
+            output_path: Optional path where to save the image. If None, uses video name with _frame.png
+
+        Returns:
+            str: Path to the saved PNG image
+        """
+        if output_path is None:
+            output_path = (
+                Path(video_path).with_stem(f"{Path(video_path).stem}_frame").with_suffix(".png")
+            )
+        else:
+            output_path = Path(output_path)
+
+        with moviepy.video.io.VideoFileClip.VideoFileClip(video_path) as video:
+            frame_time = time if time is not None else video.duration
+            frame = video.get_frame(frame_time)
+            Image.fromarray(frame).save(output_path)
+
+        return output_path.as_posix()
+
 
 def add_image(np_array: np.ndarray, name: str = "img") -> str:
     """Creates a file on disk from a numpy array and returns the created image path"""

bencher/worker_job.py

@@ -1,6 +1,5 @@
 from typing import List, Tuple, Any
 from dataclasses import dataclass, field
-from sortedcontainers import SortedDict
 from .utils import hash_sha1
 from bencher.utils import hmap_canonical_input
 
@@ -14,7 +13,7 @@ class WorkerJob:
     bench_cfg_sample_hash: str
     tag: str
 
-    function_input: SortedDict = None
+    function_input: dict = None
     canonical_input: Tuple[Any] = None
     fn_inputs_sorted: List[str] = None
     function_input_signature_pure: str = None
@@ -23,7 +22,7 @@ class WorkerJob:
     msgs: List[str] = field(default_factory=list)
 
     def setup_hashes(self) -> None:
-        self.function_input = SortedDict(zip(self.dims_name, self.function_input_vars))
+        self.function_input = dict(zip(self.dims_name, self.function_input_vars))
 
         self.canonical_input = hmap_canonical_input(self.function_input)
 
@@ -32,7 +31,7 @@ class WorkerJob:
 
         # store a tuple of the inputs as keys for a holomap
         # the signature is the hash of the inputs to to the function + meta variables such as repeat and time + the hash of the benchmark sweep as a whole (without the repeats hash)
-        self.fn_inputs_sorted = list(SortedDict(self.function_input).items())
+        self.fn_inputs_sorted = sorted(self.function_input.items())
         self.function_input_signature_pure = hash_sha1((self.fn_inputs_sorted, self.tag))
 
         self.function_input_signature_benchmark_context = hash_sha1(

{holobench-1.40.0.dist-info → holobench-1.41.0.dist-info}/METADATA

@@ -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.dist-info → holobench-1.41.0.dist-info}/RECORD

@@ -1,24 +1,26 @@
+CHANGELOG.md,sha256=alEi3CoMNOpKigEqP1uvdpuZMkpHJFCfO-tx8a_utss,284
 bencher/__init__.py,sha256=hWfQxlvuHRsFK4ZPCpRXo3nDzQB52JOUoi67wcnhopE,1890
-bencher/bench_cfg.py,sha256=gEpF1J4RAxCQPSkI8npKfhw-o3-8cw80TjiWK7As5WE,18417
+bencher/bench_cfg.py,sha256=FbjRAjbxKyHnb-3gPBLdE4GM_vgJeq7ciySH853j3gI,19040
 bencher/bench_plot_server.py,sha256=nvGTr981XgWELqV7yID91j6V1UIPGtKilzxHcNWaZ6Q,4196
 bencher/bench_report.py,sha256=ikMSHceyc8cYFH-sIza167DH-H-_iiTYDm2TmusUHDc,7515
 bencher/bench_runner.py,sha256=wShmZ504BOKgHj0sOrGZtduyPfJHFFBfHRsz5tYy5_Q,7000
 bencher/bencher.py,sha256=-vbZIzBr2IYYG7be5Hh8IZgIGUysTxoxQUV6xUToH14,35437
-bencher/caching.py,sha256=AusaNrzGGlj5m6zcwcqnTn55Mam2mQdF--oqelO806M,1627
+bencher/caching.py,sha256=RYvh6FLcYlMrfYcbkK5k8ZnT4lP2g5klUgo1oPfXhxg,1565
 bencher/class_enum.py,sha256=kYHW9qKkKcNdwaXizZL-fTptS_DUEGv4c88yCehk3gc,1492
 bencher/flask_server.py,sha256=uMhMaySUki5StC-r_TXb4KTVqAiffyqfH7UzQidFqSw,831
-bencher/job.py,sha256=8tztOwSYZqULaqD1Xv-wAdA6Rhgsa2I19P-ZzvnWPPw,6218
+bencher/job.py,sha256=cBsyw249iigZi1OhzW_ImU3AZMgCJPgvIDierI9xYNg,6147
 bencher/optuna_conversions.py,sha256=an-LfPsQXyyvhIZnG8Wl1RQVYMvJj7WOi3YNqoUnuxQ,5356
-bencher/utils.py,sha256=DP2GJP28nSEihvZwiV1Rl7YJ5NTrRt2zBLs46eQ37hQ,9887
+bencher/utils.py,sha256=HpNI-CsEFqOgAOO_pYdwqNQzkc6DU1cQeA7x7hTIIvk,9827
 bencher/utils_rerun.py,sha256=E1itolYJMjmtBE5qcSotiS20I-dobVnjznsTRvZaV0s,1212
-bencher/video_writer.py,sha256=z49tAG_ttXc8iWcTkWPJO1QaneaVdsmYL6Hpal-pd4Q,2176
-bencher/worker_job.py,sha256=FREi0yWQACFmH86R1j-LH72tALEFkKhLDmmoGQY9Jh4,1571
+bencher/video_writer.py,sha256=7oj_P6n9kWZ9geITSL1atBEdWk-GByRH--wxQJbTgHQ,3613
+bencher/worker_job.py,sha256=F8Zh1yWLaSKtDhkZL0hBZ-I3nc_ifaCOkwWAju3nq4I,1509
 bencher/example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bencher/example/benchmark_data.py,sha256=DL5Grj7UwnKZz2BHfGNKv35Ln0y2ntFwvZdkchOMHVU,6985
 bencher/example/example_all.py,sha256=_jOiz07fsjghiIuLfMpZiRVEkPaH7dM8OftOGcdL6cU,1960
 bencher/example/example_categorical.py,sha256=S6PP3LHZewHVymNZmEY-AEMRlJbv0CEgJ1NRWNDEnC8,3659
-bencher/example/example_composable_container.py,sha256=URN_2Wv98_JpjWJUhbvK2YejpqumUJMTbQ9ok07TNZw,3753
 bencher/example/example_composable_container2.py,sha256=tVcSggLAzuXsiHM00qSJk9fKOgqXbSzzyjs7IayLZCw,5667
+bencher/example/example_composable_container_image.py,sha256=FPk0JUWr8aKRMk5x7CfR2z97a6QNt2BEA_BFgsjwav4,1961
+bencher/example/example_composable_container_video.py,sha256=1kClqIP5ueOBEGSo1NJybmydCYfeyU3GmaqLwvGgfyQ,1849
 bencher/example/example_consts.py,sha256=upKkrMNYUCS38IA4duuyJHERwdZIMB4FA60Gytu_BzU,1475
 bencher/example/example_custom_sweep.py,sha256=OvAMqirV9KzbuaQ6ELOAbrRrj5zYHjpEs3tG-rgmFJM,1891
 bencher/example/example_custom_sweep2.py,sha256=6RBiyVVaxAh5Aul85DfYA5P-lwhwW3Bb54o0CBgTB6Q,1225
@@ -32,8 +34,8 @@ bencher/example/example_floats2D.py,sha256=1V5hCxr0Iz2KT2JyePn-XmugsMXlDzf0GazWW
 bencher/example/example_holosweep.py,sha256=emNUKCHPb-JrSWPjHajuAlQmUU9A9S7O-jdrvixg0Io,2989
 bencher/example/example_holosweep_objects.py,sha256=eqOjuTYh4Pis5lGsSeN7BJZXKR2upOSjynEtR0HqyoY,3196
 bencher/example/example_holosweep_tap.py,sha256=vKGyCdc1H8oECWRACW1kj5s1OJPAUETWHbP88R9hW_A,4475
-bencher/example/example_image.py,sha256=9VG2XiQnhksYh6WuU18a4b36KIrF-yY7dhZKdL0oG1I,5490
-bencher/example/example_image1.py,sha256=GO-PuiEKcFBma5fVNDi-203ZhYJvP4hojjxsDa9B9HM,2678
+bencher/example/example_image.py,sha256=QovSZtxepBwNSYDjouTCrhtP3NXJUXYoqRT2sFavsio,5554
+bencher/example/example_image1.py,sha256=XAR99ko6f4KZ6pHKoAebF2agTZRm8Hm5DZ1_lHdO2gI,2817
 bencher/example/example_levels.py,sha256=Gl3hIGYmzLufKWIG_YFTvW-TCfao6Ys6W0uc4dAcizw,6858
 bencher/example/example_levels2.py,sha256=tMhA6dYYQskzMeAZdaz6jRmQTe-c-jLXfkaUqWT30-I,1117
 bencher/example/example_pareto.py,sha256=tQxX9g8VfASv2vyRAm-Bv3qsYKjKnU-HyuLXtiZYEpw,2656
@@ -49,11 +51,11 @@ bencher/example/example_simple_float.py,sha256=c3ZR0LXfgGcH63MnUpQovRVnzpx5lpDQs
 bencher/example/example_simple_float2d.py,sha256=xsVOLO6AtMi9_fybpS_JZnhev5f11YuYWHrAOzJw2dI,1033
 bencher/example/example_strings.py,sha256=NpOGwC1KRAyAAC2VQZCg09ArraESdU0lupFj4b0I-sQ,1538
 bencher/example/example_time_event.py,sha256=l2dEut9oYnxxF7kRXnZx8Ohw1EdT5Iezo_b8CwCcCHA,2133
-bencher/example/example_video.py,sha256=LUiFV841oQ7r-cP3vSHBT0-fIJ-AK51_HyL2gOLMv9k,3839
+bencher/example/example_video.py,sha256=UGcAoY-DvYRuGQB0UgtVebCFtW2ru0s8MfZbhm3efUk,4527
 bencher/example/example_workflow.py,sha256=00QnUuViMfX_PqzqkXmg1wPX6yAq7IS7mCL_RFKwrMM,6806
 bencher/example/experimental/example_bokeh_plotly.py,sha256=3jUKh8eKIAlpklKnp8UopIHhUDw1A0_5CwjeyTzbi7o,846
 bencher/example/experimental/example_hover_ex.py,sha256=qszw4FkIfqQkVviPSpmUoFOoi6PGotGbsc7Ojyx8EtU,1052
-bencher/example/experimental/example_hvplot_explorer.py,sha256=LqTcIHwEj5DPDgvrHw0nKg_JErlraOrWqR0_6hZXvnI,1819
+bencher/example/experimental/example_hvplot_explorer.py,sha256=k3NXqLLDOf_uFi09S0RAkArasTZULMb3upwzqi09hMA,1796
 bencher/example/experimental/example_interactive.py,sha256=MM1A2EVsKTy95RERTNnld0tUmZmCy8N41_jGm2wlG7U,2619
 bencher/example/experimental/example_streamnd.py,sha256=LqkTtdY4NhnP5dEB1Ifv7RQ5Vq4dLkp5E3aWnWuzniA,1414
 bencher/example/experimental/example_streams.py,sha256=rrTmcmxDlirGoyTbJ4LT4fBIAc1k28qjnjy5JxGKyhg,1030
@@ -63,6 +65,7 @@ bencher/example/experimental/example_vector.py,sha256=3o_1dA4dc2HL6uIEvDAcvLPVJB
 bencher/example/inputs_0D/example_0_in_1_out.py,sha256=Lm4lgNGy6oLAEuqDEWHqWGbU6-T2LUudNtP3NKrFDho,1706
 bencher/example/inputs_0D/example_0_in_2_out.py,sha256=HFtuuuZspK0Hy_1hEbaQy8Ah3SFtSf04yHbaaB9YYec,1389
 bencher/example/inputs_1D/example1d_common.py,sha256=QurBf3rYq4B3nG9J7Rra30XXtoE6EeDHjPH0CrQ-T9g,2069
+bencher/example/inputs_1D/example_1_float_2_cat_repeats.py,sha256=E8IfubrWgZLX8yrZ-QdWVmEdzx2x8cjSIQUfcwJRUyk,342
 bencher/example/inputs_1D/example_1_in_1_out.py,sha256=eqAztAufMNTSVE3xdA9Nyqc8UXUn7Y2cjsIP_T_ITUw,1774
 bencher/example/inputs_1D/example_1_in_2_out.py,sha256=9qwDF5m25pzwRLeqQB_IO1I0ER07-izc9lFJBcapMdo,1908
 bencher/example/inputs_1D/example_1_in_2_out_repeats.py,sha256=0xt1B9xkCdDhTa8zBVmV565z22SO0RCQcAkCRuF4c1k,1804
@@ -71,8 +74,8 @@ bencher/example/meta/example_meta.py,sha256=ZXW8LZ1DGs05RiZRHLrOx-qt9x10qL6v2tt7
 bencher/example/meta/example_meta_cat.py,sha256=j3OCi1Yra47wrXOVr8epMYPGIXjQwdQoCcCICPmE2lo,609
 bencher/example/meta/example_meta_float.py,sha256=Y-zo7QAZkpt3mQEE4guiPmRHmKjn6-y8D_AjWeGCqEs,598
 bencher/example/meta/example_meta_levels.py,sha256=ZZ14r99z6cs73ZwvBJvDKdEVIdTyHzrWsenxRgFXfXQ,1410
-bencher/example/meta/generate_examples.py,sha256=Uicdr5PlamqiFGgEzEtdPzQPfVRE6UOa1CH-3UQ6T_I,1540
-bencher/example/meta/generate_meta.py,sha256=1euRIVEAUlT3a_olmhZXbHMaG9OCSzsgKajXXwf1vOI,3874
+bencher/example/meta/generate_examples.py,sha256=z_EoIRT_g15XftQ3_rHXpt_oAJEy0DBPGh2Vpt-ZVfE,1593
+bencher/example/meta/generate_meta.py,sha256=Pu7bvu5tNKsPuEPFU90g4z1d-ZPEitqhr4rPQe_X_I8,4861
 bencher/example/optuna/example_optuna.py,sha256=0zA6IIDWe7FM0rnYJ-FHF9GZtrhYdKHQTosUD2Raw0M,2338
 bencher/example/shelved/example_float2D_scatter.py,sha256=z8ranMq8IcJ1yoVSFDncp3gw-yWG7X9lXLimXKpy5Ks,3372
 bencher/example/shelved/example_float3D_cone.py,sha256=T3dkiEhjm6z3-Vs2SjCNWPKeHk8Bp4FbANE6yXYc_YM,2970
@@ -81,12 +84,13 @@ bencher/plotting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 bencher/plotting/plot_filter.py,sha256=hWRjZa9zTncVJiF6r_DI4Ce1xcU49PxJw4gXk7AzsnA,4931
 bencher/plotting/plt_cnt_cfg.py,sha256=0P9KjVQSUfPY7Kh7UGAbTqihaTgnmLm3oZ5Nvf-pcjM,3193
 bencher/results/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bencher/results/bench_result.py,sha256=j-Al54h26Qypma0dYbx0hs8lBUUX46xXov7DQAZsG7A,3763
-bencher/results/bench_result_base.py,sha256=a_IHbliBtLgziqBjkz0MJiu7JkSkrmz1VzBnLenXF6E,22005
+bencher/results/bench_result.py,sha256=JVVhFVMc4P9FqL6zBKsSK3npOkyn1IEKvNOOkvBciew,3811
+bencher/results/bench_result_base.py,sha256=OgSu--RcpEElJum0y7XIEKyGznSaJvrxxx3ZbhhvIl8,21980
 bencher/results/dataset_result.py,sha256=qXmFMrVAo_1qM6hhV4XpQqmCz9RiVkQo6ICYmbT-Kvk,8680
 bencher/results/float_formatter.py,sha256=sX6HNCyaXdHDxC8ybVUHwCJ3qOKbPUkBOplVIHtKWjM,1746
-bencher/results/holoview_result.py,sha256=r9G9p2i7r01O2ZnsPoyOJU39ImMQhW1QvGV0mNgolc4,29463
+bencher/results/holoview_result.py,sha256=Nc8m-kdQBylTy0JGB_mES3oaisNzHm8sRjT1mMtWWPo,29821
 bencher/results/hvplot_result.py,sha256=bYSewYhPLVzW6HF_WPjAhS1ZiRp9FJHs008UEBXgH4Y,1993
+bencher/results/laxtex_result.py,sha256=BL9iNgSoNpE8WTwW_OjVbYdYgRdlP27zv_nQ9PpwLds,2212
 bencher/results/optuna_result.py,sha256=QtZ4TGRun7gJoFVUjEyXKPF5yakwOSXrqEXQVJdJmm4,13587
 bencher/results/panel_result.py,sha256=lXOtfhWKSspf53Wgm94DTiVD3rliieHQW96sOdu5UYk,1336
 bencher/results/plotly_result.py,sha256=wkgfL38qJp6RviekXBYpNPeU4HCf0nbtKDAhu5QZhUg,2132
@@ -96,7 +100,7 @@ bencher/results/composable_container/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeu
 bencher/results/composable_container/composable_container_base.py,sha256=gmlQl3NQ3LWIfH15neLoZMNos6hbu3SklslfcFDAacA,2778
 bencher/results/composable_container/composable_container_dataframe.py,sha256=ZbFaQSo4UsRxY8NUdJPjNFW3_kzlm8jtWuoLf8y_t8U,1789
 bencher/results/composable_container/composable_container_panel.py,sha256=HrOoeGB0y0jGQcxcci_M82ftsvklLkJgo-4SjDBJCks,1232
-bencher/results/composable_container/composable_container_video.py,sha256=X6XxBNDglnNLjQ4QrhxJ8W3Re_aLeTZKKVsbjjJ3av8,7107
+bencher/results/composable_container/composable_container_video.py,sha256=yLfGRIswSHHWfFwVFBVz31wzKB9x-3bTfMtr-BqIyzk,8672
 bencher/variables/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bencher/variables/inputs.py,sha256=B4IycsuZQOx51OGO2e8zK5TjfRWvYXI7Ngle3KpVIdw,6694
 bencher/variables/parametrised_sweep.py,sha256=fxjKOQ2x5xuCyi0kO1_XS9bXiib1bjThhvpulZPeyv8,7802
@@ -104,7 +108,7 @@ bencher/variables/results.py,sha256=Wq14e8rAj5mcK22325wcaeTMjgZ6JuduqceAHItHFY8,
 bencher/variables/sweep_base.py,sha256=gfEhKvsb16ZLbe38JewZqu0AMOHpsqwRbZbt-aCg9Bc,6258
 bencher/variables/time.py,sha256=zcRS5p4ZkFjMta9nZMEuWv86rLnPkUSqyO69QwI5q3E,3142
 resource/bencher,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-holobench-1.40.0.dist-info/METADATA,sha256=hn3E2quLA2y2qpAyWnuGBOw5lvLG85A_dpUNDc8vO10,6846
-holobench-1.40.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-holobench-1.40.0.dist-info/licenses/LICENSE,sha256=dSHXTdRY4Y7qGFMv63UksV700iff7iE-p7GGs6Sbnvo,1065
-holobench-1.40.0.dist-info/RECORD,,
+holobench-1.41.0.dist-info/METADATA,sha256=M6tXWaG8Ft_a17Dm8sgcIDuMWEELgI-qmYjcpl5v4FE,6693
+holobench-1.41.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+holobench-1.41.0.dist-info/licenses/LICENSE,sha256=dSHXTdRY4Y7qGFMv63UksV700iff7iE-p7GGs6Sbnvo,1065
+holobench-1.41.0.dist-info/RECORD,,

bencher/example/example_composable_container.py

@@ -1,106 +0,0 @@
-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()
-
-
-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_image(
-    run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None
-) -> bch.Bench:
-    bench = BenchComposableContainerImage().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"])
-
-    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
-
-
-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()
-    ex_run_cfg.cache_samples = False
-    # ex_run_cfg.level = 2
-    ex_report = bch.BenchReport()
-    example_composable_container_image(ex_run_cfg, report=ex_report)
-    # example_composable_container_video(ex_run_cfg, report=ex_report)
-    ex_report.show()