code-loader 1.0.208.dev8__py3-none-any.whl → 1.0.210__py3-none-any.whl

code_loader/contract/datasetclasses.py

@@ -8,7 +8,7 @@ import numpy.typing as npt
 from code_loader.contract.enums import DataStateType, DataStateEnum, LeapDataType, ConfusionMatrixValue, \
     MetricDirection, DatasetMetadataType, LatentSpaceReduction, CustomLatentSpaceComputedAt
 from code_loader.contract.visualizer_classes import LeapImage, LeapText, LeapGraph, LeapHorizontalBar, \
-    LeapTextMask, LeapImageMask, LeapImageWithBBox, LeapImageWithHeatmap, LeapVideo, LeapAudio
+    LeapTextMask, LeapImageMask, LeapImageWithBBox, LeapImageWithHeatmap, LeapVideo, LeapAudio, LeapVolume
 from code_loader.contract.sim_config import SimConfig
 
 custom_latent_space_attribute = "custom_latent_space"
@@ -213,7 +213,7 @@ VisualizerCallableInterface = Union[
 ]
 
 LeapData = Union[LeapImage, LeapText, LeapGraph, LeapHorizontalBar, LeapImageMask, LeapTextMask, LeapImageWithBBox,
-LeapImageWithHeatmap, LeapVideo, LeapAudio]
+LeapImageWithHeatmap, LeapVideo, LeapAudio, LeapVolume]
 
 CustomCallableInterface = Callable[..., Any]
 

code_loader/contract/enums.py

@@ -29,6 +29,7 @@ class LeapDataType(Enum):
     ImageWithHeatmap = 'ImageWithHeatmap'
     Video = 'Video'
     Audio = 'Audio'
+    Volume = 'Volume'
 
 
 class MetricDirection(Enum):

code_loader/contract/visualizer_classes.py

@@ -377,6 +377,60 @@ class LeapAudio:
             raise LeapValidationError(f'sample_rate must be a positive int, got {self.sample_rate}')
 
 
+@dataclass
+class LeapVolume:
+    """
+    Visualizer representing a volume (3-D scalar field) for Tensorleap: a CT/MRI scan, a microscopy
+    z-stack, or any (D, H, W) grid. The UI slices it along any axis; the engine stores it as uint8.
+
+    Attributes:
+    data (npt.NDArray[np.float32] | npt.NDArray[np.uint8]): The volume, shaped [D, H, W]. Any finite value
+        range is accepted: the engine min-max quantizes it to uint8 for display and keeps the original
+        [min, max] so the UI can show true values.
+    mask (Optional[npt.NDArray[np.uint8]]): Optional label volume shaped like `data`; voxel value v is the
+        index into `labels`.
+    labels (Optional[List[str]]): Names for mask values; required with `mask`, len(labels) > mask.max().
+    spacing (Optional[Tuple[float, float, float]]): Physical voxel size per axis (D, H, W), e.g. mm, so the
+        UI renders anisotropic voxels with the right aspect. None means (1, 1, 1).
+    type (LeapDataType): The data type, default is LeapDataType.Volume.
+
+    Example:
+        volume = np.random.rand(64, 128, 128).astype(np.float32)
+        mask = (volume > 0.8).astype(np.uint8)
+        leap_volume = LeapVolume(data=volume, mask=mask, labels=["background", "lesion"], spacing=(2.0, 0.7, 0.7))
+    """
+    data: Union[npt.NDArray[np.float32], npt.NDArray[np.uint8]]
+    mask: Optional[npt.NDArray[np.uint8]] = None
+    labels: Optional[List[str]] = None
+    spacing: Optional[Tuple[float, float, float]] = None
+    type: LeapDataType = LeapDataType.Volume
+
+    def __post_init__(self) -> None:
+        validate_type(self.type, LeapDataType.Volume)
+        validate_type(type(self.data), np.ndarray)
+        validate_type(self.data.dtype, [np.uint8, np.float32])
+        validate_type(len(self.data.shape), 3, 'Volume data must be of shape 3 [D, H, W]')
+        if not np.isfinite(self.data).all():
+            raise LeapValidationError('Volume data must be finite (no NaN/Inf)')
+        if (self.mask is None) != (self.labels is None):
+            raise LeapValidationError('Volume mask and labels must be given together')
+        if self.mask is not None:
+            validate_type(type(self.mask), np.ndarray)
+            validate_type(self.mask.dtype, np.uint8)
+            if self.mask.shape != self.data.shape:
+                raise LeapValidationError(
+                    f'Volume mask shape {self.mask.shape} must equal data shape {self.data.shape}')
+            validate_type(type(self.labels), list)
+            for label in self.labels:
+                validate_type(type(label), str)
+            if self.mask.size and int(self.mask.max()) >= len(self.labels):
+                raise LeapValidationError(
+                    f'Volume mask has value {int(self.mask.max())} but only {len(self.labels)} labels')
+        if self.spacing is not None:
+            if len(self.spacing) != 3 or any(float(s) <= 0 for s in self.spacing):
+                raise LeapValidationError(f'Volume spacing must be 3 positive numbers, got {self.spacing}')
+
+
 map_leap_data_type_to_visualizer_class = {
     LeapDataType.Image.value: LeapImage,
     LeapDataType.Graph.value: LeapGraph,
@@ -387,5 +441,6 @@ map_leap_data_type_to_visualizer_class = {
     LeapDataType.TextMask.value: LeapTextMask,
     LeapDataType.ImageWithBBox.value: LeapImageWithBBox,
     LeapDataType.ImageWithHeatmap.value: LeapImageWithHeatmap,
-    LeapDataType.Audio.value: LeapAudio
+    LeapDataType.Audio.value: LeapAudio,
+    LeapDataType.Volume.value: LeapVolume,
 }

code_loader/inner_leap_binder/leapbinder.py

@@ -111,6 +111,10 @@ class LeapBinder:
 
         self.mapping_connections: List[NodeConnection] = []
         self.integration_test_func: Optional[Callable[[str, PreprocessResponse], Any]] = None
+        # Set by LeapLoader.exec_script when running the dataset script failed, because that
+        # also resets setup_container: an empty container after a failure means "the script
+        # crashed", not "the user forgot to register". See get_preprocess_result.
+        self.previous_script_failure: Optional[BaseException] = None
 
         self.batch_size_to_validate: Optional[int] = None
         self.leap_analysis_configuration = LeapAnalysisConfiguration()
@@ -803,6 +807,13 @@ class LeapBinder:
     def get_preprocess_result(self) -> Dict[DataStateEnum, PreprocessResponse]:
         preprocess = self.setup_container.preprocess
         if preprocess is None:
+            if self.previous_script_failure is not None:
+                # Running the dataset script already failed once, and that reset the
+                # registrations (LeapLoader.exec_script). Blaming a missing
+                # set_preprocess call here would hide the actual crash.
+                raise Exception(
+                    f"The dataset script failed before registering its handlers: "
+                    f"{self.previous_script_failure}") from self.previous_script_failure
             raise Exception("Please make sure you call the leap_binder.set_preprocess method")
         preprocess_results = preprocess.function()
         preprocess_result_dict = {}

code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -34,7 +34,7 @@ from code_loader.contract.enums import MetricDirection, LeapDataType, DatasetMet
 from code_loader import leap_binder, LeapLoader
 from code_loader.contract.mapping import NodeMapping, NodeMappingType, NodeConnection
 from code_loader.contract.visualizer_classes import LeapImage, LeapImageMask, LeapTextMask, LeapText, LeapGraph, \
-    LeapHorizontalBar, LeapImageWithBBox, LeapImageWithHeatmap, LeapVideo, LeapAudio, LeapValidationError, \
+    LeapHorizontalBar, LeapImageWithBBox, LeapImageWithHeatmap, LeapVideo, LeapAudio, LeapVolume, LeapValidationError, \
     map_leap_data_type_to_visualizer_class
 from code_loader.inner_leap_binder.leapbinder import mapping_runtime_mode_env_var_mame, \
     _reject_stringized_sample_preprocess_response
@@ -1593,7 +1593,8 @@ def tensorleap_custom_visualizer(name: str, visualizer_type: LeapDataType,
                 LeapDataType.ImageWithBBox: LeapImageWithBBox,
                 LeapDataType.ImageWithHeatmap: LeapImageWithHeatmap,
                 LeapDataType.Video: LeapVideo,
-                LeapDataType.Audio: LeapAudio
+                LeapDataType.Audio: LeapAudio,
+                LeapDataType.Volume: LeapVolume,
             }
             validate_output_structure(result, func_name=user_function.__name__,
                                       expected_type_name=result_type_map[visualizer_type])
@@ -1762,7 +1763,16 @@ def _classify_custom_latent_space_signature(user_function) -> str:
     """Dataset-computed when a parameter is typed PreprocessResponse (a subclass or an
     Optional[...] of it included), model-computed otherwise."""
     params = list(inspect.signature(user_function).parameters.values())
-    hints = typing.get_type_hints(user_function)
+    try:
+        hints = typing.get_type_hints(user_function)
+    except NameError as e:
+        raise Exception(
+            f"tensorleap_custom_latent_space validation failed: could not resolve the type "
+            f"annotations of '{user_function.__name__}' ({e}). Tensorleap reads them to tell a "
+            f"dataset-computed latent space from a model-computed one, so every annotation, the "
+            f"return type included, must be resolvable when the function is decorated. Import the "
+            f"annotated types at module level (not only under TYPE_CHECKING) or remove the "
+            f"annotation.") from e
     preprocess_params = [p.name for p in params if _is_preprocess_response_type(hints.get(p.name))]
     if preprocess_params:
         positional = [p.name for p in params
@@ -1789,18 +1799,29 @@ def _classify_custom_latent_space_signature(user_function) -> str:
             f"If you are upgrading an existing project, this signature used to be accepted "
             f"unannotated as dataset-computed; add ': PreprocessResponse' to '{second}' to keep "
             f"the previous behavior.")
+    if len(params) > 2 and not any(p.name in hints for p in params):
+        names = [p.name for p in params]
+        raise Exception(
+            f"tensorleap_custom_latent_space validation failed: '{user_function.__name__}' has "
+            f"parameters {names} and none of them has a type annotation, so Tensorleap cannot "
+            f"tell whether this is a dataset-computed latent space (one sample at a time) or a "
+            f"model-computed one (a batch of model tensors). Please annotate them:\n"
+            f"  dataset-computed: def {user_function.__name__}({names[0]}, {names[1]}: PreprocessResponse, ...) -> (d,)\n"
+            f"  model-computed:   def {user_function.__name__}({names[0]}: np.ndarray, {names[1]}: np.ndarray, ...) -> (batch, d)")
     return 'model'
 
 
 def _model_latent_space_arg_names(user_function) -> List[str]:
-    argspec = inspect.getfullargspec(user_function)
-    arg_names = list(argspec.args)
+    # inspect.signature follows functools.wraps' __wrapped__, as the classifier does.
+    params = inspect.signature(user_function).parameters.values()
+    arg_names = [p.name for p in params
+                 if p.kind in (inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD)]
     spr_count = 0
-    for arg_name, arg_type in argspec.annotations.items():
-        if arg_name == 'return':
+    for param in params:
+        if param.annotation is inspect.Parameter.empty:
             continue
-        _reject_stringized_sample_preprocess_response(user_function, arg_name, arg_type)
-        if arg_type == SamplePreprocessResponse:
+        _reject_stringized_sample_preprocess_response(user_function, param.name, param.annotation)
+        if param.annotation == SamplePreprocessResponse:
             spr_count += 1
     if spr_count > 1:
         raise Exception(
@@ -1882,7 +1903,7 @@ def _check_custom_latent_space_values(result: np.ndarray, ls_name: str, has_batc
             key=("tensorleap_custom_latent_space_nonfinite", ls_name),
             message=(
                 f"Custom latent space '{ls_name}' returned NaN or inf. Those samples are left out of "
-                f"this latent space; if they exceed 5% of the evaluated samples the latent space is "
+                f"this latent space; if they exceed 15% of the evaluated samples the latent space is "
                 f"dropped."))
     peak = 0.0
     if result.size and result.dtype.kind == 'f':

code_loader/leaploader.py

@@ -1,4 +1,5 @@
 # mypy: ignore-errors
+import copy
 import importlib.util
 import inspect
 import io
@@ -7,6 +8,7 @@ import sys
 from contextlib import redirect_stdout
 from functools import lru_cache
 from pathlib import Path
+from types import TracebackType
 from typing import Dict, List, Iterable, Set, FrozenSet, Union, Any, Type, Optional, Callable, Tuple
 
 import numpy as np
@@ -33,6 +35,44 @@ from code_loader.utils import get_root_exception_file_and_line_number, get_metad
     validate_autoregressive_state_types, autoregressive_nests_equal, is_absent_metadata_value, \
     sample_preprocess_response_arg_name
 
+_code_loader_dir = str(Path(__file__).parent)
+
+
+def _innermost_frame_outside_code_loader(e: BaseException) -> Optional[TracebackType]:
+    """The deepest traceback frame that is not code_loader's own code, if any.
+
+    That is the line the user can go and look at. The deepest frame overall is often
+    ours — a validation that raises, or a builtin we wrapped — and "raised at
+    leapbinder.py" tells the user nothing about their script.
+    """
+    frame_in_user_code = None
+    _traceback = e.__traceback__
+    while _traceback is not None:
+        if not _traceback.tb_frame.f_code.co_filename.startswith(_code_loader_dir):
+            frame_in_user_code = _traceback
+        _traceback = _traceback.tb_next
+    return frame_in_user_code
+
+
+def describe_script_exception(e: BaseException) -> str:
+    """One line describing a failure raised by user code: its type, its message and where it happened.
+
+    ``repr(e)`` on its own throws away what the user needs most: ``repr`` of an OSError
+    drops the filename (``FileNotFoundError(2, 'No such file or directory')`` — but not
+    *which* file), and no ``repr`` says which line of the integration script raised. Both
+    are what turns "the dataset script crashed" into an error the user can act on.
+    """
+    message = getattr(e, 'message', None)
+    if not isinstance(message, str) or not message:
+        message = str(e)
+    description = f'{type(e).__name__}: {message}' if message else repr(e)
+
+    frame_in_user_code = _innermost_frame_outside_code_loader(e)
+    if frame_in_user_code is not None:
+        file_name = Path(frame_in_user_code.tb_frame.f_code.co_filename).name
+        description = f'{description} (raised at {file_name}, line {frame_in_user_code.tb_lineno})'
+    return description
+
 
 def _serialize_sim_bounds(bounds) -> dict:
     if isinstance(bounds, (FloatBounds, IntBounds)):
@@ -55,6 +95,8 @@ class LeapLoader(LeapLoaderBase):
         self._preprocess_result_cached = None
         self._synthetic_lookup: Dict[str, Tuple[PreprocessResponse, Any]] = {}
         self._synthetic_populator: Optional[Callable[[str], None]] = None
+        # The first exec_script failure, re-raised by every later call. See exec_script.
+        self._exec_script_error: Optional[BaseException] = None
 
         try:
             from code_loader.mixpanel_tracker import track_code_loader_loaded
@@ -66,9 +108,33 @@ class LeapLoader(LeapLoaderBase):
         except Exception:
             pass
 
+    def _remember_exec_script_error(self, error: BaseException) -> BaseException:
+        # Also recorded on the binder: the failure handlers below wipe its setup_container,
+        # so anything that reaches the binder afterwards (another LeapLoader in the same
+        # process, say) can report the real failure instead of an empty container.
+        global_leap_binder.previous_script_failure = error
+        self._exec_script_error = error
+        return error
+
     @lru_cache()
     def exec_script(self) -> None:
         from code_loader.inner_leap_binder import leapbinder_decorators as _leap_dec
+
+        # A failed exec_script is sticky. lru_cache does not cache exceptions, so without
+        # this every later caller re-ran the script — and the re-run reports the WRONG
+        # error: the handlers below reset global_leap_binder.setup_container, while
+        # re-importing the entry file does not re-register handlers that live in modules
+        # already in sys.modules. The second run therefore raised "Please make sure you
+        # call the leap_binder.set_preprocess method", burying the real cause (a missing
+        # file, a bad path, a typo'd import). Callers do retry — the engine's samples
+        # generator calls this once per loop iteration — so the real error was logged once
+        # and then drowned in generic repeats.
+        if self._exec_script_error is not None:
+            # A fresh copy each time: re-raising the stored object would append this call's
+            # frames to its __traceback__, so a caller retrying in a loop grows it (and keeps
+            # every retry's frames alive) without bound.
+            error = self._exec_script_error
+            raise copy.copy(error) from error.__cause__
         try:
             os.environ[mapping_runtime_mode_env_var_mame] = 'TRUE'
             self.evaluate_module()
@@ -98,16 +164,19 @@ class LeapLoader(LeapLoaderBase):
                     if is_grouped else
                     PreprocessResponse(state=DataStateType.training, length=0))
                 global_leap_binder.integration_test_func(None, mapping_preprocess)
+            global_leap_binder.previous_script_failure = None
         except TypeError as e:
             import traceback
             global_leap_binder.setup_container = DatasetIntegrationSetup()
             if "leap_binder.set_metadata(" in traceback.format_exc(5):
-                raise DeprecationWarning(
-                    "Please remove the metadata_type on leap_binder.set_metadata in your dataset script")
-            raise DatasetScriptException(getattr(e, 'message', repr(e))) from e
+                raise self._remember_exec_script_error(DeprecationWarning(
+                    "Please remove the metadata_type on leap_binder.set_metadata in your dataset script"))
+            raise self._remember_exec_script_error(
+                DatasetScriptException(describe_script_exception(e))) from e
         except Exception as e:
             global_leap_binder.setup_container = DatasetIntegrationSetup()
-            raise DatasetScriptException(getattr(e, 'message', repr(e))) from e
+            raise self._remember_exec_script_error(
+                DatasetScriptException(describe_script_exception(e))) from e
         finally:
             # ensure that the environment variable is removed after the script execution
             _leap_dec._mapping_dataset_is_grouped = False
@@ -1513,8 +1582,9 @@ class LeapLoader(LeapLoaderBase):
         # Preprocess runs only when the function asks for a SamplePreprocessResponse; the metrics
         # pod that calls this has no other reason to pay for it.
         if preprocess_response_arg_name is not None:
-            input_tensors_by_arg_name[preprocess_response_arg_name] = SamplePreprocessResponse(
-                sample_ids, self._preprocess_result()[state])
+            input_tensors_by_arg_name = {
+                **input_tensors_by_arg_name,
+                preprocess_response_arg_name: SamplePreprocessResponse(sample_ids, self._preprocess_result()[state])}
 
         return handler.function(**input_tensors_by_arg_name)
 

code_loader/plot_functions/plot_functions.py

@@ -20,7 +20,7 @@ from textwrap import wrap
 import math
 
 from code_loader.contract.visualizer_classes import LeapImage, LeapImageWithBBox, LeapGraph, LeapText, \
-    LeapHorizontalBar, LeapImageMask, LeapTextMask, LeapImageWithHeatmap, LeapVideo
+    LeapHorizontalBar, LeapImageMask, LeapTextMask, LeapImageWithHeatmap, LeapVideo, LeapVolume
 from code_loader.utils import rescale_min_max
 
 
@@ -420,6 +420,28 @@ def plot_video(leap_data: LeapVideo, title: str) -> None:
         plt.pause(0.1)  # Adjust the pause duration as needed
     plt.show()
 
+@run_only_on_non_mapping_mode()
+def plot_volume(leap_data: LeapVolume, title: str) -> None:
+    """Middle slice along each axis, grayscale as the engine stores it (uint8), mask overlaid."""
+    volume = rescale_min_max(leap_data.data.astype(np.float32))
+    spacing = leap_data.spacing or (1.0, 1.0, 1.0)
+    fig, axes = plt.subplots(1, 3, figsize=(12, 4))
+    fig.patch.set_facecolor('black')
+    fig.suptitle(title, color='white')
+    for axis, ax in enumerate(axes):
+        index = volume.shape[axis] // 2
+        ax.imshow(np.take(volume, index, axis=axis), cmap='gray', vmin=0, vmax=255)
+        if leap_data.mask is not None:
+            mask = np.take(leap_data.mask, index, axis=axis)
+            ax.imshow(np.ma.masked_where(mask == 0, mask), cmap='tab10', alpha=0.4,
+                      vmin=0, vmax=max(9, len(leap_data.labels) - 1))
+        rows, cols = [i for i in range(3) if i != axis]
+        ax.set_aspect(spacing[rows] / spacing[cols])
+        ax.set_title(f'axis {axis} / slice {index}', color='white')
+        ax.axis('off')
+    plt.show()
+
+
 @run_only_on_non_mapping_mode()
 def plot_image_with_heatmap(leap_data: LeapImageWithHeatmap, title: str) -> None:
     """
@@ -474,4 +496,5 @@ plot_switch = {
     LeapDataType.ImageWithHeatmap: plot_image_with_heatmap,
     LeapDataType.ImageWithBBox: plot_image_with_b_box,
     LeapDataType.Video: plot_video,
+    LeapDataType.Volume: plot_volume,
 }

code_loader/utils.py

@@ -250,8 +250,8 @@ def autoregressive_nests_equal(a: Any, b: Any) -> bool:
 
 
 def sample_preprocess_response_arg_name(func: Callable[..., Any]) -> Optional[str]:
-    # 'return' lives in annotations too and must never be mistaken for a parameter.
-    for arg_name, arg_type in inspect.getfullargspec(func).annotations.items():
-        if arg_name != 'return' and arg_type == SamplePreprocessResponse:
-            return arg_name
+    # inspect.signature follows functools.wraps' __wrapped__; getfullargspec does not.
+    for param in inspect.signature(func).parameters.values():
+        if param.annotation == SamplePreprocessResponse:
+            return param.name
     return None

code_loader/visualizers/default_visualizers.py

@@ -5,7 +5,7 @@ import numpy as np
 import numpy.typing as npt
 
 from code_loader.contract.visualizer_classes import LeapImage, LeapGraph, LeapHorizontalBar, LeapText, \
-    LeapImageMask, LeapTextMask, LeapVideo, LeapAudio
+    LeapImageMask, LeapTextMask, LeapVideo, LeapAudio, LeapVolume
 from code_loader.utils import rescale_min_max
 
 
@@ -92,6 +92,20 @@ def default_audio_visualizer(audio: npt.NDArray[np.float32],
     raise ValueError(f'visual must be 1-D, 2-D, or 3-D, got shape {v.shape}')
 
 
+def default_volume_visualizer(data: npt.NDArray[np.float32]) -> LeapVolume:
+    """Strip the batch axis and a single channel axis (first or last) to get a [D, H, W] volume."""
+    volume = data[0]
+    if volume.ndim == 4:
+        if volume.shape[0] == 1:
+            volume = volume[0]
+        elif volume.shape[-1] == 1:
+            volume = volume[..., 0]
+    if volume.ndim != 3:
+        raise ValueError('default_volume_visualizer expects [1, D, H, W], [1, 1, D, H, W] or [1, D, H, W, 1], '
+                         f'got {data.shape}')
+    return LeapVolume(volume)
+
+
 def default_graph_visualizer(data: npt.NDArray[np.float32]) -> LeapGraph:
     return LeapGraph(data[0])
 

{code_loader-1.0.208.dev8.dist-info → code_loader-1.0.210.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: code-loader
-Version: 1.0.208.dev8
+Version: 1.0.210
 Summary: 
 Home-page: https://github.com/tensorleap/code-loader
 License: MIT

{code_loader-1.0.208.dev8.dist-info → code_loader-1.0.210.dist-info}/RECORD

@@ -1,13 +1,13 @@
 LICENSE,sha256=qIwWjdspQeSMTtnFZBC8MuT-95L02FPvzRUdWFxrwJY,1067
 code_loader/__init__.py,sha256=outxRQ0M-zMfV0QGVJmAed5qWfRmyD0TV6-goEGAzBw,406
 code_loader/contract/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-code_loader/contract/datasetclasses.py,sha256=yNEPIyZqCO54fKBgmgbFIKEMVBzvpf4n8U2zmPhXv88,18110
-code_loader/contract/enums.py,sha256=R4Ge9-oSO7-GYjZAKMTB8Ws5FNsxhCQAYAJruxViJxk,1886
+code_loader/contract/datasetclasses.py,sha256=zDywsj4N9rH7aUU8vkXvOjjj3R-rr93HiC62m0L4rb0,18134
+code_loader/contract/enums.py,sha256=9pv0TwYW6alqsx2jVPb_eylC6qpgMBbdTlCBgG6ZJn0,1908
 code_loader/contract/exceptions.py,sha256=jWqu5i7t-0IG0jGRsKF4DjJdrsdpJjIYpUkN1F4RiyQ,51
 code_loader/contract/mapping.py,sha256=i-yVyFuGUITL5lchPNfYlu7bhwk-yuoHPacAeFhcYr8,1490
 code_loader/contract/responsedataclasses.py,sha256=2SQCccuIlSeUJT0igyvIJRYtmaWSqqlQwtaAA1iEuSI,5044
 code_loader/contract/sim_config.py,sha256=le8KMALZiP0WU4UcuKnTOSWBW2rNjpnWYfII502NqDM,3493
-code_loader/contract/visualizer_classes.py,sha256=vzX9YcwxKOm3IpYj8OaqsA1odPlRgj2Cfvglwd88Wbw,18213
+code_loader/contract/visualizer_classes.py,sha256=ZXrNHbT4kBvFG2r3og1oQRxxhdVndkToqpa8OVnd9gs,21272
 code_loader/default_losses.py,sha256=NoOQym1106bDN5dcIk56Elr7ZG5quUHArqfP5-Nyxyo,1139
 code_loader/default_metrics.py,sha256=2XSlyNw_XLDGSJDoz5W_Evi5wbL0dhwq24pPr15vSPc,5025
 code_loader/experiment_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -21,18 +21,18 @@ code_loader/experiment_api/types.py,sha256=MY8xFARHwdVA7p4dxyhD60ShmttgTvb4qdp1o
 code_loader/experiment_api/utils.py,sha256=XZHtxge12TS4H4-8PjV3sKuhp8Ud6ojAiIzTZJEqBqc,3304
 code_loader/experiment_api/workingspace_config_utils.py,sha256=DLzXQCg4dgTV_YgaSbeTVzq-2ja_SQw4zi7LXwKL9cY,990
 code_loader/inner_leap_binder/__init__.py,sha256=koOlJyMNYzGbEsoIbXathSmQ-L38N_pEXH_HvL7beXU,99
-code_loader/inner_leap_binder/leapbinder.py,sha256=fplNN3TfJHg79YpEPHKK3b6CxrR7W0ugDeHhAZfYty0,62784
-code_loader/inner_leap_binder/leapbinder_decorators.py,sha256=paUtnncLn-4iFUJhqEOg3rPtKh9DoS3_HVgGUgOz8c4,210906
-code_loader/leaploader.py,sha256=DiVCs076JP21HXBfpKkzs3Qaumg8Cz26q1tIc4C-kcg,97552
+code_loader/inner_leap_binder/leapbinder.py,sha256=EhUD4OLSBuVslKYgiXFDoufnfatwCb0LQe_gH9kg5w0,63615
+code_loader/inner_leap_binder/leapbinder_decorators.py,sha256=yxo3L7GlFGpwDuU1wtopp9kscFB5V6RnetYnvII8K8g,212536
+code_loader/leaploader.py,sha256=e7jNqgurKp8o6zbjeXMwPp6Fm3Eltb9VCwv_5IxLENk,101375
 code_loader/leaploaderbase.py,sha256=JzgpEfY-kNUWbWUb_cZ1G1zHo6oSci6QhT7hqw3E1Jg,12371
 code_loader/mixpanel_tracker.py,sha256=rNwRmFifNbdUoqLQvvhhgpKczWpWiEmd8MfyJe27sxw,9131
 code_loader/plot_functions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-code_loader/plot_functions/plot_functions.py,sha256=2DC-zlVaN13P4VNx5d8csgs80C6SisaeP1-Kq2LW7iM,16075
+code_loader/plot_functions/plot_functions.py,sha256=m2Gre8fZxypE4Pdf1HrYL7Xv8AVLd_7fZPSa8WgydJc,17190
 code_loader/plot_functions/visualize.py,sha256=gsBAYYkwMh7jIpJeDMPS8G4CW-pxwx6LznoQIvi4vpo,657
-code_loader/utils.py,sha256=v6VraCdbFADoNwNx5TH89BLnZ6yfPoWMkyJrqQ_usFc,12377
+code_loader/utils.py,sha256=Yuv2hPx4G70RV2x0Fc_UCube9BLpEryyq4cuKIcsq7s,12347
 code_loader/visualizers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-code_loader/visualizers/default_visualizers.py,sha256=grTPin_lCE9aci8i8CqA7DqQwAyXRB7_EamA3na_pls,5438
-code_loader-1.0.208.dev8.dist-info/LICENSE,sha256=qIwWjdspQeSMTtnFZBC8MuT-95L02FPvzRUdWFxrwJY,1067
-code_loader-1.0.208.dev8.dist-info/METADATA,sha256=Zv4Z5dCnspuqPU778nnj7nEOkmHqIhxBg44L_ZwRIUw,1095
-code_loader-1.0.208.dev8.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-code_loader-1.0.208.dev8.dist-info/RECORD,,
+code_loader/visualizers/default_visualizers.py,sha256=bu-4A_Uix5egUJpUOq_vQzN3-vidDRoeeazjcC1l-c4,6023
+code_loader-1.0.210.dist-info/LICENSE,sha256=qIwWjdspQeSMTtnFZBC8MuT-95L02FPvzRUdWFxrwJY,1067
+code_loader-1.0.210.dist-info/METADATA,sha256=ULDVtuTKgMNB37laAG_2o51WbTmox-heCsomRRBYAEc,1090
+code_loader-1.0.210.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+code_loader-1.0.210.dist-info/RECORD,,