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

bencher/variables/results.py

@@ -0,0 +1,214 @@
+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
+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,
+    label: Optional[str] = None,
+    **kwargs,
+) -> hv.Curve:
+    label = label or y_name
+    return hv.Curve(zip(x_vals, y_vals), kdims=[x_name], vdims=[y_name], label=label, **kwargs)
+
+
+class ResultPath(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)
+
+    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(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 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):
+    __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 = (ResultPath, ResultImage, ResultVideo, ResultContainer, ResultString, ResultReference)
+
+ALL_RESULT_TYPES = (
+    ResultVar,
+    ResultVec,
+    ResultHmap,
+    ResultPath,
+    ResultVideo,
+    ResultImage,
+    ResultString,
+    ResultContainer,
+    ResultReference,
+)

bencher/variables/sweep_base.py

@@ -0,0 +1,162 @@
+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"]
+
+
+def describe_variable(v: Parameterized, 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())}")
+        sampling_str.append(f"{indent}sample values: {[str(v) for v in v.values()]}")
+
+    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"]
+    # __slots__ = shared_slots
+
+    def values(
+        self,
+    ) -> List[Any]:
+        """All sweep classes must implement this method. This generates sample values from based on the parameters bounds and sample number.
+
+        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))  # pylint: disable=no-member
+
+    def sampling_str(self) -> str:
+        """Generate a string representation of the of the sampling procedure"""
+
+        samples = self.values()
+        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) -> 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()))
+
+    def as_dim(self, compute_values=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") and self.bounds is not None:
+            if compute_values:
+                params["values"] = self.values()
+                # params["range"] = tuple(self.bounds)
+            else:
+                params["range"] = tuple(self.bounds)
+                params["default"] = self.default
+
+        else:
+            params["values"] = self.values()
+            params["default"] = self.default
+
+        if hasattr(self, "step"):
+            params["step"] = getattr(self, "step")
+
+        # TODO investigate why this stopped working after a holoviews update
+        # if hasattr(self, "units"):
+        # params["unit"] = getattr(self, "units")
+
+        return hv.Dimension(name_tuple, **params)
+
+    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: list) -> 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

@@ -0,0 +1,92 @@
+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"""
+
+    def __init__(
+        self,
+        objects=None,
+        default=None,
+        instantiate=False,
+        compute_default_fn=None,
+        check_on_set=None,
+        allow_None=None,
+        empty_default=False,
+        **params,
+    ):
+        super().__init__(
+            objects,
+            default,
+            instantiate,
+            compute_default_fn,
+            check_on_set,
+            allow_None,
+            empty_default,
+            **params,
+        )
+
+    __slots__ = shared_slots
+
+    def values(self) -> 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,
+        **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
+
+
+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,
+        **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

holobench-1.26.3.data/data/share/bencher/package.xml

@@ -0,0 +1,33 @@
+<?xml version="1.0"?>
+<package format="3">
+  <name>bencher</name>
+  <version>0.1.0</version>
+  <description>A package for benchmarking the performance of arbitrary functions</description>
+  <maintainer email="austin.gregg-smith@dyson.com">Austin Gregg-Smith</maintainer>
+  <license>MIT</license>
+
+  <depend>python3-diskcache</depend>  
+  
+  <depend>python3-pandas</depend>  
+  <depend>python3-seaborn</depend>
+  <depend>python3-matplotlib</depend>
+  <depend>python3-numpy</depend>
+  <depend>python3-pytest</depend>
+  <depend>python3-hypothesis</depend>
+  <depend>xarray</depend>  
+  <depend>python3-zarr</depend>    
+  <depend>python3-param</depend>
+  <depend>python3-panel</depend>
+  <depend>python3-hvplot</depend>
+  <depend>python3-optuna</depend> 
+  <depend>python3-plotly</depend> 
+
+  <!-- TO REMOVE WHEN WE UPGRADE TO PYTHON 3.11, This is in the standard library for python>=3.11 -->
+  <depend>strenum</depend>
+
+  <test_depend>python3-pytest-cov</test_depend>
+  
+  <export>
+    <build_type>ament_python</build_type>
+  </export>
+</package>

{holobench-1.25.2.dist-info → holobench-1.26.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: holobench
-Version: 1.25.2
+Version: 1.26.3
 Summary: A package for benchmarking the performance of arbitrary functions
 Author-email: Austin Gregg-Smith <blooop@gmail.com>
 Project-URL: Repository, https://github.com/dyson-ai/bencher
@@ -8,7 +8,7 @@ Project-URL: Home, https://github.com/dyson-ai/bencher
 Project-URL: Documentation, https://bencher.readthedocs.io/en/latest/
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: holoviews <=1.18.3,>=1.15
+Requires-Dist: holoviews <=1.19.0,>=1.15
 Requires-Dist: numpy <=1.26.4,>=1.0
 Requires-Dist: param <=2.1.0,>=1.13.0
 Requires-Dist: hvplot <=0.10.0,>=0.8
@@ -16,7 +16,7 @@ Requires-Dist: matplotlib <=3.9.0,>=3.6.3
 Requires-Dist: panel <=1.4.4,>=1.3.6
 Requires-Dist: diskcache <=5.6.3,>=5.6
 Requires-Dist: optuna <=3.6.1,>=3.2
-Requires-Dist: xarray <=2024.5.0,>=2023.7
+Requires-Dist: xarray <=2024.6.0,>=2023.7
 Requires-Dist: plotly <=5.22.0,>=5.15
 Requires-Dist: sortedcontainers <=2.4,>=2.4
 Requires-Dist: pandas <=2.2.2,>=2.0
@@ -30,8 +30,8 @@ Requires-Dist: black <=24.4.2,>=23 ; extra == 'test'
 Requires-Dist: pylint <=3.2.3,>=2.17.7 ; extra == 'test'
 Requires-Dist: pytest-cov <=5.0.0,>=4.1 ; extra == 'test'
 Requires-Dist: pytest <=8.2.2,>=7.4 ; extra == 'test'
-Requires-Dist: hypothesis <=6.103.1,>=6.82 ; extra == 'test'
-Requires-Dist: ruff <=0.4.8,>=0.0.280 ; extra == 'test'
+Requires-Dist: hypothesis <=6.103.2,>=6.82 ; extra == 'test'
+Requires-Dist: ruff <=0.4.9,>=0.0.280 ; extra == 'test'
 Requires-Dist: coverage <=7.5.3,>=7.2.7 ; extra == 'test'
 
 # Bencher

holobench-1.26.3.dist-info/RECORD

@@ -0,0 +1,93 @@
+bencher/__init__.py,sha256=gywyMfCkWiguR86HWU63s06Ts9coSY_CK2ro2V7RIbI,1561
+bencher/bench_cfg.py,sha256=8rvJyeQXalZmYF8Lb-NKb9RFJs0w08k9ogcZSR1rhgs,18413
+bencher/bench_plot_server.py,sha256=D00_SOrHa2IT8zAjwetoNL6tEiHSHvXnbea9iElCLVk,4195
+bencher/bench_report.py,sha256=jh3T_q9KByZDeMPMf0KNJojZukxRzkfaYGeuWQU8MKM,10528
+bencher/bench_runner.py,sha256=-SzAKd6QbPJ05KaW3vteFIkE-UtlFS55Ob9QeE5eRXw,6202
+bencher/bencher.py,sha256=-7XaSZWVzaXHQcKlHqPiUwsrKzYlPKBrimh9ahp8vsI,34642
+bencher/caching.py,sha256=AusaNrzGGlj5m6zcwcqnTn55Mam2mQdF--oqelO806M,1627
+bencher/class_enum.py,sha256=kYHW9qKkKcNdwaXizZL-fTptS_DUEGv4c88yCehk3gc,1492
+bencher/job.py,sha256=swa0VwrZf41v7qNjreVDIYUU6r_dfuLipPZbg_w5x7c,6089
+bencher/optuna_conversions.py,sha256=an-LfPsQXyyvhIZnG8Wl1RQVYMvJj7WOi3YNqoUnuxQ,5356
+bencher/utils.py,sha256=9KAThtIG8jNd0nd4Wft8miNM_yHWmZUkIBfJh19pzgI,6480
+bencher/video_writer.py,sha256=B-V1tALd3oPDytaAsl8I6qUztDQlFbkp9gSYco-ah44,2175
+bencher/worker_job.py,sha256=FREi0yWQACFmH86R1j-LH72tALEFkKhLDmmoGQY9Jh4,1571
+bencher/example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bencher/example/benchmark_data.py,sha256=eRAB9ZhiDylWeqsh4g8lUYP3BV50QPUBmQ785scT590,6985
+bencher/example/example_all.py,sha256=iiKV2poYWu4SUIQkpoX4qT1zTm574QfuNHpYww3meFA,1952
+bencher/example/example_categorical.py,sha256=3BeOQN58nCGx6xzB0YvkgaBFInzJ5L3XsIYKfKOs0gM,3684
+bencher/example/example_composable_container.py,sha256=uW4USZOWLJ1KDG1HuferblAqvTLYCVzZDpVAGUYU2rM,3756
+bencher/example/example_composable_container2.py,sha256=rHjT9ZCWZbvex8ORnWc0hFekWGIA_MoTjUNPHMquQ3E,5666
+bencher/example/example_consts.py,sha256=upKkrMNYUCS38IA4duuyJHERwdZIMB4FA60Gytu_BzU,1475
+bencher/example/example_custom_sweep.py,sha256=-y8mYuXYD91j8kcCEe9c6Gx6g1dK-bvHM9sbXqHL2gA,1916
+bencher/example/example_custom_sweep2.py,sha256=zvfasrN5R89IynGWeGQW_W-01A4lCkoBzoh-thxPQ14,1224
+bencher/example/example_docs.py,sha256=aUi33O543JBPoOGlpHaY2eA74GR7cHH_6-hcC8xf3z0,1174
+bencher/example/example_filepath.py,sha256=O3VO9rWAXB_1tagVSvxhiSMjcTkgZe2duw7W17ij7po,827
+bencher/example/example_float3D.py,sha256=pwi3YlDad3NL4IrfMK2V5yV1CRpqfmUO-zUnGmVYxDs,3425
+bencher/example/example_float_cat.py,sha256=nQDBWYRVZrJW5ABIizqcD6mXswHWSdEDzM-FeYFqYqY,3821
+bencher/example/example_floats.py,sha256=HcQgfwldTVeFBmBTMtZ0yRy17ZJ4cfJeI_t8TxY2iOI,4269
+bencher/example/example_floats2D.py,sha256=D0kljoUCinMKCEW-Zg-cQ8sYu_yPCZqzKJ9tRtt-Ono,3697
+bencher/example/example_holosweep.py,sha256=lxH0Z_waInGIH5AtGQi4zwPAZRI_uN0DbsJhI9iSF7Q,3017
+bencher/example/example_holosweep_objects.py,sha256=vHuAtkM1VrJelHOazn_SJfzxNywKyaMzN-DE8W7Ricc,3228
+bencher/example/example_holosweep_tap.py,sha256=NYXofWGV9GaBN72Q3kKPT5lKJ-slYZH5VzTAavUu23w,4527
+bencher/example/example_image.py,sha256=17u0exNKFN9BIvSfdhVuQd9JsKUrIi0rZe6gXEVFNZ8,5547
+bencher/example/example_levels.py,sha256=s-UfXXp8qj5U0Gx5KyMqj--nn1Ke0NtHVLSSJYIPaYY,6891
+bencher/example/example_levels2.py,sha256=6n-ceglaHAbPAp2I-IiUsET8OVubXu8wNVoRBFJ_JSw,1116
+bencher/example/example_pareto.py,sha256=yyAg8Vb-5sgsS6LkYKT7T5Evcfg69FlCqCakUippSmU,2687
+bencher/example/example_sample_cache.py,sha256=7gf1BJ63VAgdqNuNXkbL9-jeTeC3kXA_PY9yG3ulTz0,4200
+bencher/example/example_sample_cache_context.py,sha256=IAUBbL78QM20R8evaq7L8I-xPxFDFykF1Gk1y2Ru1W0,4063
+bencher/example/example_simple.py,sha256=Nn2ixNx29jbgvwH2K5vDGhSFcqKLMNaP1occPxhHoU0,11703
+bencher/example/example_simple_bool.py,sha256=GZ6pyj8FaQV9gNxaqAmX6c5XWtMvKosezAbSADEl0G0,1248
+bencher/example/example_simple_cat.py,sha256=XsV_75Jk3phVPI4om3q0vn1POfREb3CGRm9Kq1tL-OA,1760
+bencher/example/example_simple_float.py,sha256=Mfp4QwqgZ6DWgdu3reNA0cDwOV5cjG1PTuhf-SEsEkY,930
+bencher/example/example_simple_float2d.py,sha256=xsVOLO6AtMi9_fybpS_JZnhev5f11YuYWHrAOzJw2dI,1033
+bencher/example/example_strings.py,sha256=vStjrvfezNz7115iRtuwy0i7Gbu6w8mu-oHNfKNLNog,1570
+bencher/example/example_time_event.py,sha256=e6R-a6ZPe-ePiWoNvN3YuSQK-Y2HOGntsjCm_SPon28,2159
+bencher/example/example_video.py,sha256=ffeTAqDuriMXxJ1sYfA4r137D3BAii84uSef6K86QVI,3955
+bencher/example/example_workflow.py,sha256=00QnUuViMfX_PqzqkXmg1wPX6yAq7IS7mCL_RFKwrMM,6806
+bencher/example/experimental/example_bokeh_plotly.py,sha256=3jUKh8eKIAlpklKnp8UopIHhUDw1A0_5CwjeyTzbi7o,846
+bencher/example/experimental/example_hover_ex.py,sha256=qszw4FkIfqQkVviPSpmUoFOoi6PGotGbsc7Ojyx8EtU,1052
+bencher/example/experimental/example_hvplot_explorer.py,sha256=B9u-kh6D_8J0wAtkYu2w8kML8eL3DkOZg0p91n_nBT4,1815
+bencher/example/experimental/example_interactive.py,sha256=MM1A2EVsKTy95RERTNnld0tUmZmCy8N41_jGm2wlG7U,2619
+bencher/example/experimental/example_streamnd.py,sha256=LqkTtdY4NhnP5dEB1Ifv7RQ5Vq4dLkp5E3aWnWuzniA,1414
+bencher/example/experimental/example_streams.py,sha256=rrTmcmxDlirGoyTbJ4LT4fBIAc1k28qjnjy5JxGKyhg,1030
+bencher/example/experimental/example_template.py,sha256=XdIVS9RtLdE5GNnerWiZMXvP7n17lzuc_YTLqJTwb6Q,1172
+bencher/example/experimental/example_updates.py,sha256=rF4UgWY-CW6ohNtOpQklTuwbwVRvEM5j6edZOiMkspQ,1835
+bencher/example/experimental/example_vector.py,sha256=3o_1dA4dc2HL6uIEvDAcvLPVJB8jgkq1QZ3BQIL-LEo,3118
+bencher/example/meta/example_meta.py,sha256=l4TZuBjCUwzxm2lHJ5wqWWI2-Xv8LFVg3S0K0JmuX5U,5563
+bencher/example/meta/example_meta_cat.py,sha256=FMBT0yMPJJo0pmUYVtlq64R6qn_EXEt74xYAsK6HQag,641
+bencher/example/meta/example_meta_float.py,sha256=D71oiFqGauLvqTxv2BC4CJOwHIdpvq8FdCBVejwZ4Do,624
+bencher/example/meta/example_meta_levels.py,sha256=MkVL8pAIogn8ObKdSn8BC_DKk6PSVvvPU7_KUCgP5vQ,1436
+bencher/example/optuna/example_optuna.py,sha256=-RIuDrdPjfXz1c1hOAmWeJNdmGICiWnyJfAavRsiMuk,2370
+bencher/example/shelved/example_float2D_scatter.py,sha256=z8ranMq8IcJ1yoVSFDncp3gw-yWG7X9lXLimXKpy5Ks,3372
+bencher/example/shelved/example_float3D_cone.py,sha256=T3-IapccLYX3BM9sGDyOTLhZVEmzkeMsXzQMT5msnNQ,2966
+bencher/example/shelved/example_kwargs.py,sha256=Bgxkd7qeHdySBE24amdP-VNFRRgK_enyzprlxBwY9Ko,2461
+bencher/plotting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bencher/plotting/plot_filter.py,sha256=Zff02hEcRffiqDEoXUHVZQJK5kW4HbMxe2GYCrxI8jg,4688
+bencher/plotting/plt_cnt_cfg.py,sha256=RK6dot_Yb6uTBPDe7Z1UzCqCQgjgEFxANt5DCc4LLAI,3159
+bencher/results/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bencher/results/bench_result.py,sha256=JoXfAQ2dkoVt2mBM0Hp5V0843CWcSCuBfR817VhLVx0,3491
+bencher/results/bench_result_base.py,sha256=eQsw1CzaL2X3sX8uTqdLruijW0e6NkJjfJuaz1xJH-w,19024
+bencher/results/float_formatter.py,sha256=sX6HNCyaXdHDxC8ybVUHwCJ3qOKbPUkBOplVIHtKWjM,1746
+bencher/results/holoview_result.py,sha256=DHzQaDOswsPln2XIJ9NF-OIw4HgJ41Sv9JrlIz_dVe0,28499
+bencher/results/optuna_result.py,sha256=jtsWJGdCS0L98EzxTxXU_AyarCL5CkXRLOVuSvs048M,13437
+bencher/results/panel_result.py,sha256=lXOtfhWKSspf53Wgm94DTiVD3rliieHQW96sOdu5UYk,1336
+bencher/results/plotly_result.py,sha256=wkgfL38qJp6RviekXBYpNPeU4HCf0nbtKDAhu5QZhUg,2132
+bencher/results/video_result.py,sha256=E3fAxXctRVxiRyamadpKCMXanM5TTqw1tEYICS2LDLs,1146
+bencher/results/video_summary.py,sha256=ECMVnm1L58n3KHrFuy4Cm9T6aUjsOL_YHm0ncLfW4IU,8343
+bencher/results/composable_container/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bencher/results/composable_container/composable_container_base.py,sha256=MPmfig7mwmpo156N98FR83bExLyoJbUM7C9VmdBE-VY,2781
+bencher/results/composable_container/composable_container_panel.py,sha256=HrOoeGB0y0jGQcxcci_M82ftsvklLkJgo-4SjDBJCks,1232
+bencher/results/composable_container/composable_container_video.py,sha256=EHY2TIQM5ualrh_or-wzyErPWm25CaYdSdMotqo5wCo,7104
+bencher/variables/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bencher/variables/inputs.py,sha256=tASPqEN7j_uaj8vfM1nFEpgV8QXrxTH3LfltIbV0Gp4,6725
+bencher/variables/parametrised_sweep.py,sha256=ZhLkuniIq2t_WPFi2kpuYRMZBEmqTpLpto3xDQ-iCpg,7277
+bencher/variables/results.py,sha256=mjr34L27NFuXqUCI1GSO8srU8VFm8niTkaSZ1iPvvbY,7159
+bencher/variables/sweep_base.py,sha256=cOybffErb3_QUsCfiZa0mlVy9tGDueqiElZmc363apE,6258
+bencher/variables/time.py,sha256=A1QPYM-z2p-04hKcHG80u8njiKQ-2R2IHcjo7iB92_A,3136
+holobench-1.26.3.data/data/share/ament_index/resource_index/packages/bencher,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+holobench-1.26.3.data/data/share/bencher/package.xml,sha256=HxWM9qIEiLbE60tG0aKsS7q3UaSKDyCMD4-1nYw8vOs,1045
+holobench-1.26.3.dist-info/LICENSE,sha256=dSHXTdRY4Y7qGFMv63UksV700iff7iE-p7GGs6Sbnvo,1065
+holobench-1.26.3.dist-info/METADATA,sha256=QjnUcDSF8-UoMYqFlJ6CGbv2lDE3f2HQAyh4NSzU5rw,5617
+holobench-1.26.3.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+holobench-1.26.3.dist-info/top_level.txt,sha256=rkP5-F_W08mOD-25ZPkt0HJsHxedb2EiRcRA7IP6Ceg,8
+holobench-1.26.3.dist-info/RECORD,,

holobench-1.25.2.dist-info/RECORD

@@ -1,18 +0,0 @@
-bencher/__init__.py,sha256=gywyMfCkWiguR86HWU63s06Ts9coSY_CK2ro2V7RIbI,1561
-bencher/bench_cfg.py,sha256=8rvJyeQXalZmYF8Lb-NKb9RFJs0w08k9ogcZSR1rhgs,18413
-bencher/bench_plot_server.py,sha256=D00_SOrHa2IT8zAjwetoNL6tEiHSHvXnbea9iElCLVk,4195
-bencher/bench_report.py,sha256=jh3T_q9KByZDeMPMf0KNJojZukxRzkfaYGeuWQU8MKM,10528
-bencher/bench_runner.py,sha256=-SzAKd6QbPJ05KaW3vteFIkE-UtlFS55Ob9QeE5eRXw,6202
-bencher/bencher.py,sha256=-7XaSZWVzaXHQcKlHqPiUwsrKzYlPKBrimh9ahp8vsI,34642
-bencher/caching.py,sha256=AusaNrzGGlj5m6zcwcqnTn55Mam2mQdF--oqelO806M,1627
-bencher/class_enum.py,sha256=kYHW9qKkKcNdwaXizZL-fTptS_DUEGv4c88yCehk3gc,1492
-bencher/job.py,sha256=swa0VwrZf41v7qNjreVDIYUU6r_dfuLipPZbg_w5x7c,6089
-bencher/optuna_conversions.py,sha256=an-LfPsQXyyvhIZnG8Wl1RQVYMvJj7WOi3YNqoUnuxQ,5356
-bencher/utils.py,sha256=9KAThtIG8jNd0nd4Wft8miNM_yHWmZUkIBfJh19pzgI,6480
-bencher/video_writer.py,sha256=B-V1tALd3oPDytaAsl8I6qUztDQlFbkp9gSYco-ah44,2175
-bencher/worker_job.py,sha256=FREi0yWQACFmH86R1j-LH72tALEFkKhLDmmoGQY9Jh4,1571
-holobench-1.25.2.dist-info/LICENSE,sha256=dSHXTdRY4Y7qGFMv63UksV700iff7iE-p7GGs6Sbnvo,1065
-holobench-1.25.2.dist-info/METADATA,sha256=Tq6Q-IbUGYSVrbSDe212fY27PWyfxrkhbBVNI4_2UCI,5617
-holobench-1.25.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-holobench-1.25.2.dist-info/top_level.txt,sha256=rkP5-F_W08mOD-25ZPkt0HJsHxedb2EiRcRA7IP6Ceg,8
-holobench-1.25.2.dist-info/RECORD,,