holobench 1.3.5__py3-none-any.whl → 1.22.2__py3-none-any.whl

bencher/variables/inputs.py

@@ -1,193 +0,0 @@
-from enum import Enum
-from typing import List, Any
-
-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, samples_debug: int = 2, **params):
-        SweepBase.__init__(self)
-        Selector.__init__(self, **params)
-
-        self.units = units
-        if samples is None:
-            self.samples = len(self.objects)
-        else:
-            self.samples = samples
-        self.samples_debug = min(self.samples, samples_debug)
-
-    def values(self, debug=False) -> 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_debug if debug else 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, samples_debug: int = 2, default=True, **params
-    ):
-        SweepSelector.__init__(
-            self,
-            units=units,
-            samples=samples,
-            samples_debug=samples_debug,
-            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 = "",
-        samples: int = None,
-        samples_debug: int = 2,
-        **params,
-    ):
-        SweepSelector.__init__(
-            self,
-            objects=string_list,
-            instantiate=True,
-            units=units,
-            samples=samples,
-            samples_debug=samples_debug,
-            **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=" ", samples=None, samples_debug=2, **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,
-            samples_debug=samples_debug,
-            **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, samples_debug=2, sample_values=None, **params):
-        SweepBase.__init__(self)
-        Integer.__init__(self, **params)
-
-        self.units = units
-        self.samples_debug = samples_debug
-
-        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, debug=False) -> 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_debug if debug else 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, samples_debug=2, sample_values=None, step=None, **params
-    ):
-        SweepBase.__init__(self)
-        Number.__init__(self, step=step, **params)
-
-        self.units = units
-        self.samples_debug = samples_debug
-
-        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, debug=False) -> List[float]:
-        """return all the values for a parameter sweep.  If debug is true return a reduced list"""
-        samps = self.samples_debug if debug else 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)
-        if debug:
-            indices = [
-                int(i)
-                for i in np.linspace(0, len(self.sample_values) - 1, self.samples_debug, dtype=int)
-            ]
-            return [self.sample_values[i] for i in indices]
-        return self.sample_values
-
-
-def box(name, center, width):
-    var = FloatSweep(default=center, bounds=(center - width, center + width))
-    var.name = name
-    return var

bencher/variables/parametrised_sweep.py

@@ -1,206 +0,0 @@
-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 (
-    ResultVar,
-    ResultVec,
-    ResultHmap,
-    ResultVideo,
-    ResultImage,
-    ResultString,
-    ResultContainer,
-    ResultReference,
-)
-
-
-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,
-                (
-                    ResultVar,
-                    ResultVec,
-                    ResultHmap,
-                    ResultVideo,
-                    ResultImage,
-                    ResultString,
-                    ResultContainer,
-                    ResultReference,
-                ),
-            ):
-                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=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_results_only(cls) -> List[Parameter]:
-        """Return a list of input 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,
-    ) -> hv.DynamicMap:
-        if callback is None:
-            callback = self.__call__
-
-        def callback_wrapper(**kwargs):
-            return callback(**kwargs)["hmap"]
-
-        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):  # pragma: no cover
-        main = pn.Row(
-            self.to_dynamic_map(),
-        )
-        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):
-        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)

bencher/variables/results.py

@@ -1,176 +0,0 @@
-from enum import auto
-from typing import List, Callable, Any
-
-import panel as pn
-import param
-from param import Number
-from strenum import StrEnum
-import holoviews as hv
-from bencher.utils import hash_sha1
-
-# from bencher.variables.parametrised_sweep import ParametrizedSweep
-
-
-class OptDir(StrEnum):
-    minimize = auto()
-    maximize = auto()
-    none = auto()  # If none this var will not appear in pareto plots
-
-
-class ResultVar(Number):
-    """A class to represent result variables and the desired optimisation direction"""
-
-    __slots__ = ["units", "direction"]
-
-    def __init__(self, units="ul", direction: OptDir = OptDir.minimize, **params):
-        Number.__init__(self, **params)
-        assert isinstance(units, str)
-        self.units = units
-        self.default = 0  # json is terrible and does not support nan values
-        self.direction = direction
-
-    def as_dim(self) -> hv.Dimension:
-        return hv.Dimension((self.name, self.name), unit=self.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.units, self.direction))
-
-
-class ResultVec(param.List):
-    """A class to represent fixed size vector result variable"""
-
-    __slots__ = ["units", "direction", "size"]
-
-    def __init__(self, size, units="ul", direction: OptDir = OptDir.minimize, **params):
-        param.List.__init__(self, **params)
-        self.units = units
-        self.default = 0  # json is terrible and does not support nan values
-        self.direction = direction
-        self.size = size
-
-    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.units, self.direction))
-
-    def index_name(self, idx: int) -> str:
-        """given the index of the vector, return the column name that
-
-        Args:
-            idx (int): index of the result vector
-
-        Returns:
-            str: column name of the vector for the xarray dataset
-        """
-
-        mapping = ["x", "y", "z"]
-        if idx < 3:
-            index = mapping[idx]
-        else:
-            index = idx
-        return f"{self.name}_{index}"
-
-    def index_names(self) -> List[str]:
-        """Returns a list of all the xarray column names for the result vector
-
-        Returns:
-            list[str]: column names
-        """
-        return [self.index_name(i) for i in range(self.size)]
-
-
-class ResultHmap(param.Parameter):
-    """A class to represent a holomap return type"""
-
-    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)
-
-
-def curve(x_vals: List[float], y_vals: List[float], x_name: str, y_name: str, **kwargs) -> hv.Curve:
-    return hv.Curve(zip(x_vals, y_vals), kdims=[x_name], vdims=[y_name], label=y_name, **kwargs)
-
-
-class PathResult(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 ResultVideo(PathResult):
-    def __init__(self, default=None, units="video", **params):
-        super().__init__(default=default, units=units, **params)
-
-
-class ResultImage(PathResult):
-    def __init__(self, default=None, units="image", **params):
-        super().__init__(default=default, units=units, **params)
-
-
-class ResultString(param.String):
-    __slots__ = ["units"]
-
-    def __init__(self, default=None, units="str", **params):
-        super().__init__(default=default, **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 ResultContainer(param.Parameter):
-    __slots__ = ["units"]
-
-    def __init__(self, default=None, units="container", **params):
-        super().__init__(default=default, **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 ResultReference(param.Parameter):
-    """Use this class to save arbitrary objects that are not picklable or native to panel.  You can pass a container callback that takes the object and returns a panel pane to be displayed"""
-
-    __slots__ = ["units", "obj", "container"]
-
-    def __init__(
-        self,
-        obj: Any = None,
-        container: Callable[Any, pn.pane.panel] = None,
-        default: Any = None,
-        units: str = "container",
-        **params,
-    ):
-        super().__init__(default=default, **params)
-        self.units = units
-        self.obj = obj
-        self.container = container
-
-    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 ResultVolume(param.Parameter):
-    __slots__ = ["units", "obj"]
-
-    def __init__(self, obj=None, default=None, units="container", **params):
-        super().__init__(default=default, **params)
-        self.units = units
-        self.obj = obj
-
-    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)
-
-
-PANEL_TYPES = (ResultImage, ResultContainer, ResultString, ResultReference)