holobench 1.25.2__py3-none-any.whl → 1.27.0__py3-none-any.whl

bencher/example/experimental/example_interactive.py

@@ -0,0 +1,75 @@
+# import holoviews as hv
+# import numpy as np
+# import param
+# from holoviews import opts, streams
+# from holoviews.plotting.links import DataLink
+
+# import panel as pn
+
+# hv.extension("bokeh")
+
+# datasets = {
+#     "data1": np.random.randint(1, 10, size=(4, 2)),
+#     "data2": np.random.randint(1, 10, size=(4, 2)),
+# }
+
+# other_data = {i: np.random.randint(1, 10, size=(100, 100)) for i in range(4)}
+
+
+# class Explorer(param.Parameterized):
+#     dataset = param.ObjectSelector(default=list(datasets.keys())[0], objects=list(datasets.keys()))
+
+#     lines = param.Boolean(default=False)
+
+#     # streams
+#     stream = param.ClassSelector(
+#         default=streams.PointDraw(drag=False, add=False), class_=(streams.PointDraw), precedence=-1
+#     )
+
+#     selection = param.ClassSelector(
+#         default=streams.Selection1D(), class_=(streams.Selection1D), precedence=-1
+#     )
+
+#     @param.depends("dataset")
+#     def load_file(self):
+#         name = self.dataset
+#         datum = datasets[name]
+#         scatter = hv.Scatter(datum).opts(size=8)
+
+#         # update the PointDraw/Selection1D sources/data
+#         self.stream.source = scatter
+#         self.selection.source = scatter
+#         self.stream.update(data=scatter.columns())  # reset PointDraw data
+#         self.selection.update(index=[])  # reset selection index
+
+#         table = hv.Table(scatter).opts(index_position=False, editable=True, selectable=True)
+#         DataLink(scatter, table)
+
+#         return (scatter + table).opts(
+#             opts.Scatter(tools=["tap", "hover", "box_select"]), opts.Table(editable=True)
+#         )
+
+#     @param.depends("dataset", "selection.index", "lines")
+#     def view(self):
+#         """update 3rd plot whenever dataset, selection.index, or lines is changed"""
+#         if self.selection.index == []:
+#             return None
+#         else:
+#             # modify with your "other" data
+#             if self.lines is True:
+#                 return hv.Path(other_data[self.selection.index[0]]).opts(shared_axes=False)
+
+#         return hv.operation.datashader.regrid(
+#             hv.Image(other_data[self.selection.index[0]]),
+#             upsample=True,
+#             interpolation="bilinear",
+#         ).opts(shared_axes=False)
+
+#     @param.depends("stream.data", watch=True)
+#     def update_data(self):
+#         """update dataset whenever a point is deleted using PointDraw"""
+#         datasets[self.dataset] = np.vstack((self.stream.data["x"], self.stream.data["y"])).T
+
+
+# explorer = Explorer()
+# pn.Row(pn.Column(explorer.param, explorer.view), explorer.load_file).show()

bencher/example/experimental/example_streamnd.py

@@ -0,0 +1,49 @@
+# pylint: skip-file  #this is experimental still
+
+
+import time
+import numpy as np
+import holoviews as hv
+from holoviews import streams
+import panel as pn
+
+hv.extension("bokeh")
+
+# Step 1: Set up your initial data
+# For demonstration purposes, let's create a simple initial Image plot.
+
+# Initial data (replace this with your actual data source)
+initial_data = np.random.rand(10, 10)
+
+# Create an Image plot from the initial data
+initial_plot = hv.Image(initial_data)
+
+
+# Step 2: Create a callback function to update the plot with new data
+def update_plot(new_data):
+    # Update the Image plot with the new data
+    new_plot = hv.Image(new_data)
+    return new_plot
+
+
+# Step 3: Create a DynamicMap that triggers the update_plot callback
+# The DynamicMap will automatically update the plot when new_data changes.
+dmap = hv.DynamicMap(
+    update_plot, streams=[streams.Stream.define("NewData", new_data=initial_data)()]
+)
+
+# Display the initial plot and start streaming updates
+layout = initial_plot + dmap
+layout = layout.cols(1)
+
+# Simulate streaming updates by continuously updating the new_data stream
+for i in range(10):
+    # Replace this line with your actual data source/streaming mechanism
+    new_data = np.random.rand(10, 10)
+    # Update the new_data stream to trigger the DynamicMap callback
+    dmap.event(NewData=new_data)
+    # Sleep for a specified interval
+    time.sleep(1)
+
+
+pn.Row(dmap).show()

bencher/example/experimental/example_streams.py

@@ -0,0 +1,36 @@
+# pylint: skip-file  #this is experimental still
+
+import numpy as np
+import holoviews as hv
+from holoviews import opts
+from holoviews import streams
+import panel as pn
+
+xs = np.linspace(-3, 3, 400)
+
+hv.extension("bokeh")
+
+
+def function(xs, time):
+    "Some time varying function"
+    return np.exp(np.sin(xs + np.pi / time))
+
+
+def integral(limit, time):
+    print(limit, time)
+    limit = -3 if limit is None else np.clip(limit, -3, 3)
+    curve = hv.Curve((xs, function(xs, time)))[limit:]
+    area = hv.Area((xs, function(xs, time)))[:limit]
+    summed = area.dimension_values("y").sum() * 0.015  # Numeric approximation
+    return area * curve * hv.VLine(limit) * hv.Text(limit + 0.8, 2.0, "%.2f" % summed)
+
+
+integral_streams = [streams.Stream.define("Time", time=1.0)(), streams.PointerX().rename(x="limit")]
+
+integral_dmap = hv.DynamicMap(integral, streams=integral_streams)
+
+integral_dmap.opts(
+    opts.Area(color="#fff8dc", line_width=2), opts.Curve(color="black"), opts.VLine(color="red")
+)
+
+pn.Row(integral_dmap).show()

bencher/example/experimental/example_template.py

@@ -0,0 +1,40 @@
+import holoviews as hv
+import numpy as np
+import panel as pn
+
+pn.extension(sizing_mode="stretch_width")
+
+ACCENT_COLOR = pn.template.FastListTemplate.accent_base_color
+XS = np.linspace(0, np.pi)
+
+
+def sine(freq, phase):
+    return (
+        hv.Curve((XS, np.sin(XS * freq + phase)))
+        .opts(responsive=True, min_height=400, title="Sine", color=ACCENT_COLOR)
+        .opts(line_width=6)
+    )
+
+
+def cosine(freq, phase):
+    return (
+        hv.Curve((XS, np.cos(XS * freq + phase)))
+        .opts(responsive=True, min_height=400, title="Cosine", color=ACCENT_COLOR)
+        .opts(line_width=6)
+    )
+
+
+freq_widget = pn.widgets.FloatSlider(name="Frequency", start=0, end=10, value=2)
+phase_widget = pn.widgets.FloatSlider(name="Phase", start=0, end=np.pi)
+
+sine = pn.bind(sine, freq=freq_widget, phase=phase_widget)
+cosine = pn.bind(cosine, freq=freq_widget, phase=phase_widget)
+
+template = pn.template.FastListTemplate(
+    site="Panel",
+    title="FastListTemplate",
+    sidebar=[pn.pane.Markdown("## Settings"), freq_widget, phase_widget],
+    main=[
+        pn.pane.HoloViews(hv.DynamicMap(sine) + hv.DynamicMap(cosine), sizing_mode="stretch_both")
+    ],
+).show()

bencher/example/experimental/example_updates.py

@@ -0,0 +1,84 @@
+# pylint: skip-file  #this is experimental still
+
+
+import numpy as np
+import pandas as pd
+import holoviews as hv
+import panel as pn
+
+# import streamz
+# import streamz.dataframe
+
+from holoviews import opts
+from holoviews.streams import Buffer
+
+from tornado.ioloop import PeriodicCallback
+from tornado import gen
+
+
+hv.extension("bokeh")
+
+
+count = 0
+buffer = Buffer(np.zeros((0, 2)), length=50)
+
+dataType = pd.DataFrame()
+
+
+@gen.coroutine
+def f():
+    global count
+    count += 1
+    buffer.send(np.array([[count, np.random.rand()]]))
+
+
+def plot(**kwargs):
+    # print(dat)
+    return hv.Curve(**kwargs)
+
+
+cb = PeriodicCallback(f, 1)
+cb.start()
+
+# dmap = hv.DynamicMap(hv.Curve, streams=[buffer]).opts(padding=0.1, width=600)
+dmap = hv.DynamicMap(plot, streams=[buffer]).opts(padding=0.1, width=600)
+
+pn.Row(dmap).show()
+
+
+example = pd.DataFrame({"x": [], "y": [], "count": []}, columns=["x", "y", "count"])
+dfstream = Buffer(example, length=100, index=False)
+
+
+def plot():
+    curve_dmap = hv.DynamicMap(hv.Curve, streams=[dfstream])
+    point_dmap = hv.DynamicMap(hv.Points, streams=[dfstream])
+    (curve_dmap * point_dmap).opts(
+        opts.Points(color="count", line_color="black", size=5, padding=0.1, xaxis=None, yaxis=None),
+        opts.Curve(line_width=1, color="black"),
+    )
+
+
+def gen_brownian():
+    x, y, count = 0, 0, 0
+    while True:
+        x += np.random.randn()
+        y += np.random.randn()
+        count += 1
+        yield pd.DataFrame([(x, y, count)], columns=["x", "y", "count"])
+
+
+@gen.coroutine
+def update_callback():
+    brownian = gen_brownian()
+    for i in range(2):
+        dfstream.send(next(brownian))
+
+
+cb = PeriodicCallback(update_callback, 1)
+cb.start()
+
+# update_button = pn.widgets.Button(name="Update Grid", button_type="primary")
+# update_button.on_click(update_callback)
+
+pn.Row(plot()).show()

bencher/example/experimental/example_vector.py

@@ -0,0 +1,84 @@
+# """Example on how to sweep over function with vector outputs"""
+
+# from math import cos, sin
+
+# import numpy as np
+
+# import bencher as bch
+
+
+# class OffsetCfg(bch.ParametrizedSweep):
+#     """A class for describing which parameters to sweep"""
+
+#     dc_offset = bch.FloatSweep(
+#         default=0,
+#         bounds=[0.0, 2.0],
+#         samples=4,
+#         units="v",
+#         doc="DC offset to add to the result of the signal",
+#     )
+#     phase_offset = bch.FloatSweep(
+#         default=0,
+#         bounds=[0.0, 3.14],
+#         samples=4,
+#         units="rad",
+#         doc="phase offset that is added to the input before passing to the trig function",
+#     )
+
+
+# class SweepResult(bch.ParametrizedSweep):
+#     """A class to describe the vector outputs of the benchmark function"""
+
+#     sin_sweep = bch.ResultList(
+#         index_name="time", index_units="s", units="v", doc="A list of values from a sin function"
+#     )
+#     cos_sweep = bch.ResultList(
+#         index_name="time", index_units="s", units="v", doc="A list of values from a cos function"
+#     )
+
+
+# def sin_sweep(cfg: OffsetCfg) -> SweepResult:
+#     """A function that returns vector outputs of the sin and cos functions
+
+#     Args:
+#         cfg (OffsetCfg): Options for phase and dc offset
+
+#     Returns:
+#         SweepResult: vectors with sin and cos results
+#     """
+#     res = SweepResult()
+#     print(type(res.sin_sweep))
+#     for i in np.arange(0, 6.28, 0.02):
+#         res.sin_sweep.append(sin(i + cfg.phase_offset) + cfg.dc_offset, i)
+#         # res.sin_sweep.indices.append(i)
+#     for i in np.arange(0, 3.28, 0.02):
+#         res.cos_sweep.append(cos(i + cfg.phase_offset) + cfg.dc_offset, i)
+#         # res.cos_sweep.indices.append(i)
+#     return res
+
+
+# def example_vector() -> bch.Bench:
+#     """Example on how to sweep over function with vector outputs"""
+#     bencher = bch.Bench("vector output example", sin_sweep, OffsetCfg)
+
+#     bencher.plot_sweep(
+#         title="Sweep DC offset",
+#         input_vars=[OffsetCfg.param.dc_offset],
+#         result_vars=[SweepResult.param.sin_sweep, SweepResult.param.cos_sweep],
+#         description="""This is an example of how to sample function that return a vector of unknown or varying size. In this example it returns the output of the sin and cos function for varying angles and a range of dc offsets""",
+#         post_description="""The output shows stack of sin and cos functions as the dc offset increases""",
+#     )
+
+#     bencher.plot_sweep(
+#         title="Sweep phase offset",
+#         input_vars=[OffsetCfg.param.phase_offset],
+#         result_vars=[SweepResult.param.sin_sweep, SweepResult.param.cos_sweep],
+#         description="""This is an example of how to sample function that return a vector of unknown or varying size. In this example it returns the output of the sin and cos function for varying angles and a range of phase offsets""",
+#         post_description="""The output shows different phases of the sin and cos functions""",
+#     )
+
+#     return bencher
+
+
+# if __name__ == "__main__":
+#     example_vector().plot()

bencher/example/meta/example_meta.py

@@ -0,0 +1,171 @@
+from typing import Any
+import bencher as bch
+import numpy as np
+
+from enum import auto
+from strenum import StrEnum
+import random
+import holoviews as hv
+import math
+
+
+class NoiseDistribution(StrEnum):
+    """A categorical variable describing the types of random noise"""
+
+    uniform = auto()  # uniform random noiase
+    gaussian = auto()  # gaussian noise
+
+    @staticmethod
+    def calculate_noise(noisy, noise_distribution, sigma) -> float:
+        if noisy:
+            match noise_distribution:
+                case NoiseDistribution.uniform:
+                    return random.uniform(0, sigma)
+                case NoiseDistribution.gaussian:
+                    return random.gauss(0, sigma)
+        return 0.0
+
+
+class BenchableObject(bch.ParametrizedSweep):
+    """A class to represent a 3D point in space."""
+
+    # floating point variables
+    float1 = bch.FloatSweep(default=0, bounds=[0, 1.0], doc="x coordinate of the sample volume")
+    float2 = bch.FloatSweep(default=0, bounds=[0, 1.0], doc="y coordinate of the sample volume")
+    float3 = bch.FloatSweep(default=0, bounds=[0, 1.0], doc="z coordinate of the sample volume")
+
+    sigma = bch.FloatSweep(default=1, bounds=[1, 10], doc="standard deviation of the added noise")
+
+    # categorial variables
+    noisy = bch.BoolSweep(
+        default=False, doc="Optionally add random noise to the output of the function"
+    )
+    noise_distribution = bch.EnumSweep(NoiseDistribution, doc=NoiseDistribution.__doc__)
+
+    negate_output = bch.StringSweep(["positive", "negative"])
+
+    distance = bch.ResultVar("m", doc="The distance from the sample point to the origin")
+    sample_noise = bch.ResultVar("m", doc="The amount of noise added to the distance sample")
+
+    result_hmap = bch.ResultHmap()
+    # result_im
+    ##todo all var types
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+
+        # distance to origin
+        self.distance = math.pow(
+            np.linalg.norm(np.array([self.float1, self.float2, self.float3])), 2
+        )
+        self.sample_noise = NoiseDistribution.calculate_noise(
+            self.noisy, self.noise_distribution, self.sigma
+        )
+
+        self.distance += self.sample_noise
+
+        if self.negate_output == "negative":
+            self.distance *= -1
+
+        self.result_hmap = hv.Text(
+            x=0, y=0, text=f"distance:{self.distance}\nnoise:{self.sample_noise}"
+        )
+
+        return super().__call__()
+
+
+class BenchMeta(bch.ParametrizedSweep):
+    """This class uses bencher to display the multidimensional types bencher can represent"""
+
+    float_vars = bch.IntSweep(
+        default=1, bounds=(0, 4), doc="The number of floating point variables that are swept"
+    )
+    categorical_vars = bch.IntSweep(
+        default=1, bounds=(0, 3), doc="The number of categorical variables that are swept"
+    )
+    sample_with_repeats = bch.IntSweep(default=1, bounds=(1, 10))
+
+    sample_over_time = bch.BoolSweep(default=False)
+
+    level = bch.IntSweep(default=2, units="level", bounds=(2, 5))
+
+    # plots = bch.ResultHmap()
+    # plots = bch.ResultContainer()
+    plots = bch.ResultReference(units="int")
+
+    def __call__(self, **kwargs: Any) -> Any:
+        self.update_params_from_kwargs(**kwargs)
+
+        run_cfg = bch.BenchRunCfg()
+        run_cfg.level = self.level
+        run_cfg.repeats = self.sample_with_repeats
+        run_cfg.over_time = self.sample_over_time
+        run_cfg.plot_size = 500
+
+        bench = bch.Bench("benchable", BenchableObject(), run_cfg=run_cfg)
+
+        inputs_vars_float = [
+            "float1",
+            "float2",
+            "float3",
+            "sigma",
+        ]
+
+        inputs_vars_cat = [
+            "noisy",
+            "noise_distribution",
+            "negate_output",
+        ]
+
+        input_vars = (
+            inputs_vars_float[0 : self.float_vars] + inputs_vars_cat[0 : self.categorical_vars]
+        )
+
+        res = bench.plot_sweep(
+            "test",
+            input_vars=input_vars,
+            result_vars=[BenchableObject.param.distance],
+            # result_vars=[BenchableObject.param.distance, BenchableObject.param.sample_noise],
+            # result_vars=[ BenchableObject.param.sample_noise],
+            # result_vars=[BenchableObject.param.result_hmap],
+            plot_callbacks=False,
+        )
+
+        self.plots = bch.ResultReference()
+        self.plots.obj = res.to_auto()
+
+        # self.plots.obj = res.to_heatmap_multi()
+
+        # self.plots.obj = res.to_line_multi(width=500, height=300)
+
+        return super().__call__()
+
+
+def example_meta(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    bench = BenchMeta().to_bench(run_cfg, report)
+
+    bench.plot_sweep(
+        title="Meta Bench",
+        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=[
+            bch.p("float_vars", [0, 1, 2, 3]),
+            BenchMeta.param.categorical_vars,
+            bch.p("sample_with_repeats", [1, 2]),
+            # BenchMeta.param.sample_over_time,
+        ],
+        const_vars=[
+            # BenchMeta.param.float_vars.with_const(1),
+            # 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
+
+
+if __name__ == "__main__":
+    example_meta().report.show()

bencher/example/meta/example_meta_cat.py

@@ -0,0 +1,25 @@
+import bencher as bch
+from bencher.example.meta.example_meta import BenchMeta
+
+
+def example_meta_cat(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    bench = BenchMeta().to_bench(run_cfg, report)
+
+    bench.plot_sweep(
+        title="Sweeping Categorical Variables",
+        input_vars=[
+            bch.p("categorical_vars", [1, 2, 3]),
+            bch.p("sample_with_repeats", [1, 2]),
+        ],
+        const_vars=[
+            BenchMeta.param.float_vars.with_const(0),
+        ],
+    )
+
+    return bench
+
+
+if __name__ == "__main__":
+    example_meta_cat().report.show()

bencher/example/meta/example_meta_float.py

@@ -0,0 +1,23 @@
+import bencher as bch
+from bencher.example.meta.example_meta import BenchMeta
+
+
+def example_meta_float(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> bch.Bench:
+    bench = BenchMeta().to_bench(run_cfg, report)
+
+    bench.plot_sweep(
+        title="Sweeping Floating Point Variables",
+        input_vars=[bch.p("float_vars", [1, 2, 3])],
+        const_vars=[
+            BenchMeta.param.categorical_vars.with_const(0),
+            BenchMeta.param.level.with_const(3),
+        ],
+    )
+
+    return bench
+
+
+if __name__ == "__main__":
+    example_meta_float().report.show()

bencher/example/meta/example_meta_levels.py

@@ -0,0 +1,26 @@
+import bencher as bch
+from bencher.example.meta.example_meta import BenchMeta
+
+
+def example_meta_levels(
+    run_cfg: bch.BenchRunCfg = bch.BenchRunCfg(), report: bch.BenchReport = bch.BenchReport()
+) -> 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]),
+        ],
+        const_vars=[
+            BenchMeta.param.categorical_vars.with_const(0),
+        ],
+    )
+
+    return bench
+
+
+if __name__ == "__main__":
+    example_meta_levels().report.show()