holobench 1.18.0__py2.py3-none-any.whl → 1.30.0__py2.py3-none-any.whl

bencher/example/example_composable_container2.py

@@ -0,0 +1,160 @@
+import bencher as bch
+from PIL import Image, ImageDraw
+from bencher.video_writer import VideoWriter
+
+
+class BenchImageTest(bch.ParametrizedSweep):
+    character = bch.StringSweep(["a", "b", "c", "d", "e", "f"])
+    r = bch.IntSweep(default=255, bounds=[0, 255])
+    g = bch.IntSweep(default=255, bounds=[0, 255])
+    b = bch.IntSweep(default=255, bounds=[0, 255])
+    width = bch.IntSweep(default=100, bounds=[10, 100])
+    height = bch.IntSweep(default=100, bounds=[10, 100])
+
+    image = bch.ResultImage()
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+
+        img = Image.new("RGB", (self.width, self.height), color=(self.r, self.g, self.b))
+        ImageDraw.Draw(img).text(
+            (self.width / 2.0, self.height / 2.0),
+            self.character,
+            (0, 0, 0),
+            anchor="mm",
+            font_size=self.height,
+        )
+        self.image = bch.gen_image_path()
+        img.save(self.image)
+        return super().__call__(**kwargs)
+
+
+def bench_image(run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None) -> bch.Bench:
+    bench = BenchImageTest().to_bench(run_cfg, report)
+    bench.sweep_sequential(group_size=1)
+    return bench
+
+
+class BenchComposableContainerImage(BenchImageTest):
+    compose_method = bch.EnumSweep(bch.ComposeType)
+    labels = bch.BoolSweep()
+    # num_frames = bch.IntSweep(default=5, bounds=[1, 10])
+    # character = bch.StringSweep(["a", "b"])
+
+    text_vid = bch.ResultVideo()
+    frame_width = bch.ResultVar("pixels")
+    frame_height = bch.ResultVar("pixels")
+    duration = bch.ResultVar("S")
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+        # if self.labels:
+        # var_name = "sides"
+        # var_value = self.sides
+        vr = bch.ComposableContainerVideo()
+
+        for c in ["a", "b"]:
+            res = super().__call__(character=c)
+            vr.append(res["image"])
+
+        vid = vr.render(
+            bch.RenderCfg(
+                compose_method=self.compose_method,
+                # var_name=var_name,
+                # var_value=var_value,
+                max_frame_duration=2.0,
+                # max_frame_duration=1.,
+                # duration=1.
+            )
+        )
+
+        self.frame_width, self.frame_height = vid.size
+        self.duration = vid.duration
+        print("RES", self.frame_width, self.frame_height, self.duration)
+
+        self.text_vid = VideoWriter().write_video_raw(vid)
+        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 = ["text_vid", "duration"]
+    # bench.result_vars = ["duration"]
+    # bench.add_plot_callback(bch.BenchResult.to_panes)
+    # bench.add_plot_callback(bch.BenchResult.to_table)
+
+    # 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.use_sample_cache = 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()
+
+
+if __name__ == "__main__":
+    bench_runner = bch.BenchRunner("ImageChar")
+    # bench_runner.add_run(bench_image)
+    bench_runner.add_run(example_composable_container_image)
+
+    bench_runner.run(level=6, show=True, use_cache=False)

bencher/example/example_consts.py

@@ -0,0 +1,39 @@
+"""This file contains examples for how to perform basic 2D benchmarking parameter sweeps"""
+
+import math
+import bencher as bch
+
+
+class SimpleFloat(bch.ParametrizedSweep):
+    theta = bch.FloatSweep(
+        default=0, bounds=[0, math.pi], doc="Input angle", units="rad", samples=30
+    )
+    offset = bch.FloatSweep(default=0, bounds=[0, 1], doc="Input angle offset", units="rad")
+    noise = bch.FloatSweep(default=0, bounds=[0, 1], doc="noise", units="rad")
+    out_sin = bch.ResultVar(units="v", doc="sin of theta")
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+        self.out_sin = math.sin(self.theta) + self.offset + self.noise
+        return super().__call__(**kwargs)
+
+
+def example_2D_float_const(
+    run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None
+) -> bch.Bench:
+    """This example shows how to sample a 1 dimensional float variable and plot the result of passing that parameter sweep to the benchmarking function"""
+
+    bench = SimpleFloat().to_bench(run_cfg, report)
+    const_vars = SimpleFloat().get_input_defaults_override(offset=0.5)
+    bench.plot_sweep(input_vars=["theta"], const_vars=const_vars)
+
+    const_vars = SimpleFloat().get_input_defaults_override(noise=0.2)
+    bench.plot_sweep(input_vars=["theta"], const_vars=const_vars)
+
+    bench.plot_sweep(input_vars=["theta"], const_vars=dict(offset=0.3))
+
+    return bench
+
+
+if __name__ == "__main__":
+    example_2D_float_const().report.show()

bencher/example/example_custom_sweep2.py

@@ -0,0 +1,42 @@
+import bencher as bch
+
+
+class Square(bch.ParametrizedSweep):
+    """An example of a datatype with an integer and float parameter"""
+
+    x = bch.FloatSweep(default=0, bounds=[0, 6])
+
+    result = bch.ResultVar("ul", doc="Square of x")
+
+    def __call__(self, **kwargs) -> dict:
+        self.update_params_from_kwargs(**kwargs)
+        self.result = self.x * self.x
+        return self.get_results_values_as_dict()
+
+
+def example_custom_sweep2(
+    run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None
+) -> bch.Bench:
+    """This example shows how to define a custom set of value to sample from intead of a uniform sweep
+
+    Args:
+        run_cfg (BenchRunCfg): configuration of how to perform the param sweep
+
+    Returns:
+        Bench: results of the parameter sweep
+    """
+
+    bench = Square().to_bench(run_cfg=run_cfg, report=report)
+
+    # These are all equivalent
+    bench.plot_sweep(input_vars=[Square.param.x.with_sample_values([0, 1, 2])])
+    bench.plot_sweep(input_vars=[bch.p("x", [4, 5, 6])])
+
+    bench.plot_sweep(input_vars=[bch.p("x", samples=5)])
+    bench.plot_sweep(input_vars=[bch.p("x", samples=6)])
+
+    return bench
+
+
+if __name__ == "__main__":
+    example_custom_sweep2().report.show()

bencher/example/example_dataframe.py

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

bencher/example/example_filepath.py

@@ -0,0 +1,27 @@
+import bencher as bch
+
+
+class ExampleFile(bch.ParametrizedSweep):
+    content = bch.StringSweep(["entry1", "entry2", "entry3"])
+
+    file_result = bch.ResultPath()
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+
+        # this generates a unique filename and stores it in the cache directory
+        filename = bch.gen_path(self.content, suffix=".txt")
+        with open(filename, "w", encoding="utf-8") as text_file:
+            text_file.write(f"content:{self.content}")
+        self.file_result = filename
+        return super().__call__()
+
+
+def example_filepath(run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None):
+    bench = ExampleFile().to_bench(run_cfg, report)
+    bench.plot_sweep()
+    return bench
+
+
+if __name__ == "__main__":
+    example_filepath().report.show()

bencher/example/example_image.py

@@ -4,10 +4,11 @@ import math
 import matplotlib.pyplot as plt
 
 
-def polygon_points(radius: float, sides: int):
+def polygon_points(radius: float, sides: int, start_angle: float):
     points = []
-    for ang in np.linspace(0, math.pi * 2, sides + 1):
-        points.append(([math.sin(ang) * radius, math.cos(ang) * radius]))
+    for ang in np.linspace(0, 360, sides + 1):
+        angle = math.radians(start_angle + ang)
+        points.append(([math.sin(angle) * radius, math.cos(angle) * radius]))
     return points
 
 
@@ -17,16 +18,16 @@ class BenchPolygons(bch.ParametrizedSweep):
     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()
     area = bch.ResultVar()
     side_length = bch.ResultVar()
 
     def __call__(self, **kwargs):
         self.update_params_from_kwargs(**kwargs)
-        points = polygon_points(self.radius, self.sides)
+        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"))
-        self.area = self.radius * self.sides
 
         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))
@@ -82,15 +83,31 @@ def example_image(
     return bench
 
 
-def example_image_vid(
-    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
-) -> bch.Bench:
+def example_image_vid(run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None) -> 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, target_duration=1)
-    bench.plot_sweep(input_vars=["sides"])
+    bench.add_plot_callback(
+        bch.BenchResult.to_video_grid,
+        target_duration=0.06,
+        compose_method_list=[
+            bch.ComposeType.right,
+            bch.ComposeType.right,
+            bch.ComposeType.sequence,
+        ],
+    )
+    # from functools import partial
+    # bench.add_plot_callback(bch.BenchResult.to_video_summary)
+    # bench.add_plot_callback(bch.BenchResult.to_video_grid, time_sequence_dimension=0)
+    # bench.add_plot_callback(bch.BenchResult.to_video_grid)
+    # bench.add_plot_callback(bch.BenchResult.to_video_grid, time_sequence_dimension=2)
+    # bench.add_plot_callback(bch.BenchResult.to_video_grid, time_sequence_dimension=3)
+
+    bench.plot_sweep(input_vars=["radius"])
+    # res = bench.plot_sweep(input_vars=["radius"], plot=False)
+    # bench.report.append(res.to_video_grid(target_duration=0.06))
     bench.plot_sweep(input_vars=["radius", "sides"])
-    bench.plot_sweep(input_vars=["radius", "sides", "linewidth"])
+    # bench.plot_sweep(input_vars=["radius", "sides", "linewidth"])
+    # bench.plot_sweep(input_vars=["radius", "sides", "linewidth", "color"])
 
     return bench
 
@@ -104,14 +121,12 @@ if __name__ == "__main__":
 
         # res = bench.sweep(input_vars=["sides", "radius"])
 
-        # bench.report.append(res.to_heatmap(target_dimension=3))
-
         bench.plot_sweep(input_vars=["sides"])
         bench.plot_sweep(input_vars=["sides", "color"])
 
-        bench.plot_sweep(input_vars=["sides", "radius"])
-
-        # bench.report.append(res.to_line(target_dimension=1))
+        res = bench.plot_sweep(input_vars=["sides", "radius"])
+        bench.report.append(res.to_heatmap(target_dimension=3))
+        bench.report.append(res.to_line(target_dimension=1))
 
         return bench
 

bencher/example/example_image1.py

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

bencher/example/example_levels2.py

@@ -0,0 +1,37 @@
+import bencher as bch
+
+
+class Square(bch.ParametrizedSweep):
+    """An example of a datatype with an integer and float parameter"""
+
+    x = bch.FloatSweep(default=0, bounds=[0, 6])
+
+    result = bch.ResultVar("ul", doc="Square of x")
+
+    def __call__(self, **kwargs) -> dict:
+        self.update_params_from_kwargs(**kwargs)
+        self.result = self.x * self.x
+        return self.get_results_values_as_dict()
+
+
+def example_levels2(run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None) -> bch.Bench:
+    """This example shows how to define a custom set of value to sample from intead of a uniform sweep
+
+    Args:
+        run_cfg (BenchRunCfg): configuration of how to perform the param sweep
+
+    Returns:
+        Bench: results of the parameter sweep
+    """
+
+    bench = Square().to_bench(run_cfg=run_cfg, report=report)
+
+    # These are all equivalent
+    bench.plot_sweep(input_vars=[Square.param.x.with_level(run_cfg.level, 3)])
+    bench.plot_sweep(input_vars=[bch.p("x", max_level=3)])
+
+    return bench
+
+
+if __name__ == "__main__":
+    example_levels2(bch.BenchRunCfg(level=4)).report.show()

bencher/example/example_simple_float.py

@@ -1,38 +1,28 @@
 """This file has some examples for how to perform basic benchmarking parameter sweeps"""
 
+import math
 import bencher as bch
 
-# All the examples will be using the data structures and benchmark function defined in this file
-from bencher.example.benchmark_data import ExampleBenchCfgIn, ExampleBenchCfgOut, bench_function
 
+class SimpleFloat(bch.ParametrizedSweep):
+    theta = bch.FloatSweep(
+        default=0, bounds=[0, math.pi], doc="Input angle", units="rad", samples=30
+    )
+    out_sin = bch.ResultVar(units="v", doc="sin of theta")
 
-def example_1D_float(
-    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
-) -> bch.Bench:
-    """This example shows how to sample a 1 dimensional float variable and plot the result of passing that parameter sweep to the benchmarking function"""
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+        self.out_sin = math.sin(self.theta)
+        return super().__call__(**kwargs)
 
-    bench = bch.Bench(
-        "benchmarking_example_float1D",
-        bench_function,
-        ExampleBenchCfgIn,
-        run_cfg=run_cfg,
-        report=report,
-    )
 
-    # here we sample the input variable theta and plot the value of output1. The (noisy) function is sampled 20 times so you can see the distribution
-    bench.plot_sweep(
-        title="Example 1D Float",
-        input_vars=[ExampleBenchCfgIn.param.theta],
-        result_vars=[ExampleBenchCfgOut.param.out_sin],
-        description=example_1D_float.__doc__,
-    )
+def example_1D_float(run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None) -> bch.Bench:
+    """This example shows how to sample a 1 dimensional float variable and plot the result of passing that parameter sweep to the benchmarking function"""
 
+    bench = SimpleFloat().to_bench(run_cfg, report)
+    bench.plot_sweep()
     return bench
 
 
 if __name__ == "__main__":
-    ex_run_cfg = bch.BenchRunCfg()
-    ex_run_cfg.repeats = 2
-    # ex_run_cfg.over_time = True
-
-    example_1D_float(ex_run_cfg).report.show()
+    example_1D_float().report.show()

bencher/example/example_simple_float2d.py

@@ -0,0 +1,29 @@
+"""This file contains examples for how to perform basic 2D benchmarking parameter sweeps"""
+
+import math
+import bencher as bch
+
+
+class SimpleFloat(bch.ParametrizedSweep):
+    theta = bch.FloatSweep(
+        default=0, bounds=[0, math.pi], doc="Input angle", units="rad", samples=30
+    )
+    offset = bch.FloatSweep(default=0, bounds=[0, 1], doc="Input angle", units="rad")
+    out_sin = bch.ResultVar(units="v", doc="sin of theta")
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+        self.out_sin = math.sin(self.theta) + self.offset
+        return super().__call__(**kwargs)
+
+
+def example_2D_float(run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None) -> bch.Bench:
+    """This example shows how to sample a 1 dimensional float variable and plot the result of passing that parameter sweep to the benchmarking function"""
+
+    bench = SimpleFloat().to_bench(run_cfg, report)
+    bench.plot_sweep()
+    return bench
+
+
+if __name__ == "__main__":
+    example_2D_float().report.show()

bencher/example/example_strings.py

@@ -21,6 +21,9 @@ class TestPrinting(bch.ParametrizedSweep):
             self.result += f",{self.c}"
         if self.d is not None:
             self.result += f",{self.d}"
+        self.result += "\n\ttab\n\t\ttab2"
+
+        self.result = bch.tabs_in_markdown(self.result)
         return super().__call__()
 
 
@@ -36,8 +39,6 @@ def example_strings(
         [TestPrinting.param.a, TestPrinting.param.b, TestPrinting.param.c, TestPrinting.param.d],
     ]:
         bench.plot_sweep(f"String Panes {[v.name for v in s]}", input_vars=s)
-        # bench.report.append(res.to_sweep_summary())
-        # bench.report.append(res.to_panes())
 
     return bench
 

bencher/example/example_video.py

@@ -95,24 +95,15 @@ def example_video(
 def example_video_tap(
     run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
 ) -> bch.Bench:  # pragma: no cover
-    tp = TuringPattern()
-
-    # run_cfg.use_sample_cache = False
-    # run_cfg.use_optuna = True
-    run_cfg.auto_plot = False
-    run_cfg.run_tag = "3"
-    bench = tp.to_bench(run_cfg=run_cfg, report=report)
-
+    bench = TuringPattern().to_bench(run_cfg=run_cfg, report=report)
     res = bench.plot_sweep(
-        "phase",
         input_vars=["alpha", "beta"],
         # result_vars=["video","score"],
         # result_vars=["score"],
         run_cfg=run_cfg,
     )
 
-    bench.report.append(res.describe_sweep())
-    bench.report.append(res.to_heatmap())
+    bench.report.append(res.to_video_grid())
 
     return bench
 

bencher/example/meta/example_meta.py

@@ -151,9 +151,9 @@ def example_meta(
         description="""## All Combinations of Variable Sweeps and Resulting Plots
 This uses bencher to display all the combinatios of plots bencher is able to produce""",
         input_vars=[
-            BenchMeta.param.float_vars.with_sample_values([0, 1, 2, 3]),
+            bch.p("float_vars", [0, 1, 2, 3]),
             BenchMeta.param.categorical_vars,
-            BenchMeta.param.sample_with_repeats.with_sample_values([1, 2]),
+            bch.p("sample_with_repeats", [1, 2]),
             # BenchMeta.param.sample_over_time,
         ],
         const_vars=[