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

bencher/__init__.py

@@ -6,7 +6,7 @@ from .variables.sweep_base import hash_sha1
 from .variables.inputs import IntSweep, FloatSweep, StringSweep, EnumSweep, BoolSweep, SweepBase
 from .variables.time import TimeSnapshot
 
-from .variables.inputs import box
+from .variables.inputs import box, p
 from .variables.results import (
     ResultVar,
     ResultVec,
@@ -19,9 +19,19 @@ from .variables.results import (
     ResultReference,
     ResultVolume,
     OptDir,
+    ResultDataSet,
     curve,
 )
 
+from .results.composable_container.composable_container_base import (
+    ComposeType,
+    ComposableContainerBase,
+)
+from .results.composable_container.composable_container_video import (
+    ComposableContainerVideo,
+    RenderCfg,
+)
+
 from .plotting.plot_filter import VarRange, PlotFilter
 from .utils import (
     hmap_canonical_input,
@@ -31,6 +41,7 @@ from .utils import (
     gen_image_path,
     gen_video_path,
     lerp,
+    tabs_in_markdown,
 )
 from .variables.parametrised_sweep import ParametrizedSweep
 from .caching import CachedParams

bencher/bench_report.py

@@ -157,112 +157,9 @@ class BenchReport(BenchPlotServer):
 
         return publish_url
 
-
-# def append(self,pane):
-# self.report.append(pane)
-
-# def __getstate__(self):
-#     state = self.__dict__.copy()
-#     # Don't pickle baz
-#     del state["pane"]
-#     return state
-
-# def __setstate__(self, state):
-#     self.__dict__.update(state)
-#     # Add baz back since it doesn't exist in the pickle
-#     self.report = []
-
-# def publish_old(
-#     self,
-#     directory: str = "bench_results",
-#     branch_name: str = "bench_results",
-#     url_postprocess: Callable = None,
-#     **kwargs,
-# ) -> str:
-#     """Publish the results as an html file by committing it to the bench_results branch in the current repo. If you have set up your repo with github pages or equivalent then the html file will be served as a viewable webpage.
-
-#     Args:
-#         directory (str, optional): Directory to save the results. Defaults to "bench_results".
-#         branch_name (str, optional): Branch to publish on. Defaults to "bench_results".
-#         url_postprocess (Callable, optional): A function that maps the origin url to a github pages url. Pass your own function if you are using another git providers. Defaults to None.
-
-#     Returns:
-#         str: _description_
-#     """
-
-#     def get_output(cmd: str) -> str:
-#         return (
-#             subprocess.run(cmd.split(" "), stdout=subprocess.PIPE, check=False)
-#             .stdout.decode("utf=8")
-#             .strip()
-#         )
-
-#     def postprocess_url(publish_url: str, branch_name: str, report_path: str, **kwargs) -> str:
-#         # import re
-
-#         # return re.sub(
-#         #     """((git|ssh|http(s)?)|(git@[\w\.-]+))(:(//)?)([\w\.@\:/\-~]+)(\.git)(/)?""",
-#         #     """https://$7/""",
-#         #     publish_url,
-#         # )
-#         # git@github.com:user/project.git
-#         # https://github.com/user/project.git
-#         # http://github.com/user/project.git
-#         # git@192.168.101.127:user/project.git
-#         # https://192.168.101.127/user/project.git
-#         # http://192.168.101.127/user/project.git
-#         # ssh://user@host.xz:port/path/to/repo.git/
-#         # ssh://user@host.xz/path/to/repo.git/
-#         # ssh://host.xz:port/path/to/repo.git/
-#         # ssh://host.xz/path/to/repo.git/
-#         # ssh://user@host.xz/path/to/repo.git/
-#         # ssh://host.xz/path/to/repo.git/
-#         # ssh://user@host.xz/~user/path/to/repo.git/
-#         # ssh://host.xz/~user/path/to/repo.git/
-#         # ssh://user@host.xz/~/path/to/repo.git
-#         # ssh://host.xz/~/path/to/repo.git
-#         # git://host.xz/path/to/repo.git/
-#         # git://host.xz/~user/path/to/repo.git/
-#         # http://host.xz/path/to/repo.git/
-#         # https://host.xz/path/to/repo.git/
-#         # https://regex101.com/r/qT7NP0/3
-
-#         return publish_url.replace(".git", f"/blob/{directory}/{report_path}")
-
-#     if url_postprocess is None:
-#         url_postprocess = postprocess_url
-#     current_branch = get_output("git symbolic-ref --short HEAD")
-#     logging.info(f"on branch: {current_branch}")
-#     stash_msg = get_output("git stash")
-#     logging.info(f"stashing current work :{stash_msg}")
-#     checkout_msg = get_output(f"git checkout -b {branch_name}")
-#     checkout_msg = get_output(f"git checkout {branch_name}")
-#     get_output("git pull")
-
-#     logging.info(f"checking out branch: {checkout_msg}")
-#     report_path = self.save(directory, in_html_folder=False)
-#     logging.info(f"created report at: {report_path.absolute()}")
-#     # commit_msg = f""
-#     logging.info("adding report to git")
-#     get_output(f"git add {report_path.absolute()}")
-#     get_output("git status")
-#     logging.info("committing report")
-#     cmd = f'git commit -m "generate_report:{self.bench_name}"'
-#     logging.info(cmd)
-#     get_output(cmd)
-#     logging.info("pushing report to origin")
-#     get_output(f"git push --set-upstream origin {branch_name}")
-#     logging.info("checking out original branch")
-#     get_output(f"git checkout {current_branch}")
-#     if "No local changes" not in stash_msg:
-#         logging.info("restoring work with git stash pop")
-#         get_output("git stash pop")
-
-#     publish_url = get_output("git remote get-url --push origin")
-#     logging.info(f"raw url:{publish_url}")
-#     publish_url = url_postprocess(
-#         publish_url, branch_name=branch_name, report_path=report_path, **kwargs
-#     )
-#     logging.info("Published report @")
-#     logging.info(publish_url)
-#     return publish_url
+    # @staticmethod
+    # def publish_github(github_user: str, repo_name: str, branch_name: str) -> Tuple[str, str]:
+    #     return (
+    #         f"https://github.com/{github_user}/{repo_name}.git",
+    #         f"https://github.com/{github_user}/{repo_name}/blob/{branch_name}",
+    #     )

bencher/bench_runner.py

@@ -121,7 +121,7 @@ class BenchRunner:
                     self.show_publish(report_level, show, publish, save, debug)
         return self.results
 
-    def show_publish(self, report, show, publish, save, debug):
+    def show_publish(self, report: BenchReport, show: bool, publish: bool, save: bool, debug: bool):
         if save:
             report.save_index()
         if publish and self.publisher is not None:

bencher/bencher.py

@@ -2,7 +2,7 @@ import logging
 from datetime import datetime
 from itertools import product, combinations
 
-from typing import Callable, List
+from typing import Callable, List, Optional
 from copy import deepcopy
 import numpy as np
 import param
@@ -30,6 +30,7 @@ from bencher.variables.results import (
     ResultString,
     ResultContainer,
     ResultReference,
+    ResultDataSet,
 )
 from bencher.results.bench_result import BenchResult
 from bencher.variables.parametrised_sweep import ParametrizedSweep
@@ -220,9 +221,11 @@ class Bench(BenchPlotServer):
         relationship_cb=None,
         plot_callbacks: List | bool = None,
     ) -> List[BenchResult]:
-        results = []
         if relationship_cb is None:
             relationship_cb = combinations
+        if input_vars is None:
+            input_vars = self.worker_class_instance.get_inputs_only()
+        results = []
         for it in range(iterations):
             for input_group in relationship_cb(input_vars, group_size):
                 title_gen = title + "Sweeping " + " vs ".join(params_to_str(input_group))
@@ -278,57 +281,42 @@ class Bench(BenchPlotServer):
             BenchResult: A class with all the data used to generate the results and the results
         """
 
+        input_vars_in = deepcopy(input_vars)
+        result_vars_in = deepcopy(result_vars)
+        const_vars_in = deepcopy(const_vars)
+
         if self.worker_class_instance is not None:
-            if input_vars is None:
+            if input_vars_in is None:
                 logging.info(
                     "No input variables passed, using all param variables in bench class as inputs"
                 )
                 if self.input_vars is None:
-                    input_vars = self.worker_class_instance.get_inputs_only()
+                    input_vars_in = self.worker_class_instance.get_inputs_only()
                 else:
-                    input_vars = self.input_vars
-                for i in input_vars:
+                    input_vars_in = deepcopy(self.input_vars)
+                for i in input_vars_in:
                     logging.info(f"input var: {i.name}")
-            if result_vars is None:
+            if result_vars_in is None:
                 logging.info(
                     "No results variables passed, using all result variables in bench class:"
                 )
                 if self.result_vars is None:
-                    result_vars = self.worker_class_instance.get_results_only()
+                    result_vars_in = self.worker_class_instance.get_results_only()
                 else:
-                    result_vars = self.result_vars
+                    result_vars_in = deepcopy(self.result_vars)
 
-            if const_vars is None:
+            if const_vars_in is None:
                 if self.const_vars is None:
-                    const_vars = self.worker_class_instance.get_input_defaults()
+                    const_vars_in = self.worker_class_instance.get_input_defaults()
                 else:
-                    const_vars = self.const_vars
+                    const_vars_in = deepcopy(self.const_vars)
         else:
-            if input_vars is None:
-                input_vars = []
-            if result_vars is None:
-                result_vars = []
-            if const_vars is None:
-                const_vars = []
-            else:
-                const_vars = deepcopy(const_vars)
-
-        for i in range(len(input_vars)):
-            input_vars[i] = self.convert_vars_to_params(input_vars[i], "input")
-        for i in range(len(result_vars)):
-            result_vars[i] = self.convert_vars_to_params(result_vars[i], "result")
-
-        for r in result_vars:
-            logging.info(f"result var: {r.name}")
-
-        if isinstance(const_vars, dict):
-            const_vars = list(const_vars.items())
-
-        for i in range(len(const_vars)):
-            # consts come as tuple pairs
-            cv_list = list(const_vars[i])
-            cv_list[0] = self.convert_vars_to_params(cv_list[0], "const")
-            const_vars[i] = cv_list
+            if input_vars_in is None:
+                input_vars_in = []
+            if result_vars_in is None:
+                result_vars_in = []
+            if const_vars_in is None:
+                const_vars_in = []
 
         if run_cfg is None:
             if self.run_cfg is None:
@@ -343,37 +331,68 @@ class Bench(BenchPlotServer):
 
         self.last_run_cfg = run_cfg
 
+        if isinstance(input_vars_in, dict):
+            input_lists = []
+            for k, v in input_vars_in.items():
+                param_var = self.convert_vars_to_params(k, "input", run_cfg)
+                if isinstance(v, list):
+                    assert len(v) > 0
+                    param_var = param_var.with_sample_values(v)
+
+                else:
+                    raise RuntimeError("Unsupported type")
+                input_lists.append(param_var)
+
+            input_vars_in = input_lists
+        else:
+            for i in range(len(input_vars_in)):
+                input_vars_in[i] = self.convert_vars_to_params(input_vars_in[i], "input", run_cfg)
+        for i in range(len(result_vars_in)):
+            result_vars_in[i] = self.convert_vars_to_params(result_vars_in[i], "result", run_cfg)
+
+        for r in result_vars_in:
+            logging.info(f"result var: {r.name}")
+
+        if isinstance(const_vars_in, dict):
+            const_vars_in = list(const_vars_in.items())
+
+        for i in range(len(const_vars_in)):
+            # consts come as tuple pairs
+            cv_list = list(const_vars_in[i])
+            cv_list[0] = self.convert_vars_to_params(cv_list[0], "const", run_cfg)
+            const_vars_in[i] = cv_list
+
         if title is None:
-            if len(input_vars) > 0:
-                title = "Sweeping " + " vs ".join([i.name for i in input_vars])
-            elif len(const_vars) > 0:
+            if len(input_vars_in) > 0:
+                title = "Sweeping " + " vs ".join([i.name for i in input_vars_in])
+            elif len(const_vars_in) > 0:
                 title = "Constant Value"
-                if len(const_vars) > 1:
+                if len(const_vars_in) > 1:
                     title += "s"
-                title += ": " + ", ".join([f"{c[0].name}={c[1]}" for c in const_vars])
+                title += ": " + ", ".join([f"{c[0].name}={c[1]}" for c in const_vars_in])
             else:
                 raise RuntimeError("you must pass a title, or define inputs or consts")
 
         if run_cfg.level > 0:
             inputs = []
-            print(input_vars)
-            if len(input_vars) > 0:
-                for i in input_vars:
+            print(input_vars_in)
+            if len(input_vars_in) > 0:
+                for i in input_vars_in:
                     inputs.append(i.with_level(run_cfg.level))
-                input_vars = inputs
+                input_vars_in = inputs
 
         # if any of the inputs have been include as constants, remove those variables from the list of constants
         with suppress(ValueError, AttributeError):
-            for i in input_vars:
-                for c in const_vars:
+            for i in input_vars_in:
+                for c in const_vars_in:
                     # print(i.hash_persistent())
                     if i.name == c[0].name:
-                        const_vars.remove(c)
+                        const_vars_in.remove(c)
                         logging.info(f"removing {i.name} from constants")
 
         result_hmaps = []
         result_vars_only = []
-        for i in result_vars:
+        for i in result_vars_in:
             if isinstance(i, ResultHmap):
                 result_hmaps.append(i)
             else:
@@ -393,10 +412,10 @@ class Bench(BenchPlotServer):
             plot_callbacks = [BenchResult.to_auto_plots] if plot_callbacks else []
 
         bench_cfg = BenchCfg(
-            input_vars=input_vars,
+            input_vars=input_vars_in,
             result_vars=result_vars_only,
             result_hmaps=result_hmaps,
-            const_vars=const_vars,
+            const_vars=const_vars_in,
             bench_name=self.bench_name,
             description=description,
             post_description=post_description,
@@ -470,7 +489,12 @@ class Bench(BenchPlotServer):
         self.results.append(bench_res)
         return bench_res
 
-    def convert_vars_to_params(self, variable: param.Parameter, var_type: str):
+    def convert_vars_to_params(
+        self,
+        variable: param.Parameter | str | dict | tuple,
+        var_type: str,
+        run_cfg: Optional[BenchRunCfg],
+    ) -> param.Parameter:
         """check that a variable is a subclass of param
 
         Args:
@@ -482,6 +506,17 @@ class Bench(BenchPlotServer):
         """
         if isinstance(variable, str):
             variable = self.worker_class_instance.param.objects(instance=False)[variable]
+        if isinstance(variable, dict):
+            param_var = self.worker_class_instance.param.objects(instance=False)[variable["name"]]
+            if variable.get("values"):
+                param_var = param_var.with_sample_values(variable["values"])
+
+            if variable.get("samples"):
+                param_var = param_var.with_samples(variable["samples"])
+            if variable.get("max_level"):
+                if run_cfg is not None:
+                    param_var = param_var.with_level(run_cfg.level, variable["max_level"])
+            variable = param_var
         if not isinstance(variable, param.Parameter):
             raise TypeError(
                 f"You need to use {var_type}_vars =[{self.worker_input_cfg}.param.your_variable], instead of {var_type}_vars =[{self.worker_input_cfg}.your_variable]"
@@ -578,12 +613,13 @@ class Bench(BenchPlotServer):
         )
         # xarray stores K N-dimensional arrays of data.  Each array is named and in this case we have a nd array for each result variable
         data_vars = {}
+        dataset_list = []
 
         for rv in bench_cfg.result_vars:
             if isinstance(rv, ResultVar):
                 result_data = np.full(dims_cfg.dims_size, np.nan, dtype=float)
                 data_vars[rv.name] = (dims_cfg.dims_name, result_data)
-            if isinstance(rv, ResultReference):
+            if isinstance(rv, (ResultReference, ResultDataSet)):
                 result_data = np.full(dims_cfg.dims_size, -1, dtype=int)
                 data_vars[rv.name] = (dims_cfg.dims_name, result_data)
             if isinstance(
@@ -591,7 +627,8 @@ class Bench(BenchPlotServer):
             ):
                 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:
+
+            elif type(rv) is ResultVec:
                 for i in range(rv.size):
                     result_data = np.full(dims_cfg.dims_size, np.nan)
                     data_vars[rv.index_name(i)] = (dims_cfg.dims_name, result_data)
@@ -599,6 +636,7 @@ class Bench(BenchPlotServer):
         bench_res = BenchResult(bench_cfg)
         bench_res.ds = xr.Dataset(data_vars=data_vars, coords=dims_cfg.coords)
         bench_res.ds_dynamic = self.ds_dynamic
+        bench_res.dataset_list = dataset_list
         bench_res.setup_object_index()
 
         return bench_res, function_inputs, dims_cfg.dims_name
@@ -736,6 +774,13 @@ class Bench(BenchPlotServer):
                     ),
                 ):
                     set_xarray_multidim(bench_res.ds[rv.name], worker_job.index_tuple, result_value)
+                elif isinstance(rv, ResultDataSet):
+                    bench_res.dataset_list.append(result_value)
+                    set_xarray_multidim(
+                        bench_res.ds[rv.name],
+                        worker_job.index_tuple,
+                        len(bench_res.dataset_list) - 1,
+                    )
                 elif isinstance(rv, ResultReference):
                     bench_res.object_index.append(result_value)
                     set_xarray_multidim(
@@ -743,6 +788,7 @@ class Bench(BenchPlotServer):
                         worker_job.index_tuple,
                         len(bench_res.object_index) - 1,
                     )
+
                 elif isinstance(rv, ResultVec):
                     if isinstance(result_value, (list, np.ndarray)):
                         if len(result_value) == rv.size:
@@ -788,10 +834,10 @@ class Bench(BenchPlotServer):
         """
 
         for rv in bench_res.bench_cfg.result_vars:
-            if type(rv) == ResultVar:
+            if type(rv) is ResultVar:
                 bench_res.ds[rv.name].attrs["units"] = rv.units
                 bench_res.ds[rv.name].attrs["long_name"] = rv.name
-            elif type(rv) == ResultVec:
+            elif type(rv) is ResultVec:
                 for i in range(rv.size):
                     bench_res.ds[rv.index_name(i)].attrs["units"] = rv.units
                     bench_res.ds[rv.index_name(i)].attrs["long_name"] = rv.name

bencher/example/benchmark_data.py

@@ -6,13 +6,9 @@ You can define a subclass which contains an input configuration which can be pas
 import math
 import random
 from enum import auto
-
 from strenum import StrEnum
-
-
 from bencher.variables.inputs import IntSweep, FloatSweep, StringSweep, EnumSweep, BoolSweep
 from bencher.variables.results import ResultVar, OptDir
-
 from bencher.variables.parametrised_sweep import ParametrizedSweep
 
 

bencher/example/example_composable_container.py

@@ -0,0 +1,106 @@
+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.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()