holobench 1.41.0__py3-none-any.whl → 1.43.0__py3-none-any.whl

bencher/class_enum.py

@@ -1,52 +1,115 @@
 from __future__ import annotations
 from strenum import StrEnum
-from typing import Any
+from typing import Any, TypeVar
 import importlib
 from abc import abstractmethod
 from dataclasses import dataclass
 from enum import auto
 
+T = TypeVar("T")  # Generic type for return value of to_class
+
 
 class ClassEnum(StrEnum):
-    """A ClassEnum is a pattern to make it easier to create factory a factory method that converts from an enum to a corresponding class.  Subclasses should implement to_class(enum_instance:EnumType) which takes an enum returns the corresponding instance of that class."""
+    """A string-based enum class that maps enum values to corresponding class instances.
+
+    ClassEnum is a pattern to make it easier to create a factory method that converts
+    from an enum value to a corresponding class instance. Subclasses should implement
+    the to_class() method which takes an enum value and returns an instance of the
+    corresponding class.
+
+    This pattern is useful for configuration-driven class instantiation, allowing
+    classes to be selected via string configuration values that match enum names.
+    """
 
     @classmethod
     def to_class_generic(cls, module_import: str, class_name: str) -> Any:
-        """Create an instance of the class referred to by this enum
+        """Create an instance of a class from its module path and class name.
+
+        This utility method dynamically imports a module and instantiates a class from it.
+
+        Args:
+            module_import (str): The module path to import (e.g., "bencher.class_enum")
+            class_name (str): The name of the class to instantiate
 
         Returns:
-            Any: instance of the class
+            Any: A new instance of the specified class
         """
-
         class_def = getattr(importlib.import_module(module_import), class_name)
         return class_def()
 
     @classmethod
     @abstractmethod
     def to_class(cls, enum_val: ClassEnum) -> Any:
-        """Subclasses should overrides this method to take  an enum returns the corresponding instance of that class."""
-        raise NotImplementedError()
+        """Convert an enum value to its corresponding class instance.
+
+        Subclasses must override this method to implement the mapping from
+        enum values to class instances.
+
+        Args:
+            enum_val (ClassEnum): The enum value to convert to a class instance
+
+        Returns:
+            Any: An instance of the class corresponding to the enum value
+
+        Raises:
+            NotImplementedError: If this method is not overridden by a subclass
+        """
+        raise NotImplementedError("Subclasses must implement to_class()")
 
 
 @dataclass
 class BaseClass:
+    """Base class for the ClassEnum example.
+
+    A simple dataclass that serves as the base class for the ClassEnum example classes.
+
+    Attributes:
+        baseclassname (str): A name for the base class
+    """
+
     baseclassname: str = "class0"
 
 
 @dataclass
 class Class1(BaseClass):
+    """Example subclass 1 for the ClassEnum demonstration.
+
+    Attributes:
+        classname (str): A name for this class
+    """
+
     classname: str = "class1"
 
 
 @dataclass
 class Class2(BaseClass):
+    """Example subclass 2 for the ClassEnum demonstration.
+
+    Attributes:
+        classname (str): A name for this class
+    """
+
     classname: str = "class2"
 
 
 class ExampleEnum(ClassEnum):
+    """An example implementation of ClassEnum.
+
+    This enum demonstrates how to use ClassEnum to map enum values to class instances.
+    Each enum value corresponds to a class name that can be instantiated.
+    """
+
     Class1 = auto()
     Class2 = auto()
 
     @classmethod
     def to_class(cls, enum_val: ExampleEnum) -> BaseClass:
+        """Convert an ExampleEnum value to its corresponding class instance.
+
+        Args:
+            enum_val (ExampleEnum): The enum value to convert
+
+        Returns:
+            BaseClass: An instance of either Class1 or Class2, depending on the enum value
+        """
         return cls.to_class_generic("bencher.class_enum", enum_val)

bencher/example/example_dataframe.py

@@ -25,7 +25,7 @@ class ExampleMergeDataset(bch.ParametrizedSweep):
 
 def example_dataset(run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None):
     bench = ExampleMergeDataset().to_bench(run_cfg, report)
-    res = bench.plot_sweep(input_vars=["value"], const_vars=dict(repeats_x=4))
+    bench.plot_sweep(input_vars=["value"], const_vars=dict(repeats_x=4))
     # bench.report.append(res.to_panes(target_dimension=1))
     # bench.report.append(res.to_panes(target_dimension=2))
     # bench.reprt.append(res.to_video_grid
@@ -39,7 +39,7 @@ def example_dataset(run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = N
     # )
     # bench.report.append(res.to_panes(container=hv.Bars,target_dimension=1))
     # bench.report.append(res.to_panes(container=hv.Curve))
-    bench.report.append(res.to_dataset1(container=hv.Curve))
+    bench.add(bch.DataSetResult, container=hv.Curve)
     return bench
 
 

bencher/example/example_levels.py

@@ -1,179 +1,23 @@
 import bencher as bch
-from bencher.utils import int_to_col
-
-import math
-import holoviews as hv
-from typing import Any, List
-import panel as pn
-from holoviews import opts
-
-
-class LevelsExample(bch.ParametrizedSweep):
-    xval = bch.FloatSweep(bounds=[0, 3.14])
-    yval = bch.FloatSweep(bounds=[0, 3.14])
-    level = bch.IntSweep(default=1, bounds=[1, 6])
-
-    output = bch.ResultVar(units="v")
-    hmap = bch.ResultHmap()
-
-    def __call__(self, **kwargs: Any) -> Any:
-        self.update_params_from_kwargs(**kwargs)
-        self.output = math.sin(self.xval) + math.cos(self.yval)
-        self.hmap = hv.Points((self.xval, self.yval)).opts(
-            marker="o", size=110 - self.level * 20, color=int_to_col(self.level - 1)
-        )
-
-        return self.get_results_values_as_dict()
-
-
-class RunWithLevel(bch.ParametrizedSweep):
-    level = bch.IntSweep(default=1, bounds=[1, 8])
-    dimensions = bch.IntSweep(default=1, bounds=[1, 2])
-
-    level_samples = bch.ResultVar()
-
-    def __call__(self, **kwargs) -> dict():
-        self.update_params_from_kwargs(**kwargs)
-
-        self.level_samples = int(
-            pow(
-                len(bch.FloatSweep(bounds=[0, 1]).with_level(self.level).values()),
-                self.dimensions,
-            )
-        )
-        return self.get_results_values_as_dict()
-
-
-def run_with_dim(bench: bch.Bench, dims: List[bch.SweepBase]) -> List[bch.BenchResult]:
-    results = []
-    for level in range(1, 6):
-        print(level)
-        res = bench.plot_sweep(
-            f"Level:{level}",
-            input_vars=dims,
-            const_vars=LevelsExample.get_input_defaults(
-                [LevelsExample.param.level.with_const(level)]
-            ),
-            result_vars=[LevelsExample.param.output, LevelsExample.param.hmap],
-            run_cfg=bch.BenchRunCfg(level=level, auto_plot=False),
-        )
-
-        results.append(res)
-    return results
-
-
-def run_levels_1D(bench: bch.Bench) -> bch.Bench:
-    results = run_with_dim(bench, [LevelsExample.param.xval])
-    bench.report.append_title("Using Levels to define sample density")
-
-    bench1 = bch.Bench("levels", RunWithLevel(), run_cfg=bch.BenchRunCfg(auto_plot=False))
-    res1 = bench1.plot_sweep("Levels", input_vars=[RunWithLevel.param.level])
-
-    bench.report.append_markdown(
-        "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",
-        width=600,
-    )
-    row = pn.Row()
-    row.append(res1.to_table())
-    # row.append(res1.to_curve().opts(shared_axes=False))
-    row.append(res1.to_curve())
-
-    bench.report.append(row)
-
-    bench.report.append_markdown(
-        "Level 1 returns a single point at the lower bound of the parameter. Level 2 uses the upper and lower bounds of the parameter. All subsequent levels are created by adding a sample between each previously calculated sample to ensure that all previous values can be reused while retaining an equal sample spacing.  The following plots show the sample points as circles and the corresponding plot of a sin function sampled at that level.",
-        width=600,
+from bencher.example.meta.example_meta import BenchMeta
+
+
+def example_levels(run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None) -> bch.Bench:
+    bench = BenchMeta().to_bench(run_cfg, report)
+
+    bench.plot_sweep(
+        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=[
+            bch.p("float_vars", [1, 2]),
+            bch.p("level", [2, 3, 4, 5]),
+        ],
+        const_vars=[
+            BenchMeta.param.categorical_vars.with_const(0),
+        ],
     )
-
-    combined_pts = hv.Overlay()
-    combined_curve = hv.Overlay()
-    for it, r in enumerate(results):
-        lvl = it + 1
-        row = pn.Row()
-        pts = r.to_holomap().overlay().opts(title=f"Sample Points for level: {lvl}", height=300)
-        ds = r.to_hv_dataset()
-        crv = r.to_curve_ds(ds.data).opts(shared_axes=False, height=300) * r.to_hv_dataset(
-            bch.ReduceType.NONE
-        ).to(hv.Scatter).opts(
-            title=f"Function Values for level: {lvl}", size=5, height=300, shared_axes=False
-        )
-
-        combined_pts *= pts
-        combined_curve *= crv
-        row.append(pts)
-        row.append(crv)
-        bench.report.append_markdown(f"## {r.bench_cfg.title}")
-        bench.report.append(row)
-
-    bench.report.append_markdown(
-        "This plot overlays the previous plots into a single image. It shows how each level overlaps the previous level"
-    )
-
-    bench.report.append(pn.Row(combined_pts, combined_curve))
-    return bench
-
-
-def run_levels_2D(bench: bch.Bench) -> bch.Bench:
-    results = run_with_dim(bench, [LevelsExample.param.xval, LevelsExample.param.yval])
-    bench.report.append_markdown("# Using Levels to define 2D sample density", "Levels 2D")
-
-    bench1 = bch.Bench("lol", RunWithLevel(), run_cfg=bch.BenchRunCfg(auto_plot=False))
-    res1 = bench1.plot_sweep(
-        "Levels",
-        input_vars=[RunWithLevel.param.level],
-        const_vars=[RunWithLevel.param.dimensions.with_const(2)],
-    )
-    row = pn.Row()
-    row.append(res1.to_table())
-    # row.append(res1.to_curve().opts(shared_axes=False))
-    row.append(res1.to_curve())
-
-    bench.report.append(row)
-
-    for it, r in enumerate(results):
-        lvl = it + 1
-        row = pn.Row()
-        bench.report.append_markdown(f"## {r.bench_cfg.title}")
-        row.append(
-            r.to_holomap()
-            .overlay()
-            .opts(title=f"Sample Points for level: {lvl}", shared_axes=False)
-        )
-        row.append(
-            r.to_heatmap_single(r.bench_cfg.result_vars[0], bch.ReduceType.NONE).opts(
-                title=f"Function Value Heatmap for level: {lvl}", shared_axes=False
-            )
-        )
-        bench.report.append(row)
-
-    bench.report.append_markdown(
-        "This plot overlays the previous plots into a single image. It shows how each level overlaps the previous level"
-    )
-    overlay = hv.Overlay()
-    for lvl, r in enumerate(results):
-        overlay *= (
-            r.to_holomap()
-            .overlay()
-            .opts(width=1000, height=1000, show_legend=False, shared_axes=False)
-        )
-
-    bench.report.append(overlay)
-    return bench
-
-
-def run_levels(run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None) -> bch.Bench:
-    hv.extension("bokeh")
-    opts.defaults(
-        opts.Curve(show_legend=False),
-        opts.Points(show_legend=False),
-    )
-
-    bench = bch.Bench("Levels", LevelsExample(), run_cfg=run_cfg, report=report)
-    bench = run_levels_1D(bench)
-    bench = run_levels_2D(bench)
-
     return bench
 
 
 if __name__ == "__main__":
-    run_levels().report.show()
+    example_levels().report.show()

bencher/example/example_pareto.py

@@ -1,51 +1,127 @@
-# pylint: disable=duplicate-code
+"""
+Advanced Pareto Optimization Example with Randomness
+
+This example demonstrates multi-objective optimization using Optuna with the Bencher framework.
+It shows how to:
+1. Define a problem with multiple competing objectives
+2. Use Optuna's multi-objective optimization capabilities
+3. Visualize and analyze the Pareto front
+4. Compare different optimization approaches
+5. Demonstrate the effect of randomness on Pareto optimization
+"""
 
 import bencher as bch
+import numpy as np
+
+np.random.seed(0)
+
+
+class EngineeringDesignProblem(bch.ParametrizedSweep):
+    """
+    A simplified engineering design problem with two competing objectives.
+
+    This example simulates a common engineering trade-off problem:
+    - Performance vs Cost
+
+    This is a classic multi-objective optimization scenario.
+    The problem includes controlled randomness to simulate real-world variability
+    in manufacturing processes and materials.
+    """
+
+    # Input design parameters - reduced to just 2
+    material_quality = bch.FloatSweep(
+        default=0.5, bounds=[0.1, 1.0], doc="Quality of the material (dimensionless)", samples=20
+    )
+    thickness = bch.FloatSweep(
+        default=0.05, bounds=[0.01, 0.2], doc="Component thickness (m)", samples=20
+    )
+
+    # Result variables - reduced to just 2 objectives to be optimized
+    performance = bch.ResultVar("score", bch.OptDir.maximize, doc="Performance metric (maximize)")
+    cost = bch.ResultVar("$", bch.OptDir.minimize, doc="Manufacturing cost (minimize)")
+
+    def __call__(self, **kwargs) -> dict:
+        """
+        Calculate the multi-objective outcomes based on input parameters.
 
-# All the examples will be using the data structures and benchmark function defined in this file
-from bencher.example.benchmark_data import ExampleBenchCfgIn, ExampleBenchCfgOut, bench_function
+        This simulates an engineering design problem where various objectives
+        compete with each other:
+        - Higher quality materials improve performance but increase cost
+        - Thicker material improves performance but increases cost
+
+        Includes inherent randomness to simulate:
+        - Manufacturing variability
+        - Material property variations
+        - Measurement uncertainty
+        """
+        self.update_params_from_kwargs(**kwargs)
+
+        # Base performance calculation
+        base_performance = self.material_quality * 80 + self.thickness * 50
+
+        # Add significant randomness (standard deviation = 10% of the base value)
+        # This will create noticeably different results on each run
+        performance_variability = 0.15 * base_performance
+        self.performance = base_performance + np.random.normal(0, performance_variability)
+
+        # Introduce a 30% chance of failure (e.g., due to manufacturing defects)
+        if np.random.rand() < 0.3:
+            self.performance = np.nan
+
+        # Base cost calculation
+        base_cost = self.material_quality * 100 + 10 / (self.thickness + 0.01)
+
+        # Add randomness to cost (standard deviation = 8% of the base value)
+        # Manufacturing costs can vary significantly in real-world scenarios
+        cost_variability = 0.12 * base_cost
+        self.cost = base_cost + np.random.normal(0, cost_variability)
+
+        return self.get_results_values_as_dict()
 
 
 def example_pareto(run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None) -> bch.Bench:
-    """Example of how to calculate the pareto front of a parameter sweep
+    """
+    Advanced example of multi-objective Pareto optimization using Optuna.
+
+    This function demonstrates:
+    1. Grid search approach to visualize the entire parameter space
+    2. True multi-objective optimization with Optuna
+    3. Analysis of the Pareto front
+    4. Effect of randomness on the Pareto front
 
     Args:
-        run_cfg (BenchRunCfg): configuration of how to perform the param sweep
+        run_cfg (BenchRunCfg): Configuration for the benchmark run
+        report (BenchReport): Report object to store results
 
     Returns:
-        Bench: results of the parameter sweep
+        Bench: Benchmark object with results
     """
+    if run_cfg is None:
+        run_cfg = bch.BenchRunCfg()
+        run_cfg.repeats = 5  # Multiple repeats to demonstrate randomness effects
+        run_cfg.level = 4
+
+    # Set up Optuna for multi-objective optimization
     run_cfg.use_optuna = True
 
-    bench = bch.Bench(
-        "Multi-objective optimisation",
-        bench_function,
-        ExampleBenchCfgIn,
-        run_cfg=run_cfg,
-        report=report,
-    )
+    # Important: Set multiple repeats to demonstrate the effect of randomness
+    # The framework will automatically calculate and plot both individual runs and averages
+    run_cfg.repeats = 5
+
+    # Create problem definition and benchmark
+    bench = EngineeringDesignProblem().to_bench(run_cfg, report)
 
-    res = bench.plot_sweep(
-        title="Pareto Optimisation with Optuna",
-        description="This example shows how to plot the pareto front of the tradeoff between multiple criteria.  When multiple result variable are defined, and use_optuna=True a pareto plot and the relative importance of each input variable on the output criteria is plotted. A summary of the points on the pareto front is printed as well.  You can use the pareto plot to decide the how to trade off one objective for another.  Pareto plots are supported for 2D and 3D.  If you have more than 3 result variables the first 3 are selected for the pareto plot.  Plotting 4D surfaces is left as an exercise to the reader",
-        input_vars=[
-            ExampleBenchCfgIn.param.theta,
-            ExampleBenchCfgIn.param.offset,
-        ],
-        result_vars=[ExampleBenchCfgOut.param.out_sin, ExampleBenchCfgOut.param.out_cos],
-        const_vars=ExampleBenchCfgIn.get_input_defaults(
-            [ExampleBenchCfgIn.param.noisy.with_const(True)]
-        ),
-        post_description="""# Post Description 
-This is a slightly unusual way of doing pareto optimisation as we are not using a typical multi-objective optimisation algorithm [TODO, add example].  Instead we are performing a grid search and looking at the resulting pareto plot.  The reason for doing a grid search instead of standard pareto optimisation is that we can produce more isolated plots of how an input affects an output which can help understanding of the parameter space.  Future examples will show how to use grid search to bootstrap further optimisation with a multi objective optimiser""",
+    # Perform grid search on our two input variables
+    grid_result = bench.plot_sweep(
+        title="Parameter Space Exploration with Variability",
+        description="Exploring how material quality and thickness affect performance and cost with inherent randomness",
     )
 
-    bench.report.append(res.to_optuna_plots())
+    # Add Optuna-specific visualizations
+    bench.report.append(grid_result.to_optuna_plots())
+
     return bench
 
 
 if __name__ == "__main__":
-    run_cfg_ex = bch.BenchRunCfg()
-    run_cfg_ex.repeats = 2
-    run_cfg_ex.level = 2
-    example_pareto(run_cfg_ex).report.show()
+    example_pareto().report.show()

bencher/example/example_rerun2.py

@@ -23,7 +23,7 @@ else:
     # publish data to a github branch
     bch.publish_and_view_rrd(
         file_path,
-        remote="https://github.com/dyson-ai/bencher.git",
+        remote="https://github.com/blooop/bencher.git",
         branch_name="test_rrd",
         content_callback=bch.github_content,
     ).show()

bencher/example/example_simple_bool.py

@@ -16,14 +16,14 @@ def example_1D_bool(run_cfg: bch.BenchRunCfg) -> bch.Bench:
     )
 
     # here we sample the input variable theta and plot the value of output1. The (noisy) function is sampled 20 times so you can see the distribution
-    res = bench.plot_sweep(
+    bench.plot_sweep(
         title="Example 1D Bool",
         input_vars=[ExampleBenchCfgIn.param.noisy],
         result_vars=[ExampleBenchCfgOut.param.out_sin],
         description=example_1D_bool.__doc__,
         run_cfg=run_cfg,
     )
-    bench.report.append(res.to_bar())
+    bench.add(bch.BarResult)
 
     return bench
 

bencher/example/example_simple_float2d.py

@@ -21,7 +21,12 @@ def example_2D_float(run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport =
     """This example shows how to sample a 1 dimensional float variable and plot the result of passing that parameter sweep to the benchmarking function"""
 
     bench = SimpleFloat().to_bench(run_cfg, report)
-    bench.plot_sweep()
+    res = bench.plot_sweep()
+
+    bench.add(bch.CurveResult)
+    bench.report.append(res.to(bch.CurveResult))
+    bench.report.append(res.to(bch.HeatmapResult))
+    bench.add(bch.BarResult)
     return bench
 
 

bencher/example/example_video.py

@@ -119,6 +119,8 @@ def example_video_tap(
         )
     )
 
+    bench.worker_class_instance.get_results_only()
+
     return bench
 
 

bencher/example/experimental/example_hvplot_explorer.py

@@ -7,7 +7,7 @@ bench = bch.Bench("Bencher_Example_Simple", bench_function, ExampleBenchCfgIn)
 
 
 if __name__ == "__main__":
-    bench_out = bench.plot_sweep(
+    res = bench.plot_sweep(
         input_vars=[ExampleBenchCfgIn.param.theta, ExampleBenchCfgIn.param.offset],
         result_vars=[ExampleBenchCfgOut.param.out_sin],
         title="Float 1D Example",
@@ -34,5 +34,5 @@ if __name__ == "__main__":
         ),
     )
 
-    bench.report.append(bench_out.to_explorer())
+    bench.add(bch.ExplorerResult)
     bench.report.show()

bencher/example/inputs_0D/example_0_in_1_out.py

@@ -5,13 +5,13 @@ import random
 
 
 class SimpleFloat0D(bch.ParametrizedSweep):
-    """This class has 0 input dimensions and 1 output dimensions.  It samples from a gaussian distribution"""
+    """This class has 0 input dimensions and 1 output dimension. It samples from a Gaussian distribution"""
 
     # This defines a variable that we want to plot
     output = bch.ResultVar(units="ul", doc="a sample from a gaussian distribution")
 
     def __call__(self, **kwargs) -> dict:
-        """Generate a sample from a uniform distribution
+        """Generate a sample from a Gaussian distribution
 
         Returns:
             dict: a dictionary with all the result variables in the ParametrisedSweep class as named key value pairs.
@@ -24,31 +24,41 @@ class SimpleFloat0D(bch.ParametrizedSweep):
 def example_0_in_1_out(
     run_cfg: bch.BenchRunCfg = None, report: bch.BenchReport = None
 ) -> bch.Bench:
-    """This example shows how to sample a 1 dimensional float variable and plot the result of passing that parameter sweep to the benchmarking function"""
+    """This example shows how to sample a 0-dimensional variable (no input parameters)
+    and plot the result of that sampling operation.
+
+    Args:
+        run_cfg: Configuration for the benchmark run
+        report: Report to append the results to
+
+    Returns:
+        bch.Bench: The benchmark object
+    """
 
     bench = SimpleFloat0D().to_bench(run_cfg, report)
     bench.plot_sweep()
 
-    bench.report.append(bench.get_result().to_table())
+    bench.add(bch.TableResult)
     return bench
 
 
 if __name__ == "__main__":
-    run_config = bch.BenchRunCfg(repeats=100)
-    reprt = bch.BenchReport()
-    # example_0_in_1_out(run_cfg, report).report.show()
+    example_0_in_1_out().report.show()
+    # run_config = bch.BenchRunCfg(repeats=100)
+    # report_obj = bch.BenchReport()
+    # example_0_in_1_out(run_config, report_obj).report.show()
 
     # run_cfg.over_time = True
     # run_cfg.cache_samples = True
     # for i in range(4):
-    #     example_0_in_1_out(run_cfg, report)
+    #     example_0_in_1_out(run_cfg, report_obj)
 
-    run_config.over_time = True
-    run_config.auto_plot = False
-    for _ in range(4):
-        example_0_in_1_out(run_config, reprt)
+    # run_config.over_time = True
+    # run_config.auto_plot = False
+    # for _ in range(4):
+    #     example_0_in_1_out(run_config, report_obj)
 
-    run_config.auto_plot = True
-    example_0_in_1_out(run_config, reprt)
+    # run_config.auto_plot = True
+    # example_0_in_1_out(run_config, report_obj)
 
-    reprt.show()
+    # report_obj.show()