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

bencher/results/dataset_result.py

@@ -0,0 +1,227 @@
+from typing import Optional
+import panel as pn
+from param import Parameter
+from bencher.results.bench_result_base import BenchResultBase, ReduceType
+
+
+from functools import partial
+import holoviews as hv
+from bencher.variables.results import (
+    PANEL_TYPES,
+)
+
+
+class DataSetResult(BenchResultBase):
+    def to_dataset1(
+        self,
+        result_var: Parameter = None,
+        hv_dataset=None,
+        target_dimension: int = 0,
+        container=None,
+        level: int = None,
+        **kwargs,
+    ) -> Optional[pn.pane.panel]:
+        if hv_dataset is None:
+            hv_dataset = self.to_hv_dataset(ReduceType.SQUEEZE, level=level)
+        elif not isinstance(hv_dataset, hv.Dataset):
+            hv_dataset = hv.Dataset(hv_dataset)
+        return self.map_plot_panes(
+            partial(self.ds_to_container, container=container),
+            hv_dataset=hv_dataset,
+            target_dimension=target_dimension,
+            result_var=result_var,
+            result_types=PANEL_TYPES,
+            **kwargs,
+        )
+
+
+# class DataSetResult(BenchResultBase):
+
+#     def to_datatset(
+#         self,
+#         result_var: Parameter = None,
+#         result_types=(ResultDataSet,),
+#         pane_collection: pn.pane = None,
+#         time_sequence_dimension=0,
+#         target_duration: float = None,
+#         **kwargs,
+#     ) -> Optional[pn.panel]:
+#         """Returns the results compiled into a video
+
+#         Args:
+#             result_var (Parameter, optional): The result var to plot. Defaults to None.
+#             result_types (tuple, optional): The types of result var to convert to video. Defaults to (ResultDataSet,).
+#             collection (pn.pane, optional): If there are multiple results, use this collection to stack them. Defaults to pn.Row().
+
+#         Returns:
+#             Optional[pn.panel]: a panel pane with a video of all results concatenated together
+#         """
+#         plot_filter = PlotFilter(
+#             float_range=VarRange(0, None),
+#             cat_range=VarRange(0, None),
+#             panel_range=VarRange(1, None),
+#             input_range=VarRange(0, None),
+#         )
+#         matches_res = plot_filter.matches_result(
+#             self.plt_cnt_cfg, callable_name(self.to_video_grid_ds)
+#         )
+
+#         if pane_collection is None:
+#             pane_collection = pn.Row()
+
+#         if matches_res.overall:
+#             ds = self.to_dataset(ReduceType.SQUEEZE)
+#             for rv in self.get_results_var_list(result_var):
+#                 if isinstance(rv, result_types):
+#                     pane_collection.append(
+#                         self.to_video_grid_ds(
+#                             ds,
+#                             rv,
+#                             time_sequence_dimension=time_sequence_dimension,
+#                             target_duration=target_duration,
+#                             **kwargs,
+#                         )
+#                     )
+#             return pane_collection
+#         return matches_res.to_panel()
+
+#     def to_video_grid_ds(
+#         self,
+#         dataset: xr.Dataset,
+#         result_var: Parameter,
+#         reverse=True,
+#         time_sequence_dimension=0,
+#         video_controls: VideoControls = None,
+#         target_duration: float = None,
+#         **kwargs,
+#     ):
+#         cvc = self._to_video_panes_ds(
+#             dataset,
+#             self.plot_cb,
+#             target_dimension=0,
+#             horizontal=True,
+#             compose_method=ComposeType.right,
+#             time_sequence_dimension=time_sequence_dimension,
+#             result_var=result_var,
+#             final=True,
+#             reverse=reverse,
+#             target_duration=target_duration,
+#             **kwargs,
+#         )
+
+#         filename = VideoWriter().write_video_raw(cvc)
+
+#         if filename is not None:
+#             if video_controls is None:
+#                 video_controls = VideoControls()
+#             return video_controls.video_container(
+#                 filename, width=kwargs.get("width", None), height=kwargs.get("height", None)
+#             )
+#         return None
+
+#     def plot_cb(self, dataset, result_var, **kwargs):
+#         val = self.ds_to_container(dataset, result_var, container=None, **kwargs)
+#         return val
+
+#     def dataset_to_compose_list(
+#         self,
+#         dataset: xr.Dataset,
+#         first_compose_method: ComposeType = ComposeType.down,
+#         time_sequence_dimension: int = 0,
+#     ) -> List[ComposeType]:
+#         """ "Given a dataset, chose an order for composing the results.  By default will flip between right and down and the last dimension will be a time sequence.
+
+#         Args:
+#             dataset (xr.Dataset): the dataset to render
+#             first_compose_method (ComposeType, optional): the direction of the first composition method. Defaults to ComposeType.right.
+#             time_sequence_dimension (int, optional): The dimension to start time sequencing instead of composing in space. Defaults to 0.
+
+#         Returns:
+#             List[ComposeType]: A list of composition methods for composing the dataset result
+#         """
+
+#         num_dims = len(dataset.sizes)
+#         if time_sequence_dimension == -1:  # use time sequence for everything
+#             compose_method_list = [ComposeType.sequence] * (num_dims + 1)
+#         else:
+#             compose_method_list = [first_compose_method]
+#             compose_method_list.extend(
+#                 ComposeType.flip(compose_method_list[-1]) for _ in range(num_dims - 1)
+#             )
+#             compose_method_list.append(ComposeType.sequence)
+
+#             for i in range(min(len(compose_method_list), time_sequence_dimension + 1)):
+#                 compose_method_list[i] = ComposeType.sequence
+
+#         return compose_method_list
+
+#     def _to_video_panes_ds(
+#         self,
+#         dataset: xr.Dataset,
+#         plot_callback: callable = None,
+#         target_dimension=0,
+#         compose_method=ComposeType.right,
+#         compose_method_list=None,
+#         result_var=None,
+#         time_sequence_dimension=0,
+#         root_dimensions=None,
+#         reverse=False,
+#         target_duration: float = None,
+#         **kwargs,
+#     ) -> pn.panel:
+#         num_dims = len(dataset.sizes)
+#         dims = list(d for d in dataset.sizes)
+#         if reverse:
+#             dims = list(reversed(dims))
+
+#         if root_dimensions is None:
+#             root_dimensions = num_dims
+
+#         if compose_method_list is None:
+#             compose_method_list = self.dataset_to_compose_list(
+#                 dataset, compose_method, time_sequence_dimension=time_sequence_dimension
+#             )
+
+#             # print(compose_method_list)
+
+#         compose_method_list_pop = deepcopy(compose_method_list)
+#         if len(compose_method_list_pop) > 1:
+#             compose_method = compose_method_list_pop.pop()
+
+#         if num_dims > (target_dimension) and num_dims != 0:
+#             selected_dim = dims[-1]
+#             outer_container = ComposableContainerVideo()
+#             for i in range(dataset.sizes[selected_dim]):
+#                 sliced = dataset.isel({selected_dim: i})
+#                 label_val = sliced.coords[selected_dim].values.item()
+#                 inner_container = ComposableContainerVideo()
+
+#                 panes = self._to_video_panes_ds(
+#                     sliced,
+#                     plot_callback=plot_callback,
+#                     target_dimension=target_dimension,
+#                     compose_method_list=compose_method_list_pop,
+#                     result_var=result_var,
+#                     root_dimensions=root_dimensions,
+#                     time_sequence_dimension=time_sequence_dimension,
+#                 )
+#                 inner_container.append(panes)
+
+#                 rendered = inner_container.render(
+#                     RenderCfg(
+#                         var_name=selected_dim,
+#                         var_value=label_val,
+#                         compose_method=compose_method,
+#                         duration=target_duration,
+#                     )
+#                 )
+#                 outer_container.append(rendered)
+#             return outer_container.render(
+#                 RenderCfg(
+#                     compose_method=compose_method,
+#                     duration=target_duration,
+#                     background_col=color_tuple_to_255(int_to_col(num_dims - 2, 0.05, 1.0)),
+#                     # background_col= (255,0,0),
+#                 )
+#             )
+#         return plot_callback(dataset=dataset, result_var=result_var, **kwargs)

bencher/results/holoview_result.py

@@ -140,7 +140,7 @@ class HoloviewResult(PanelResult):
         elif not isinstance(tap_var, list):
             tap_var = [tap_var]
 
-        if len(tap_var) == 0 or self.plt_cnt_cfg.inputs_cnt > 1:
+        if len(tap_var) == 0 or self.plt_cnt_cfg.inputs_cnt > 1 or not use_tap:
             heatmap_cb = self.to_line_ds
         else:
             heatmap_cb = partial(
@@ -200,6 +200,7 @@ class HoloviewResult(PanelResult):
         result_var: Parameter = None,
         tap_var=None,
         tap_container: pn.pane.panel = None,
+        tap_container_direction: pn.Column | pn.Row = None,
         target_dimension=2,
         **kwargs,
     ) -> Optional[pn.panel]:
@@ -208,11 +209,14 @@ class HoloviewResult(PanelResult):
         elif not isinstance(tap_var, list):
             tap_var = [tap_var]
 
-        if len(tap_var) == 0:
+        if len(tap_var) == 0 or not use_tap:
             heatmap_cb = self.to_heatmap_ds
         else:
             heatmap_cb = partial(
-                self.to_heatmap_container_tap_ds, result_var_plots=tap_var, container=tap_container
+                self.to_heatmap_container_tap_ds,
+                result_var_plots=tap_var,
+                container=tap_container,
+                tap_container_direction=tap_container_direction,
             )
 
         return self.filter(
@@ -251,7 +255,7 @@ class HoloviewResult(PanelResult):
         else:
             containers = listify(container)
 
-        cont_instances = [c(**kwargs) for c in containers]
+        cont_instances = [c(**kwargs) if c is not None else None for c in containers]
         return result_var_plots, cont_instances
 
     def to_heatmap_container_tap_ds(
@@ -260,6 +264,7 @@ class HoloviewResult(PanelResult):
         result_var: Parameter,
         result_var_plots: List[Parameter] = None,
         container: pn.pane.panel = None,
+        tap_container_direction: pn.Column | pn.Row = None,
         **kwargs,
     ) -> pn.Row:
         htmap = self.to_heatmap_ds(dataset, result_var).opts(tools=["hover"], **kwargs)
@@ -322,8 +327,11 @@ class HoloviewResult(PanelResult):
         ls = hv.streams.MouseLeave(source=htmap)
         ls.add_subscriber(on_exit)
 
-        bound_plot = pn.Column(title, *cont_instances)
-        return pn.Row(htmap, bound_plot)
+        if tap_container_direction is None:
+            tap_container_direction = pn.Column
+        bound_plot = tap_container_direction(*cont_instances)
+
+        return pn.Row(htmap, pn.Column(title, bound_plot))
 
     def to_line_tap_ds(
         self,
@@ -677,7 +685,7 @@ class HoloviewResult(PanelResult):
             try:
                 surface = hvds.to(hv.Surface, vdims=[result_var.name])
                 surface = surface.opts(colorbar=True)
-            except Exception as e:
+            except Exception as e:  # pylint: disable=broad-except
                 logging.warning(e)
 
             if self.bench_cfg.repeats > 1:

bencher/results/optuna_result.py

@@ -63,6 +63,7 @@ class OptunaResult:
         self.studies = []
         self.plt_cnt_cfg = PltCntCfg()
         self.plot_inputs = []
+        self.dataset_list = []
 
         # self.width=600/
         # self.height=600
@@ -177,7 +178,7 @@ class OptunaResult:
             df = self.to_pandas()
             all_vars = []
             for v in self.bench_cfg.all_vars:
-                if type(v) != TimeEvent:
+                if type(v) is not TimeEvent:
                     all_vars.append(v)
 
             print("All vars", all_vars)
@@ -202,8 +203,8 @@ class OptunaResult:
             params = {}
             values = []
             for i in all_vars:
-                if type(i) == TimeSnapshot:
-                    if type(row[1][i.name]) == np.datetime64:
+                if type(i) is TimeSnapshot:
+                    if type(row[1][i.name]) is np.datetime64:
                         params[i.name] = row[1][i.name].timestamp()
                 else:
                     params[i.name] = row[1][i.name]

bencher/results/panel_result.py

@@ -25,7 +25,7 @@ class PanelResult(BenchResultBase):
         target_dimension: int = 0,
         container=None,
         level: int = None,
-        **kwargs
+        **kwargs,
     ) -> Optional[pn.pane.panel]:
         if hv_dataset is None:
             hv_dataset = self.to_hv_dataset(ReduceType.SQUEEZE, level=level)

bencher/results/video_summary.py

@@ -1,94 +1,44 @@
-from bencher.utils import params_to_str
 from typing import Optional, List
-import itertools
+from copy import deepcopy
 import panel as pn
 import xarray as xr
 from param import Parameter
 from bencher.results.bench_result_base import BenchResultBase, ReduceType
 from bencher.variables.results import ResultImage
 from bencher.plotting.plot_filter import VarRange, PlotFilter
-from bencher.utils import callable_name, listify
+from bencher.utils import callable_name, int_to_col, color_tuple_to_255
 from bencher.video_writer import VideoWriter
-from bencher.results.float_formatter import FormatFloat
 from bencher.results.video_result import VideoControls
-from bencher.utils import int_to_col
-from bencher.results.composable_container.composable_container_video import ComposableContainerVideo
+from bencher.results.composable_container.composable_container_video import (
+    ComposableContainerVideo,
+    ComposeType,
+    RenderCfg,
+)
 
 
 class VideoSummaryResult(BenchResultBase):
     def to_video_summary(
         self,
         result_var: Parameter = None,
-        input_order: List[str] = None,
         reverse: bool = True,
         result_types=(ResultImage,),
         **kwargs,
     ) -> Optional[pn.panel]:
-        plot_filter = PlotFilter(
-            float_range=VarRange(0, None),
-            cat_range=VarRange(0, None),
-            panel_range=VarRange(1, None),
-        )
-        matches_res = plot_filter.matches_result(
-            self.plt_cnt_cfg, callable_name(self.to_video_summary_ds)
+        return self.to_video_grid(
+            result_var=result_var,
+            result_types=result_types,
+            time_sequence_dimension=-1,
+            reverse=reverse,
+            **kwargs,
         )
 
-        # video_controls = VideoControls()
-        if matches_res.overall:
-            ds = self.to_dataset(ReduceType.SQUEEZE)
-            row = pn.Row()
-            for rv in self.get_results_var_list(result_var):
-                if isinstance(rv, result_types):
-                    row.append(self.to_video_summary_ds(ds, rv, input_order, reverse, **kwargs))
-            return row
-        return matches_res.to_panel()
-
-    def to_video_summary_ds(
-        self,
-        dataset: xr.Dataset,
-        result_var: Parameter,
-        input_order: List[str] = None,
-        reverse: bool = True,
-        video_controls: VideoControls = None,
-        **kwargs,
-    ):
-        vr = VideoWriter()
-        da = dataset[result_var.name]
-
-        if input_order is None:
-            input_order = list(da.dims)
-        else:
-            input_order = params_to_str(input_order)
-        if reverse:
-            input_order = list(reversed(input_order))
-
-        inputs_produc = [da.coords[i].values for i in input_order]
-
-        for index in itertools.product(*inputs_produc):
-            lookup = dict(zip(input_order, index))
-            val = da.loc[lookup].item()
-            index = listify(index)
-            for i in range(len(index)):
-                if isinstance(index[i], (int, float)):
-                    index[i] = FormatFloat()(index[i])
-            label = ", ".join(f"{a[0]}={a[1]}" for a in list(zip(input_order, index)))
-            if val is not None:
-                vr.append_file(val, label)
-        fn = vr.write_png(**kwargs)
-        kwargs.pop("target_duration", None)
-        if fn is not None:
-            if video_controls is None:
-                video_controls = VideoControls()
-            vid = video_controls.video_container(fn, **kwargs)
-            return vid
-
-        return None
-
     def to_video_grid(
         self,
         result_var: Parameter = None,
         result_types=(ResultImage,),
         pane_collection: pn.pane = None,
+        time_sequence_dimension=0,
+        target_duration: float = None,
         **kwargs,
     ) -> Optional[pn.panel]:
         """Returns the results compiled into a video
@@ -118,7 +68,15 @@ class VideoSummaryResult(BenchResultBase):
             ds = self.to_dataset(ReduceType.SQUEEZE)
             for rv in self.get_results_var_list(result_var):
                 if isinstance(rv, result_types):
-                    pane_collection.append(self.to_video_grid_ds(ds, rv, **kwargs))
+                    pane_collection.append(
+                        self.to_video_grid_ds(
+                            ds,
+                            rv,
+                            time_sequence_dimension=time_sequence_dimension,
+                            target_duration=target_duration,
+                            **kwargs,
+                        )
+                    )
             return pane_collection
         return matches_res.to_panel()
 
@@ -127,17 +85,18 @@ class VideoSummaryResult(BenchResultBase):
         dataset: xr.Dataset,
         result_var: Parameter,
         reverse=True,
+        time_sequence_dimension=0,
         video_controls: VideoControls = None,
         target_duration: float = None,
         **kwargs,
     ):
-        vr = VideoWriter()
-
         cvc = self._to_video_panes_ds(
             dataset,
             self.plot_cb,
             target_dimension=0,
             horizontal=True,
+            compose_method=ComposeType.right,
+            time_sequence_dimension=time_sequence_dimension,
             result_var=result_var,
             final=True,
             reverse=reverse,
@@ -145,27 +104,62 @@ class VideoSummaryResult(BenchResultBase):
             **kwargs,
         )
 
-        fn = vr.write_video_raw(cvc)
+        filename = VideoWriter().write_video_raw(cvc)
 
-        if fn is not None:
+        if filename is not None:
             if video_controls is None:
                 video_controls = VideoControls()
-            vid = video_controls.video_container(fn, **kwargs)
-            return vid
+            return video_controls.video_container(
+                filename, width=kwargs.get("width", None), height=kwargs.get("height", None)
+            )
         return None
 
     def plot_cb(self, dataset, result_var, **kwargs):
         val = self.ds_to_container(dataset, result_var, container=None, **kwargs)
         return val
 
+    def dataset_to_compose_list(
+        self,
+        dataset: xr.Dataset,
+        first_compose_method: ComposeType = ComposeType.down,
+        time_sequence_dimension: int = 0,
+    ) -> List[ComposeType]:
+        """ "Given a dataset, chose an order for composing the results.  By default will flip between right and down and the last dimension will be a time sequence.
+
+        Args:
+            dataset (xr.Dataset): the dataset to render
+            first_compose_method (ComposeType, optional): the direction of the first composition method. Defaults to ComposeType.right.
+            time_sequence_dimension (int, optional): The dimension to start time sequencing instead of composing in space. Defaults to 0.
+
+        Returns:
+            List[ComposeType]: A list of composition methods for composing the dataset result
+        """
+
+        num_dims = len(dataset.sizes)
+        if time_sequence_dimension == -1:  # use time sequence for everything
+            compose_method_list = [ComposeType.sequence] * (num_dims + 1)
+        else:
+            compose_method_list = [first_compose_method]
+            compose_method_list.extend(
+                ComposeType.flip(compose_method_list[-1]) for _ in range(num_dims - 1)
+            )
+            compose_method_list.append(ComposeType.sequence)
+
+            for i in range(min(len(compose_method_list), time_sequence_dimension + 1)):
+                compose_method_list[i] = ComposeType.sequence
+
+        return compose_method_list
+
     def _to_video_panes_ds(
         self,
         dataset: xr.Dataset,
         plot_callback: callable = None,
         target_dimension=0,
-        horizontal=False,
+        compose_method=ComposeType.right,
+        compose_method_list=None,
         result_var=None,
-        final=False,
+        time_sequence_dimension=0,
+        root_dimensions=None,
         reverse=False,
         target_duration: float = None,
         **kwargs,
@@ -175,43 +169,54 @@ class VideoSummaryResult(BenchResultBase):
         if reverse:
             dims = list(reversed(dims))
 
+        if root_dimensions is None:
+            root_dimensions = num_dims
+
+        if compose_method_list is None:
+            compose_method_list = self.dataset_to_compose_list(
+                dataset, compose_method, time_sequence_dimension=time_sequence_dimension
+            )
+
+            # print(compose_method_list)
+
+        compose_method_list_pop = deepcopy(compose_method_list)
+        if len(compose_method_list_pop) > 1:
+            compose_method = compose_method_list_pop.pop()
+
         if num_dims > (target_dimension) and num_dims != 0:
             selected_dim = dims[-1]
-            # print(f"selected dim {selected_dim}")
-            dim_color = int_to_col(num_dims - 2, 0.05, 1.0)
-            # sliced = dataset.isel({selected_dim: i})
-            # label_val = sliced.coords[selected_dim].values.item()
-
-            outer_container = ComposableContainerVideo(
-                name=" vs ".join(dims),
-                background_col=dim_color,
-                horizontal=horizontal,
-                target_duration=target_duration,
-                # var_name=selected_dim,
-                # var_value=label_val,
-            )
-            max_len = 0
+            outer_container = ComposableContainerVideo()
             for i in range(dataset.sizes[selected_dim]):
                 sliced = dataset.isel({selected_dim: i})
                 label_val = sliced.coords[selected_dim].values.item()
-                inner_container = ComposableContainerVideo(
-                    outer_container.name,
-                    var_name=selected_dim,
-                    var_value=label_val,
-                    horizontal=horizontal,
-                    target_duration=target_duration,
-                )
+                inner_container = ComposableContainerVideo()
+
                 panes = self._to_video_panes_ds(
                     sliced,
                     plot_callback=plot_callback,
                     target_dimension=target_dimension,
-                    horizontal=len(sliced.sizes) <= target_dimension + 1,
+                    compose_method_list=compose_method_list_pop,
                     result_var=result_var,
+                    root_dimensions=root_dimensions,
+                    time_sequence_dimension=time_sequence_dimension,
                 )
                 inner_container.append(panes)
 
-                max_len = max(max_len, inner_container.label_len)
-                rendered = inner_container.render()
+                rendered = inner_container.render(
+                    RenderCfg(
+                        var_name=selected_dim,
+                        var_value=label_val,
+                        compose_method=compose_method,
+                        duration=target_duration,
+                    )
+                )
                 outer_container.append(rendered)
-            return outer_container.render(concatenate=final)
+            return outer_container.render(
+                RenderCfg(
+                    compose_method=compose_method,
+                    duration=target_duration,
+                    background_col=color_tuple_to_255(int_to_col(num_dims - 2, 0.05, 1.0)),
+                    # background_col= (255,0,0),
+                )
+            )
         return plot_callback(dataset=dataset, result_var=result_var, **kwargs)

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 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)