holobench 1.3.6__py2.py3-none-any.whl

bencher/variables/sweep_base.py

@@ -0,0 +1,167 @@
+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

@@ -0,0 +1,74 @@
+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)

bencher/video_writer.py

@@ -0,0 +1,30 @@
+from bencher import gen_video_path, gen_image_path
+from PIL import Image
+import numpy as np
+
+
+class VideoWriter:
+    def __init__(self, filename: str = "vid") -> None:
+        self.images = []
+        self.filename = gen_video_path(filename)
+
+    def append(self, img):
+        self.images.append(img)
+
+    def write(self, bitrate: int = 1500) -> str:
+        import moviepy.video.io.ImageSequenceClip
+
+        # todo
+        # if len(self.images[0.shape) == 2:
+        #     for i in range(len(self.images)):
+        #         self.images[i] = np.expand_dims(self.images[i], 2)
+
+        clip = moviepy.video.io.ImageSequenceClip.ImageSequenceClip(self.images, fps=30)
+        clip.write_videofile(self.filename, bitrate=f"{bitrate}k", logger=None)
+        return self.filename
+
+
+def add_image(np_array: np.ndarray, name: str = "img"):
+    filename = gen_image_path(name)
+    Image.fromarray(np_array).save(filename)
+    return filename

bencher/worker_job.py

@@ -0,0 +1,40 @@
+from typing import List, Tuple, Any
+from dataclasses import dataclass, field
+from sortedcontainers import SortedDict
+from .utils import hash_sha1
+from bencher.utils import hmap_canonical_input
+
+
+@dataclass
+class WorkerJob:
+    function_input_vars: List
+    index_tuple: Tuple[int]
+    dims_name: List[str]
+    constant_inputs: dict
+    bench_cfg_sample_hash: str
+    tag: str
+
+    function_input: SortedDict = None
+    canonical_input: Tuple[Any] = None
+    fn_inputs_sorted: List[str] = None
+    function_input_signature_pure: str = None
+    function_input_signature_benchmark_context: str = None
+    found_in_cache: bool = False
+    msgs: List[str] = field(default_factory=list)
+
+    def setup_hashes(self) -> None:
+        self.function_input = SortedDict(zip(self.dims_name, self.function_input_vars))
+
+        self.canonical_input = hmap_canonical_input(self.function_input)
+
+        if self.constant_inputs is not None:
+            self.function_input = self.function_input | self.constant_inputs
+
+        # store a tuple of the inputs as keys for a holomap
+        # the signature is the hash of the inputs to to the function + meta variables such as repeat and time + the hash of the benchmark sweep as a whole (without the repeats hash)
+        self.fn_inputs_sorted = list(SortedDict(self.function_input).items())
+        self.function_input_signature_pure = hash_sha1((self.fn_inputs_sorted, self.tag))
+
+        self.function_input_signature_benchmark_context = hash_sha1(
+            (self.function_input_signature_pure, self.bench_cfg_sample_hash)
+        )

holobench-1.3.6.dist-info/METADATA

@@ -0,0 +1,85 @@
+Metadata-Version: 2.1
+Name: holobench
+Version: 1.3.6
+Summary: A package for benchmarking the performance of arbitrary functions
+Author-email: Austin Gregg-Smith <blooop@gmail.com>
+Description-Content-Type: text/markdown
+Requires-Dist: holoviews>=1.15,<=1.18.1
+Requires-Dist: numpy>=1.0,<=1.26.2
+Requires-Dist: param>=1.13.0,<=2.0.1
+Requires-Dist: hvplot>=0.8,<=0.9.1
+Requires-Dist: matplotlib>=3.6.3,<=3.8.2
+Requires-Dist: panel>=1.3.6,<=1.3.6
+Requires-Dist: diskcache>=5.6,<=5.6.3
+Requires-Dist: optuna>=3.2,<=3.5.0
+Requires-Dist: xarray>=2023.7,<=2023.12.0
+Requires-Dist: plotly>=5.15,<=5.18.0
+Requires-Dist: sortedcontainers>=2.4,<=2.4
+Requires-Dist: pandas>=2.0,<=2.1.4
+Requires-Dist: strenum>=0.4.0,<=0.4.15
+Requires-Dist: scikit-learn>=1.2,<=1.3.2
+Requires-Dist: str2bool>=1.1,<=1.1
+Requires-Dist: scoop>=0.7.0,<=0.7.2.0
+Requires-Dist: moviepy>=1.0.3,<=1.0.3
+Requires-Dist: black>=23,<=23.12.1 ; extra == "test"
+Requires-Dist: pylint>=2.16,<=3.0.3 ; extra == "test"
+Requires-Dist: pytest-cov>=4.1,<=4.1 ; extra == "test"
+Requires-Dist: pytest>=7.4,<=7.4.4 ; extra == "test"
+Requires-Dist: hypothesis>=6.82,<=6.92.2 ; extra == "test"
+Requires-Dist: ruff>=0.0.280,<=0.1.9 ; extra == "test"
+Requires-Dist: coverage>=7.2.7,<=7.4.0 ; extra == "test"
+Project-URL: Documentation, https://bencher.readthedocs.io/en/latest/
+Project-URL: Home, https://github.com/dyson-ai/bencher
+Project-URL: Repository, https://github.com/dyson-ai/bencher
+Provides-Extra: test
+
+# Bencher
+ 
+ ## Continuous Integration Status
+
+[![Ci](https://github.com/dyson-ai/bencher/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/dyson-ai/bencher/actions/workflows/ci.yml?query=branch%3Amain)
+![Read the Docs](https://img.shields.io/readthedocs/bencher)
+[![Codecov](https://codecov.io/gh/dyson-ai/bencher/branch/main/graph/badge.svg?token=Y212GW1PG6)](https://codecov.io/gh/dyson-ai/bencher)
+[![GitHub issues](https://img.shields.io/github/issues/dyson-ai/bencher.svg)](https://GitHub.com/dyson-ai/bencher/issues/)
+[![GitHub pull-requests merged](https://badgen.net/github/merged-prs/dyson-ai/bencher)](https://github.com/dyson-ai/bencher/pulls?q=is%3Amerged)
+[![PyPI](https://img.shields.io/pypi/v/holobench)](https://pypi.org/project/holobench/)
+[![GitHub release](https://img.shields.io/github/release/dyson-ai/bencher.svg)](https://GitHub.com/dyson-ai/bencher/releases/)
+[![License](https://img.shields.io/pypi/l/bencher)](https://opensource.org/license/mit/)
+[![Python](https://img.shields.io/badge/python-3.10%20%7C%203.11-blue)](https://www.python.org/downloads/release/python-310/)
+
+
+## Intro
+
+Bencher is a tool to make it easy to benchmark the interactions between the input parameters to your algorithm and its resulting performance on a set of metrics.
+
+Parameters for bencher are defined using the param library https://param.holoviz.org/ as a config class with extra metadata that describes the bounds of the search space you want to measure.  You must define a benchmarking function that accepts an instance of the config class and return a dictionary with string metric names and float values.
+
+Parameters are benchmarked by passing in a list N parameters, and an N-Dimensional tensor is returned.   You can optionally sample each point multiple times to get back a distribution and also track its value over time.  By default the data will be plotted automatically based on the types of parameters you are sampling (e.g, continous, discrete), but you can also pass in a callback to customize plotting.
+
+The data is stored in a persistent database so that past performance is tracked.
+
+## Assumptions
+
+The input types should also be of one of the basic datatypes (bool, int, float, str, enum, datetime) so that the data can be easily hashed, cached and stored in the database and processed with seaborn and xarray plotting functions. You can use class inheritance to define hierarchical parameter configuration class types that can be reused in a bigger configuration classes.
+
+Bencher is designed to work with stochastic pure functions with no side effects.  It assumes that when the objective function is given the same inputs, it will return the same output +- random noise.  This is because the function must be called multiple times to get a good statistical distribution of it and so each call must not be influenced by anything or the results will be corrupted.
+
+### Pseudocode of bencher
+
+    Enumerate a list of all input parameter combinations
+    for each set of input parameters:
+        pass the inputs to the objective function and store results in the N-D array
+
+        get unique hash for the set of inputs parameters
+        look up previous results for that hash
+        if it exists:
+            load historical data
+            combine latest data with historical data
+        
+        store the results using the input hash as a key
+    deduce the type of plot based on the input types
+    return data and plot
+    
+### Example Output
+
+https://dyson-ai.github.io/bencher/

holobench-1.3.6.dist-info/RECORD

@@ -0,0 +1,74 @@
+bencher/__init__.py,sha256=lw9moEkY3rb3kQVS3_SM9L0LsOAXRSM1JUJ_mm16tMQ,1236
+bencher/bench_cfg.py,sha256=0dIF_JrvWYiugNDi28wh_8a8ejm99cnw3RrlMIDI2Ww,18714
+bencher/bench_plot_server.py,sha256=HnW6XpmARweMCd-koqzu1lxuj0gA4_fP-72D3Yfy-0M,4087
+bencher/bench_report.py,sha256=b9jLksrXzBhSmvI7KetO1i0hsHknE7qk4b4k0MGGtNw,10484
+bencher/bench_runner.py,sha256=TLJGn-NO4BBBZMG8W5E6u7IPyij67Yk3S4B29ONClnk,6049
+bencher/bencher.py,sha256=jYOkqs5F6vIL9_KLygVgi0O_vj-xspBVlipduNMtt1Y,32012
+bencher/caching.py,sha256=AusaNrzGGlj5m6zcwcqnTn55Mam2mQdF--oqelO806M,1627
+bencher/job.py,sha256=Q2zpia95Ibukk8EeFq5IBbpo2PMRe7o5keelJCJlGnI,5927
+bencher/optuna_conversions.py,sha256=9nLVPAydSQ8PyJlyhzs__Em6_Rx8l8Ld94UNJZxy6cY,5303
+bencher/utils.py,sha256=oKUtD3Uw76n82ZeyWRBleneYKrZuuNE8pb7Gswlhwjc,5034
+bencher/video_writer.py,sha256=L_RVrHU4C6hj9BhbEPelgPgtGZeHH4PYYW4CHjGXgJ0,937
+bencher/worker_job.py,sha256=FREi0yWQACFmH86R1j-LH72tALEFkKhLDmmoGQY9Jh4,1571
+bencher/example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bencher/example/benchmark_data.py,sha256=D9yUg_KKtqqEkAiLceodDwsv6sh7xEFWZNp6P6Y3pj4,6989
+bencher/example/example_all.py,sha256=iiKV2poYWu4SUIQkpoX4qT1zTm574QfuNHpYww3meFA,1952
+bencher/example/example_categorical.py,sha256=3BeOQN58nCGx6xzB0YvkgaBFInzJ5L3XsIYKfKOs0gM,3684
+bencher/example/example_custom_sweep.py,sha256=-y8mYuXYD91j8kcCEe9c6Gx6g1dK-bvHM9sbXqHL2gA,1916
+bencher/example/example_docs.py,sha256=aUi33O543JBPoOGlpHaY2eA74GR7cHH_6-hcC8xf3z0,1174
+bencher/example/example_float3D.py,sha256=pwi3YlDad3NL4IrfMK2V5yV1CRpqfmUO-zUnGmVYxDs,3425
+bencher/example/example_float_cat.py,sha256=RZiKEACZyGDnubxhaUcabI43AYvm3h7qt0SCUp5Yuso,3810
+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=d9g5aWCAUb7FMZahb4t3xNs344EshPhA-8-K6K1SBXg,3180
+bencher/example/example_holosweep_objects.py,sha256=vHuAtkM1VrJelHOazn_SJfzxNywKyaMzN-DE8W7Ricc,3228
+bencher/example/example_holosweep_tap.py,sha256=3ayQ0bTj_XWP_92ifQJAhe1whwPAj_xWHPkzC7fvqAY,4540
+bencher/example/example_image.py,sha256=DBB7oe-67XoxPBPhUJNSr45U8t8xJvi9KiC3ptZkAHE,2713
+bencher/example/example_levels.py,sha256=rpSNB571yfMnT7iO66Ds-DPGHWzOTM9FLMNfSetJdHY,6896
+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=36KMSHyXZhzS1cp2TZnDLn7-GpShLdQ7mycuT0M3le8,1247
+bencher/example/example_simple_cat.py,sha256=YFccE84g37U2M3ByWYIcGNLXWdW_ktJbbZvGL0D6oHA,1759
+bencher/example/example_simple_float.py,sha256=X4vsH0F4fZAoO0EKB1xIzFMY0f0Wyk8LV2plPlSEsbI,1323
+bencher/example/example_strings.py,sha256=BdsEZgLT9mOxLkBKNHz2XpPwwe4SzNTdjnY1WVlOmNM,1570
+bencher/example/example_time_event.py,sha256=y1vpK7UDrObEu0Z1x3e4OQzvGCQ7pF5GZvpKLegMbYk,2158
+bencher/example/example_video.py,sha256=w2NtsDL-afZWGlScrrHxr9vdCrxTvyzqOUhIeDOHjvU,4079
+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=P71Q-3G8B44DYaZQe5eFmFxUsjbViSat3DcUvgdSSuw,5605
+bencher/example/meta/example_meta_cat.py,sha256=YKVUiZ7M1tFFYgUTVQZeOe-1bnmxOjLdWy3nmCoyEe0,693
+bencher/example/meta/example_meta_float.py,sha256=f3OcORsRUt9Bnd1M1hOjmgxulxcalwdQHSQ0Psx1rY8,650
+bencher/example/meta/example_meta_levels.py,sha256=O77D4gAGYf7uZo7-Kj2ZwyNmpnc4paoQXE_DQtKKWKo,1488
+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=BkiAsgHm35Mqb5OsjULGVK0Q6pGZ0WSsJxxwSOrbaQs,3124
+bencher/results/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bencher/results/bench_result.py,sha256=NiJ8UIYrw5QBksltIHAOh-4CaIMYI8YA-cEcWgfwZ70,2838
+bencher/results/bench_result_base.py,sha256=-c46om4Gulzxn3PPvQAsQF9qzT7rQLtX6hsO65f9N2A,15767
+bencher/results/float_formatter.py,sha256=sX6HNCyaXdHDxC8ybVUHwCJ3qOKbPUkBOplVIHtKWjM,1746
+bencher/results/holoview_result.py,sha256=nfXYTaGQkXwLqJ_gEB3TYJxHfKAQCN1E60D9Tfbkxos,22254
+bencher/results/optuna_result.py,sha256=jtsWJGdCS0L98EzxTxXU_AyarCL5CkXRLOVuSvs048M,13437
+bencher/results/panel_result.py,sha256=SpVHHdTdlNHh1pGcK3DYLw6BClDRJ_37TNTkicnErTU,3936
+bencher/results/plotly_result.py,sha256=wkgfL38qJp6RviekXBYpNPeU4HCf0nbtKDAhu5QZhUg,2132
+bencher/variables/inputs.py,sha256=XtUko3qNYB1xk7fwM9teVGRU0MNCW673n2teGtoyFGU,6393
+bencher/variables/parametrised_sweep.py,sha256=3ioxqm8xg9WYIH-eRFRhDSn_YphGD-269gZ_FaxuEv8,7029
+bencher/variables/results.py,sha256=omENIr_Y3RxRG8sr4RQKD1Y_vTyMJUoA7P-fV1uSX5Y,6015
+bencher/variables/sweep_base.py,sha256=I1LEeG1y5Jsw0a-Ik03t0tSzcfENht2GmBECJ3KNs28,6559
+bencher/variables/time.py,sha256=Le7s8_oUYJD4wCqwQw-a_FRDpYQOi8CqMbGYsBF07jg,2860
+holobench-1.3.6.dist-info/WHEEL,sha256=Sgu64hAMa6g5FdzHxXv9Xdse9yxpGGMeagVtPMWpJQY,99
+holobench-1.3.6.dist-info/METADATA,sha256=LyfizZKUZi92A3pYWd_faXDRH-fpfDsNyv_4NThnHWo,4996
+holobench-1.3.6.dist-info/RECORD,,

holobench-1.3.6.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: flit 3.9.0
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any