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

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)

bencher/variables/sweep_base.py

@@ -1,167 +0,0 @@
-from __future__ import annotations
-from typing import List, Any, Tuple
-from copy import deepcopy
-
-import numpy as np
-import param
-from param import Parameterized
-import holoviews as hv
-import panel as pn
-from bencher.utils import hash_sha1
-
-# slots that are shared across all Sweep classes
-# param and slots don't work easily with multiple inheritance so define here
-shared_slots = ["units", "samples", "samples_debug"]
-
-
-def describe_variable(
-    v: Parameterized, debug: bool, include_samples: bool, value=None
-) -> List[str]:
-    """Generate a string description of a variable
-
-    Args:
-        v (param.Parameterized): parameter to describe
-        debug (bool): Generate a reduced number of samples from the variable
-        include_samples (bool): Include a description of the samples
-
-    Returns:
-        str: String description of the variable
-    """
-    indent = "    "
-    sampling_str = []
-    sampling_str.append(f"{v.name}:")
-    if include_samples:
-        # sampling_str.append(f"{indent}{v.sampling_str(debug)}")
-        sampling_str.append(f"{indent}number of samples: {len(v.values(debug))}")
-        sampling_str.append(f"{indent}sample values: {[str(v) for v in v.values(debug)]}")
-
-    if value is not None:
-        sampling_str.append(f"{indent}value: {value}")
-    if hasattr(v, "units"):
-        if v.units != "ul" and len(v.units) > 0:
-            sampling_str.append(f"{indent}units: [{v.units}]")
-    if v.doc is not None:
-        sampling_str.append(f"{indent}docs: {v.doc}")
-    for i in range(len(sampling_str)):
-        sampling_str[i] = f"{indent}{sampling_str[i]}"
-    return sampling_str
-
-
-class SweepBase(param.Parameter):
-    # def __init__(self, **params):
-    # super().__init__(**params)
-    # self.units = ""
-    # slots = ["units", "samples", "samples_debug"]
-    # __slots__ = shared_slots
-
-    def values(self, debug: bool) -> List[Any]:
-        """All sweep classes must implement this method. This generates sample values from based on the parameters bounds and sample number.
-
-        Args:
-            debug (bool): Return a reduced set of samples to enable fast debugging of a data generation and plotting pipeline. Ideally when debug is true, 2 samples will be returned
-
-        Returns:
-            List[Any]: A list of samples from the variable
-        """
-        raise NotImplementedError
-
-    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.samples, self.samples_debug)  # pylint: disable=no-member
-        )
-
-    def sampling_str(self, debug=False) -> str:
-        """Generate a string representation of the of the sampling procedure
-
-        Args:
-            debug (bool): If true then self.samples_debug is used
-        """
-
-        samples = self.values(debug)
-        object_str = ",".join([str(i) for i in samples])
-        return f"Taking {len(samples)} samples from {self.name} with values: [{object_str}]"
-
-    def as_slider(self, debug=False) -> pn.widgets.slider.DiscreteSlider:
-        """given a sweep variable (self), return the range of values as a panel slider
-
-        Args:
-            debug (bool, optional): pass to the sweepvar to produce a full set of varaibles, or when debug=True, a reduces number of sweep vars. Defaults to False.
-
-        Returns:
-            pn.widgets.slider.DiscreteSlider: A panel slider with the values() of the sweep variable
-        """
-        return pn.widgets.slider.DiscreteSlider(name=self.name, options=list(self.values(debug)))
-
-    def as_dim(self, compute_values=False, debug=False) -> hv.Dimension:
-        """Takes a sweep variable and turns it into a holoview dimension
-
-        Returns:
-            hv.Dimension:
-        """
-        name_tuple = (self.name, self.name)
-
-        params = {}
-        if hasattr(self, "bounds"):
-            if compute_values:
-                params["values"] = self.values(debug)
-                # params["range"] = tuple(self.bounds)
-            else:
-                params["range"] = tuple(self.bounds)
-                params["default"] = self.default
-
-        else:
-            params["values"] = self.values(debug)
-            params["default"] = self.default
-
-        if hasattr(self, "step"):
-            params["step"] = getattr(self, "step")
-
-        return hv.Dimension(name_tuple, unit=self.units, **params)  # pylint: disable=no-member
-
-    def indices_to_samples(self, desires_num_samples, sample_values):
-        indices = [
-            int(i) for i in np.linspace(0, len(sample_values) - 1, desires_num_samples, dtype=int)
-        ]
-
-        if len(indices) > len(sample_values):
-            return sample_values
-
-        return [sample_values[i] for i in indices]
-
-    def with_samples(self, samples: int) -> SweepBase:
-        output = deepcopy(self)
-        # TODO set up class properly. Slightly complicated due to slots
-        output.samples = samples  # pylint: disable = attribute-defined-outside-init
-        if hasattr(output, "step"):
-            # hack TODO fix this
-            output.step = None  # pylint: disable = attribute-defined-outside-init
-        return output
-
-    def with_sample_values(self, sample_values: int) -> SweepBase:
-        output = deepcopy(self)
-        # TODO set up class properly. Slightly complicated due to slots
-        try:
-            output.sample_values = sample_values  # pylint: disable = attribute-defined-outside-init
-        except AttributeError:
-            output.objects = sample_values  # pylint: disable = attribute-defined-outside-init
-        output.samples = len(sample_values)  # pylint: disable = attribute-defined-outside-init
-        return output
-
-    def with_const(self, const_value: Any) -> Tuple[SweepBase, Any]:
-        """Create a new instance of SweepBase with a constant value.
-
-        Args:
-            const_value (Any): The constant value to be associated with the new instance.
-
-        Returns:
-            Tuple[SweepBase, Any]: A tuple containing the new instance of SweepBase and the constant value.
-        """
-        return (deepcopy(self), const_value)
-
-    def with_level(self, level: int = 1, max_level: int = 12) -> SweepBase:
-        assert level >= 1
-        # TODO work out if the order can be returned in level order always
-        samples = [0, 1, 2, 3, 5, 9, 17, 33, 65, 129, 257, 513, 1025, 2049]
-        out = self.with_sample_values(self.with_samples(samples[min(max_level, level)]).values())
-        return out

bencher/variables/time.py

@@ -1,74 +0,0 @@
-from datetime import datetime
-from typing import List
-
-from pandas import Timestamp
-from param import Selector
-from bencher.variables.sweep_base import SweepBase, shared_slots
-
-
-class TimeBase(SweepBase, Selector):
-    """A class to capture a time snapshot of benchmark values.  Time is reprented as a continous value i.e a datetime which is converted into a np.datetime64.  To represent time as a discrete value use the TimeEvent class. The distinction is because holoview and plotly code makes different assumptions about discrete vs continous variables"""
-
-    __slots__ = shared_slots
-
-    def values(self, debug=False) -> List[str]:
-        """return all the values for a parameter sweep.  If debug is true return a reduced list"""
-        # print(self.sampling_str(debug))
-        return self.objects
-
-
-class TimeSnapshot(TimeBase):
-    """A class to capture a time snapshot of benchmark values.  Time is reprented as a continous value i.e a datetime which is converted into a np.datetime64.  To represent time as a discrete value use the TimeEvent class. The distinction is because holoview and plotly code makes different assumptions about discrete vs continous variables"""
-
-    __slots__ = shared_slots
-
-    def __init__(
-        self,
-        datetime_src: datetime | str,
-        units: str = "time",
-        samples: int = None,
-        samples_debug: int = 2,
-        **params,
-    ):
-        if isinstance(datetime_src, str):
-            TimeBase.__init__(self, [datetime_src], instantiate=True, **params)
-        else:
-            TimeBase.__init__(
-                self,
-                objects=[Timestamp(datetime_src)],
-                instantiate=True,
-                **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)
-
-
-class TimeEvent(TimeBase):
-    """A class to represent a discrete event in time where the data was captured i.e a series of pull requests.  Here time is discrete and can't be interpolated, to represent time as a continous value use the TimeSnapshot class.  The distinction is because holoview and plotly code makes different assumptions about discrete vs continous variables"""
-
-    __slots__ = shared_slots
-
-    def __init__(
-        self,
-        time_event: str,
-        units: str = "event",
-        samples: int = None,
-        samples_debug: int = 2,
-        **params,
-    ):
-        TimeBase.__init__(
-            self,
-            objects=[time_event],
-            instantiate=True,
-            **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)