holobench 1.19.0__py2.py3-none-any.whl → 1.30.1__py2.py3-none-any.whl

bencher/example/meta/example_meta_levels.py

@@ -11,8 +11,8 @@ def example_meta_levels(
         title="Using Levels to define sample density",
         description="Sample levels let you perform parameter sweeps without having to decide how many samples to take when defining the class.  If you perform a sweep at level 2, then all the points are reused when sampling at level 3.  The higher levels reuse the points from lower levels to avoid having to recompute potentially expensive samples. The other advantage is that it enables a workflow where you can quickly see the results of the sweep at a low resolution to sense check the code, and then run it at a high level to get the fidelity you want.  When calling a sweep at a high level, you can publish the intermediate lower level results as the computiation continues so that you can track the progress of the computation and end the sweep early when you have sufficient resolution",
         input_vars=[
-            BenchMeta.param.float_vars.with_sample_values([1, 2]),
-            BenchMeta.param.level.with_sample_values([2, 3, 4]),
+            bch.p("float_vars", [1, 2]),
+            bch.p("level", [2, 3, 4]),
         ],
         const_vars=[
             BenchMeta.param.categorical_vars.with_const(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}```")

bencher/plotting/plt_cnt_cfg.py

@@ -47,6 +47,7 @@ class PltCntCfg(param.Parameterized):
         plt_cnt_cfg.float_vars = []
 
         for iv in bench_cfg.input_vars:
+            type_allocated = False
             if isinstance(iv, (IntSweep, FloatSweep, TimeSnapshot)):
                 # if "IntSweep" in typestr or "FloatSweep" in typestr:
                 plt_cnt_cfg.float_vars.append(iv)

bencher/results/bench_result.py

@@ -7,15 +7,17 @@ from bencher.results.video_summary import VideoSummaryResult
 from bencher.results.panel_result import PanelResult
 from bencher.results.plotly_result import PlotlyResult
 from bencher.results.holoview_result import HoloviewResult
+from bencher.results.dataset_result import DataSetResult
 from bencher.utils import listify
 
 
-class BenchResult(PlotlyResult, HoloviewResult, VideoSummaryResult):
+class BenchResult(PlotlyResult, HoloviewResult, VideoSummaryResult, DataSetResult):
     """Contains the results of the benchmark and has methods to cast the results to various datatypes and graphical representations"""
 
     def __init__(self, bench_cfg) -> None:
         PlotlyResult.__init__(self, bench_cfg)
         HoloviewResult.__init__(self, bench_cfg)
+        # DataSetResult.__init__(self.bench_cfg)
 
     @staticmethod
     def default_plot_callbacks():

bencher/results/bench_result_base.py

@@ -19,9 +19,7 @@ from bencher.variables.results import ResultVar
 from bencher.plotting.plot_filter import VarRange, PlotFilter
 from bencher.utils import listify
 
-from bencher.variables.results import (
-    ResultReference,
-)
+from bencher.variables.results import ResultReference, ResultDataSet
 
 from bencher.results.composable_container.composable_container_panel import ComposableContainerPanel
 
@@ -242,6 +240,46 @@ class BenchResultBase(OptunaResult):
             row.append(plot_callback(rv))
         return row.get()
 
+    @staticmethod
+    def zip_results1D(args):  # pragma: no cover
+        first_el = [a[0] for a in args]
+        out = pn.Column()
+        for a in zip(*first_el):
+            row = pn.Row()
+            row.append(a[0])
+            for a1 in range(1, len(a[1])):
+                row.append(a[a1][1])
+            out.append(row)
+        return out
+
+    @staticmethod
+    def zip_results1D1(panel_list):  # pragma: no cover
+        container_args = {"styles": {}}
+        container_args["styles"]["border-bottom"] = f"{2}px solid grey"
+        print(panel_list)
+        out = pn.Column()
+        for a in zip(*panel_list):
+            row = pn.Row(**container_args)
+            row.append(a[0][0])
+            for a1 in range(0, len(a)):
+                row.append(a[a1][1])
+            out.append(row)
+        return out
+
+    @staticmethod
+    def zip_results1D2(panel_list):  # pragma: no cover
+        if panel_list is not None:
+            print(panel_list)
+            primary = panel_list[0]
+            secondary = panel_list[1:]
+            for i in range(len(primary)):
+                print(type(primary[i]))
+                if isinstance(primary[i], (pn.Column, pn.Row)):
+                    for j in range(len(secondary)):
+                        primary[i].append(secondary[j][i][1])
+            return primary
+        return panel_list
+
     def map_plot_panes(
         self,
         plot_callback: callable,
@@ -250,6 +288,7 @@ class BenchResultBase(OptunaResult):
         result_var: ResultVar = None,
         result_types=None,
         pane_collection: pn.pane = None,
+        zip_results=False,
         **kwargs,
     ) -> Optional[pn.Row]:
         if hv_dataset is None:
@@ -271,6 +310,9 @@ class BenchResultBase(OptunaResult):
                         target_dimension=target_dimension,
                     )
                 )
+
+        if zip_results:
+            return self.zip_results1D2(row.get())
         return row.get()
 
     def filter(
@@ -365,7 +407,7 @@ class BenchResultBase(OptunaResult):
                 sliced = dataset.isel({selected_dim: i})
                 label_val = sliced.coords[selected_dim].values.item()
                 inner_container = ComposableContainerPanel(
-                    outer_container.name,
+                    name=outer_container.name,
                     width=num_dims - target_dimension,
                     var_name=selected_dim,
                     var_value=label_val,
@@ -405,15 +447,23 @@ class BenchResultBase(OptunaResult):
             return da_ds.values.squeeze().item()
         return da.expand_dims(dim).values[0]
 
-    def ds_to_container(
+    def ds_to_container(  # pylint: disable=too-many-return-statements
         self, dataset: xr.Dataset, result_var: Parameter, container, **kwargs
     ) -> Any:
         val = self.zero_dim_da_to_val(dataset[result_var.name])
+        if isinstance(result_var, ResultDataSet):
+            ref = self.dataset_list[val]
+            if ref is not None:
+                if container is not None:
+                    return container(ref.obj)
+                return ref.obj
+            return None
         if isinstance(result_var, ResultReference):
             ref = self.object_index[val]
-            val = ref.obj
-            if ref.container is not None:
-                return ref.container(val, **kwargs)
+            if ref is not None:
+                val = ref.obj
+                if ref.container is not None:
+                    return ref.container(val, **kwargs)
         if container is not None:
             return container(val, styles={"background": "white"}, **kwargs)
         try:

bencher/results/composable_container/composable_container_base.py

@@ -1,18 +1,38 @@
-from enum import Enum, auto
-from typing import Any
+from enum import auto
+from typing import Any, List
+from dataclasses import dataclass, field
+from strenum import StrEnum
 from bencher.results.float_formatter import FormatFloat
 
 
 # TODO enable these options
-class ComposeType(Enum):
+class ComposeType(StrEnum):
     right = auto()  # append the container to the right (creates a row)
     down = auto()  # append the container below (creates a column)
-    overlay = auto()  # overlay on top of the current container (alpha blending)
     sequence = auto()  # display the container after (in time)
+    overlay = auto()  # overlay on top of the current container (alpha blending)
 
+    def flip(self):
+        match self:
+            case ComposeType.right:
+                return ComposeType.down
+            case ComposeType.down:
+                return ComposeType.right
+            case _:
+                raise RuntimeError("cannot flip this type")
+
+    @staticmethod
+    def from_horizontal(horizontal: bool):
+        return ComposeType.right if horizontal else ComposeType.down
 
+
+@dataclass(kw_only=True)
 class ComposableContainerBase:
-    """A base class for renderer backends.  A composable renderr"""
+    """A base class for renderer backends.  A composable renderer"""
+
+    compose_method: ComposeType = ComposeType.right
+    container: List[Any] = field(default_factory=list)
+    label_len: int = 0
 
     @staticmethod
     def label_formatter(var_name: str, var_value: int | float | str) -> str:
@@ -36,13 +56,6 @@ class ComposableContainerBase:
             return f"{var_value}"
         return None
 
-    def __init__(
-        self, horizontal: bool = True, compose_method: ComposeType = ComposeType.right
-    ) -> None:
-        self.horizontal: bool = horizontal
-        self.compose_method = compose_method
-        self.container = []
-
     def append(self, obj: Any) -> None:
         """Add an object to the container.  The relationship between the objects is defined by the ComposeType
 

bencher/results/composable_container/composable_container_dataframe.py

@@ -0,0 +1,52 @@
+from dataclasses import dataclass
+import panel as pn
+import xarray as xr
+from bencher.results.composable_container.composable_container_base import ComposableContainerBase
+from bencher.results.composable_container.composable_container_base import ComposeType
+
+
+@dataclass(kw_only=True)
+class ComposableContainerDataset(ComposableContainerBase):
+    name: str = None
+    var_name: str = None
+    var_value: str = None
+    width: int = None
+    background_col: str = None
+    horizontal: bool = True
+
+    def __post_init__(
+        self,
+    ) -> None:
+        container_args = {
+            "name": self.name,
+            "styles": {},
+        }
+
+        if self.width is not None:
+            container_args["styles"]["border-bottom"] = f"{self.width}px solid grey"
+        if self.background_col is not None:
+            container_args["styles"]["background"] = self.background_col
+
+        if self.horizontal:
+            self.container = pn.Column(**container_args)
+            align = ("center", "center")
+        else:
+            self.container = pn.Row(**container_args)
+            align = ("end", "center")
+
+        label = self.label_formatter(self.var_name, self.var_value)
+        if label is not None:
+            self.label_len = len(label)
+            side = pn.pane.Markdown(label, align=align)
+            self.append(side)
+
+    def render(self, **kwargs):  # pylint: disable=unused-argument
+        match self.compose_method:
+            case ComposeType.right:
+                return xr.concat(self.container, 0)
+            case ComposeType.down:
+                return xr.concat(self.container, 1)
+            case ComposeType.sequence:
+                return xr.concat(self.container, 2)
+            # case ComposeType.overlay:
+            # return xr.Dataset.mean()

bencher/results/composable_container/composable_container_panel.py

@@ -1,39 +1,38 @@
 import panel as pn
 from bencher.results.composable_container.composable_container_base import ComposableContainerBase
+from dataclasses import dataclass
 
 
+@dataclass(kw_only=True)
 class ComposableContainerPanel(ComposableContainerBase):
-    def __init__(
+    name: str = None
+    var_name: str = None
+    var_value: str = None
+    width: int = None
+    background_col: str = None
+    horizontal: bool = True
+
+    def __post_init__(
         self,
-        name: str = None,
-        var_name: str = None,
-        var_value: str = None,
-        width: int = None,
-        background_col: str = None,
-        horizontal: bool = True,
     ) -> None:
-        super().__init__(horizontal)
-
         container_args = {
-            "name": name,
+            "name": self.name,
             "styles": {},
         }
 
-        self.name = name
-
-        if width is not None:
-            container_args["styles"]["border-bottom"] = f"{width}px solid grey"
-        if background_col is not None:
-            container_args["styles"]["background"] = background_col
+        if self.width is not None:
+            container_args["styles"]["border-bottom"] = f"{self.width}px solid grey"
+        if self.background_col is not None:
+            container_args["styles"]["background"] = self.background_col
 
-        if horizontal:
+        if self.horizontal:
             self.container = pn.Column(**container_args)
             align = ("center", "center")
         else:
             self.container = pn.Row(**container_args)
             align = ("end", "center")
 
-        label = self.label_formatter(var_name, var_value)
+        label = self.label_formatter(self.var_name, self.var_value)
         if label is not None:
             self.label_len = len(label)
             side = pn.pane.Markdown(label, align=align)

bencher/results/composable_container/composable_container_video.py

@@ -1,76 +1,184 @@
+from __future__ import annotations
 import numpy as np
+from copy import deepcopy
+from pathlib import Path
+from dataclasses import dataclass
 from moviepy.editor import (
     ImageClip,
     CompositeVideoClip,
     clips_array,
     concatenate_videoclips,
     VideoClip,
+    VideoFileClip,
 )
+from moviepy.video.fx.margin import margin
 
-from bencher.results.composable_container.composable_container_base import ComposableContainerBase
+from bencher.results.composable_container.composable_container_base import (
+    ComposableContainerBase,
+    ComposeType,
+)
 from bencher.video_writer import VideoWriter
 
 
+@dataclass()
+class RenderCfg:
+    compose_method: ComposeType = ComposeType.sequence
+    var_name: str = None
+    var_value: str = None
+    background_col: tuple[int, int, int] = (255, 255, 255)
+    duration: float = 10.0
+    duration_target: bool = True
+    min_frame_duration: float = 1.0 / 30
+    max_frame_duration: float = 2.0
+    margin: int = 0
+
+
+@dataclass
 class ComposableContainerVideo(ComposableContainerBase):
-    def __init__(
-        self,
-        name: str = None,
-        var_name: str = None,
-        var_value: str = None,
-        background_col: tuple[3] = (255, 255, 255),
-        horizontal: bool = True,
-        target_duration: float = None,
-    ) -> None:
-        super().__init__(horizontal)
-        self.name = name
-        self.container = []
-        self.background_col = background_col
-        self.target_duration = 10 if target_duration is None else target_duration
-        self.var_name = var_name
-
-        self.label = self.label_formatter(var_name, var_value)
-        if self.label is not None:
-            self.label_len = len(self.label)
-
-        # label = self.label_formatter(var_name, var_value)
-        # if label is not None:
-        # self.label_len = len(label)
-        # side = pn.pane.Markdown(label, align=align)
-        # self.append(side)
-
-    def append(self, obj: VideoClip | str) -> None:
-        if isinstance(obj, VideoClip):
-            self.container.append(obj)
+    def append(self, obj: VideoClip | ImageClip | str | np.ndarray) -> None:
+        """Appends an image or video to the container
+
+        Args:
+            obj (VideoClip | ImageClip | str | np.ndarray): Any representation of an image or video
+
+        Raises:
+            RuntimeWarning: if file format is not recognised
+        """
+
+        # print(f"append obj: {type(obj)}, {obj}")
+        if obj is not None:
+            if isinstance(obj, VideoClip):
+                self.container.append(obj)
+            elif isinstance(obj, ComposableContainerVideo):
+                self.container.append(obj.render())
+            elif isinstance(obj, np.ndarray):
+                self.container.append(ImageClip(obj))
+            else:
+                path = Path(obj)
+                extension = str.lower(path.suffix)
+                if extension in [".jpg", ".jepg", ".png"]:
+                    self.container.append(ImageClip(obj))
+                elif extension in [".mpeg", ".mpg", ".mp4", ".webm"]:
+                    # print(obj)
+                    self.container.append(VideoFileClip(obj))
+                else:
+                    raise RuntimeWarning(f"unsupported filetype {extension}")
+        else:
+            raise RuntimeWarning("No data passed to ComposableContainerVideo.append()")
+
+    def calculate_duration(self, frames, render_cfg: RenderCfg):
+        if render_cfg.duration_target:
+            # calculate duration based on fps constraints
+            duration = 10.0 if render_cfg.duration is None else render_cfg.duration
+            frame_duration = duration / frames
+            if render_cfg.min_frame_duration is not None:
+                frame_duration = max(frame_duration, render_cfg.min_frame_duration)
+            if render_cfg.max_frame_duration is not None:
+                frame_duration = min(frame_duration, render_cfg.max_frame_duration)
+            duration = frame_duration * frames
         else:
-            # if self.label is not None:
-            # img_obj = np.array(VideoWriter.label_image(obj, self.label))
-            # else:
-            # img_obj = obj
-            self.container.append(ImageClip(obj))
+            duration = render_cfg.duration
+            frame_duration = duration / float(frames)
+
+        print("max_frame_duration", render_cfg.max_frame_duration)
+        print("DURATION", duration)
+
+        return duration, frame_duration
+
+    def render(self, render_cfg: RenderCfg = None, **kwargs) -> CompositeVideoClip:
+        """Composes the images/videos into a single image/video based on the type of compose method
 
-    def render(self, concatenate: bool = False) -> CompositeVideoClip:
-        fps = len(self.container) / self.target_duration
-        fps = max(fps, 1.0)  # never slower that 1 seconds per frame
-        fps = min(fps, 30.0)
+        Args:
+            compose_method (ComposeType, optional): optionally override the default compose type. Defaults to None.
+
+        Returns:
+            CompositeVideoClip: A composite video clip containing the images/videos added via append()
+        """
+        if render_cfg is None:
+            render_cfg = RenderCfg(**kwargs)
+
+        print("rc", render_cfg)
+        _, frame_duration = self.calculate_duration(float(len(self.container)), render_cfg)
+        out = None
+        print(f"using compose type{render_cfg.compose_method}")
+        max_duration = 0.0
 
         for i in range(len(self.container)):
-            self.container[i].duration = 1.0 / fps
-        if concatenate:
-            out = concatenate_videoclips(self.container)
-        else:
-            if self.horizontal:
-                clips = [self.container]
-            else:
-                clips = [[c] for c in self.container]
-            out = clips_array(clips, bg_color=self.background_col)
-
-        if self.label is not None:
-            label = ImageClip(np.array(VideoWriter.create_label(self.label)))
-            con2 = ComposableContainerVideo(
-                background_col=self.background_col,
-                horizontal=not self.horizontal,
+            if self.container[i].duration is None:
+                self.container[i].duration = frame_duration
+            max_duration = max(max_duration, self.container[i].duration)
+        match render_cfg.compose_method:
+            case ComposeType.right | ComposeType.down:
+                for i in range(len(self.container)):
+                    self.container[i] = self.extend_clip(self.container[i], max_duration)
+                    self.container[i] = margin(
+                        self.container[i], top=render_cfg.margin, color=render_cfg.background_col
+                    )
+
+                if render_cfg.compose_method == ComposeType.right:
+                    clips = [self.container]
+                else:
+                    clips = [[c] for c in self.container]
+                out = clips_array(clips, bg_color=render_cfg.background_col)
+                if out.duration is None:
+                    out.duration = max_duration
+            case ComposeType.sequence:
+                out = concatenate_videoclips(
+                    self.container, bg_color=render_cfg.background_col, method="compose"
+                )
+            # case ComposeType.overlay:
+            #     for i in range(len(self.container)):
+            #         self.container[i].alpha = 1./len(self.container)
+            #     out = CompositeVideoClip(self.container, bg_color=render_args.background_col)
+            #     out.duration = fps
+            case _:
+                raise RuntimeError("This compose type is not supported")
+
+        label = self.label_formatter(render_cfg.var_name, render_cfg.var_value)
+        if label is not None:
+            # print("adding label")
+            label = ImageClip(
+                np.array(VideoWriter.create_label(label, color=render_cfg.background_col))
             )
+            label.duration = out.duration
+            label_compose = ComposeType.down
+            if render_cfg.compose_method == ComposeType.down:
+                label_compose = ComposeType.right
+            con2 = ComposableContainerVideo()
             con2.append(label)
             con2.append(out)
-            return con2.render()
+            return con2.render(
+                RenderCfg(
+                    background_col=render_cfg.background_col,
+                    compose_method=label_compose,
+                    duration=out.duration,
+                    duration_target=False,  # want exact duration
+                )
+            )
         return out
+
+    def to_video(
+        self,
+        render_args: RenderCfg = None,
+    ) -> str:
+        """Returns the composite video clip as a webm file path
+
+        Returns:
+            str: webm filepath
+        """
+        return VideoWriter().write_video_raw(self.render(render_args))
+
+    def deep(self):
+        return deepcopy(self)
+
+    def extend_clip(self, clip: VideoClip, desired_duration: float):
+        if clip.duration < desired_duration:
+            return concatenate_videoclips(
+                [
+                    clip,
+                    ImageClip(
+                        clip.get_frame(clip.duration), duration=desired_duration - clip.duration
+                    ),
+                ]
+            )
+        return clip