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

bencher/results/video_summary.py

@@ -0,0 +1,222 @@
+from typing import Optional, List
+from copy import deepcopy
+import panel as pn
+import xarray as xr
+from param import Parameter
+from bencher.results.bench_result_base import BenchResultBase, ReduceType
+from bencher.variables.results import ResultImage
+from bencher.plotting.plot_filter import VarRange, PlotFilter
+from bencher.utils import callable_name, int_to_col, color_tuple_to_255
+from bencher.video_writer import VideoWriter
+from bencher.results.video_result import VideoControls
+from bencher.results.composable_container.composable_container_video import (
+    ComposableContainerVideo,
+    ComposeType,
+    RenderCfg,
+)
+
+
+class VideoSummaryResult(BenchResultBase):
+    def to_video_summary(
+        self,
+        result_var: Parameter = None,
+        reverse: bool = True,
+        result_types=(ResultImage,),
+        **kwargs,
+    ) -> Optional[pn.panel]:
+        return self.to_video_grid(
+            result_var=result_var,
+            result_types=result_types,
+            time_sequence_dimension=-1,
+            reverse=reverse,
+            **kwargs,
+        )
+
+    def to_video_grid(
+        self,
+        result_var: Parameter = None,
+        result_types=(ResultImage,),
+        pane_collection: pn.pane = None,
+        time_sequence_dimension=0,
+        target_duration: float = None,
+        **kwargs,
+    ) -> Optional[pn.panel]:
+        """Returns the results compiled into a video
+
+        Args:
+            result_var (Parameter, optional): The result var to plot. Defaults to None.
+            result_types (tuple, optional): The types of result var to convert to video. Defaults to (ResultImage,).
+            collection (pn.pane, optional): If there are multiple results, use this collection to stack them. Defaults to pn.Row().
+
+        Returns:
+            Optional[pn.panel]: a panel pane with a video of all results concatenated together
+        """
+        plot_filter = PlotFilter(
+            float_range=VarRange(0, None),
+            cat_range=VarRange(0, None),
+            panel_range=VarRange(1, None),
+            input_range=VarRange(1, None),
+        )
+        matches_res = plot_filter.matches_result(
+            self.plt_cnt_cfg, callable_name(self.to_video_grid_ds)
+        )
+
+        if pane_collection is None:
+            pane_collection = pn.Row()
+
+        if matches_res.overall:
+            ds = self.to_dataset(ReduceType.SQUEEZE)
+            for rv in self.get_results_var_list(result_var):
+                if isinstance(rv, result_types):
+                    pane_collection.append(
+                        self.to_video_grid_ds(
+                            ds,
+                            rv,
+                            time_sequence_dimension=time_sequence_dimension,
+                            target_duration=target_duration,
+                            **kwargs,
+                        )
+                    )
+            return pane_collection
+        return matches_res.to_panel()
+
+    def to_video_grid_ds(
+        self,
+        dataset: xr.Dataset,
+        result_var: Parameter,
+        reverse=True,
+        time_sequence_dimension=0,
+        video_controls: VideoControls = None,
+        target_duration: float = None,
+        **kwargs,
+    ):
+        cvc = self._to_video_panes_ds(
+            dataset,
+            self.plot_cb,
+            target_dimension=0,
+            horizontal=True,
+            compose_method=ComposeType.right,
+            time_sequence_dimension=time_sequence_dimension,
+            result_var=result_var,
+            final=True,
+            reverse=reverse,
+            target_duration=target_duration,
+            **kwargs,
+        )
+
+        filename = VideoWriter().write_video_raw(cvc)
+
+        if filename is not None:
+            if video_controls is None:
+                video_controls = VideoControls()
+            return video_controls.video_container(
+                filename, width=kwargs.get("width", None), height=kwargs.get("height", None)
+            )
+        return None
+
+    def plot_cb(self, dataset, result_var, **kwargs):
+        val = self.ds_to_container(dataset, result_var, container=None, **kwargs)
+        return val
+
+    def dataset_to_compose_list(
+        self,
+        dataset: xr.Dataset,
+        first_compose_method: ComposeType = ComposeType.down,
+        time_sequence_dimension: int = 0,
+    ) -> List[ComposeType]:
+        """ "Given a dataset, chose an order for composing the results.  By default will flip between right and down and the last dimension will be a time sequence.
+
+        Args:
+            dataset (xr.Dataset): the dataset to render
+            first_compose_method (ComposeType, optional): the direction of the first composition method. Defaults to ComposeType.right.
+            time_sequence_dimension (int, optional): The dimension to start time sequencing instead of composing in space. Defaults to 0.
+
+        Returns:
+            List[ComposeType]: A list of composition methods for composing the dataset result
+        """
+
+        num_dims = len(dataset.sizes)
+        if time_sequence_dimension == -1:  # use time sequence for everything
+            compose_method_list = [ComposeType.sequence] * (num_dims + 1)
+        else:
+            compose_method_list = [first_compose_method]
+            compose_method_list.extend(
+                ComposeType.flip(compose_method_list[-1]) for _ in range(num_dims - 1)
+            )
+            compose_method_list.append(ComposeType.sequence)
+
+            for i in range(min(len(compose_method_list), time_sequence_dimension + 1)):
+                compose_method_list[i] = ComposeType.sequence
+
+        return compose_method_list
+
+    def _to_video_panes_ds(
+        self,
+        dataset: xr.Dataset,
+        plot_callback: callable = None,
+        target_dimension=0,
+        compose_method=ComposeType.right,
+        compose_method_list=None,
+        result_var=None,
+        time_sequence_dimension=0,
+        root_dimensions=None,
+        reverse=False,
+        target_duration: float = None,
+        **kwargs,
+    ) -> pn.panel:
+        num_dims = len(dataset.sizes)
+        dims = list(d for d in dataset.sizes)
+        if reverse:
+            dims = list(reversed(dims))
+
+        if root_dimensions is None:
+            root_dimensions = num_dims
+
+        if compose_method_list is None:
+            compose_method_list = self.dataset_to_compose_list(
+                dataset, compose_method, time_sequence_dimension=time_sequence_dimension
+            )
+
+            # print(compose_method_list)
+
+        compose_method_list_pop = deepcopy(compose_method_list)
+        if len(compose_method_list_pop) > 1:
+            compose_method = compose_method_list_pop.pop()
+
+        if num_dims > (target_dimension) and num_dims != 0:
+            selected_dim = dims[-1]
+            outer_container = ComposableContainerVideo()
+            for i in range(dataset.sizes[selected_dim]):
+                sliced = dataset.isel({selected_dim: i})
+                label_val = sliced.coords[selected_dim].values.item()
+                inner_container = ComposableContainerVideo()
+
+                panes = self._to_video_panes_ds(
+                    sliced,
+                    plot_callback=plot_callback,
+                    target_dimension=target_dimension,
+                    compose_method_list=compose_method_list_pop,
+                    result_var=result_var,
+                    root_dimensions=root_dimensions,
+                    time_sequence_dimension=time_sequence_dimension,
+                )
+                inner_container.append(panes)
+
+                rendered = inner_container.render(
+                    RenderCfg(
+                        var_name=selected_dim,
+                        var_value=label_val,
+                        compose_method=compose_method,
+                        duration=target_duration,
+                    )
+                )
+                outer_container.append(rendered)
+            return outer_container.render(
+                RenderCfg(
+                    compose_method=compose_method,
+                    duration=target_duration,
+                    background_col=color_tuple_to_255(int_to_col(num_dims - 2, 0.05, 1.0)),
+                    # background_col= (255,0,0),
+                )
+            )
+        return plot_callback(dataset=dataset, result_var=result_var, **kwargs)

bencher/variables/inputs.py

@@ -0,0 +1,202 @@
+from enum import Enum
+from typing import List, Any, Dict
+
+import numpy as np
+from param import Integer, Number, Selector
+from bencher.variables.sweep_base import SweepBase, shared_slots
+
+
+class SweepSelector(Selector, SweepBase):
+    """A class to reprsent a parameter sweep of bools"""
+
+    __slots__ = shared_slots
+
+    def __init__(self, units: str = "ul", samples: int = None, **params):
+        SweepBase.__init__(self)
+        Selector.__init__(self, **params)
+
+        self.units = units
+        if samples is None:
+            self.samples = len(self.objects)
+        else:
+            self.samples = samples
+
+    def values(self) -> List[Any]:
+        """return all the values for a parameter sweep.  If debug is true return a reduced list"""
+        return self.indices_to_samples(self.samples, self.objects)
+
+
+class BoolSweep(SweepSelector):
+    """A class to reprsent a parameter sweep of bools"""
+
+    def __init__(self, units: str = "ul", samples: int = None, default=True, **params):
+        SweepSelector.__init__(
+            self,
+            units=units,
+            samples=samples,
+            default=default,
+            objects=[True, False] if default else [False, True],
+            **params,
+        )
+
+
+class StringSweep(SweepSelector):
+    """A class to reprsent a parameter sweep of strings"""
+
+    def __init__(
+        self,
+        string_list: List[str],
+        units: str = "ul",
+        samples: int = None,
+        **params,
+    ):
+        SweepSelector.__init__(
+            self,
+            objects=string_list,
+            instantiate=True,
+            units=units,
+            samples=samples,
+            **params,
+        )
+
+
+class EnumSweep(SweepSelector):
+    """A class to reprsent a parameter sweep of enums"""
+
+    __slots__ = shared_slots
+
+    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)
+        SweepSelector.__init__(
+            self,
+            objects=selector_list,
+            instantiate=True,
+            units=units,
+            samples=samples,
+            **params,
+        )
+        if not list_of_enums:  # Grab the docs from the enum type def
+            self.doc = enum_type.__doc__
+
+
+class IntSweep(Integer, SweepBase):
+    """A class to reprsent a parameter sweep of ints"""
+
+    __slots__ = shared_slots + ["sample_values"]
+
+    def __init__(self, units="ul", samples=None, sample_values=None, **params):
+        SweepBase.__init__(self)
+        Integer.__init__(self, **params)
+
+        self.units = units
+
+        if sample_values is None:
+            if samples is None:
+                if self.bounds is None:
+                    raise RuntimeError("You must define bounds for integer types")
+                self.samples = 1 + self.bounds[1] - self.bounds[0]
+            else:
+                self.samples = samples
+            self.sample_values = None
+        else:
+            self.sample_values = sample_values
+            self.samples = len(self.sample_values)
+            if "default" not in params:
+                self.default = sample_values[0]
+
+    def values(self) -> List[int]:
+        """return all the values for a parameter sweep.  If debug is true return the  list"""
+        sample_values = (
+            self.sample_values
+            if self.sample_values is not None
+            else list(range(int(self.bounds[0]), int(self.bounds[1] + 1)))
+        )
+
+        return self.indices_to_samples(self.samples, sample_values)
+
+    ###THESE ARE COPIES OF INTEGER VALIDATION BUT ALSO ALLOW NUMPY INT TYPES
+    def _validate_value(self, val, allow_None):
+        if callable(val):
+            return
+
+        if allow_None and val is None:
+            return
+
+        if not isinstance(val, (int, np.integer)):
+            raise ValueError(
+                "Integer parameter %r must be an integer, " "not type %r." % (self.name, type(val))
+            )
+
+    ###THESE ARE COPIES OF INTEGER VALIDATION BUT ALSO ALLOW NUMPY INT TYPES
+    def _validate_step(self, val, step):
+        if step is not None and not isinstance(step, (int, np.integer)):
+            raise ValueError(
+                "Step can only be None or an " "integer value, not type %r" % type(step)
+            )
+
+
+class FloatSweep(Number, SweepBase):
+    """A class to represent a parameter sweep of floats"""
+
+    __slots__ = shared_slots + ["sample_values"]
+
+    def __init__(self, units="ul", samples=10, sample_values=None, step=None, **params):
+        SweepBase.__init__(self)
+        Number.__init__(self, step=step, **params)
+
+        self.units = units
+
+        self.sample_values = sample_values
+
+        if sample_values is None:
+            self.samples = samples
+        else:
+            self.samples = len(self.sample_values)
+            if "default" not in params:
+                self.default = sample_values[0]
+
+    def values(self) -> List[float]:
+        """return all the values for a parameter sweep.  If debug is true return a reduced list"""
+        samps = self.samples
+        if self.sample_values is None:
+            if self.step is None:
+                return np.linspace(self.bounds[0], self.bounds[1], samps)
+
+            return np.arange(self.bounds[0], self.bounds[1], self.step)
+        return self.sample_values
+
+
+def box(name, center, width):
+    var = FloatSweep(default=center, bounds=(center - width, center + width))
+    var.name = name
+    return var
+
+
+def p(
+    name: str, values: List[Any] = None, samples: int = None, max_level: int = None
+) -> Dict[str, Any]:
+    """
+    Create a parameter dictionary with optional values, samples, and max_level.
+
+    Args:
+        name (str): The name of the parameter.
+        values (List[Any], optional): A list of values for the parameter. Defaults to None.
+        samples (int, optional): The number of samples. Must be greater than 0 if provided. Defaults to None.
+        max_level (int, optional): The maximum level. Must be greater than 0 if provided. Defaults to None.
+
+    Returns:
+        Dict[str, Any]: A dictionary containing the parameter details.
+    """
+    if max_level is not None and max_level <= 0:
+        raise ValueError("max_level must be greater than 0")
+
+    if samples is not None and samples <= 0:
+        raise ValueError("samples must be greater than 0")
+    return {"name": name, "values": values, "max_level": max_level, "samples": samples}
+
+
+def with_level(arr: list, level) -> list:
+    return IntSweep(sample_values=arr).with_level(level).values()
+    # return tmp.with_sample_values(arr).with_level(level).values()

bencher/variables/parametrised_sweep.py

@@ -0,0 +1,208 @@
+from functools import partial
+from typing import List, Tuple, Any
+from param import Parameter, Parameterized
+import holoviews as hv
+import panel as pn
+
+
+from bencher.utils import make_namedtuple, hash_sha1
+from bencher.variables.results import ALL_RESULT_TYPES, ResultHmap
+
+
+class ParametrizedSweep(Parameterized):
+    """Parent class for all Sweep types that need a custom hash"""
+
+    @staticmethod
+    def param_hash(param_type: Parameterized, hash_value: bool = True) -> int:
+        """A custom hash function for parametrised types with options for hashing the value of the type and hashing metadata
+
+        Args:
+            param_type (Parameterized): A parameter
+            hash_value (bool, optional): use the value as part of the hash. Defaults to True.
+            # hash_meta (bool, optional): use metadata as part of the hash. Defaults to False.
+
+        Returns:
+            int: a hash
+        """
+
+        curhash = 0
+        if hash_value:
+            for k, v in param_type.param.values().items():
+                if k != "name":
+                    curhash = hash_sha1((curhash, hash_sha1(v)))
+
+        # if hash_meta:
+        #     for k, v in param_type.param.objects().items():
+        #         if k != "name":
+        #             print(f"key:{k}, hash:{hash_sha1(k)}")
+        #             print(f"value:{v}, hash:{hash_sha1(v)}")
+        #             curhash = hash_sha1((curhash, hash_sha1(k), hash_sha1(v)))
+        return curhash
+
+    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 ParametrizedSweep.param_hash(self, True)
+
+    def update_params_from_kwargs(self, **kwargs) -> None:
+        """Given a dictionary of kwargs, set the parameters of the passed class 'self' to the values in the dictionary."""
+        used_params = {}
+        for key in self.param.objects().keys():
+            if key in kwargs:
+                if key != "name":
+                    used_params[key] = kwargs[key]
+
+        self.param.update(**used_params)
+
+    @classmethod
+    def get_input_and_results(cls, include_name: bool = False) -> Tuple[dict, dict]:
+        """Get dictionaries of input parameters and result parameters
+
+        Args:
+            cls: A parametrised class
+            include_name (bool): Include the name parameter that all parametrised classes have. Default False
+
+        Returns:
+            Tuple[dict, dict]: a tuple containing the inputs and result parameters as dictionaries
+        """
+        inputs = {}
+        results = {}
+        for k, v in cls.param.objects().items():
+            if isinstance(
+                v,
+                ALL_RESULT_TYPES,
+            ):
+                results[k] = v
+            else:
+                inputs[k] = v
+
+        if not include_name:
+            inputs.pop("name")
+        return make_namedtuple("inputresult", inputs=inputs, results=results)
+
+    def get_inputs_as_dict(self) -> dict:
+        """Get the key:value pairs for all the input variables"""
+        inp = self.get_input_and_results().inputs
+        vals = self.param.values()
+        return {i: vals[i] for i, v in inp.items()}
+
+    def get_results_values_as_dict(self, holomap=None) -> dict:
+        """Get a dictionary of result variables with the name and the current value"""
+        values = self.param.values()
+        output = {key: values[key] for key in self.get_input_and_results().results}
+        if holomap is not None:
+            output |= {"hmap": holomap}
+        return output
+
+    @classmethod
+    def get_inputs_only(cls) -> List[Parameter]:
+        """Return a list of input parameters
+
+        Returns:
+            List[param.Parameter]: A list of input parameters
+        """
+        return list(cls.get_input_and_results().inputs.values())
+
+    @staticmethod
+    def filter_fn(item, p_name):
+        return item.name != p_name
+
+    @classmethod
+    def get_input_defaults(
+        cls,
+        override_defaults: List = None,
+    ) -> List[Tuple[Parameter, Any]]:
+        inp = cls.get_inputs_only()
+        if override_defaults is None:
+            override_defaults = []
+        assert isinstance(override_defaults, list)
+
+        for p in override_defaults:
+            inp = filter(partial(ParametrizedSweep.filter_fn, p_name=p[0].name), inp)
+
+        return override_defaults + [[i, i.default] for i in inp]
+
+    @classmethod
+    def get_input_defaults_override(cls, **kwargs) -> dict[str, Any]:
+        inp = cls.get_inputs_only()
+        defaults = {}
+        for i in inp:
+            defaults[i.name] = i.default
+
+        for k, v in kwargs.items():
+            defaults[k] = v
+
+        return defaults
+
+    @classmethod
+    def get_results_only(cls) -> List[Parameter]:
+        """Return a list of result parameters
+
+        Returns:
+            List[param.Parameter]: A list of result parameters
+        """
+        return list(cls.get_input_and_results().results.values())
+
+    @classmethod
+    def get_inputs_as_dims(
+        self, compute_values=False, remove_dims: str | List[str] = None
+    ) -> List[hv.Dimension]:
+        inputs = self.get_inputs_only()
+
+        if remove_dims is not None:
+            if isinstance(remove_dims, str):
+                remove_dims = [remove_dims]
+            filtered_inputs = [i for i in inputs if i.name not in remove_dims]
+            inputs = filtered_inputs
+
+        return [iv.as_dim(compute_values) for iv in inputs]
+
+    def to_dynamic_map(
+        self, callback=None, name=None, remove_dims: str | List[str] = None, result_var: str = None
+    ) -> hv.DynamicMap:
+        if callback is None:
+            callback = self.__call__
+
+        if result_var is None:
+            result_vars = self.get_input_and_results().results
+            for k, rv in result_vars.items():
+                if isinstance(rv, ResultHmap):
+                    result_var = k
+
+        def callback_wrapper(**kwargs):
+            return callback(**kwargs)[result_var]
+
+        return hv.DynamicMap(
+            callback=callback_wrapper,
+            kdims=self.get_inputs_as_dims(compute_values=False, remove_dims=remove_dims),
+            name=name,
+        ).opts(shared_axes=False, framewise=True, width=1000, height=1000)
+
+    def to_gui(self, result_var: str = None, **kwargs):  # pragma: no cover
+        main = pn.Row(
+            self.to_dynamic_map(result_var=result_var, **kwargs),
+        )
+        main.show()
+
+    def to_holomap(self, callback, remove_dims: str | List[str] = None) -> hv.DynamicMap:
+        return hv.HoloMap(
+            hv.DynamicMap(
+                callback=callback,
+                kdims=self.get_inputs_as_dims(compute_values=True, remove_dims=remove_dims),
+            )
+        )
+
+    def __call__(self, **kwargs):
+        return self.get_results_values_as_dict()
+
+    def plot_hmap(self, **kwargs):
+        return self.__call__(**kwargs)["hmap"]
+
+    def to_bench(self, run_cfg=None, report=None, name: str = None):
+        from bencher import Bench
+
+        assert isinstance(self, ParametrizedSweep)
+
+        if name is None:
+            name = self.name[:-5]  # param adds 5 digit number to the end, so remove it
+
+        return Bench(name, self, run_cfg=run_cfg, report=report)