bencher.results.video_summary
=============================

.. py:module:: bencher.results.video_summary


Classes
-------

.. autoapisummary::

   bencher.results.video_summary.VideoSummaryResult


Module Contents
---------------

.. py:class:: VideoSummaryResult(bench_cfg: bencher.bench_cfg.BenchCfg)

   Bases: :py:obj:`bencher.results.bench_result_base.BenchResultBase`


   .. py:method:: to_video_summary(result_var: param.Parameter | None = None, reverse: bool = True, result_types=(ResultImage, ), **kwargs) -> panel.panel | None


   .. py:method:: to_video_grid(result_var: param.Parameter | None = None, result_types=(ResultImage, ), pane_collection: panel.pane = None, time_sequence_dimension=0, target_duration: float | None = None, compose_method_list: list | None = None, **kwargs) -> panel.panel | None

      Returns the results compiled into a video

      :param result_var: The result var to plot. Defaults to None.
      :type result_var: Parameter, optional
      :param result_types: The types of result var to convert to video. Defaults to (ResultImage,).
      :type result_types: tuple, optional
      :param collection: If there are multiple results, use this collection to stack them. Defaults to pn.Row().
      :type collection: pn.pane, optional
      :param compose_method_list (list: optional): Defines how each of the dimensions is composed in the video. ie, concatenate the videos horizontally, vertically, sequentially or alpha overlay. Seee bn.ComposeType for the options.

      :returns: a panel pane with a video of all results concatenated together
      :rtype: pn.panel | None



   .. py:method:: to_video_grid_ds(dataset: xarray.Dataset, result_var: param.Parameter, reverse=True, time_sequence_dimension=0, video_controls: bencher.results.video_controls.VideoControls | None = None, target_duration: float | None = None, compose_method_list: list | None = None, target_dimension: int = 0, **kwargs)

      Creates a video grid from the provided dataset.

      This method generates a video by composing multiple plot panes into a grid
      layout and renders them as a video file.

      :param dataset: The dataset containing benchmark results.
      :type dataset: xr.Dataset
      :param result_var: The result variable to plot.
      :type result_var: Parameter
      :param reverse: Whether to reverse the sequence. Defaults to True.
      :type reverse: bool, optional
      :param time_sequence_dimension: The dimension to use for time sequencing. Defaults to 0.
      :type time_sequence_dimension: int, optional
      :param video_controls: Controls for video playback. If None, creates default controls.
      :type video_controls: VideoControls, optional
      :param target_duration: Target duration for the video in seconds.
      :type target_duration: float, optional
      :param compose_method_list: List of composition methods for combining panes.
      :type compose_method_list: list, optional
      :param target_dimension: The target dimensionality for data filtering. Defaults to 0.
      :type target_dimension: int, optional
      :param \*\*kwargs: Additional keyword arguments passed to video rendering.

      :returns: A video container with playback controls if successful, None otherwise.
      :rtype: pn.pane.HTML | None



   .. py:method:: plot_cb(dataset, result_var, **kwargs)


   .. py:method:: dataset_to_compose_list(dataset: xarray.Dataset, first_compose_method: bencher.results.composable_container.composable_container_video.ComposeType = ComposeType.down, time_sequence_dimension: int = 0) -> list[bencher.results.composable_container.composable_container_video.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.

      :param dataset: the dataset to render
      :type dataset: xr.Dataset
      :param first_compose_method: the direction of the first composition method. Defaults to ComposeType.right.
      :type first_compose_method: ComposeType, optional
      :param time_sequence_dimension: The dimension to start time sequencing instead of composing in space. Defaults to 0.
      :type time_sequence_dimension: int, optional

      :returns: A list of composition methods for composing the dataset result
      :rtype: list[ComposeType]



   .. py:method:: _to_video_panes_ds(dataset: xarray.Dataset, plot_callback: Callable | None = 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 = None, **kwargs) -> panel.panel