holobench 1.17.1__tar.gz → 1.19.0__tar.gz

{holobench-1.17.1 → holobench-1.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: holobench
-Version: 1.17.1
+Version: 1.19.0
 Summary: A package for benchmarking the performance of arbitrary functions
 Author-email: Austin Gregg-Smith <blooop@gmail.com>
 Description-Content-Type: text/markdown

{holobench-1.17.1 → holobench-1.19.0}/bencher/__init__.py

@@ -11,6 +11,7 @@ from .variables.results import (
     ResultVar,
     ResultVec,
     ResultHmap,
+    ResultPath,
     ResultVideo,
     ResultImage,
     ResultString,

{holobench-1.17.1 → holobench-1.19.0}/bencher/bench_cfg.py

@@ -374,26 +374,19 @@ class BenchCfg(BenchRunCfg):
         for rv in self.result_vars:
             benchmark_sampling_str.extend(describe_variable(rv, False))
 
-        print_meta = True
-        # if len(self.meta_vars) == 1:
-        #     mv = self.meta_vars[0]
-        #     if mv.name == "repeat" and mv.samples == 1:
-        #         print_meta = False
-
-        if print_meta:
-            benchmark_sampling_str.append("\nMeta Variables:")
-            benchmark_sampling_str.append(f"    run date: {self.run_date}")
-            if self.run_tag is not None and len(self.run_tag) > 0:
-                benchmark_sampling_str.append(f"    run tag: {self.run_tag}")
-            if self.level is not None:
-                benchmark_sampling_str.append(f"    bench level: {self.level}")
-            benchmark_sampling_str.append(f"    use_cache: {self.use_cache}")
-            benchmark_sampling_str.append(f"    use_sample_cache: {self.use_sample_cache}")
-            benchmark_sampling_str.append(f"    only_hash_tag: {self.only_hash_tag}")
-            benchmark_sampling_str.append(f"    parallel: {self.executor}")
-
-            for mv in self.meta_vars:
-                benchmark_sampling_str.extend(describe_variable(mv, True))
+        benchmark_sampling_str.append("\nMeta Variables:")
+        benchmark_sampling_str.append(f"    run date: {self.run_date}")
+        if self.run_tag:
+            benchmark_sampling_str.append(f"    run tag: {self.run_tag}")
+        if self.level is not None:
+            benchmark_sampling_str.append(f"    bench level: {self.level}")
+        benchmark_sampling_str.append(f"    use_cache: {self.use_cache}")
+        benchmark_sampling_str.append(f"    use_sample_cache: {self.use_sample_cache}")
+        benchmark_sampling_str.append(f"    only_hash_tag: {self.only_hash_tag}")
+        benchmark_sampling_str.append(f"    executor: {self.executor}")
+
+        for mv in self.meta_vars:
+            benchmark_sampling_str.extend(describe_variable(mv, True))
 
         benchmark_sampling_str.append("```")
 

{holobench-1.17.1 → holobench-1.19.0}/bencher/bencher.py

@@ -24,6 +24,7 @@ from bencher.variables.results import (
     ResultVar,
     ResultVec,
     ResultHmap,
+    ResultPath,
     ResultVideo,
     ResultImage,
     ResultString,
@@ -557,7 +558,7 @@ class Bench(BenchPlotServer):
             time_src (datetime | str): a representation of the sample time
 
         Returns:
-            _type_: _description_
+            tuple[BenchResult, List, List]: bench_result, function intputs, dimension names
         """
 
         if time_src is None:
@@ -565,9 +566,7 @@ class Bench(BenchPlotServer):
         bench_cfg.meta_vars = self.define_extra_vars(bench_cfg, bench_cfg.repeats, time_src)
 
         bench_cfg.all_vars = bench_cfg.input_vars + bench_cfg.meta_vars
-
         # bench_cfg.all_vars = bench_cfg.iv_time + bench_cfg.input_vars +[ bench_cfg.iv_repeat]
-
         # bench_cfg.all_vars = [ bench_cfg.iv_repeat] +bench_cfg.input_vars + bench_cfg.iv_time
 
         for i in bench_cfg.all_vars:
@@ -587,7 +586,9 @@ class Bench(BenchPlotServer):
             if isinstance(rv, ResultReference):
                 result_data = np.full(dims_cfg.dims_size, -1, dtype=int)
                 data_vars[rv.name] = (dims_cfg.dims_name, result_data)
-            if isinstance(rv, (ResultVideo, ResultImage, ResultString, ResultContainer)):
+            if isinstance(
+                rv, (ResultPath, ResultVideo, ResultImage, ResultString, ResultContainer)
+            ):
                 result_data = np.full(dims_cfg.dims_size, "NAN", dtype=object)
                 data_vars[rv.name] = (dims_cfg.dims_name, result_data)
             elif type(rv) == ResultVec:
@@ -724,7 +725,15 @@ class Bench(BenchPlotServer):
                     logging.info(f"{rv.name}: {result_value}")
 
                 if isinstance(
-                    rv, (ResultVar, ResultVideo, ResultImage, ResultString, ResultContainer)
+                    rv,
+                    (
+                        ResultVar,
+                        ResultVideo,
+                        ResultImage,
+                        ResultString,
+                        ResultContainer,
+                        ResultPath,
+                    ),
                 ):
                     set_xarray_multidim(bench_res.ds[rv.name], worker_job.index_tuple, result_value)
                 elif isinstance(rv, ResultReference):

holobench-1.19.0/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()

{holobench-1.17.1 → holobench-1.19.0}/bencher/example/example_image.py

@@ -131,7 +131,7 @@ if __name__ == "__main__":
     # ex_run_cfg.debug = True
     # ex_run_cfg.repeats = 2
     ex_run_cfg.level = 4
-    # example_image_vid(ex_run_cfg).report.show()
+    example_image_vid(ex_run_cfg).report.show()
     simple().report.show()
 
     # example_image_vid_sequential(ex_run_cfg).report.show()

{holobench-1.17.1 → holobench-1.19.0}/bencher/results/bench_result_base.py

@@ -416,6 +416,13 @@ class BenchResultBase(OptunaResult):
                 return ref.container(val, **kwargs)
         if container is not None:
             return container(val, styles={"background": "white"}, **kwargs)
+        try:
+            container = result_var.to_container()
+            if container is not None:
+                return container(val)
+        except AttributeError as _:
+            # TODO make sure all vars have to_container method
+            pass
         return val
 
     @staticmethod

{holobench-1.17.1 → holobench-1.19.0}/bencher/results/panel_result.py

@@ -27,8 +27,6 @@ class PanelResult(BenchResultBase):
         level: int = None,
         **kwargs
     ) -> Optional[pn.pane.panel]:
-        if container is None:
-            container = pn.pane.panel
         if hv_dataset is None:
             hv_dataset = self.to_hv_dataset(ReduceType.SQUEEZE, level=level)
         elif not isinstance(hv_dataset, hv.Dataset):

{holobench-1.17.1 → holobench-1.19.0}/bencher/utils.py

@@ -129,7 +129,7 @@ def color_tuple_to_css(color: tuple[float, float, float]) -> str:
     return f"rgb{(color[0] * 255, color[1] * 255, color[2] * 255)}"
 
 
-def gen_path(filename, folder, suffix):
+def gen_path(filename, folder="generic", suffix=".dat"):
     path = Path(f"cachedir/{folder}/{filename}/")
     path.mkdir(parents=True, exist_ok=True)
     return f"{path.absolute().as_posix()}/{filename}_{uuid4()}{suffix}"

{holobench-1.17.1 → holobench-1.19.0}/bencher/variables/inputs.py

@@ -46,7 +46,7 @@ class StringSweep(SweepSelector):
     def __init__(
         self,
         string_list: List[str],
-        units: str = "",
+        units: str = "ul",
         samples: int = None,
         **params,
     ):
@@ -65,7 +65,7 @@ class EnumSweep(SweepSelector):
 
     __slots__ = shared_slots
 
-    def __init__(self, enum_type: Enum | List[Enum], units=" ", samples=None, **params):
+    def __init__(self, enum_type: Enum | List[Enum], units="ul", samples=None, **params):
         # The enum can either be an Enum type or a list of enums
         list_of_enums = isinstance(enum_type, list)
         selector_list = enum_type if list_of_enums else list(enum_type)

{holobench-1.17.1 → holobench-1.19.0}/bencher/variables/parametrised_sweep.py

@@ -6,16 +6,7 @@ import panel as pn
 
 
 from bencher.utils import make_namedtuple, hash_sha1
-from bencher.variables.results import (
-    ResultVar,
-    ResultVec,
-    ResultHmap,
-    ResultVideo,
-    ResultImage,
-    ResultString,
-    ResultContainer,
-    ResultReference,
-)
+from bencher.variables.results import ALL_RESULT_TYPES, ResultHmap
 
 
 class ParametrizedSweep(Parameterized):
@@ -78,16 +69,7 @@ class ParametrizedSweep(Parameterized):
         for k, v in cls.param.objects().items():
             if isinstance(
                 v,
-                (
-                    ResultVar,
-                    ResultVec,
-                    ResultHmap,
-                    ResultVideo,
-                    ResultImage,
-                    ResultString,
-                    ResultContainer,
-                    ResultReference,
-                ),
+                ALL_RESULT_TYPES,
             ):
                 results[k] = v
             else:

{holobench-1.17.1 → holobench-1.19.0}/bencher/variables/results.py

@@ -1,6 +1,6 @@
 from enum import auto
 from typing import List, Callable, Any, Optional
-
+from functools import partial
 import panel as pn
 import param
 from param import Number
@@ -99,7 +99,7 @@ def curve(
     return hv.Curve(zip(x_vals, y_vals), kdims=[x_name], vdims=[y_name], label=label, **kwargs)
 
 
-class PathResult(param.Filename):
+class ResultPath(param.Filename):
     __slots__ = ["units"]
 
     def __init__(self, default=None, units="path", **params):
@@ -110,15 +110,33 @@ class PathResult(param.Filename):
         """A hash function that avoids the PYTHONHASHSEED 'feature' which returns a different hash value each time the program is run"""
         return hash_sha1(self)
 
+    def to_container(self):
+        """Returns a partial function for creating a FileDownload widget with embedding enabled.  This function is used to create a panel container to represent the ResultPath object"""
+        return partial(pn.widgets.FileDownload, embed=True)
 
-class ResultVideo(PathResult):
-    def __init__(self, default=None, units="video", **params):
-        super().__init__(default=default, units=units, **params)
 
+class ResultVideo(param.Filename):
+    __slots__ = ["units"]
 
-class ResultImage(PathResult):
-    def __init__(self, default=None, units="image", **params):
-        super().__init__(default=default, units=units, **params)
+    def __init__(self, default=None, units="path", **params):
+        super().__init__(default=default, check_exists=False, **params)
+        self.units = units
+
+    def hash_persistent(self) -> str:
+        """A hash function that avoids the PYTHONHASHSEED 'feature' which returns a different hash value each time the program is run"""
+        return hash_sha1(self)
+
+
+class ResultImage(param.Filename):
+    __slots__ = ["units"]
+
+    def __init__(self, default=None, units="path", **params):
+        super().__init__(default=default, check_exists=False, **params)
+        self.units = units
+
+    def hash_persistent(self) -> str:
+        """A hash function that avoids the PYTHONHASHSEED 'feature' which returns a different hash value each time the program is run"""
+        return hash_sha1(self)
 
 
 class ResultString(param.String):
@@ -181,4 +199,16 @@ class ResultVolume(param.Parameter):
         return hash_sha1(self)
 
 
-PANEL_TYPES = (ResultImage, ResultVideo, ResultContainer, ResultString, ResultReference)
+PANEL_TYPES = (ResultPath, ResultImage, ResultVideo, ResultContainer, ResultString, ResultReference)
+
+ALL_RESULT_TYPES = (
+    ResultVar,
+    ResultVec,
+    ResultHmap,
+    ResultPath,
+    ResultVideo,
+    ResultImage,
+    ResultString,
+    ResultContainer,
+    ResultReference,
+)

{holobench-1.17.1 → holobench-1.19.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "holobench"
-version = "1.17.1"
+version = "1.19.0"
 
 authors = [{ name = "Austin Gregg-Smith", email = "blooop@gmail.com" }]
 description = "A package for benchmarking the performance of arbitrary functions"