holobench 1.40.1__tar.gz → 1.41.0__tar.gz

holobench-1.41.0/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.3.10]
+
+Before changelogs

{holobench-1.40.1 → holobench-1.41.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: holobench
-Version: 1.40.1
+Version: 1.41.0
 Summary: A package for benchmarking the performance of arbitrary functions
 Project-URL: Repository, https://github.com/dyson-ai/bencher
 Project-URL: Home, https://github.com/dyson-ai/bencher
@@ -12,28 +12,24 @@ Requires-Python: <3.13,>=3.10
 Requires-Dist: diskcache<=5.6.3,>=5.6
 Requires-Dist: holoviews<=1.20.0,>=1.15
 Requires-Dist: hvplot<=0.10.0,>=0.8
-Requires-Dist: matplotlib<=3.10.0,>=3.6.3
-Requires-Dist: moviepy-fix-codec
-Requires-Dist: numpy<=2.2.2,>=1.0
-Requires-Dist: optuna<=4.2.0,>=3.2
+Requires-Dist: moviepy<=2.1.2,>=2.1.2
+Requires-Dist: numpy<=2.2.3,>=1.0
+Requires-Dist: optuna<=4.2.1,>=3.2
 Requires-Dist: pandas<=2.2.3,>=2.0
-Requires-Dist: panel<=1.6.0,>=1.3.6
+Requires-Dist: panel<=1.6.1,>=1.3.6
 Requires-Dist: param<=2.2.0,>=1.13.0
 Requires-Dist: plotly<=6.0.0,>=5.15
 Requires-Dist: scikit-learn<=1.6.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<=2025.1.2,>=2023.7
 Provides-Extra: rerun
 Requires-Dist: flask; extra == 'rerun'
 Requires-Dist: flask-cors; extra == 'rerun'
 Requires-Dist: rerun-notebook; extra == 'rerun'
-Requires-Dist: rerun-sdk==0.21.0; extra == 'rerun'
+Requires-Dist: rerun-sdk==0.22.0; extra == 'rerun'
 Provides-Extra: test
-Requires-Dist: coverage<=7.6.10,>=7.5.4; extra == 'test'
-Requires-Dist: hypothesis<=6.124.9,>=6.104.2; extra == 'test'
+Requires-Dist: coverage<=7.6.12,>=7.5.4; extra == 'test'
+Requires-Dist: hypothesis<=6.125.3,>=6.104.2; extra == 'test'
 Requires-Dist: ipykernel; extra == 'test'
 Requires-Dist: jupyter-bokeh; extra == 'test'
 Requires-Dist: nbformat; extra == 'test'
@@ -42,7 +38,7 @@ Requires-Dist: pre-commit<=4.1.0; extra == 'test'
 Requires-Dist: pylint<=3.3.4,>=3.2.5; extra == 'test'
 Requires-Dist: pytest-cov<=6.0.0,>=4.1; extra == 'test'
 Requires-Dist: pytest<=8.3.4,>=7.4; extra == 'test'
-Requires-Dist: ruff<=0.9.4,>=0.5.0; extra == 'test'
+Requires-Dist: ruff<=0.9.6,>=0.5.0; extra == 'test'
 Description-Content-Type: text/markdown
 
 # Bencher

{holobench-1.40.1 → holobench-1.41.0}/bencher/bench_cfg.py

@@ -6,7 +6,6 @@ import logging
 from typing import List
 
 import param
-from str2bool import str2bool
 import panel as pn
 from datetime import datetime
 
@@ -197,11 +196,8 @@ class BenchRunCfg(BenchPlotSrvCfg):
 
         parser.add_argument(
             "--nightly",
-            type=lambda b: bool(str2bool(b)),
-            nargs="?",
-            const=False,
-            default=False,
-            help="turn on nightly benchmarking",
+            action="store_true",
+            help="Turn on nightly benchmarking",
         )
 
         parser.add_argument(
@@ -351,7 +347,7 @@ class BenchCfg(BenchRunCfg):
         latex = self.to_latex()
         desc = pn.pane.Markdown(self.describe_benchmark(), width=width)
         if accordion:
-            desc = pn.Accordion(("Data Collection Parameters", desc))
+            desc = pn.Accordion(("Expand Full Data Collection Parameters", desc))
 
         sentence = self.sweep_sentence()
         if latex is not None:

{holobench-1.40.1 → holobench-1.41.0}/bencher/caching.py

@@ -3,9 +3,6 @@ from diskcache import Cache
 from bencher.variables.parametrised_sweep import ParametrizedSweep
 from bencher.utils import hash_sha1
 import logging
-from sortedcontainers import SortedDict
-
-# from job import job,JobCache,JobFunctionCache
 
 
 class CachedParams(ParametrizedSweep):
@@ -20,7 +17,7 @@ class CachedParams(ParametrizedSweep):
             self.cache.clear()
 
     def kwargs_to_hash_key(self, **kwargs):
-        return tuple(SortedDict(kwargs).items())
+        return tuple(sorted(kwargs.items(), key=lambda item: str(item[0])))
 
     def in_cache(self, **kwargs):
         self.update_params_from_kwargs(**kwargs)

holobench-1.41.0/bencher/example/example_composable_container_image.py

@@ -0,0 +1,60 @@
+import bencher as bch
+
+from bencher.example.example_image import BenchPolygons
+
+
+class BenchComposableContainerImage(BenchPolygons):
+    compose_method = bch.EnumSweep(bch.ComposeType)
+    labels = bch.BoolSweep()
+    num_frames = bch.IntSweep(default=5, bounds=[1, 100])
+
+    polygon_vid = bch.ResultVideo()
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+        var_name = None
+        var_value = None
+
+        if self.labels:
+            var_name = "sides"
+            var_value = self.sides
+        vr = bch.ComposableContainerVideo()
+        for i in range(self.num_frames):
+            res = super().__call__(start_angle=i)
+            print(res)
+            vr.append(res["polygon"])
+        self.polygon_vid = vr.to_video(
+            bch.RenderCfg(
+                compose_method=self.compose_method,
+                var_name=var_name,
+                var_value=var_value,
+                max_frame_duration=1.0 / 20.0,
+            )
+        )
+        return self.get_results_values_as_dict()
+
+
+def example_composable_container_image(
+    run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None
+) -> bch.Bench:
+    bench = BenchComposableContainerImage().to_bench(run_cfg, report)
+    # bench.add_plot_callback(bch.BenchResult.to_panes)
+    # bench.add_plot_callback(bch.BenchResult.to_video_grid, result_types=(bch.ResultVideo))
+    # bench.add_plot_callback(bch.BenchResult.to_video_summary, result_types=(bch.ResultVideo))
+    # bench.plot_sweep(input_vars=["compose_method", "labels"])
+
+    bench.plot_sweep(input_vars=["compose_method"])
+
+    # bench.compose_
+    # bench.plot_sweep(
+    # input_vars=[bch.p("num_frames", [2, 8, 20])],
+    # const_vars=dict(compose_method=bch.ComposeType.sequence),
+    # )
+
+    return bench
+
+
+if __name__ == "__main__":
+    ex_run_cfg = bch.BenchRunCfg()
+    ex_composable_image = example_composable_container_image(ex_run_cfg)
+    ex_composable_image.report.show()

holobench-1.41.0/bencher/example/example_composable_container_video.py

@@ -0,0 +1,49 @@
+import bencher as bch
+from bencher.example.example_composable_container_image import BenchComposableContainerImage
+
+
+class BenchComposableContainerVideo(bch.ParametrizedSweep):
+    unequal_length = bch.BoolSweep()
+    compose_method = bch.EnumSweep(bch.ComposeType)
+    labels = bch.BoolSweep()
+    polygon_vid = bch.ResultVideo()
+
+    def __call__(self, **kwargs):
+        self.update_params_from_kwargs(**kwargs)
+        vr = bch.ComposableContainerVideo()
+        for i in range(3, 5):
+            num_frames = i * 10 if self.unequal_length else 5
+            res = BenchComposableContainerImage().__call__(
+                compose_method=bch.ComposeType.sequence, sides=i, num_frames=num_frames
+            )
+            vr.append(res["polygon_vid"])
+
+        self.polygon_vid = vr.to_video(bch.RenderCfg(compose_method=kwargs.get("compose_method")))
+        return self.get_results_values_as_dict()
+
+
+def example_composable_container_video(
+    run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None
+) -> bch.Bench:
+    bench = BenchComposableContainerVideo().to_bench(run_cfg, report)
+
+    bench.result_vars = ["polygon_vid"]
+    bench.add_plot_callback(bch.BenchResult.to_panes)
+    bench.add_plot_callback(bch.BenchResult.to_video_grid, result_types=(bch.ResultVideo))
+    bench.add_plot_callback(bch.BenchResult.to_video_summary, result_types=(bch.ResultVideo))
+    bench.plot_sweep(input_vars=["compose_method", "labels"], const_vars=dict(unequal_length=True))
+
+    res = bench.plot_sweep(
+        input_vars=[],
+        const_vars=dict(unequal_length=False, compose_method=bch.ComposeType.sequence),
+        plot_callbacks=False,
+    )
+
+    bench.report.append(res.to_video_grid())
+
+    return bench
+
+
+if __name__ == "__main__":
+    ex_run_cfg = bch.BenchRunCfg()
+    example_composable_container_video(ex_run_cfg).report.show()

{holobench-1.40.1 → holobench-1.41.0}/bencher/example/example_image.py

@@ -1,7 +1,7 @@
 import bencher as bch
 import numpy as np
 import math
-import matplotlib.pyplot as plt
+from PIL import Image, ImageDraw
 
 
 def polygon_points(radius: float, sides: int, start_angle: float):
@@ -16,7 +16,6 @@ class BenchPolygons(bch.ParametrizedSweep):
     sides = bch.IntSweep(default=3, bounds=(3, 7))
     radius = bch.FloatSweep(default=1, bounds=(0.2, 1))
     linewidth = bch.FloatSweep(default=1, bounds=(1, 10))
-    linestyle = bch.StringSweep(["solid", "dashed", "dotted"])
     color = bch.StringSweep(["red", "green", "blue"])
     start_angle = bch.FloatSweep(default=0, bounds=[0, 360])
     polygon = bch.ResultImage()
@@ -26,33 +25,30 @@ class BenchPolygons(bch.ParametrizedSweep):
     def __call__(self, **kwargs):
         self.update_params_from_kwargs(**kwargs)
         points = polygon_points(self.radius, self.sides, self.start_angle)
-        # self.hmap = hv.Curve(points)
-        self.polygon = self.points_to_polygon_png(points, bch.gen_image_path("polygon"))
+        filepath = bch.gen_image_path("polygon")
+        self.polygon = self.points_to_polygon_png(points, filepath)
+        # Verify filepath is being returned
+        assert isinstance(self.polygon, str), f"Expected string filepath, got {type(self.polygon)}"
 
         self.side_length = 2 * self.radius * math.sin(math.pi / self.sides)
         self.area = (self.sides * self.side_length**2) / (4 * math.tan(math.pi / self.sides))
         return super().__call__()
 
     def points_to_polygon_png(self, points: list[float], filename: str):
-        """Draw a closed polygon and save to png"""
-        fig = plt.figure(frameon=False)
-        ax = plt.Axes(fig, [0.0, 0.0, 1.0, 1.0], frameon=False)
-        ax.set_axis_off()
-        ax.plot(
-            [p[0] for p in points],
-            [p[1] for p in points],
-            linewidth=self.linewidth,
-            linestyle=self.linestyle,
-            color=self.color,
-        )
-        ax.set_xlim(-1, 1)
-        ax.set_ylim(-1, 1)
+        """Draw a closed polygon and save to png using PIL"""
+        size = 300
+        img = Image.new("RGBA", (size, size), (0, 0, 0, 0))
+        draw = ImageDraw.Draw(img)
+
+        # Scale points to image size (from [-1,1] to [0,size])
+        scaled_points = [(((p[0] + 1) * size / 2), ((1 - p[1]) * size / 2)) for p in points]
 
-        ax.set_aspect("equal")
-        fig.add_axes(ax)
-        fig.savefig(filename, dpi=30)
+        # Draw polygon outline
+        draw.line(scaled_points, fill=self.color, width=int(self.linewidth))
 
-        return filename
+        img.save(filename, "PNG")
+        # Explicitly return the filename string
+        return str(filename)
 
 
 def example_image(run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None) -> bch.Bench:

{holobench-1.40.1 → holobench-1.41.0}/bencher/example/example_image1.py

@@ -1,7 +1,7 @@
 import bencher as bch
 import numpy as np
 import math
-import matplotlib.pyplot as plt
+from PIL import Image, ImageDraw
 
 
 def polygon_points(radius: float, sides: int, start_angle: float):
@@ -28,36 +28,32 @@ class BenchPolygons(bch.ParametrizedSweep):
     def __call__(self, **kwargs):
         self.update_params_from_kwargs(**kwargs)
         points = polygon_points(self.radius, self.sides, self.start_angle)
-        # self.hmap = hv.Curve(points)
-        self.polygon = self.points_to_polygon_png(points, bch.gen_image_path("polygon"), dpi=30)
+        filepath = bch.gen_image_path("polygon")
+        self.polygon = self.points_to_polygon_png(points, filepath, dpi=30)
         self.polygon_small = self.points_to_polygon_png(
             points, bch.gen_image_path("polygon"), dpi=10
         )
+        # Verify filepaths are being returned
+        assert isinstance(self.polygon, str), f"Expected string filepath, got {type(self.polygon)}"
+        assert isinstance(self.polygon_small, str), (
+            f"Expected string filepath, got {type(self.polygon_small)}"
+        )
 
         self.side_length = 2 * self.radius * math.sin(math.pi / self.sides)
         self.area = (self.sides * self.side_length**2) / (4 * math.tan(math.pi / self.sides))
         return super().__call__()
 
     def points_to_polygon_png(self, points: list[float], filename: str, dpi):
-        """Draw a closed polygon and save to png"""
-        fig = plt.figure(frameon=False)
-        ax = plt.Axes(fig, [0.0, 0.0, 1.0, 1.0], frameon=False)
-        ax.set_axis_off()
-        ax.plot(
-            [p[0] for p in points],
-            [p[1] for p in points],
-            linewidth=self.linewidth,
-            linestyle=self.linestyle,
-            color=self.color,
-        )
-        ax.set_xlim(-1, 1)
-        ax.set_ylim(-1, 1)
+        """Draw a closed polygon and save to png using PIL"""
+        size = int(100 * (dpi / 30))
+        img = Image.new("RGBA", (size, size), (0, 0, 0, 0))
+        draw = ImageDraw.Draw(img)
 
-        ax.set_aspect("equal")
-        fig.add_axes(ax)
-        fig.savefig(filename, dpi=dpi)
+        scaled_points = [(((p[0] + 1) * size / 2), ((1 - p[1]) * size / 2)) for p in points]
+        draw.line(scaled_points, fill=self.color, width=int(self.linewidth))
 
-        return filename
+        img.save(filename, "PNG")
+        return str(filename)
 
 
 def example_image_vid_sequential1(

{holobench-1.40.1 → holobench-1.41.0}/bencher/example/example_video.py

@@ -1,9 +1,24 @@
 import bencher as bch
 import numpy as np
-import matplotlib.pyplot as plt
+from PIL import Image
+import colorcet as cc
+import numpy.typing as npt
+
+
+def apply_colormap(data: npt.NDArray) -> npt.NDArray:
+    """Apply a perceptually uniform colormap to the data"""
+    # Normalize data to [0, 1]
+    normalized = (data - data.min()) / (data.max() - data.min())
+    # Convert hex colors to RGB values using numpy's frombuffer
+    colors = np.array(
+        [np.frombuffer(bytes.fromhex(c.lstrip("#")), dtype=np.uint8) for c in cc.rainbow]
+    )
+    # Map normalized values to colormap indices
+    indices = (normalized * (len(colors) - 1)).astype(int)
+    # Create RGB array from the colormap
+    return colors[indices]
 
 
-# code from https://ipython-books.github.io/124-simulating-a-partial-differential-equation-reaction-diffusion-systems-and-turing-patterns/
 class TuringPattern(bch.ParametrizedSweep):
     alpha = bch.FloatSweep(default=2.8e-4, bounds=(2e-4, 5e-3))
     beta = bch.FloatSweep(default=5e-3, bounds=(1e-3, 9e-3))
@@ -17,6 +32,7 @@ class TuringPattern(bch.ParametrizedSweep):
     video = bch.ResultVideo()
     score = bch.ResultVar()
     img = bch.ResultImage()
+    img_extracted = bch.ResultImage()
 
     def laplacian(self, Z, dx):
         Ztop = Z[0:-2, 1:-1]
@@ -49,28 +65,28 @@ class TuringPattern(bch.ParametrizedSweep):
     def __call__(self, **kwargs):
         self.update_params_from_kwargs(**kwargs)
 
-        n = int(self.time / self.dt)  # number of iterations
-        dx = 2.0 / self.size  # space step
+        n = int(self.time / self.dt)
+        dx = 2.0 / self.size
 
         U = np.random.rand(self.size, self.size)
         V = np.random.rand(self.size, self.size)
 
-        fig, ax = plt.subplots(frameon=False, figsize=(2, 2))
-        fig.set_tight_layout(True)
-        ax.set_axis_off()
         vid_writer = bch.VideoWriter()
         for i in range(n):
             self.update(U, V, dx)
             if i % 500 == 0:
-                ax.imshow(U)
-                fig.canvas.draw()
-                rgb = np.array(fig.canvas.renderer.buffer_rgba())
-                vid_writer.append(rgb)
-
-        self.img = bch.add_image(rgb)
-
+                # Apply colormap to create RGB image
+                rgb = apply_colormap(U)
+                # Create PIL image with alpha channel
+                img = Image.fromarray(rgb, "RGB").convert("RGBA")
+                img = img.resize((200, 200), Image.Resampling.LANCZOS)
+                rgb_alpha = np.array(img)
+                vid_writer.append(rgb_alpha)
+
+        self.img = bch.add_image(rgb_alpha)
         self.video = vid_writer.write()
-
+        self.img_extracted = bch.video_writer.VideoWriter.extract_frame(self.video)
+        print("img path", self.img_extracted)
         self.score = self.alpha + self.beta
         return super().__call__()
 
@@ -109,8 +125,8 @@ def example_video_tap(
 if __name__ == "__main__":
     run_cfg_ex = bch.BenchRunCfg()
     run_cfg_ex.level = 2
-    run_cfg_ex.cache_samples = True
-    run_cfg_ex.only_hash_tag = True
+    # run_cfg_ex.cache_samples = True
+    # run_cfg_ex.only_hash_tag = True
 
     # example_video(run_cfg_ex).report.show()
     example_video_tap(run_cfg_ex).report.show()

{holobench-1.40.1 → holobench-1.41.0}/bencher/example/experimental/example_hvplot_explorer.py

@@ -1,6 +1,5 @@
 # THIS IS NOT A WORKING EXAMPLE YET
 # pylint: disable=duplicate-code
-import hvplot
 import bencher as bch
 from bencher import ExampleBenchCfgIn, ExampleBenchCfgOut, bench_function
 
@@ -35,5 +34,5 @@ if __name__ == "__main__":
         ),
     )
 
-    hvexplorer = hvplot.explorer(bench_out.get_dataframe())
-    hvexplorer.show()
+    bench.report.append(bench_out.to_explorer())
+    bench.report.show()

holobench-1.41.0/bencher/example/inputs_1D/example_1_float_2_cat_repeats.py

@@ -0,0 +1,12 @@
+import bencher as bch
+from bencher.example.meta.example_meta import BenchableObject
+
+run_cfg = bch.BenchRunCfg()
+run_cfg.repeats = 20
+run_cfg.level = 4
+bench = BenchableObject().to_bench(run_cfg)
+res = bench.plot_sweep(
+    input_vars=["float1", "noisy", "noise_distribution"], result_vars=["distance", "sample_noise"]
+)
+
+bench.report.show()

{holobench-1.40.1 → holobench-1.41.0}/bencher/example/meta/generate_examples.py

@@ -48,3 +48,9 @@ if __name__ == "__main__":
     convert_example_to_jupyter_notebook(
         "/workspaces/bencher/bencher/example/inputs_1D/example_1_in_2_out_repeats.py", "1D"
     )
+
+    # todo, enable
+    # convert_example_to_jupyter_notebook(
+    #     "/workspaces/bencher/bencher/example/example_composable_container_video.py",
+    #     "Media",
+    # )

{holobench-1.40.1 → holobench-1.41.0}/bencher/job.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 from typing import Callable
-from sortedcontainers import SortedDict
 import logging
 from diskcache import Cache
 from concurrent.futures import Future, ProcessPoolExecutor
@@ -11,7 +10,6 @@ from enum import auto
 try:
     from scoop import futures as scoop_future_executor
 except ImportError as e:
-    logging.warning(e.msg)
     scoop_future_executor = None
 
 
@@ -23,7 +21,7 @@ class Job:
         self.function = function
         self.job_args = job_args
         if job_key is None:
-            self.job_key = hash_sha1(tuple(SortedDict(self.job_args).items()))
+            self.job_key = hash_sha1(tuple(sorted(self.job_args.items())))
         else:
             self.job_key = job_key
         self.tag = tag

{holobench-1.40.1 → holobench-1.41.0}/bencher/results/bench_result.py

@@ -53,6 +53,7 @@ class BenchResult(PlotlyResult, HoloviewResult, HvplotResult, VideoSummaryResult
         self,
         plot_list: List[callable] = None,
         remove_plots: List[callable] = None,
+        default_container=pn.Column,
         **kwargs,
     ) -> List[pn.panel]:
         self.plt_cnt_cfg.print_debug = False
@@ -67,7 +68,7 @@ class BenchResult(PlotlyResult, HoloviewResult, HvplotResult, VideoSummaryResult
 
         kwargs = self.set_plot_size(**kwargs)
 
-        row = EmptyContainer(pn.Row())
+        row = EmptyContainer(default_container())
         for plot_callback in plot_list:
             if self.plt_cnt_cfg.print_debug:
                 print(f"checking: {plot_callback.__name__}")

{holobench-1.40.1 → holobench-1.41.0}/bencher/results/bench_result_base.py

@@ -321,7 +321,7 @@ class BenchResultBase(OptunaResult):
         **kwargs,
     ) -> Optional[pn.Row]:
         if hv_dataset is None:
-            hv_dataset = self.to_hv_dataset()
+            hv_dataset = self.to_hv_dataset(reduce=reduce)
 
         if pane_collection is None:
             pane_collection = pn.Row()
@@ -333,7 +333,7 @@ class BenchResultBase(OptunaResult):
             if result_types is None or isinstance(rv, result_types):
                 row.append(
                     self.to_panes_multi_panel(
-                        self.to_hv_dataset(reduce=reduce, result_var=rv),
+                        hv_dataset,
                         rv,
                         plot_callback=partial(plot_callback, **kwargs),
                         target_dimension=target_dimension,

{holobench-1.40.1 → holobench-1.41.0}/bencher/results/composable_container/composable_container_video.py

@@ -3,7 +3,7 @@ import numpy as np
 from copy import deepcopy
 from pathlib import Path
 from dataclasses import dataclass
-from moviepy.editor import (
+from moviepy import (
     ImageClip,
     CompositeVideoClip,
     clips_array,
@@ -11,22 +11,43 @@ from moviepy.editor import (
     VideoClip,
     VideoFileClip,
 )
-from moviepy.video.fx.margin import margin
 
 from bencher.results.composable_container.composable_container_base import (
     ComposableContainerBase,
     ComposeType,
 )
 from bencher.video_writer import VideoWriter
+from moviepy import vfx
 
 
 @dataclass()
 class RenderCfg:
+    """Configuration class for video rendering options.
+
+    This class controls how videos and images are composed and rendered together.
+    It provides options for timing, layout, appearance, and labeling of the output.
+
+    Attributes:
+        compose_method (ComposeType): Method to compose multiple clips (sequence, right, down, overlay).
+            Defaults to ComposeType.sequence.
+        var_name (str, optional): Variable name for labeling. Defaults to None.
+        var_value (str, optional): Variable value for labeling. Defaults to None.
+        background_col (tuple[int, int, int]): RGB color for background. Defaults to white (255, 255, 255).
+        duration (float): Target duration for the composed video in seconds. Defaults to 10.0.
+        default_duration (float): Fallback duration when duration is None. Defaults to 10.0.
+        duration_target (bool): If True, tries to match target duration while respecting frame
+            duration constraints. If False, uses exact duration. Defaults to True.
+        min_frame_duration (float): Minimum duration for each frame in seconds. Defaults to 1/30.
+        max_frame_duration (float): Maximum duration for each frame in seconds. Defaults to 2.0.
+        margin (int): Margin size in pixels to add around clips. Defaults to 0.
+    """
+
     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
+    default_duration: float = 10.0
     duration_target: bool = True
     min_frame_duration: float = 1.0 / 30
     max_frame_duration: float = 2.0
@@ -69,7 +90,9 @@ class ComposableContainerVideo(ComposableContainerBase):
     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
+            duration = (
+                render_cfg.default_duration 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)
@@ -77,7 +100,10 @@ class ComposableContainerVideo(ComposableContainerBase):
                 frame_duration = min(frame_duration, render_cfg.max_frame_duration)
             duration = frame_duration * frames
         else:
-            duration = render_cfg.duration
+            if render_cfg.duration is None:
+                duration = render_cfg.default_duration
+            else:
+                duration = render_cfg.duration
             frame_duration = duration / float(frames)
 
         print("max_frame_duration", render_cfg.max_frame_duration)
@@ -111,8 +137,8 @@ class ComposableContainerVideo(ComposableContainerBase):
             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
+                    self.container[i] = self.container[i].with_effects(
+                        [vfx.Margin(top=render_cfg.margin, color=render_cfg.background_col)]
                     )
 
                 if render_cfg.compose_method == ComposeType.right:
@@ -126,13 +152,14 @@ class ComposableContainerVideo(ComposableContainerBase):
                 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_cfg.background_col)
-            #     # out.duration = fps
+            case ComposeType.overlay:
+                for i in range(len(self.container)):
+                    self.container[i] = self.container[i].with_opacity(1.0 / len(self.container))
+                out = CompositeVideoClip(self.container, bg_color=render_cfg.background_col)
             case _:
-                raise RuntimeError("This compose type is not supported")
+                raise RuntimeError(
+                    f"This compose type is not supported: {render_cfg.compose_method}"
+                )
 
         label = self.label_formatter(render_cfg.var_name, render_cfg.var_value)
         if label is not None: