holobench 1.28.1__py3-none-any.whl → 1.30.2__py3-none-any.whl

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
 
@@ -62,7 +60,7 @@ class BenchResultBase(OptunaResult):
         """Generate a holoviews dataset from the xarray dataset.
 
         Args:
-            reduce (ReduceType, optional): Optionally perform reduce options on the dataset.  By default the returned dataset will calculate the mean and standard devation over the "repeat" dimension so that the dataset plays nicely with most of the holoviews plot types.  Reduce.Sqeeze is used if there is only 1 repeat and you want the "reduce" variable removed from the dataset. ReduceType.None returns an unaltered dataset. Defaults to ReduceType.AUTO.
+            reduce (ReduceType, optional): Optionally perform reduce options on the dataset.  By default the returned dataset will calculate the mean and standard deviation over the "repeat" dimension so that the dataset plays nicely with most of the holoviews plot types.  Reduce.Sqeeze is used if there is only 1 repeat and you want the "reduce" variable removed from the dataset. ReduceType.None returns an unaltered dataset. Defaults to ReduceType.AUTO.
 
         Returns:
             hv.Dataset: results in the form of a holoviews dataset
@@ -79,7 +77,7 @@ class BenchResultBase(OptunaResult):
         """Generate a summarised xarray dataset.
 
         Args:
-            reduce (ReduceType, optional): Optionally perform reduce options on the dataset.  By default the returned dataset will calculate the mean and standard devation over the "repeat" dimension so that the dataset plays nicely with most of the holoviews plot types.  Reduce.Sqeeze is used if there is only 1 repeat and you want the "reduce" variable removed from the dataset. ReduceType.None returns an unaltered dataset. Defaults to ReduceType.AUTO.
+            reduce (ReduceType, optional): Optionally perform reduce options on the dataset.  By default the returned dataset will calculate the mean and standard deviation over the "repeat" dimension so that the dataset plays nicely with most of the holoviews plot types.  Reduce.Sqeeze is used if there is only 1 repeat and you want the "reduce" variable removed from the dataset. ReduceType.None returns an unaltered dataset. Defaults to ReduceType.AUTO.
 
         Returns:
             xr.Dataset: results in the form of an xarray dataset
@@ -89,7 +87,7 @@ class BenchResultBase(OptunaResult):
 
         ds_out = self.ds if result_var is None else self.ds[result_var.name]
 
-        match (reduce):
+        match reduce:
             case ReduceType.REDUCE:
                 ds_reduce_mean = ds_out.mean(dim="repeat", keep_attrs=True)
                 ds_reduce_std = ds_out.std(dim="repeat", keep_attrs=True)
@@ -149,9 +147,9 @@ class BenchResultBase(OptunaResult):
             opt_val = result_da.max()
         else:
             opt_val = result_da.min()
-        indicies = result_da.where(result_da == opt_val, drop=True).squeeze()
+        indices = result_da.where(result_da == opt_val, drop=True).squeeze()
         logging.info(f"optimal value of {result_var.name}: {opt_val.values}")
-        return indicies
+        return indices
 
     def get_optimal_inputs(
         self,
@@ -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(
@@ -405,10 +447,17 @@ 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]
             if ref is not None:

bencher/results/composable_container/composable_container_base.py

@@ -10,7 +10,7 @@ class ComposeType(StrEnum):
     right = auto()  # append the container to the right (creates a row)
     down = auto()  # append the container below (creates a column)
     sequence = auto()  # display the container after (in time)
-    # overlay = auto()  # overlay on top of the current container (alpha blending)
+    overlay = auto()  # overlay on top of the current container (alpha blending)
 
     def flip(self):
         match self:
@@ -65,7 +65,7 @@ class ComposableContainerBase:
         self.container.append(obj)
 
     def render(self):
-        """Return a representation of the container that can be composed with other render() results. This function can also be used to defer layout and rending options until all the information about the container content is known.  You may need to ovverride this method depending on the container. See composable_container_video as an example.
+        """Return a representation of the container that can be composed with other render() results. This function can also be used to defer layout and rending options until all the information about the container content is known.  You may need to override this method depending on the container. See composable_container_video as an example.
 
         Returns:
             Any: Visual representation of the container that can be combined with other containers

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/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/optuna_result.py

@@ -34,7 +34,7 @@ from bencher.optuna_conversions import (
 
 
 def convert_dataset_bool_dims_to_str(dataset: xr.Dataset) -> xr.Dataset:
-    """Given a dataarray that contains boolean coordinates, conver them to strings so that holoviews loads the data properly
+    """Given a dataarray that contains boolean coordinates, convert them to strings so that holoviews loads the data properly
 
     Args:
         dataarray (xr.DataArray): dataarray with boolean coordinates
@@ -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]
@@ -341,14 +342,14 @@ class OptunaResult:
         if "width" not in kwargs:
             if self.bench_cfg.plot_size is not None:
                 kwargs["width"] = self.bench_cfg.plot_size
-            # specific width overrrides general size
+            # specific width overrides general size
             if self.bench_cfg.plot_width is not None:
                 kwargs["width"] = self.bench_cfg.plot_width
 
         if "height" not in kwargs:
             if self.bench_cfg.plot_size is not None:
                 kwargs["height"] = self.bench_cfg.plot_size
-            # specific height overrrides general size
+            # specific height overrides general size
             if self.bench_cfg.plot_height is not None:
                 kwargs["height"] = self.bench_cfg.plot_height
         return kwargs

bencher/variables/inputs.py

@@ -7,7 +7,7 @@ from bencher.variables.sweep_base import SweepBase, shared_slots
 
 
 class SweepSelector(Selector, SweepBase):
-    """A class to reprsent a parameter sweep of bools"""
+    """A class to represent a parameter sweep of bools"""
 
     __slots__ = shared_slots
 
@@ -27,7 +27,7 @@ class SweepSelector(Selector, SweepBase):
 
 
 class BoolSweep(SweepSelector):
-    """A class to reprsent a parameter sweep of bools"""
+    """A class to represent a parameter sweep of bools"""
 
     def __init__(self, units: str = "ul", samples: int = None, default=True, **params):
         SweepSelector.__init__(
@@ -41,7 +41,7 @@ class BoolSweep(SweepSelector):
 
 
 class StringSweep(SweepSelector):
-    """A class to reprsent a parameter sweep of strings"""
+    """A class to represent a parameter sweep of strings"""
 
     def __init__(
         self,
@@ -61,7 +61,7 @@ class StringSweep(SweepSelector):
 
 
 class EnumSweep(SweepSelector):
-    """A class to reprsent a parameter sweep of enums"""
+    """A class to represent a parameter sweep of enums"""
 
     __slots__ = shared_slots
 
@@ -82,7 +82,7 @@ class EnumSweep(SweepSelector):
 
 
 class IntSweep(Integer, SweepBase):
-    """A class to reprsent a parameter sweep of ints"""
+    """A class to represent a parameter sweep of ints"""
 
     __slots__ = shared_slots + ["sample_values"]
 

bencher/variables/parametrised_sweep.py

@@ -3,7 +3,7 @@ from typing import List, Tuple, Any
 from param import Parameter, Parameterized
 import holoviews as hv
 import panel as pn
-
+from copy import deepcopy
 
 from bencher.utils import make_namedtuple, hash_sha1
 from bencher.variables.results import ALL_RESULT_TYPES, ResultHmap
@@ -127,7 +127,7 @@ class ParametrizedSweep(Parameterized):
         inp = cls.get_inputs_only()
         defaults = {}
         for i in inp:
-            defaults[i.name] = i.default
+            defaults[i.name] = deepcopy(i.default)
 
         for k, v in kwargs.items():
             defaults[k] = v

bencher/variables/results.py

@@ -186,6 +186,25 @@ class ResultReference(param.Parameter):
         return hash_sha1(self)
 
 
+class ResultDataSet(param.Parameter):
+    __slots__ = ["units", "obj"]
+
+    def __init__(
+        self,
+        obj: Any = None,
+        default: Any = None,
+        units: str = "dataset",
+        **params,
+    ):
+        super().__init__(default=default, **params)
+        self.units = units
+        self.obj = obj
+
+    def hash_persistent(self) -> str:
+        """A hash function that avoids the PYTHONHASHSEED 'feature' which returns a different hash value each time the program is run"""
+        return hash_sha1(self)
+
+
 class ResultVolume(param.Parameter):
     __slots__ = ["units", "obj"]
 
@@ -199,7 +218,15 @@ class ResultVolume(param.Parameter):
         return hash_sha1(self)
 
 
-PANEL_TYPES = (ResultPath, ResultImage, ResultVideo, ResultContainer, ResultString, ResultReference)
+PANEL_TYPES = (
+    ResultPath,
+    ResultImage,
+    ResultVideo,
+    ResultContainer,
+    ResultString,
+    ResultReference,
+    ResultDataSet,
+)
 
 ALL_RESULT_TYPES = (
     ResultVar,
@@ -210,5 +237,6 @@ ALL_RESULT_TYPES = (
     ResultImage,
     ResultString,
     ResultContainer,
+    ResultDataSet,
     ResultReference,
 )

bencher/variables/sweep_base.py

@@ -77,7 +77,7 @@ class SweepBase(param.Parameter):
         """given a sweep variable (self), return the range of values as a panel slider
 
         Args:
-            debug (bool, optional): pass to the sweepvar to produce a full set of varaibles, or when debug=True, a reduces number of sweep vars. Defaults to False.
+            debug (bool, optional): pass to the sweepvar to produce a full set of variables, or when debug=True, a reduces number of sweep vars. Defaults to False.
 
         Returns:
             pn.widgets.slider.DiscreteSlider: A panel slider with the values() of the sweep variable

bencher/variables/time.py

@@ -7,7 +7,7 @@ from bencher.variables.sweep_base import SweepBase, shared_slots
 
 
 class TimeBase(SweepBase, Selector):
-    """A class to capture a time snapshot of benchmark values.  Time is reprented as a continous value i.e a datetime which is converted into a np.datetime64.  To represent time as a discrete value use the TimeEvent class. The distinction is because holoview and plotly code makes different assumptions about discrete vs continous variables"""
+    """A class to capture a time snapshot of benchmark values.  Time is represent as a continuous value i.e a datetime which is converted into a np.datetime64.  To represent time as a discrete value use the TimeEvent class. The distinction is because holoview and plotly code makes different assumptions about discrete vs continuous variables"""
 
     def __init__(
         self,
@@ -40,7 +40,7 @@ class TimeBase(SweepBase, Selector):
 
 
 class TimeSnapshot(TimeBase):
-    """A class to capture a time snapshot of benchmark values.  Time is reprented as a continous value i.e a datetime which is converted into a np.datetime64.  To represent time as a discrete value use the TimeEvent class. The distinction is because holoview and plotly code makes different assumptions about discrete vs continous variables"""
+    """A class to capture a time snapshot of benchmark values.  Time is represent as a continuous value i.e a datetime which is converted into a np.datetime64.  To represent time as a discrete value use the TimeEvent class. The distinction is because holoview and plotly code makes different assumptions about discrete vs continuous variables"""
 
     __slots__ = shared_slots
 
@@ -68,7 +68,7 @@ class TimeSnapshot(TimeBase):
 
 
 class TimeEvent(TimeBase):
-    """A class to represent a discrete event in time where the data was captured i.e a series of pull requests.  Here time is discrete and can't be interpolated, to represent time as a continous value use the TimeSnapshot class.  The distinction is because holoview and plotly code makes different assumptions about discrete vs continous variables"""
+    """A class to represent a discrete event in time where the data was captured i.e a series of pull requests.  Here time is discrete and can't be interpolated, to represent time as a continuous value use the TimeSnapshot class.  The distinction is because holoview and plotly code makes different assumptions about discrete vs continuous variables"""
 
     __slots__ = shared_slots
 

bencher/video_writer.py

@@ -30,7 +30,7 @@ class VideoWriter:
         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), label, (0, 0, 0),align="center",anchor="ms")
         ImageDraw.Draw(new_img).text(
             (width / 2.0, 0), label, (0, 0, 0), anchor="mt", font_size=height
         )