holobench 1.22.2__tar.gz → 1.24.0__tar.gz

{holobench-1.22.2/holobench.egg-info → holobench-1.24.0}/PKG-INFO

@@ -1,8 +1,10 @@
 Metadata-Version: 2.1
 Name: holobench
-Version: 1.22.2
+Version: 1.24.0
 Summary: A package for benchmarking the performance of arbitrary functions
 Author-email: Austin Gregg-Smith <blooop@gmail.com>
+Maintainer: austin.gregg-smith
+Maintainer-email: austin.gregg-smith@dyson.com
 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/
@@ -13,7 +15,7 @@ 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
 Requires-Dist: matplotlib<=3.9.0,>=3.6.3
-Requires-Dist: panel<=1.4.3,>=1.3.6
+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
@@ -30,9 +32,9 @@ Requires-Dist: black<=24.4.2,>=23; extra == "test"
 Requires-Dist: pylint<=3.2.2,>=2.17.7; extra == "test"
 Requires-Dist: pytest-cov<=5.0.0,>=4.1; extra == "test"
 Requires-Dist: pytest<=8.2.1,>=7.4; extra == "test"
-Requires-Dist: hypothesis<=6.102.6,>=6.82; extra == "test"
-Requires-Dist: ruff<=0.4.5,>=0.3; extra == "test"
-Requires-Dist: coverage<=7.5.2,>=7.2.7; extra == "test"
+Requires-Dist: hypothesis<=6.103.0,>=6.82; extra == "test"
+Requires-Dist: ruff<=0.4.7,>=0.3; extra == "test"
+Requires-Dist: coverage<=7.5.3,>=7.2.7; extra == "test"
 
 # Bencher
  

{holobench-1.22.2 → holobench-1.24.0}/bencher/__init__.py

@@ -22,6 +22,15 @@ from .variables.results import (
     curve,
 )
 
+from .results.composable_container.composable_container_base import (
+    ComposeType,
+    ComposableContainerBase,
+)
+from .results.composable_container.composable_container_video import (
+    ComposableContainerVideo,
+    RenderCfg,
+)
+
 from .plotting.plot_filter import VarRange, PlotFilter
 from .utils import (
     hmap_canonical_input,

{holobench-1.22.2 → holobench-1.24.0}/bencher/bench_runner.py

@@ -121,7 +121,7 @@ class BenchRunner:
                     self.show_publish(report_level, show, publish, save, debug)
         return self.results
 
-    def show_publish(self, report, show, publish, save, debug):
+    def show_publish(self, report: BenchReport, show: bool, publish: bool, save: bool, debug: bool):
         if save:
             report.save_index()
         if publish and self.publisher is not None:

{holobench-1.22.2 → holobench-1.24.0}/bencher/bencher.py

@@ -220,9 +220,11 @@ class Bench(BenchPlotServer):
         relationship_cb=None,
         plot_callbacks: List | bool = None,
     ) -> List[BenchResult]:
-        results = []
         if relationship_cb is None:
             relationship_cb = combinations
+        if input_vars is None:
+            input_vars = self.worker_class_instance.get_inputs_only()
+        results = []
         for it in range(iterations):
             for input_group in relationship_cb(input_vars, group_size):
                 title_gen = title + "Sweeping " + " vs ".join(params_to_str(input_group))
@@ -313,8 +315,21 @@ class Bench(BenchPlotServer):
             else:
                 const_vars = deepcopy(const_vars)
 
-        for i in range(len(input_vars)):
-            input_vars[i] = self.convert_vars_to_params(input_vars[i], "input")
+        if isinstance(input_vars, dict):
+            input_lists = []
+            for k, v in input_vars.items():
+                param_var = self.convert_vars_to_params(k, "input")
+                if isinstance(v, list):
+                    assert len(v) > 0
+                    param_var = param_var.with_sample_values(v)
+                else:
+                    raise RuntimeError("Unsupported type")
+                input_lists.append(param_var)
+
+            input_vars = input_lists
+        else:
+            for i in range(len(input_vars)):
+                input_vars[i] = self.convert_vars_to_params(input_vars[i], "input")
         for i in range(len(result_vars)):
             result_vars[i] = self.convert_vars_to_params(result_vars[i], "result")
 
@@ -482,6 +497,10 @@ class Bench(BenchPlotServer):
         """
         if isinstance(variable, str):
             variable = self.worker_class_instance.param.objects(instance=False)[variable]
+        if isinstance(variable, tuple):
+            variable = self.worker_class_instance.param.objects(instance=False)[
+                variable[0]
+            ].with_sample_values(variable[1])
         if not isinstance(variable, param.Parameter):
             raise TypeError(
                 f"You need to use {var_type}_vars =[{self.worker_input_cfg}.param.your_variable], instead of {var_type}_vars =[{self.worker_input_cfg}.your_variable]"

{holobench-1.22.2 → holobench-1.24.0}/bencher/optuna_conversions.py

@@ -1,4 +1,5 @@
 from typing import List
+import logging
 
 import optuna
 import panel as pn
@@ -158,8 +159,8 @@ def summarise_optuna_study(study: optuna.study.Study) -> pn.pane.panel:
     row.append(plot_param_importances(study))
     try:
         row.append(plot_pareto_front(study))
-    except Exception:
-        pass
+    except Exception as e:  # pylint: disable=broad-except
+        logging.exception(e)
 
     row.append(
         pn.pane.Markdown(f"```\nBest value: {study.best_value}\nParams: {study.best_params}```")

{holobench-1.22.2 → holobench-1.24.0}/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,10 @@ 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
 
@@ -142,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 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)
 
 

holobench-1.24.0/bencher/video_writer.py

@@ -0,0 +1,67 @@
+import numpy as np
+import moviepy.video.io.ImageSequenceClip
+from pathlib import Path
+from .utils import gen_video_path, gen_image_path
+
+import moviepy
+from PIL import Image, ImageDraw
+
+
+class VideoWriter:
+    def __init__(self, filename: str = "vid") -> None:
+        self.images = []
+        self.image_files = []
+        self.video_files = []
+        self.filename = gen_video_path(filename)
+
+    def append(self, img):
+        self.images.append(img)
+
+    def write(self) -> str:
+        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=16, color=(255, 255, 255)):
+        if width is None:
+            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=height
+        )
+
+        return new_img
+
+    @staticmethod
+    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, color=color
+        )
+        new_img.paste(image, (0, padding))
+        return new_img
+
+    def write_video_raw(self, video_clip: moviepy.video.VideoClip, fps: int = 30) -> str:
+        video_clip.write_videofile(
+            self.filename,
+            codec="libx264",
+            audio=False,
+            bitrate="0",
+            fps=fps,
+            ffmpeg_params=["-crf", "23"],
+            threads=8,
+        )
+        video_clip.close()
+        return self.filename
+
+
+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.22.2 → holobench-1.24.0/holobench.egg-info}/PKG-INFO

@@ -1,8 +1,10 @@
 Metadata-Version: 2.1
 Name: holobench
-Version: 1.22.2
+Version: 1.24.0
 Summary: A package for benchmarking the performance of arbitrary functions
 Author-email: Austin Gregg-Smith <blooop@gmail.com>
+Maintainer: austin.gregg-smith
+Maintainer-email: austin.gregg-smith@dyson.com
 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/
@@ -13,7 +15,7 @@ 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
 Requires-Dist: matplotlib<=3.9.0,>=3.6.3
-Requires-Dist: panel<=1.4.3,>=1.3.6
+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
@@ -30,9 +32,9 @@ Requires-Dist: black<=24.4.2,>=23; extra == "test"
 Requires-Dist: pylint<=3.2.2,>=2.17.7; extra == "test"
 Requires-Dist: pytest-cov<=5.0.0,>=4.1; extra == "test"
 Requires-Dist: pytest<=8.2.1,>=7.4; extra == "test"
-Requires-Dist: hypothesis<=6.102.6,>=6.82; extra == "test"
-Requires-Dist: ruff<=0.4.5,>=0.3; extra == "test"
-Requires-Dist: coverage<=7.5.2,>=7.2.7; extra == "test"
+Requires-Dist: hypothesis<=6.103.0,>=6.82; extra == "test"
+Requires-Dist: ruff<=0.4.7,>=0.3; extra == "test"
+Requires-Dist: coverage<=7.5.3,>=7.2.7; extra == "test"
 
 # Bencher
  

{holobench-1.22.2 → holobench-1.24.0}/holobench.egg-info/SOURCES.txt

@@ -32,6 +32,8 @@ test/test_bencher.py
 test/test_cache.py
 test/test_class_enum.py
 test/test_combinations.py
+test/test_composable_container_base.py
+test/test_composable_container_video.py
 test/test_float_formatter.py
 test/test_job.py
 test/test_meta_tests.py

{holobench-1.22.2 → holobench-1.24.0}/holobench.egg-info/requires.txt

@@ -3,7 +3,7 @@ numpy<=1.26.4,>=1.0
 param<=2.1.0,>=1.13.0
 hvplot<=0.10.0,>=0.8
 matplotlib<=3.9.0,>=3.6.3
-panel<=1.4.3,>=1.3.6
+panel<=1.4.4,>=1.3.6
 diskcache<=5.6.3,>=5.6
 optuna<=3.6.1,>=3.2
 xarray<=2024.5.0,>=2023.7
@@ -21,6 +21,6 @@ black<=24.4.2,>=23
 pylint<=3.2.2,>=2.17.7
 pytest-cov<=5.0.0,>=4.1
 pytest<=8.2.1,>=7.4
-hypothesis<=6.102.6,>=6.82
-ruff<=0.4.5,>=0.3
-coverage<=7.5.2,>=7.2.7
+hypothesis<=6.103.0,>=6.82
+ruff<=0.4.7,>=0.3
+coverage<=7.5.3,>=7.2.7

{holobench-1.22.2 → holobench-1.24.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "holobench"
-version = "1.22.2"
+version = "1.24.0"
 
 authors = [{ name = "Austin Gregg-Smith", email = "blooop@gmail.com" }]
 description = "A package for benchmarking the performance of arbitrary functions"
@@ -12,7 +12,7 @@ dependencies = [
   "param>=1.13.0,<=2.1.0",
   "hvplot>=0.8,<=0.10.0",
   "matplotlib>=3.6.3,<=3.9.0",
-  "panel>=1.3.6,<=1.4.3",
+  "panel>=1.3.6,<=1.4.4",
   "diskcache>=5.6,<=5.6.3",
   "optuna>=3.2,<=3.6.1",
   "xarray>=2023.7,<=2024.5.0",
@@ -48,9 +48,9 @@ test = [
   "pylint>=2.17.7,<=3.2.2",
   "pytest-cov>=4.1,<=5.0.0",
   "pytest>=7.4,<=8.2.1",
-  "hypothesis>=6.82,<=6.102.6",
-  "ruff>=0.3,<=0.4.5",
-  "coverage>=7.2.7,<=7.5.2",
+  "hypothesis>=6.82,<=6.103.0",
+  "ruff>=0.3,<=0.4.7",
+  "coverage>=7.2.7,<=7.5.3",
 ]
 
 [project.urls]
@@ -72,20 +72,29 @@ py311 = ["py311", "test"]
 format = "black ."
 check-clean-workspace = "git diff --exit-code"
 ruff-lint = "ruff check . --fix"
-pylint = "pylint --version && echo 'running pylint...'&& pylint $(git ls-files '*.py')"
+pylint = "pylint --version && echo 'running pylint...' && pylint $(git ls-files '*.py')"
 lint = { depends_on = ["ruff-lint", "pylint"] }
 style = { depends_on = ["format", "lint"] }
+commit-format = "git commit -a -m'autoformat code'"
 test = "pytest"
 coverage = "coverage run -m pytest && coverage xml -o coverage.xml"
 coverage-report = "coverage report -m"
+update-lock = "pixi update && git commit -a -m'update pixi.lock'"
+fix = { depends_on = ["update-lock", "format", "ruff-lint"] }
+push = "git push"
+update-lock-push = { depends_on = ["update-lock", "push"] }
+fix-commit-push = { depends_on = ["fix", "commit-format", "update-lock-push"] }
+
 ci-no-cover = { depends_on = ["style", "test"] }
 ci = { depends_on = [
-  "style",
+  "format",
+  "ruff-lint",
   "check-clean-workspace",
+  "pylint",
   "coverage",
   "coverage-report",
 ] }
-update-lock-push = "pixi update; git commit -a -m'update pixi.lock';git push"
+ci-push = { depends_on = ["format", "ruff-lint", "update-lock", "ci", "push"] }
 clear-pixi = "rm -rf .pixi pixi.lock"
 
 
@@ -97,7 +106,7 @@ extension-pkg-whitelist = ["numpy", "scipy"]
 jobs = 16                                    #detect number of cores
 
 [tool.pylint.'MESSAGES CONTROL']
-disable = "C,logging-fstring-interpolation,line-too-long,fixme,broad-exception-caught,missing-module-docstring,too-many-instance-attributes,too-few-public-methods,too-many-arguments,too-many-locals,too-many-branches,too-many-statements,use-dict-literal,cyclic-import,duplicate-code,too-many-public-methods,too-many-nested-blocks"
+disable = "C,logging-fstring-interpolation,line-too-long,fixme,missing-module-docstring,too-many-instance-attributes,too-few-public-methods,too-many-arguments,too-many-locals,too-many-branches,too-many-statements,use-dict-literal,duplicate-code,too-many-public-methods,too-many-nested-blocks"
 enable = "no-else-return,consider-using-in"
 
 [tool.black]

{holobench-1.22.2 → holobench-1.24.0}/setup.py

@@ -4,17 +4,14 @@ package_name = "bencher"
 
 setup(
     name=package_name,
-    # version="0.0.1",
     description="A library for benchmarking code and generating reports for analysis",
-    # maintainer="austin.gregg-smith",
-    # maintainer_email="austin.gregg-smith@dyson.com",
+    maintainer="austin.gregg-smith",
+    maintainer_email="austin.gregg-smith@dyson.com",
     packages=find_packages(exclude=["test.*", "test"]),
     data_files=[
         ("share/ament_index/resource_index/packages", ["resource/" + package_name]),
         ("share/" + package_name, ["package.xml"]),
     ],
-    include_package_data=False,
-    # install_requires=["setuptools"],
     zip_safe=False,
     test_suite="test",
     tests_require=["pytest"],

{holobench-1.22.2 → holobench-1.24.0}/test/test_bench_examples.py

@@ -9,6 +9,7 @@ from bencher.example.example_time_event import run_example_time_event
 from bencher.example.example_float3D import example_floats3D
 
 from bencher.example.example_custom_sweep import example_custom_sweep
+from bencher.example.example_custom_sweep2 import example_custom_sweep2
 from bencher.example.example_workflow import example_floats2D_workflow, example_floats3D_workflow
 from bencher.example.example_holosweep import example_holosweep
 from bencher.example.example_holosweep_tap import example_holosweep_tap
@@ -85,6 +86,9 @@ class TestBenchExamples(unittest.TestCase):
     def test_example_custom_sweep(self) -> None:
         self.examples_asserts(example_custom_sweep(self.create_run_cfg()))
 
+    def test_example_custom2(self) -> None:
+        self.examples_asserts(example_custom_sweep2(self.create_run_cfg()))
+
     def test_example_floats2D_workflow(self) -> None:
         self.examples_asserts(example_floats2D_workflow(self.create_run_cfg()))
 

holobench-1.24.0/test/test_composable_container_base.py

@@ -0,0 +1,77 @@
+# Generated by CodiumAI
+from bencher.results.composable_container.composable_container_base import (
+    ComposeType,
+    ComposableContainerBase,
+)
+
+
+import pytest
+
+
+class TestFlip:
+
+    # flipping ComposeType.right returns ComposeType.down
+    def test_flip_right_returns_down(self):
+        assert ComposeType.right.flip() == ComposeType.down
+
+    # flipping ComposeType.down returns ComposeType.right
+    def test_flip_down_returns_right(self):
+        assert ComposeType.down.flip() == ComposeType.right
+
+    # flipping an invalid ComposeType raises RuntimeError
+    def test_flip_invalid_raises_runtime_error(self):
+        with pytest.raises(RuntimeError):
+            invalid_type = ComposeType.sequence
+            invalid_type.flip()
+
+    # method should handle large number of flip calls without performance degradation
+    def test_flip_large_number_of_calls(self):
+        for _ in range(1000000):
+            assert ComposeType.right.flip() == ComposeType.down
+            assert ComposeType.down.flip() == ComposeType.right
+
+    # method should maintain immutability of the original ComposeType instance
+    def test_flip_maintains_immutability(self):
+        original = ComposeType.right
+        flipped = original.flip()
+        assert original == ComposeType.right
+        assert flipped == ComposeType.down
+
+
+# Generated by CodiumAI
+class TestComposableContainerBase:
+
+    # append method adds an object to the container
+    def test_append_adds_object(self):
+        container = ComposableContainerBase()
+        obj = "test_object"
+        container.append(obj)
+        assert obj in container.container
+
+    # render method returns the current state of the container
+    def test_render_returns_container_state(self):
+        container = ComposableContainerBase()
+        obj = "test_object"
+        container.append(obj)
+        assert container.render() == [obj]
+
+    # Ensure label_formatter formats int values correctly with spaces included
+    def test_label_formatter_formats_int_with_spaces(self):
+        formatted_label = ComposableContainerBase.label_formatter("var", 12345)
+        assert formatted_label == "var=  12345."
+
+    # label_formatter handles None values for var_name and var_value
+    def test_label_formatter_handles_none(self):
+        formatted_label = ComposableContainerBase.label_formatter(None, None)
+        assert formatted_label is None
+
+    # append method handles appending None
+    def test_append_handles_none(self):
+        container = ComposableContainerBase()
+        container.append(None)
+        assert None in container.container
+
+    # render method handles an empty container
+    def test_render_empty_container(self):
+        container = ComposableContainerBase()
+        assert container.render() == []

holobench-1.24.0/test/test_composable_container_video.py

@@ -0,0 +1,255 @@
+import unittest
+import bencher as bch
+import numpy as np
+from hypothesis import given, strategies as st
+
+
+class TestComposableContainerVideo(unittest.TestCase):
+    def small_img(self, size=None):
+        if size is None:
+            size = (2, 1)
+        return np.ones((size[0], size[1], 3))
+        # return np.array(
+        #     [[[1, 1, 1]], [[0, 0, 0]]]
+        # )  # represents an image of 1x2 (keep it small for speed)
+
+    def small_video(self, num_frames: int = 2, render_cfg=None, size=None):
+        img = self.small_img(size=size)
+        vid = bch.ComposableContainerVideo()
+        for _ in range(num_frames):
+            vid.append(img)
+        return vid.render(render_cfg)
+
+    # @given(frames=st.sampled_from([1, 2, 10, 100]))
+    # def test_duration_default(self, frames):
+    #     ccv = bch.ComposableContainerVideo()
+    #     duration, frame_duration = ccv.calculate_duration(frames, bch.RenderCfg())
+    #     self.assertEqual(duration, 10)
+    #     self.assertEqual(frame_duration, 10 / frames)
+
+    @given(frames=st.sampled_from([1, 2, 10, 100]), duration=st.sampled_from([0.1, 1, 10, 100]))
+    def test_set_duration(self, frames, duration):
+        ccv = bch.ComposableContainerVideo()
+        duration, frame_duration = ccv.calculate_duration(frames, bch.RenderCfg(duration=duration))
+        self.assertEqual(duration, duration)
+        self.assertEqual(frame_duration, duration / frames)
+
+    @given(frames=st.sampled_from([1, 2, 10, 100]), duration=st.sampled_from([0.1, 1, 10, 100]))
+    def test_set_duration1(self, frames, duration):
+        ccv = bch.ComposableContainerVideo()
+        min_frame_duration = 1 / 30
+        max_frame_duration = 2.0
+        duration, frame_duration = ccv.calculate_duration(
+            frames,
+            bch.RenderCfg(
+                duration=duration,
+                min_frame_duration=1 / 30,
+                max_frame_duration=2,
+                duration_target=True,
+            ),
+        )
+        self.assertEqual(duration, duration)
+        self.assertEqual(frame_duration, duration / frames)
+        self.assertLessEqual(frame_duration, max_frame_duration)
+        self.assertGreaterEqual(frame_duration, min_frame_duration)
+
+    def test_img_right(self):
+        res = self.small_video(1, bch.RenderCfg(duration=0.1, compose_method=bch.ComposeType.right))
+        self.assertEqual(res.size, (1, 2))
+        self.assertEqual(res.duration, 0.1)
+
+    def test_img_down(self):
+        res = self.small_video(1, bch.RenderCfg(duration=0.1, compose_method=bch.ComposeType.down))
+        self.assertEqual(res.size, (1, 2))
+        self.assertEqual(res.duration, 0.1)
+
+    def test_img_sequence(self):
+        res = self.small_video(
+            1, bch.RenderCfg(duration=0.1, compose_method=bch.ComposeType.sequence)
+        )
+        self.assertEqual(res.size, (1, 2))
+        self.assertEqual(res.duration, 0.1)
+
+    def test_img_right_x2(self):
+        res = self.small_video(2, bch.RenderCfg(compose_method=bch.ComposeType.right))
+        self.assertEqual(res.size, (2, 2))
+        self.assertEqual(res.duration, 2)
+
+    def test_img_down_x2(self):
+        res = self.small_video(2, bch.RenderCfg(compose_method=bch.ComposeType.down))
+        self.assertEqual(res.size, (1, 4))
+        self.assertEqual(res.duration, 2)
+
+    def test_img_seq_x2(self):
+        res = self.small_video(2, bch.RenderCfg(compose_method=bch.ComposeType.sequence))
+        self.assertEqual(res.size, (1, 2))
+        self.assertEqual(res.duration, 4)
+
+    def test_video_seq(self):
+        img = self.small_img()
+        vid1 = bch.ComposableContainerVideo()
+        vid1.append(img)
+        vid1.append(img)
+
+        res = vid1.deep().render(
+            bch.RenderCfg(duration=0.1, compose_method=bch.ComposeType.sequence)
+        )
+
+        self.assertEqual(res.size, (1, 2))
+        self.assertEqual(res.duration, 0.1)  # two frames
+
+        render_cfg = bch.RenderCfg(
+            duration=10.0,
+            duration_target=True,
+            min_frame_duration=1.0 / 30,
+            max_frame_duration=1.0,
+        )
+
+        res = vid1.deep().render(render_cfg)
+
+        self.assertEqual(res.size, (1, 2))
+        self.assertEqual(res.duration, 2.0)  # 2 frames of minimum frame time 1.0
+
+        vid1.append(img)
+
+        res = vid1.render(render_cfg)
+        self.assertEqual(res.size, (1, 2))
+        self.assertEqual(res.duration, 3.0)  # 3 frames of minimum frame time 1.0
+
+    def test_concat_equal_video_len(self):
+        render_cfg = bch.RenderCfg(duration_target=True)
+        res1 = self.small_video(num_frames=2, render_cfg=render_cfg)
+        res2 = self.small_video(num_frames=2, render_cfg=render_cfg)
+
+        self.assertEqual(res1.size, (1, 2))
+        self.assertEqual(res1.duration, 4.0)  # 2 frames of minimum frame time 2.0
+
+        self.assertEqual(res2.size, (1, 2))
+        self.assertEqual(res2.duration, 4.0)  # 1 frames of minimum frame time 2.0
+
+        vid = bch.ComposableContainerVideo()
+
+        vid.append(res1)
+        vid.append(res2)
+
+        res = vid.deep().render(bch.RenderCfg(bch.ComposeType.right))
+        self.assertEqual(res.size, (2, 2))
+        self.assertEqual(res.duration, 4.0)  # the duration of the longer clip
+
+        res = vid.deep().render(bch.RenderCfg(bch.ComposeType.down))
+        self.assertEqual(res.size, (1, 4))
+        self.assertEqual(res.duration, 4.0)  # the duration of the longer clip
+
+        res = vid.deep().render(bch.RenderCfg(bch.ComposeType.sequence))
+        self.assertEqual(res.size, (1, 2))
+        self.assertEqual(res.duration, 8.0)  # the duration of both clips
+
+    def test_concat_unequal_video_len(self):
+        render_cfg = bch.RenderCfg(duration_target=True)
+        res1 = self.small_video(num_frames=2, render_cfg=render_cfg)
+        self.assertEqual(res1.size, (1, 2))
+        self.assertEqual(res1.duration, 4.0)  # 3 frames of minimum frame time 1.0
+
+        res2 = self.small_video(num_frames=3, render_cfg=render_cfg)
+        self.assertEqual(res2.size, (1, 2))
+        self.assertEqual(res2.duration, 6.0)  # 3 frames of minimum frame time 1.0
+
+        vid = bch.ComposableContainerVideo()
+
+        vid.append(res1)
+        vid.append(res2)
+
+        res = vid.deep().render(bch.RenderCfg(bch.ComposeType.right))
+        self.assertEqual(res.size, (2, 2))
+        self.assertEqual(res.duration, 6.0)  # the duration of the longer clip
+
+        res = vid.deep().render(bch.RenderCfg(bch.ComposeType.down))
+        self.assertEqual(res.size, (1, 4))
+        self.assertEqual(res.duration, 6.0)  # the duration of the longer clip
+
+        res = vid.deep().render(bch.RenderCfg(bch.ComposeType.sequence))
+        self.assertEqual(res.size, (1, 2))
+        self.assertEqual(res.duration, 10.0)  # the duration of both clips
+
+        res_label = vid.deep().render(bch.RenderCfg(bch.ComposeType.sequence))
+        self.assertEqual(res.duration, res_label.duration)  # the duration of both clips
+
+    def test_bad_filetype(self):
+        vid = bch.ComposableContainerVideo()
+        with self.assertRaises(RuntimeWarning):
+            vid.append("bad.badextension")
+
+    def test_simple_image_length(self):
+        ccv = bch.ComposableContainerVideo()
+        ccv.append(self.small_img())
+        ccv.append(self.small_img())
+
+        res = ccv.render()
+        self.assertEqual(res.duration, 4.0)  # limited by maximum frame time
+
+        ccv = bch.ComposableContainerVideo()
+        for _ in range(20):
+            ccv.append(self.small_img())
+
+        self.assertEqual(ccv.render().duration, 10.0)  # limited by target video duration
+
+        ccv = bch.ComposableContainerVideo()
+        for _ in range(200):
+            ccv.append(self.small_img())
+
+        # still limited by target video duration
+        self.assertAlmostEqual(ccv.render().duration, 10.0)
+
+    def test_composite_image_length(self):
+        ccv = bch.ComposableContainerVideo()
+
+        for _ in range(2):
+            sub_img = bch.ComposableContainerVideo()
+            sub_img.append(self.small_img())
+            sub_img.append(self.small_img())
+            sub_img.append(self.small_img())
+            ccv.append(sub_img.render(compose_method=bch.ComposeType.right))
+
+        # should be 4 because there are two sequential frames
+        self.assertEqual(ccv.render().duration, 4.0)
+
+        ccv = bch.ComposableContainerVideo()
+
+        for _ in range(5):
+            sub_img = bch.ComposableContainerVideo()
+            sub_img.append(self.small_img())
+            sub_img.append(self.small_img())
+            sub_img.append(self.small_img())
+            ccv.append(sub_img.render(compose_method=bch.ComposeType.right))
+
+        # should be 10 because of the default target length
+        self.assertEqual(ccv.render().duration, 10.0)
+
+    def test_video_lengths(self):
+        ccv = bch.ComposableContainerVideo()
+        ccv.append(self.small_video())
+        ccv.append(self.small_video())
+
+        res = ccv.render()
+        self.assertEqual(res.duration, 8.0)  # no frame limits, just concat videos
+
+        ccv = bch.ComposableContainerVideo()
+        for _ in range(20):
+            ccv.append(self.small_video())
+
+        self.assertEqual(ccv.render().duration, 80.0)  # concatted vid time
+
+        ccv = bch.ComposableContainerVideo()
+        for _ in range(200):
+            ccv.append(self.small_video())
+
+        # still concatted vid time
+        self.assertAlmostEqual(ccv.render().duration, 800.0)
+
+
+if __name__ == "__main__":
+    tst = TestComposableContainerVideo()
+
+    tst.test_img_right()
+
+    unittest.main()

{holobench-1.22.2 → holobench-1.24.0}/test/test_utils.py

@@ -9,6 +9,7 @@ from bencher.utils import (
     lerp,
     listify,
     tabs_in_markdown,
+    mult_tuple,
 )
 from functools import partial
 import xarray as xr
@@ -78,6 +79,9 @@ class TestBencherUtils(unittest.TestCase):
             bch.hmap_canonical_input(dic2),
         )
 
+    def test_mult_tuple(self) -> None:
+        self.assertTupleEqual(mult_tuple((1, 2, 3), 2), (2, 4, 6))
+
     # Tests that the function returns the nearest coordinate name value pair for a dataset containing multiple coordinates
     def test_multiple_coordinates(self):
         ds = xr.Dataset({"x": [1, 2, 3], "y": [4, 5, 6]})

holobench-1.22.2/bencher/video_writer.py

@@ -1,121 +0,0 @@
-import numpy as np
-import moviepy.video.io.ImageSequenceClip
-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
-
-
-class VideoWriter:
-    def __init__(self, filename: str = "vid") -> None:
-        self.images = []
-        self.image_files = []
-        self.video_files = []
-        self.filename = gen_video_path(filename)
-
-    def append(self, img):
-        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)
-        return self.filename
-
-    @staticmethod
-    def create_label(label, width=None, height=14):
-        if width is None:
-            width = len(label) * 8
-        new_img = Image.new("RGB", (width, height), (255, 255, 255))
-        # 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)
-
-        return new_img
-
-    @staticmethod
-    def label_image(path: Path, label, padding=20) -> Path:
-        image = Image.open(path)
-        new_img = VideoWriter.create_label(label, image.size[0], image.size[1] + padding)
-        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",
-            audio=False,
-            bitrate="0",
-            fps=fps,
-            ffmpeg_params=["-crf", "34"],
-        )
-        video_clip.close()
-        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