holobench 1.18.0__py2.py3-none-any.whl → 1.30.0__py2.py3-none-any.whl

bencher/utils.py

@@ -8,8 +8,9 @@ from colorsys import hsv_to_rgb
 from pathlib import Path
 from uuid import uuid4
 from functools import partial
-from typing import Callable, Any, List
+from typing import Callable, Any, List, Tuple
 import param
+import numpy as np
 
 
 def hmap_canonical_input(dic: dict) -> tuple:
@@ -98,6 +99,23 @@ def un_camel(camel: str) -> str:
     return capitalise_words(re.sub("([a-z])([A-Z])", r"\g<1> \g<2>", camel.replace("_", " ")))
 
 
+def mult_tuple(inp: Tuple[float], val: float) -> Tuple[float]:
+    return tuple(np.array(inp) * val)
+
+
+def tabs_in_markdown(regular_str: str, spaces: int = 2) -> str:
+    """Given a string with tabs in the form \t convert the to &ensp; which is a double space in markdown
+
+    Args:
+        regular_str (str): A string with tabs in it
+        spaces (int): the number of spaces per tab
+
+    Returns:
+        str: A string with sets of &nbsp; to represent the tabs in markdown
+    """
+    return regular_str.replace("\t", "".join(["&nbsp;"] * spaces))
+
+
 def int_to_col(int_val, sat=0.5, val=0.95, alpha=-1) -> tuple[float, float, float]:
     """Uses the golden angle to generate colors programmatically with minimum overlap between colors.
     https://martin.ankerl.com/2009/12/09/how-to-create-random-colors-programmatically/
@@ -129,13 +147,21 @@ def color_tuple_to_css(color: tuple[float, float, float]) -> str:
     return f"rgb{(color[0] * 255, color[1] * 255, color[2] * 255)}"
 
 
-def gen_path(filename, folder, suffix):
+def color_tuple_to_255(color: tuple[float, float, float]) -> tuple[float, float, float]:
+    return (
+        min(int(color[0] * 255), 255),
+        min(int(color[1] * 255), 255),
+        min(int(color[2] * 255), 255),
+    )
+
+
+def gen_path(filename, folder="generic", suffix=".dat"):
     path = Path(f"cachedir/{folder}/{filename}/")
     path.mkdir(parents=True, exist_ok=True)
     return f"{path.absolute().as_posix()}/{filename}_{uuid4()}{suffix}"
 
 
-def gen_video_path(video_name: str = "vid", extension: str = ".webm") -> str:
+def gen_video_path(video_name: str = "vid", extension: str = ".mp4") -> str:
     return gen_path(video_name, "vid", extension)
 
 

bencher/variables/inputs.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import List, Any
+from typing import List, Any, Dict
 
 import numpy as np
 from param import Integer, Number, Selector
@@ -174,6 +174,29 @@ def box(name, center, width):
     return var
 
 
+def p(
+    name: str, values: List[Any] = None, samples: int = None, max_level: int = None
+) -> Dict[str, Any]:
+    """
+    Create a parameter dictionary with optional values, samples, and max_level.
+
+    Args:
+        name (str): The name of the parameter.
+        values (List[Any], optional): A list of values for the parameter. Defaults to None.
+        samples (int, optional): The number of samples. Must be greater than 0 if provided. Defaults to None.
+        max_level (int, optional): The maximum level. Must be greater than 0 if provided. Defaults to None.
+
+    Returns:
+        Dict[str, Any]: A dictionary containing the parameter details.
+    """
+    if max_level is not None and max_level <= 0:
+        raise ValueError("max_level must be greater than 0")
+
+    if samples is not None and samples <= 0:
+        raise ValueError("samples must be greater than 0")
+    return {"name": name, "values": values, "max_level": max_level, "samples": samples}
+
+
 def with_level(arr: list, level) -> list:
     return IntSweep(sample_values=arr).with_level(level).values()
     # return tmp.with_sample_values(arr).with_level(level).values()

bencher/variables/parametrised_sweep.py

@@ -3,19 +3,11 @@ from typing import List, Tuple, Any
 from param import Parameter, Parameterized
 import holoviews as hv
 import panel as pn
-
+from copy import deepcopy
 
 from bencher.utils import make_namedtuple, hash_sha1
-from bencher.variables.results import (
-    ResultVar,
-    ResultVec,
-    ResultHmap,
-    ResultVideo,
-    ResultImage,
-    ResultString,
-    ResultContainer,
-    ResultReference,
-)
+from bencher.variables.results import ALL_RESULT_TYPES, ResultHmap
+from bencher.bench_cfg import BenchRunCfg
 
 
 class ParametrizedSweep(Parameterized):
@@ -78,16 +70,7 @@ class ParametrizedSweep(Parameterized):
         for k, v in cls.param.objects().items():
             if isinstance(
                 v,
-                (
-                    ResultVar,
-                    ResultVec,
-                    ResultHmap,
-                    ResultVideo,
-                    ResultImage,
-                    ResultString,
-                    ResultContainer,
-                    ResultReference,
-                ),
+                ALL_RESULT_TYPES,
             ):
                 results[k] = v
             else:
@@ -144,7 +127,7 @@ class ParametrizedSweep(Parameterized):
         inp = cls.get_inputs_only()
         defaults = {}
         for i in inp:
-            defaults[i.name] = i.default
+            defaults[i.name] = deepcopy(i.default)
 
         for k, v in kwargs.items():
             defaults[k] = v
@@ -209,13 +192,14 @@ class ParametrizedSweep(Parameterized):
             )
         )
 
-    def __call__(self):
+    def __call__(self, **kwargs):
         return self.get_results_values_as_dict()
 
     def plot_hmap(self, **kwargs):
         return self.__call__(**kwargs)["hmap"]
 
-    def to_bench(self, run_cfg=None, report=None, name: str = None):
+    # TODO Add type hints here and fix the circular imports
+    def to_bench(self, run_cfg: BenchRunCfg = None, report=None, name: str = None):
         from bencher import Bench
 
         assert isinstance(self, ParametrizedSweep)

bencher/variables/results.py

@@ -1,6 +1,6 @@
 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
@@ -99,7 +99,7 @@ def curve(
     return hv.Curve(zip(x_vals, y_vals), kdims=[x_name], vdims=[y_name], label=label, **kwargs)
 
 
-class PathResult(param.Filename):
+class ResultPath(param.Filename):
     __slots__ = ["units"]
 
     def __init__(self, default=None, units="path", **params):
@@ -110,15 +110,33 @@ class PathResult(param.Filename):
         """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(PathResult):
-    def __init__(self, default=None, units="video", **params):
-        super().__init__(default=default, units=units, **params)
+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(PathResult):
-    def __init__(self, default=None, units="image", **params):
-        super().__init__(default=default, units=units, **params)
+
+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):
@@ -168,6 +186,25 @@ class ResultReference(param.Parameter):
         return hash_sha1(self)
 
 
+class ResultDataSet(param.Parameter):
+    __slots__ = ["units", "obj"]
+
+    def __init__(
+        self,
+        obj: Any = None,
+        default: Any = None,
+        units: str = "dataset",
+        **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)
+
+
 class ResultVolume(param.Parameter):
     __slots__ = ["units", "obj"]
 
@@ -181,4 +218,25 @@ class ResultVolume(param.Parameter):
         return hash_sha1(self)
 
 
-PANEL_TYPES = (ResultImage, ResultVideo, ResultContainer, ResultString, ResultReference)
+PANEL_TYPES = (
+    ResultPath,
+    ResultImage,
+    ResultVideo,
+    ResultContainer,
+    ResultString,
+    ResultReference,
+    ResultDataSet,
+)
+
+ALL_RESULT_TYPES = (
+    ResultVar,
+    ResultVec,
+    ResultHmap,
+    ResultPath,
+    ResultVideo,
+    ResultImage,
+    ResultString,
+    ResultContainer,
+    ResultDataSet,
+    ResultReference,
+)

bencher/variables/time.py

@@ -9,6 +9,28 @@ 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]:

bencher/video_writer.py

@@ -4,13 +4,6 @@ from pathlib import Path
 from .utils import gen_video_path, gen_image_path
 
 import moviepy
-from moviepy.editor import (
-    VideoFileClip,
-    ImageClip,
-    ImageSequenceClip,
-    clips_array,
-    concatenate_videoclips,
-)
 from PIL import Image, ImageDraw
 
 
@@ -25,97 +18,50 @@ class VideoWriter:
         self.images.append(img)
 
     def write(self) -> str:
-        clip = moviepy.video.io.ImageSequenceClip.ImageSequenceClip(
-            self.images, fps=30, with_mask=False, load_images=True
-        )
-        self.write_video_raw(clip)
+        if len(self.images) > 0:
+            clip = moviepy.video.io.ImageSequenceClip.ImageSequenceClip(
+                self.images, fps=30, with_mask=False, load_images=True
+            )
+            self.write_video_raw(clip)
         return self.filename
 
     @staticmethod
-    def create_label(label, width=None, height=14):
+    def create_label(label, width=None, height=16, color=(255, 255, 255)):
         if width is None:
-            width = len(label) * 8
-        new_img = Image.new("RGB", (width, height), (255, 255, 255))
+            width = len(label) * 10
+        new_img = Image.new("RGB", (width, height), color=color)
         # ImageDraw.Draw(new_img).text((width/2, 0), label, (0, 0, 0),align="center",achor="ms")
-        ImageDraw.Draw(new_img).text((width / 2.0, 0), label, (0, 0, 0), anchor="mt", font_size=12)
+        ImageDraw.Draw(new_img).text(
+            (width / 2.0, 0), label, (0, 0, 0), anchor="mt", font_size=height
+        )
 
         return new_img
 
     @staticmethod
-    def label_image(path: Path, label, padding=20) -> Path:
+    def label_image(path: Path, label, padding=20, color=(255, 255, 255)) -> Path:
         image = Image.open(path)
-        new_img = VideoWriter.create_label(label, image.size[0], image.size[1] + padding)
+        new_img = VideoWriter.create_label(
+            label, image.size[0], image.size[1] + padding, color=color
+        )
         new_img.paste(image, (0, padding))
         return new_img
 
-    def append_file(self, filepath, label=None):
-        if label is not None:
-            path = Path(filepath)
-            new_path = path.with_name(path.stem + "_labelled" + path.suffix).as_posix()
-            padding = 20
-            match path.suffix:
-                case ".png" | ".jpg":
-                    image = Image.open(filepath)
-                    new_img = self.create_label(label, image.size[0], image.size[1] + padding)
-                    new_img.paste(image, (0, padding))
-                    new_img.save(new_path)
-                    self.image_files.append(new_path)
-                case ".webm":
-                    import warnings
-
-                    video_clip = VideoFileClip(filepath)
-                    new_img = self.create_label(label, video_clip.w, padding)
-
-                    # Convert PIL image to MoviePy clip
-                    label_clip = ImageClip(np.array(new_img), duration=video_clip.duration)
-
-                    labeled_video_clip = clips_array([[label_clip], [video_clip]])
-
-                    # otherwise ffmpeg complains that the file is not getting read. We don't need the file just the size
-                    with warnings.catch_warnings():
-                        warnings.simplefilter(action="ignore")
-                        labeled_video_clip.write_videofile(new_path, remove_temp=True, logger=None)
-                    self.video_files.append(new_path)
-        else:
-            self.image_files.append(filepath)
-
-    def to_images_sequence(self, images, target_duration: float = 10.0, frame_time=None, **kwargs):
-        target_duration = kwargs.pop("target_duration", target_duration)
-        if isinstance(images, list) and len(images) > 0:
-            if frame_time is None:
-                fps = len(images) / target_duration
-                fps = max(fps, 1)  # never slower that 1 seconds per frame
-                fps = min(fps, 30)
-            else:
-                fps = 1.0 / frame_time
-            return ImageSequenceClip(images, fps=fps, with_mask=False)
-        return None
-
-    def write_png(self, **kwargs):
-        clip = None
-        if len(self.image_files) > 0:
-            clip = self.to_images_sequence(self.image_files, **kwargs)
-        if len(self.video_files) > 0:
-            clip = concatenate_videoclips([VideoFileClip(f) for f in self.video_files])
-        if clip is not None:
-            clip.write_videofile(self.filename)
-            return self.filename
-        return None
-
     def write_video_raw(self, video_clip: moviepy.video.VideoClip, fps: int = 30) -> str:
         video_clip.write_videofile(
             self.filename,
-            codec="libvpx",
+            codec="libx264",
             audio=False,
             bitrate="0",
             fps=fps,
-            ffmpeg_params=["-crf", "34"],
+            ffmpeg_params=["-crf", "23"],
+            threads=8,
         )
         video_clip.close()
         return self.filename
 
 
-def add_image(np_array: np.ndarray, name: str = "img"):
+def add_image(np_array: np.ndarray, name: str = "img") -> str:
+    """Creates a file on disk from a numpy array and returns the created image path"""
     filename = gen_image_path(name)
     Image.fromarray(np_array).save(filename)
     return filename

{holobench-1.18.0.dist-info → holobench-1.30.0.dist-info}/METADATA

@@ -1,37 +1,39 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: holobench
-Version: 1.18.0
+Version: 1.30.0
 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.3
-Requires-Dist: numpy>=1.0,<=1.26.4
-Requires-Dist: param>=1.13.0,<=2.1.0
-Requires-Dist: hvplot>=0.8,<=0.10.0
-Requires-Dist: matplotlib>=3.6.3,<=3.8.4
-Requires-Dist: panel>=1.3.6,<=1.4.2
-Requires-Dist: diskcache>=5.6,<=5.6.3
-Requires-Dist: optuna>=3.2,<=3.6.1
-Requires-Dist: xarray>=2023.7,<=2024.5.0
-Requires-Dist: plotly>=5.15,<=5.22.0
-Requires-Dist: sortedcontainers>=2.4,<=2.4
-Requires-Dist: pandas>=2.0,<=2.2.2
-Requires-Dist: strenum>=0.4.0,<=0.4.15
-Requires-Dist: scikit-learn>=1.2,<=1.4.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,<=24.4.2 ; extra == "test"
-Requires-Dist: pylint>=2.16,<=3.1.0 ; extra == "test"
-Requires-Dist: pytest-cov>=4.1,<=5.0.0 ; extra == "test"
-Requires-Dist: pytest>=7.4,<=8.2.0 ; extra == "test"
-Requires-Dist: hypothesis>=6.82,<=6.101.0 ; extra == "test"
-Requires-Dist: ruff>=0.0.280,<=0.4.4 ; extra == "test"
-Requires-Dist: coverage>=7.2.7,<=7.5.1 ; 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
+Project-URL: Home, https://github.com/dyson-ai/bencher
+Project-URL: Documentation, https://bencher.readthedocs.io/en/latest/
+Author-email: Austin Gregg-Smith <blooop@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: diskcache<=5.6.3,>=5.6
+Requires-Dist: holoviews<=1.19.1,>=1.15
+Requires-Dist: hvplot<=0.10.0,>=0.8
+Requires-Dist: matplotlib<=3.9.2,>=3.6.3
+Requires-Dist: moviepy-fix-codec
+Requires-Dist: numpy<=2.1.0,>=1.0
+Requires-Dist: optuna<=4.0.0,>=3.2
+Requires-Dist: pandas<=2.2.2,>=2.0
+Requires-Dist: panel<=1.4.5,>=1.3.6
+Requires-Dist: param<=2.1.1,>=1.13.0
+Requires-Dist: plotly<=5.24.0,>=5.15
+Requires-Dist: scikit-learn<=1.5.1,>=1.2
+Requires-Dist: scoop<=0.7.2.0,>=0.7.0
+Requires-Dist: sortedcontainers<=2.4,>=2.4
+Requires-Dist: str2bool<=1.1,>=1.1
+Requires-Dist: strenum<=0.4.15,>=0.4.0
+Requires-Dist: xarray<=2024.7.0,>=2023.7
 Provides-Extra: test
+Requires-Dist: black<=24.8.0,>=23; extra == 'test'
+Requires-Dist: coverage<=7.6.1,>=7.5.4; extra == 'test'
+Requires-Dist: hypothesis<=6.112.2,>=6.104.2; extra == 'test'
+Requires-Dist: pylint<=3.3.1,>=3.2.5; extra == 'test'
+Requires-Dist: pytest-cov<=5.0.0,>=4.1; extra == 'test'
+Requires-Dist: pytest<=8.3.3,>=7.4; extra == 'test'
+Requires-Dist: ruff<=0.6.8,>=0.5.0; extra == 'test'
+Description-Content-Type: text/markdown
 
 # Bencher
  
@@ -43,10 +45,16 @@ Provides-Extra: test
 [![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/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/holobench)](https://pypistats.org/packages/holobench)
 [![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/)
+[![Python](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12-blue)](https://www.python.org/downloads/)
+[![Pixi Badge](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/prefix-dev/pixi/main/assets/badge/v0.json)](https://pixi.sh)
+
+## Install
 
+```bash
+pip install holobench
+```
 
 ## Intro
 
@@ -77,9 +85,43 @@ Bencher is designed to work with stochastic pure functions with no side effects.
             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
+    deduce the type of plot based on the input and output types
     return data and plot
     
-### Example Output
 
-https://dyson-ai.github.io/bencher/
+## Demo
+
+if you have [pixi](https://github.com/prefix-dev/pixi/) installed you can run a demo example with:
+
+```bash
+pixi run demo
+```
+
+An example of the type of output bencher produces can be seen here:
+
+https://dyson-ai.github.io/bencher/ 
+
+
+## Examples
+
+Most of the features that are supported are demonstrated in the examples folder.
+
+Start with example_simple_float.py and explore other examples based on your data types:
+- example_float.py: More complex float operations
+- example_float2D.py: 2D float sweeps
+- example_float3D.py: 3D float sweeps 
+- example_categorical.py: Sweeping categorical values (enums)
+- example_strings.py: Sweeping categorical string values
+- example_float_cat.py: Mixing float and categorical values
+- example_image.py: Output images as part of the sweep
+- example_video.py: Output videos as part of the sweep
+- example_filepath.py: Output arbitrary files as part of the sweep
+- and many others
+
+
+## Documentation
+
+API documentation can be found at https://bencher.readthedocs.io/en/latest/
+
+More documentation is needed for the examples and general workflow. 
+