holobench 1.40.1__py3-none-any.whl → 1.42.0__py3-none-any.whl

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/class_enum.py

@@ -1,52 +1,115 @@
 from __future__ import annotations
 from strenum import StrEnum
-from typing import Any
+from typing import Any, TypeVar
 import importlib
 from abc import abstractmethod
 from dataclasses import dataclass
 from enum import auto
 
+T = TypeVar("T")  # Generic type for return value of to_class
+
 
 class ClassEnum(StrEnum):
-    """A ClassEnum is a pattern to make it easier to create factory a factory method that converts from an enum to a corresponding class.  Subclasses should implement to_class(enum_instance:EnumType) which takes an enum returns the corresponding instance of that class."""
+    """A string-based enum class that maps enum values to corresponding class instances.
+
+    ClassEnum is a pattern to make it easier to create a factory method that converts
+    from an enum value to a corresponding class instance. Subclasses should implement
+    the to_class() method which takes an enum value and returns an instance of the
+    corresponding class.
+
+    This pattern is useful for configuration-driven class instantiation, allowing
+    classes to be selected via string configuration values that match enum names.
+    """
 
     @classmethod
     def to_class_generic(cls, module_import: str, class_name: str) -> Any:
-        """Create an instance of the class referred to by this enum
+        """Create an instance of a class from its module path and class name.
+
+        This utility method dynamically imports a module and instantiates a class from it.
+
+        Args:
+            module_import (str): The module path to import (e.g., "bencher.class_enum")
+            class_name (str): The name of the class to instantiate
 
         Returns:
-            Any: instance of the class
+            Any: A new instance of the specified class
         """
-
         class_def = getattr(importlib.import_module(module_import), class_name)
         return class_def()
 
     @classmethod
     @abstractmethod
     def to_class(cls, enum_val: ClassEnum) -> Any:
-        """Subclasses should overrides this method to take  an enum returns the corresponding instance of that class."""
-        raise NotImplementedError()
+        """Convert an enum value to its corresponding class instance.
+
+        Subclasses must override this method to implement the mapping from
+        enum values to class instances.
+
+        Args:
+            enum_val (ClassEnum): The enum value to convert to a class instance
+
+        Returns:
+            Any: An instance of the class corresponding to the enum value
+
+        Raises:
+            NotImplementedError: If this method is not overridden by a subclass
+        """
+        raise NotImplementedError("Subclasses must implement to_class()")
 
 
 @dataclass
 class BaseClass:
+    """Base class for the ClassEnum example.
+
+    A simple dataclass that serves as the base class for the ClassEnum example classes.
+
+    Attributes:
+        baseclassname (str): A name for the base class
+    """
+
     baseclassname: str = "class0"
 
 
 @dataclass
 class Class1(BaseClass):
+    """Example subclass 1 for the ClassEnum demonstration.
+
+    Attributes:
+        classname (str): A name for this class
+    """
+
     classname: str = "class1"
 
 
 @dataclass
 class Class2(BaseClass):
+    """Example subclass 2 for the ClassEnum demonstration.
+
+    Attributes:
+        classname (str): A name for this class
+    """
+
     classname: str = "class2"
 
 
 class ExampleEnum(ClassEnum):
+    """An example implementation of ClassEnum.
+
+    This enum demonstrates how to use ClassEnum to map enum values to class instances.
+    Each enum value corresponds to a class name that can be instantiated.
+    """
+
     Class1 = auto()
     Class2 = auto()
 
     @classmethod
     def to_class(cls, enum_val: ExampleEnum) -> BaseClass:
+        """Convert an ExampleEnum value to its corresponding class instance.
+
+        Args:
+            enum_val (ExampleEnum): The enum value to convert
+
+        Returns:
+            BaseClass: An instance of either Class1 or Class2, depending on the enum value
+        """
         return cls.to_class_generic("bencher.class_enum", enum_val)

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_dataframe.py

@@ -25,7 +25,7 @@ class ExampleMergeDataset(bch.ParametrizedSweep):
 
 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.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
@@ -39,7 +39,7 @@ def example_dataset(run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = N
     # )
     # 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))
+    bench.add(bch.DataSetResult, container=hv.Curve)
     return bench
 
 

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_levels.py

@@ -1,179 +1,23 @@
 import bencher as bch
-from bencher.utils import int_to_col
-
-import math
-import holoviews as hv
-from typing import Any, List
-import panel as pn
-from holoviews import opts
-
-
-class LevelsExample(bch.ParametrizedSweep):
-    xval = bch.FloatSweep(bounds=[0, 3.14])
-    yval = bch.FloatSweep(bounds=[0, 3.14])
-    level = bch.IntSweep(default=1, bounds=[1, 6])
-
-    output = bch.ResultVar(units="v")
-    hmap = bch.ResultHmap()
-
-    def __call__(self, **kwargs: Any) -> Any:
-        self.update_params_from_kwargs(**kwargs)
-        self.output = math.sin(self.xval) + math.cos(self.yval)
-        self.hmap = hv.Points((self.xval, self.yval)).opts(
-            marker="o", size=110 - self.level * 20, color=int_to_col(self.level - 1)
-        )
-
-        return self.get_results_values_as_dict()
-
-
-class RunWithLevel(bch.ParametrizedSweep):
-    level = bch.IntSweep(default=1, bounds=[1, 8])
-    dimensions = bch.IntSweep(default=1, bounds=[1, 2])
-
-    level_samples = bch.ResultVar()
-
-    def __call__(self, **kwargs) -> dict():
-        self.update_params_from_kwargs(**kwargs)
-
-        self.level_samples = int(
-            pow(
-                len(bch.FloatSweep(bounds=[0, 1]).with_level(self.level).values()),
-                self.dimensions,
-            )
-        )
-        return self.get_results_values_as_dict()
-
-
-def run_with_dim(bench: bch.Bench, dims: List[bch.SweepBase]) -> List[bch.BenchResult]:
-    results = []
-    for level in range(1, 6):
-        print(level)
-        res = bench.plot_sweep(
-            f"Level:{level}",
-            input_vars=dims,
-            const_vars=LevelsExample.get_input_defaults(
-                [LevelsExample.param.level.with_const(level)]
-            ),
-            result_vars=[LevelsExample.param.output, LevelsExample.param.hmap],
-            run_cfg=bch.BenchRunCfg(level=level, auto_plot=False),
-        )
-
-        results.append(res)
-    return results
-
-
-def run_levels_1D(bench: bch.Bench) -> bch.Bench:
-    results = run_with_dim(bench, [LevelsExample.param.xval])
-    bench.report.append_title("Using Levels to define sample density")
-
-    bench1 = bch.Bench("levels", RunWithLevel(), run_cfg=bch.BenchRunCfg(auto_plot=False))
-    res1 = bench1.plot_sweep("Levels", input_vars=[RunWithLevel.param.level])
-
-    bench.report.append_markdown(
-        "Sample levels let you perform parameter sweeps without having to decide how many samples to take when defining the class.  If you perform a sweep at level 2, then all the points are reused when sampling at level 3.  The higher levels reuse the points from lower levels to avoid having to recompute potentially expensive samples. The other advantage is that it enables a workflow where you can quickly see the results of the sweep at a low resolution to sense check the code, and then run it at a high level to get the fidelity you want.  When calling a sweep at a high level, you can publish the intermediate lower level results as the computiation continues so that you can track the progress of the computation and end the sweep early when you have sufficient resolution",
-        width=600,
-    )
-    row = pn.Row()
-    row.append(res1.to_table())
-    # row.append(res1.to_curve().opts(shared_axes=False))
-    row.append(res1.to_curve())
-
-    bench.report.append(row)
-
-    bench.report.append_markdown(
-        "Level 1 returns a single point at the lower bound of the parameter. Level 2 uses the upper and lower bounds of the parameter. All subsequent levels are created by adding a sample between each previously calculated sample to ensure that all previous values can be reused while retaining an equal sample spacing.  The following plots show the sample points as circles and the corresponding plot of a sin function sampled at that level.",
-        width=600,
+from bencher.example.meta.example_meta import BenchMeta
+
+
+def example_levels(run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None) -> bch.Bench:
+    bench = BenchMeta().to_bench(run_cfg, report)
+
+    bench.plot_sweep(
+        title="Using Levels to define sample density",
+        description="Sample levels let you perform parameter sweeps without having to decide how many samples to take when defining the class.  If you perform a sweep at level 2, then all the points are reused when sampling at level 3.  The higher levels reuse the points from lower levels to avoid having to recompute potentially expensive samples. The other advantage is that it enables a workflow where you can quickly see the results of the sweep at a low resolution to sense check the code, and then run it at a high level to get the fidelity you want.  When calling a sweep at a high level, you can publish the intermediate lower level results as the computiation continues so that you can track the progress of the computation and end the sweep early when you have sufficient resolution",
+        input_vars=[
+            bch.p("float_vars", [1, 2]),
+            bch.p("level", [2, 3, 4, 5]),
+        ],
+        const_vars=[
+            BenchMeta.param.categorical_vars.with_const(0),
+        ],
     )
-
-    combined_pts = hv.Overlay()
-    combined_curve = hv.Overlay()
-    for it, r in enumerate(results):
-        lvl = it + 1
-        row = pn.Row()
-        pts = r.to_holomap().overlay().opts(title=f"Sample Points for level: {lvl}", height=300)
-        ds = r.to_hv_dataset()
-        crv = r.to_curve_ds(ds.data).opts(shared_axes=False, height=300) * r.to_hv_dataset(
-            bch.ReduceType.NONE
-        ).to(hv.Scatter).opts(
-            title=f"Function Values for level: {lvl}", size=5, height=300, shared_axes=False
-        )
-
-        combined_pts *= pts
-        combined_curve *= crv
-        row.append(pts)
-        row.append(crv)
-        bench.report.append_markdown(f"## {r.bench_cfg.title}")
-        bench.report.append(row)
-
-    bench.report.append_markdown(
-        "This plot overlays the previous plots into a single image. It shows how each level overlaps the previous level"
-    )
-
-    bench.report.append(pn.Row(combined_pts, combined_curve))
-    return bench
-
-
-def run_levels_2D(bench: bch.Bench) -> bch.Bench:
-    results = run_with_dim(bench, [LevelsExample.param.xval, LevelsExample.param.yval])
-    bench.report.append_markdown("# Using Levels to define 2D sample density", "Levels 2D")
-
-    bench1 = bch.Bench("lol", RunWithLevel(), run_cfg=bch.BenchRunCfg(auto_plot=False))
-    res1 = bench1.plot_sweep(
-        "Levels",
-        input_vars=[RunWithLevel.param.level],
-        const_vars=[RunWithLevel.param.dimensions.with_const(2)],
-    )
-    row = pn.Row()
-    row.append(res1.to_table())
-    # row.append(res1.to_curve().opts(shared_axes=False))
-    row.append(res1.to_curve())
-
-    bench.report.append(row)
-
-    for it, r in enumerate(results):
-        lvl = it + 1
-        row = pn.Row()
-        bench.report.append_markdown(f"## {r.bench_cfg.title}")
-        row.append(
-            r.to_holomap()
-            .overlay()
-            .opts(title=f"Sample Points for level: {lvl}", shared_axes=False)
-        )
-        row.append(
-            r.to_heatmap_single(r.bench_cfg.result_vars[0], bch.ReduceType.NONE).opts(
-                title=f"Function Value Heatmap for level: {lvl}", shared_axes=False
-            )
-        )
-        bench.report.append(row)
-
-    bench.report.append_markdown(
-        "This plot overlays the previous plots into a single image. It shows how each level overlaps the previous level"
-    )
-    overlay = hv.Overlay()
-    for lvl, r in enumerate(results):
-        overlay *= (
-            r.to_holomap()
-            .overlay()
-            .opts(width=1000, height=1000, show_legend=False, shared_axes=False)
-        )
-
-    bench.report.append(overlay)
-    return bench
-
-
-def run_levels(run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None) -> bch.Bench:
-    hv.extension("bokeh")
-    opts.defaults(
-        opts.Curve(show_legend=False),
-        opts.Points(show_legend=False),
-    )
-
-    bench = bch.Bench("Levels", LevelsExample(), run_cfg=run_cfg, report=report)
-    bench = run_levels_1D(bench)
-    bench = run_levels_2D(bench)
-
     return bench
 
 
 if __name__ == "__main__":
-    run_levels().report.show()
+    example_levels().report.show()