code-loader 1.0.186.dev4__py3-none-any.whl → 1.0.187.dev0__py3-none-any.whl

code_loader/contract/visualizer_classes.py

@@ -32,12 +32,14 @@ class LeapImage:
     Visualizer representing an image for Tensorleap.
 
     Attributes:
-    data (npt.NDArray[np.float32] | npt.NDArray[np.uint8]): The image data.
+    data (npt.NDArray[np.float32] | npt.NDArray[np.uint8]): The image data, shaped [H, W, 3] or [H, W, 1].
+        Expected pixel range is [0, 255]. Float values are cast to int (truncated, not scaled), so a
+        normalized [0, 1] float image renders near-black - scale it to [0, 255] or pass uint8.
     type (LeapDataType): The data type, default is LeapDataType.Image.
     compress: Optional[bool]: Whether to compress the image (.jpg) or not (.png)
 
     Example:
-        image_data = np.random.rand(100, 100, 3).astype(np.float32)
+        image_data = (np.random.rand(100, 100, 3) * 255).astype(np.float32)  # [0, 255]
         leap_image = LeapImage(data=image_data)
     """
     data: Union[npt.NDArray[np.float32], npt.NDArray[np.uint8]]
@@ -60,10 +62,12 @@ class LeapVideo:
 
     Attributes:
     data (npt.NDArray[np.float32] | npt.NDArray[np.uint8]): The video data, shaped [T, H, W, C], where T is the number of frames.
+        Note the range differs from still images: float video is expected in [0, 1] (it is scaled by 255),
+        while uint8 is used as-is in [0, 255]. Float values above 1 saturate to white.
     type (LeapDataType): The data type, default is LeapDataType.Video.
 
     Example:
-        video_data = np.random.rand(10, 100, 100, 3).astype(np.float32)
+        video_data = np.random.rand(10, 100, 100, 3).astype(np.float32)  # [0, 1]
         leap_video = LeapVideo(data=video_data)
     """
     data: Union[npt.NDArray[np.float32], npt.NDArray[np.uint8]]
@@ -84,11 +88,13 @@ class LeapImageWithBBox:
 
     Attributes:
     data (npt.NDArray[np.float32] | npt.NDArray[np.uint8]): The image data, shaped [H, W, 3] or [H, W, 1].
+        Expected pixel range is [0, 255]. Float values are cast to int (truncated, not scaled), so a
+        normalized [0, 1] float image renders near-black - scale it to [0, 255] or pass uint8.
     bounding_boxes (List[BoundingBox]): List of Tensorleap bounding boxes objects in relative size to image size.
     type (LeapDataType): The data type, default is LeapDataType.ImageWithBBox.
 
     Example:
-        image_data = np.random.rand(100, 100, 3).astype(np.float32)
+        image_data = (np.random.rand(100, 100, 3) * 255).astype(np.float32)  # [0, 255]
         bbox = BoundingBox(x=0.5, y=0.5, width=0.2, height=0.2, confidence=0.9, label="object")
         leap_image_with_bbox = LeapImageWithBBox(data=image_data, bounding_boxes=[bbox])
     """
@@ -231,6 +237,8 @@ class LeapImageMask:
     Attributes:
     mask (npt.NDArray[np.uint8]): The mask data, shaped [H, W].
     image (npt.NDArray[np.float32] | npt.NDArray[np.uint8]): The image data, shaped [H, W, 3] or shaped [H, W, 1].
+        Any pixel range is accepted: the image is min-max normalized to [0, 255] for display, so unlike the
+        plain Image visualizer, a normalized [0, 1] float renders fine here.
     labels (List[str]): Labels associated with the mask regions; e.g., class names for segmented objects. The length of `labels` should match the number of unique values in `mask`.
     type (LeapDataType): The data type, default is LeapDataType.ImageMask.
 
@@ -304,12 +312,14 @@ class LeapImageWithHeatmap:
 
     Attributes:
     image (npt.NDArray[np.float32]): The image data, shaped [H, W, C], where C is the number of channels.
+        Expected pixel range is [0, 255] (float is truncated to int, not scaled), so a normalized [0, 1] float
+        base image renders near-black - scale it to [0, 255]. The overlaid heatmaps are normalized separately.
     heatmaps (npt.NDArray[np.float32]): The heatmap data, shaped [N, H, W], where N is the number of heatmaps.
     labels (List[str]): Labels associated with the heatmaps; e.g., feature names or attention regions. The length of `labels` should match the number of heatmaps, N.
     type (LeapDataType): The data type, default is LeapDataType.ImageWithHeatmap.
 
     Example:
-        image_data = np.random.rand(100, 100, 3).astype(np.float32)
+        image_data = (np.random.rand(100, 100, 3) * 255).astype(np.float32)  # [0, 255]
         heatmaps = np.random.rand(3, 100, 100).astype(np.float32)
         labels = ["heatmap1", "heatmap2", "heatmap3"]
         leap_image_with_heatmap = LeapImageWithHeatmap(image=image_data, heatmaps=heatmaps, labels=labels)

code_loader/inner_leap_binder/leapbinder.py

@@ -31,6 +31,31 @@ from code_loader.visualizers.default_visualizers import DefaultVisualizer, \
 mapping_runtime_mode_env_var_mame = '__MAPPING_RUNTIME_MODE__'
 
 
+def _stringized_annotation_type_name(annotation: Any) -> Optional[str]:
+    """Return the bare type name when ``annotation`` is a *stringized* annotation
+    (e.g. produced by ``from __future__ import annotations`` or a quoted hint),
+    otherwise ``None``. code_loader inspects raw annotations expecting real classes,
+    so a stringized annotation silently breaks type detection."""
+    if isinstance(annotation, str):
+        return annotation.split("[")[0].strip().rsplit(".", 1)[-1]
+    return None
+
+
+def _reject_stringized_sample_preprocess_response(function: Callable, arg_name: str, annotation: Any) -> None:
+    """Fail fast when a ``SamplePreprocessResponse`` argument was stringized. Otherwise
+    ``arg_type == SamplePreprocessResponse`` silently evaluates to ``False`` and the
+    argument is mis-wired as a regular input — a bug that only surfaces on the platform.
+    Fires only on the actual damage (a stringized SamplePreprocessResponse), not merely
+    because the file uses future annotations."""
+    if _stringized_annotation_type_name(annotation) == SamplePreprocessResponse.__name__:
+        raise Exception(
+            f"Argument '{arg_name}' of function '{function.__name__}' is annotated with a string "
+            f"('{annotation}') instead of the SamplePreprocessResponse type. This usually means the "
+            f"file uses 'from __future__ import annotations' (or a quoted hint), which stringizes "
+            f"annotations and breaks Tensorleap type detection. Remove that import (or the quotes) so "
+            f"SamplePreprocessResponse is referenced as a real type.")
+
+
 
 
 class LeapBinder:
@@ -123,6 +148,7 @@ class LeapBinder:
         regular_arg_names = inspect.getfullargspec(function)[0]
         preprocess_response_arg_name = None
         for arg_name, arg_type in inspect.getfullargspec(function).annotations.items():
+            _reject_stringized_sample_preprocess_response(function, arg_name, arg_type)
             if arg_type == SamplePreprocessResponse:
                 if preprocess_response_arg_name is not None:
                     raise Exception("only one argument can be of type SamplePreprocessResponse")
@@ -155,6 +181,13 @@ class LeapBinder:
                   f"https://docs.python.org/3/library/typing.html")
         else:
             return_type = func_annotations["return"]
+            if isinstance(return_type, str):
+                raise Exception(
+                    f"The return type hint of function '{function.__name__}' is a string "
+                    f"('{return_type}') instead of a type. This usually means the file uses "
+                    f"'from __future__ import annotations' (or a quoted return hint), which stringizes "
+                    f"annotations and prevents Tensorleap from detecting the visualizer type. Remove "
+                    f"that import (or the quotes) so the return type is a real class.")
             if return_type not in LeapData.__args__:  # type: ignore[attr-defined]
                 raise Exception(
                     f'The return type of function {function.__name__} is invalid. current return type: {return_type}, '  # type: ignore[attr-defined]
@@ -296,6 +329,7 @@ class LeapBinder:
         regular_arg_names = inspect.getfullargspec(function)[0]
         preprocess_response_arg_name = None
         for arg_name, arg_type in inspect.getfullargspec(function).annotations.items():
+            _reject_stringized_sample_preprocess_response(function, arg_name, arg_type)
             if arg_type == SamplePreprocessResponse:
                 if preprocess_response_arg_name is not None:
                     raise Exception("only one argument can be of type SamplePreprocessResponse")
@@ -339,6 +373,7 @@ class LeapBinder:
         regular_arg_names = inspect.getfullargspec(function)[0]
         preprocess_response_arg_name = None
         for arg_name, arg_type in inspect.getfullargspec(function).annotations.items():
+            _reject_stringized_sample_preprocess_response(function, arg_name, arg_type)
             if arg_type == SamplePreprocessResponse:
                 if preprocess_response_arg_name is not None:
                     raise Exception("only one argument can be of type SamplePreprocessResponse")
@@ -380,6 +415,7 @@ class LeapBinder:
         regular_arg_names = inspect.getfullargspec(function)[0]
         preprocess_response_arg_name = None
         for arg_name, arg_type in inspect.getfullargspec(function).annotations.items():
+            _reject_stringized_sample_preprocess_response(function, arg_name, arg_type)
             if arg_type == SamplePreprocessResponse:
                 if preprocess_response_arg_name is not None:
                     raise Exception("only one argument can be of type SamplePreprocessResponse")

code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -1102,19 +1102,33 @@ def _viz_prefix(viz_name: str, leap_type_name: str) -> str:
     return f"Visualizer '{viz_name}' ({leap_type_name}):"
 
 
+def _warn_nonfinite(arr, viz_name: str, leap_type_name: str, field_name: str = "image data") -> None:
+    """Warn when a float array contains NaN/Inf. Applies to every image-like visualizer, including
+    ImageMask (whose min-max normalization also can't render non-finite values)."""
+    if not isinstance(arr, np.ndarray) or arr.size == 0:
+        return
+    if np.issubdtype(arr.dtype, np.floating) and not np.all(np.isfinite(arr)):
+        store_general_warning(
+            key=("viz_nonfinite", viz_name, leap_type_name, field_name),
+            message=f"{_viz_prefix(viz_name, leap_type_name)} {field_name} contains NaN or Inf values, "
+                    f"which will render incorrectly.",
+            link_to_docs=_VIZ_DOCS,
+        )
+
+
 def _warn_image_value_range(image, viz_name: str, leap_type_name: str, field_name: str = "image data") -> None:
-    """Warn when image pixel values sit in a range that will render near-black or clipped."""
+    """Warn when still-image pixel values sit in a range that renders near-black or clipped.
+
+    Applies to Image / ImageWithBBox / ImageWithHeatmap, which the engine encodes with cv2
+    (saturate_cast float->uint8, no scaling). Float is therefore expected in [0, 255]; a
+    normalized [0, 1] float renders near-black. (Video and ImageMask use different conventions.)
+    """
     if not isinstance(image, np.ndarray) or image.size == 0:
         return
     prefix = _viz_prefix(viz_name, leap_type_name)
 
     if np.issubdtype(image.dtype, np.floating):
-        if not np.all(np.isfinite(image)):
-            store_general_warning(
-                key=("viz_image_nonfinite", viz_name, leap_type_name, field_name),
-                message=f"{prefix} {field_name} contains NaN or Inf values, which will render incorrectly.",
-                link_to_docs=_VIZ_DOCS,
-            )
+        _warn_nonfinite(image, viz_name, leap_type_name, field_name)
         finite = image[np.isfinite(image)]
         if finite.size == 0:
             return
@@ -1147,6 +1161,42 @@ def _warn_image_value_range(image, viz_name: str, leap_type_name: str, field_nam
             )
 
 
+def _warn_video_value_range(video, viz_name: str, leap_type_name: str, field_name: str = "video data") -> None:
+    """Warn when video pixel values won't survive the engine's float->uint8 scaling.
+
+    Unlike still images, the engine scales float video by 255 (videoencoder.py), so float is
+    expected in [0, 1]; values above 1 saturate to white and negatives clip to black. uint8 is
+    used as-is in [0, 255].
+    """
+    if not isinstance(video, np.ndarray) or video.size == 0:
+        return
+    prefix = _viz_prefix(viz_name, leap_type_name)
+
+    if np.issubdtype(video.dtype, np.floating):
+        _warn_nonfinite(video, viz_name, leap_type_name, field_name)
+        finite = video[np.isfinite(video)]
+        if finite.size == 0:
+            return
+        mn, mx = float(finite.min()), float(finite.max())
+        if mn < 0.0 or mx > 1.0:
+            store_general_warning(
+                key=("viz_video_range", viz_name, leap_type_name, field_name),
+                message=(f"{prefix} {field_name} is float with values in [{mn:.3g}, {mx:.3g}], outside the "
+                         f"expected [0,1] range. Tensorleap scales float video by 255, so values > 1 saturate "
+                         f"to white and negatives clip to black. Provide float video in [0,1], or uint8 in [0,255]."),
+                link_to_docs=_VIZ_DOCS,
+            )
+    elif np.issubdtype(video.dtype, np.integer):
+        mn, mx = int(video.min()), int(video.max())
+        if mx <= 1:
+            store_general_warning(
+                key=("viz_video_int_low", viz_name, leap_type_name, field_name),
+                message=(f"{prefix} {field_name} is uint8 but values span only [{mn}, {mx}] - this will appear "
+                         f"near-black. uint8 video is used as-is in [0,255]; scale to [0,255] before casting."),
+                link_to_docs=_VIZ_DOCS,
+            )
+
+
 def _warn_bbox_coords(bounding_boxes, viz_name: str, leap_type_name: str) -> None:
     """Warn when bbox coords are not relative [0,1] (i.e. look like absolute pixels)."""
     for bbox in bounding_boxes:
@@ -1247,9 +1297,14 @@ def _emit_visualizer_warnings(result, viz_name: str, visualizer_type: LeapDataTy
             _warn_image_value_range(result.data, viz_name, leap_type_name)
             _warn_bbox_coords(result.bounding_boxes, viz_name, leap_type_name)
         elif visualizer_type == LeapDataType.Video:
-            _warn_image_value_range(result.data, viz_name, leap_type_name, field_name="video data")
+            # Engine scales float video by 255 (videoencoder.py), so float is expected in [0,1] here,
+            # the opposite of the still-image convention.
+            _warn_video_value_range(result.data, viz_name, leap_type_name)
         elif visualizer_type == LeapDataType.ImageMask:
-            _warn_image_value_range(result.image, viz_name, leap_type_name)
+            # Engine min-max normalizes the mask image (MaskEngineVisualizer._rescale_min_max), so any
+            # finite value range renders fine - no range warning here. NaN/Inf still break normalization,
+            # so keep that check alongside the structural mask checks.
+            _warn_nonfinite(result.image, viz_name, leap_type_name)
             _warn_image_mask(result, viz_name, leap_type_name)
         elif visualizer_type == LeapDataType.ImageWithHeatmap:
             _warn_image_with_heatmap(result, viz_name, leap_type_name)

code_loader/leaploader.py

@@ -446,8 +446,8 @@ class LeapLoader(LeapLoaderBase):
         return result_payloads
 
     def run_simulation(self, sim_name, params=None, n_samples=1, seed=0,
-                       sample_ids=None, extend_preprocess=True, allow_partial=False):
-        # type: (str, Optional[Dict[str, Any]], int, int, Optional[List[str]], bool, bool) -> Dict[str, Any]
+                       sample_ids=None, extend_preprocess=True):
+        # type: (str, Optional[Dict[str, Any]], int, int, Optional[List[str]], bool) -> Dict[str, Any]
         # extend_preprocess=True (default): also extend preprocess_result[additional] with the
         # new synthetic sample_ids (producer-side behavior — synthetic worker needs this for
         # enumeration / data_length tracking). Pass False from consumer-side populators that
@@ -474,26 +474,19 @@ class LeapLoader(LeapLoaderBase):
         for sample_id in original_sample_ids:
             for handler in global_leap_binder.setup_container.inputs:
                 per_encoder[handler.name].append(handler.function(sample_id, sim_preprocess))
-        encoded = {
-            name: np.stack(arrays) if arrays else np.empty((0,), dtype=np.float32)
-            for name, arrays in per_encoder.items()
-        }
+        encoded = {name: np.stack(arrays) for name, arrays in per_encoder.items()}
         if sample_ids is not None:
+            if len(sample_ids) != len(original_sample_ids):
+                raise ValueError(
+                    "sample_ids length ({}) does not match simulation output length ({})".format(
+                        len(sample_ids), len(original_sample_ids)
+                    )
+                )
             for sid in sample_ids:
                 if not isinstance(sid, str):
                     raise TypeError(
                         "All sample_ids must be of type str. Got: {}".format(type(sid))
                     )
-            if len(sample_ids) != len(original_sample_ids):
-                if not allow_partial:
-                    raise ValueError(
-                        "sample_ids length ({}) does not match simulation output length ({})".format(
-                            len(sample_ids), len(original_sample_ids)
-                        )
-                    )
-                n_bound = min(len(sample_ids), len(original_sample_ids))
-                sample_ids = list(sample_ids)[:n_bound]
-                original_sample_ids = original_sample_ids[:n_bound]
             for synth_id, original_local_id in zip(sample_ids, original_sample_ids):
                 self._synthetic_lookup[synth_id] = (sim_preprocess, original_local_id)
             if extend_preprocess:
@@ -503,19 +496,6 @@ class LeapLoader(LeapLoaderBase):
             returned_sample_ids = original_sample_ids
         return {"encoded": encoded, "sample_ids": returned_sample_ids}
 
-    def prune_synthetic_lookup(self, keep_ids):
-        # type: (List[str]) -> None
-        # Keep only the given synthetic sample_ids in the in-memory lookup and
-        # drop the rest, so preprocess responses don't accumulate across many
-        # run_simulation calls (e.g. a synthetic calibration loop keeps only its
-        # running top-K trials). Keep-set semantics (rather than evict-list) so
-        # the caller can bound the lookup to a known-good set each iteration
-        # without tracking everything it ever generated.
-        keep = set(keep_ids)
-        self._synthetic_lookup = {
-            sid: entry for sid, entry in self._synthetic_lookup.items() if sid in keep
-        }
-
     def _extend_additional_preprocess(self, new_sample_ids: List[str]) -> None:
         if self._preprocess_result_cached is None:
             self._preprocess_result()

code_loader/leaploaderbase.py

@@ -154,13 +154,8 @@ class LeapLoaderBase:
         pass
 
     @abstractmethod
-    def run_simulation(self, sim_name, params=None, n_samples=1, seed=0, sample_ids=None,
-                       extend_preprocess=True, allow_partial=False):
-        # type: (str, Optional[Dict[str, Any]], int, int, Optional[List[str]], bool, bool) -> Dict[str, Any]
-        pass
-
-    def prune_synthetic_lookup(self, keep_ids):
-        # type: (List[str]) -> None
+    def run_simulation(self, sim_name, params=None, n_samples=1, seed=0, sample_ids=None):
+        # type: (str, Optional[Dict[str, Any]], int, int, Optional[List[str]]) -> Dict[str, Any]
         pass
 
     def is_custom_latent_space(self) -> bool:

code_loader/plot_functions/plot_functions.py

@@ -21,6 +21,25 @@ import math
 
 from code_loader.contract.visualizer_classes import LeapImage, LeapImageWithBBox, LeapGraph, LeapText, \
     LeapHorizontalBar, LeapImageMask, LeapTextMask, LeapImageWithHeatmap, LeapVideo
+from code_loader.utils import rescale_min_max
+
+
+def _to_engine_image(image: np.ndarray) -> np.ndarray:
+    """Match the engine's still-image encoding (cv2 saturate_cast): round + clip to [0,255],
+    no scaling, returned as uint8. Float is expected in [0,255]; a normalized [0,1] float
+    therefore renders near-black, exactly as it would on the platform."""
+    if np.issubdtype(image.dtype, np.floating):
+        return np.clip(np.rint(image), 0, 255).astype(np.uint8)
+    return np.clip(image, 0, 255).astype(np.uint8)
+
+
+def _to_engine_video(video: np.ndarray) -> np.ndarray:
+    """Match the engine's video encoding (videoencoder.py): float is scaled by 255 then clipped,
+    uint8 is used as-is. Float is expected in [0,1]."""
+    if np.issubdtype(video.dtype, np.floating):
+        return (video * 255).clip(0, 255).astype(np.uint8)
+    return np.clip(video, 0, 255).astype(np.uint8)
+
 
 def run_only_on_non_mapping_mode():
     """
@@ -51,7 +70,7 @@ def plot_image_with_b_box(leap_data: LeapImageWithBBox, title: str) -> None:
         visualize(leap_image_with_bbox, title)
     """
 
-    image = leap_data.data
+    image = _to_engine_image(leap_data.data)
     bounding_boxes = leap_data.bounding_boxes
 
     # Create figure and axes
@@ -107,7 +126,7 @@ def plot_image(leap_data: LeapImage, title: str) -> None:
         title = "Image"
         visualize(leap_image, title)
     """
-    image_data = leap_data.data
+    image_data = _to_engine_image(leap_data.data)
 
     # If the image has one channel, convert it to a 3-channel image for display
     if image_data.shape[2] == 1:
@@ -305,7 +324,8 @@ def plot_image_mask(leap_data: LeapImageMask, title: str) -> None:
             visualize(leap_image_mask, title)
         """
 
-    image = leap_data.image
+    # Engine min-max normalizes the mask image to [0,255] (MaskEngineVisualizer._rescale_min_max)
+    image = rescale_min_max(leap_data.image)
     mask = leap_data.mask
     labels = leap_data.labels
 
@@ -390,7 +410,7 @@ def plot_text_mask(leap_data: LeapTextMask, title: str) -> None:
 
 @run_only_on_non_mapping_mode()
 def plot_video(leap_data: LeapVideo, title: str) -> None:
-    video_data = leap_data.data
+    video_data = _to_engine_video(leap_data.data)
     fig, ax = plt.subplots()
     fig.patch.set_facecolor('black')
     ax.set_facecolor('black')
@@ -416,7 +436,7 @@ def plot_image_with_heatmap(leap_data: LeapImageWithHeatmap, title: str) -> None
             title = "Image With Heatmap"
             visualize(leap_image_with_heatmap, title)
         """
-    image = leap_data.image
+    image = _to_engine_image(leap_data.image)
     heatmaps = leap_data.heatmaps
     labels = leap_data.labels
 

{code_loader-1.0.186.dev4.dist-info → code_loader-1.0.187.dev0.dist-info}/METADATA

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: code-loader
-Version: 1.0.186.dev4
+Version: 1.0.187.dev0
 Summary: 
-Home-page: https://github.com/tensorleap/code-loader
 License: MIT
 Author: dorhar
 Author-email: doron.harnoy@tensorleap.ai
@@ -20,6 +19,7 @@ Requires-Dist: numpy (>=2.3.2,<3.0.0) ; python_version >= "3.11" and python_vers
 Requires-Dist: psutil (>=5.9.5,<6.0.0)
 Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
+Project-URL: Homepage, https://github.com/tensorleap/code-loader
 Project-URL: Repository, https://github.com/tensorleap/code-loader
 Description-Content-Type: text/markdown
 

{code_loader-1.0.186.dev4.dist-info → code_loader-1.0.187.dev0.dist-info}/RECORD

@@ -1,4 +1,3 @@
-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=RYZcnX7vLMYhyQtCbX2PscVFNAYULxgAA9U4DRRfLqA,10456
@@ -7,7 +6,7 @@ code_loader/contract/exceptions.py,sha256=jWqu5i7t-0IG0jGRsKF4DjJdrsdpJjIYpUkN1F
 code_loader/contract/mapping.py,sha256=sWJhpng-IkOzQnWQdMT5w2ZZ3X1Z_OOzSwCLXIS7oxE,1446
 code_loader/contract/responsedataclasses.py,sha256=5VFgGjRubMW8ItMPils3rkBNejunCGLaa192AIi-xko,4925
 code_loader/contract/sim_config.py,sha256=le8KMALZiP0WU4UcuKnTOSWBW2rNjpnWYfII502NqDM,3493
-code_loader/contract/visualizer_classes.py,sha256=Wz9eItmoRaKEHa3p0aW0Ypxx4_xUmaZyLBznnTuxwi0,15425
+code_loader/contract/visualizer_classes.py,sha256=cWXkBBYk_YP7-VdNwLJvSPQfvBAvoNWircgIuZwHQVc,16519
 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 +20,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=XLYYcV50qjMvoC1S6WW0tLBch_0g5gl1UyHiVSWYbvg,40491
-code_loader/inner_leap_binder/leapbinder_decorators.py,sha256=8a7aJ1o4f60VnlErNjX_4RbUXpLWt91pgGcIDLBvOWc,115314
-code_loader/leaploader.py,sha256=8Jkmn2k2vyUdRbKM5bTxFFUrUBYZdkHp54kQa5LCdWM,45744
-code_loader/leaploaderbase.py,sha256=QynV_LE0l4HnsXLZKjM8p4w2VQL4Fo8dnjQ618OgGjs,6708
+code_loader/inner_leap_binder/leapbinder.py,sha256=aboZWAUr56mjD7iZZFqFARWBxlrugOwz3OqFgW2eyso,43013
+code_loader/inner_leap_binder/leapbinder_decorators.py,sha256=qfKa--0kG_K_Eb8wRd5tIXEJ6rbKva3360gU8EU9eKo,118375
+code_loader/leaploader.py,sha256=K9Q5kiCZ_A2GkS5qOEantAMvWGaz3bmO1X8buXDSpgg,44682
+code_loader/leaploaderbase.py,sha256=l36qDA00GhZEG5NLKpEtAXgWJA-UQQIhNFGxywK7mUA,6530
 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=6Q7VWGxetL2W0EK2QeCdObVATvBuHs3YBA09H4uoIk0,14996
+code_loader/plot_functions/plot_functions.py,sha256=2DC-zlVaN13P4VNx5d8csgs80C6SisaeP1-Kq2LW7iM,16075
 code_loader/plot_functions/visualize.py,sha256=gsBAYYkwMh7jIpJeDMPS8G4CW-pxwx6LznoQIvi4vpo,657
 code_loader/utils.py,sha256=YecipkdTA-VcE9F0RQcY9cFnY8P3AksPnHM2Db7xUSk,3972
 code_loader/visualizers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 code_loader/visualizers/default_visualizers.py,sha256=onRnLE_TXfgLN4o52hQIOOhUcFexGlqJ3xSpQDVLuZM,2604
-code_loader-1.0.186.dev4.dist-info/LICENSE,sha256=qIwWjdspQeSMTtnFZBC8MuT-95L02FPvzRUdWFxrwJY,1067
-code_loader-1.0.186.dev4.dist-info/METADATA,sha256=qsP-4jYZ3tDf_6C8Z36Zh7fZU7qIplT0wCtSw-RR5kc,1095
-code_loader-1.0.186.dev4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-code_loader-1.0.186.dev4.dist-info/RECORD,,
+code_loader-1.0.187.dev0.dist-info/LICENSE,sha256=qIwWjdspQeSMTtnFZBC8MuT-95L02FPvzRUdWFxrwJY,1067
+code_loader-1.0.187.dev0.dist-info/METADATA,sha256=-aaO2OF82TaWblF2LBoSDFCUJFIlHhV_gpg6ioR3-2M,1107
+code_loader-1.0.187.dev0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+code_loader-1.0.187.dev0.dist-info/RECORD,,

{code_loader-1.0.186.dev4.dist-info → code_loader-1.0.187.dev0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: poetry-core 2.1.3
 Root-Is-Purelib: true
 Tag: py3-none-any

code_loader-1.0.186.dev4.dist-info/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2021 TensorLeap
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.