code-loader 1.0.184.dev3__py3-none-any.whl → 1.0.184.dev5__py3-none-any.whl

code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -1091,6 +1091,170 @@ def tensorleap_custom_instances_metric(name: str,
     return decorating_function
 
 
+# ---- visualizer semantic warnings (local-only) ----
+# These fire only when NOT running on the platform. They catch inputs that are
+# structurally valid (pass the Leap*.__post_init__ type/shape checks) but render
+# badly given how the platform draws them (see code_loader/plot_functions).
+_VIZ_DOCS = "https://docs.tensorleap.ai/tensorleap-integration/writing-integration-code/visualizers"
+
+
+def _viz_prefix(viz_name: str, leap_type_name: str) -> str:
+    return f"Visualizer '{viz_name}' ({leap_type_name}):"
+
+
+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."""
+    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,
+            )
+        finite = image[np.isfinite(image)]
+        if finite.size == 0:
+            return
+        mn, mx = float(finite.min()), float(finite.max())
+        if 0.0 <= mn and mx <= 1.0 and mx > 0.0:
+            store_general_warning(
+                key=("viz_image_unit_range", viz_name, leap_type_name, field_name),
+                message=(f"{prefix} {field_name} is float with values in [{mn:.3g}, {mx:.3g}] - looks normalized "
+                         f"to [0,1]. Tensorleap renders images by casting to int, so this will appear near-black. "
+                         f"Scale to [0,255] or cast to uint8 before visualizing."),
+                link_to_docs=_VIZ_DOCS,
+            )
+        elif mn < 0.0 or mx > 255.0:
+            store_general_warning(
+                key=("viz_image_out_of_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"displayable [0,255] range - looks like a normalized model input (e.g. standardized or "
+                         f"scaled to [-1,1]). Values will be clipped and the image will render incorrectly. "
+                         f"De-normalize back to [0,255] before visualizing."),
+                link_to_docs=_VIZ_DOCS,
+            )
+    elif np.issubdtype(image.dtype, np.integer):
+        mn, mx = int(image.min()), int(image.max())
+        if mx <= 1:
+            store_general_warning(
+                key=("viz_image_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. If the data is normalized to [0,1], scale to [0,255] before casting to uint8."),
+                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:
+        vals = [bbox.x, bbox.y, bbox.width, bbox.height]
+        if any(v is not None and (v > 1.0 or v < 0.0) for v in vals):
+            store_general_warning(
+                key=("viz_bbox_relative", viz_name, leap_type_name),
+                message=(f"{_viz_prefix(viz_name, leap_type_name)} bounding box coordinates (x, y, width, height) "
+                         f"should be relative to image size, in [0,1]. Got values outside [0,1] - looks like absolute "
+                         f"pixel coordinates. Boxes will be drawn off-image. Divide coordinates by image width/height."),
+                link_to_docs=_VIZ_DOCS,
+            )
+            return
+
+
+def _warn_hbar(leap_data, viz_name: str, leap_type_name: str) -> None:
+    body, labels, gt = leap_data.body, leap_data.labels, leap_data.gt
+    if len(body) != len(labels):
+        store_general_warning(
+            key=("viz_hbar_body_labels", viz_name, leap_type_name),
+            message=(f"{_viz_prefix(viz_name, leap_type_name)} body length ({len(body)}) does not match labels "
+                     f"length ({len(labels)}). Bars and labels will be misaligned or truncated."),
+            link_to_docs=_VIZ_DOCS,
+        )
+    if gt is not None and len(gt) != len(body):
+        store_general_warning(
+            key=("viz_hbar_gt_body", viz_name, leap_type_name),
+            message=(f"{_viz_prefix(viz_name, leap_type_name)} gt length ({len(gt)}) does not match body length "
+                     f"({len(body)}). Prediction and GT bars will be misaligned."),
+            link_to_docs=_VIZ_DOCS,
+        )
+
+
+def _warn_image_mask(leap_data, viz_name: str, leap_type_name: str) -> None:
+    mask, image, labels = leap_data.mask, leap_data.image, leap_data.labels
+    if tuple(mask.shape) != tuple(image.shape[:2]):
+        store_general_warning(
+            key=("viz_mask_shape", viz_name, leap_type_name),
+            message=(f"{_viz_prefix(viz_name, leap_type_name)} mask shape {tuple(mask.shape)} does not match image "
+                     f"H x W {tuple(image.shape[:2])}. The mask overlay will fail or be misaligned."),
+            link_to_docs=_VIZ_DOCS,
+        )
+    nonzero = np.unique(mask)
+    nonzero = nonzero[nonzero != 0]
+    if len(nonzero) != len(labels):
+        store_general_warning(
+            key=("viz_mask_labels", viz_name, leap_type_name),
+            message=(f"{_viz_prefix(viz_name, leap_type_name)} mask has {len(nonzero)} distinct non-zero value(s) "
+                     f"but {len(labels)} label(s) were provided. Some regions may be uncolored or some labels unused."),
+            link_to_docs=_VIZ_DOCS,
+        )
+
+
+def _warn_text_mask(leap_data, viz_name: str, leap_type_name: str) -> None:
+    mask, text, labels = leap_data.mask, leap_data.text, leap_data.labels
+    if len(mask) != len(text):
+        store_general_warning(
+            key=("viz_textmask_len", viz_name, leap_type_name),
+            message=(f"{_viz_prefix(viz_name, leap_type_name)} mask length ({len(mask)}) does not match text length "
+                     f"({len(text)}). Tokens will be dropped or misaligned (zip truncates to the shorter one)."),
+            link_to_docs=_VIZ_DOCS,
+        )
+    if mask.size > 0 and int(mask.max()) > len(labels):
+        store_general_warning(
+            key=("viz_textmask_labels", viz_name, leap_type_name),
+            message=(f"{_viz_prefix(viz_name, leap_type_name)} mask has values up to {int(mask.max())} but only "
+                     f"{len(labels)} label(s) were provided. Colors will wrap and label mapping will be wrong."),
+            link_to_docs=_VIZ_DOCS,
+        )
+
+
+def _warn_image_with_heatmap(leap_data, viz_name: str, leap_type_name: str) -> None:
+    image, heatmaps = leap_data.image, leap_data.heatmaps
+    if heatmaps.ndim >= 3 and tuple(heatmaps.shape[1:3]) != tuple(image.shape[:2]):
+        store_general_warning(
+            key=("viz_heatmap_shape", viz_name, leap_type_name),
+            message=(f"{_viz_prefix(viz_name, leap_type_name)} heatmap spatial size {tuple(heatmaps.shape[1:3])} "
+                     f"does not match image H x W {tuple(image.shape[:2])}. The heatmap overlay will be stretched "
+                     f"or misaligned."),
+            link_to_docs=_VIZ_DOCS,
+        )
+    _warn_image_value_range(image, viz_name, leap_type_name)
+
+
+def _emit_visualizer_warnings(result, viz_name: str, visualizer_type: LeapDataType) -> None:
+    """Dispatch semantic warning checks per visualizer type. Never raises."""
+    try:
+        leap_type_name = visualizer_type.name
+        if visualizer_type == LeapDataType.Image:
+            _warn_image_value_range(result.data, viz_name, leap_type_name)
+        elif visualizer_type == LeapDataType.ImageWithBBox:
+            _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")
+        elif visualizer_type == LeapDataType.ImageMask:
+            _warn_image_value_range(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)
+        elif visualizer_type == LeapDataType.HorizontalBar:
+            _warn_hbar(result, viz_name, leap_type_name)
+        elif visualizer_type == LeapDataType.TextMask:
+            _warn_text_mask(result, viz_name, leap_type_name)
+    except Exception as e:
+        logger.debug(f"visualizer warning check failed for '{viz_name}': {e}")
+
+
 def tensorleap_custom_visualizer(name: str, visualizer_type: LeapDataType,
                                  heatmap_function: Optional[Callable[..., npt.NDArray[np.float32]]] = None,
                                  connects_to=None):
@@ -1149,6 +1313,9 @@ def tensorleap_custom_visualizer(name: str, visualizer_type: LeapDataType,
                 (f'{user_function.__name__}() validation failed: '
                  f'The return type should be {result_type_map[visualizer_type]}. Got {type(result)}.')
 
+            if not _call_from_tl_platform:
+                _emit_visualizer_warnings(result, name, visualizer_type)
+
         @functools.wraps(user_function)
         def inner_without_validate(*args, **kwargs):
             global _called_from_inside_tl_decorator
@@ -2082,7 +2249,7 @@ def tensorleap_status_table():
         if not data and not stored:
             return
 
-        print("\nWarnings (Default use. It is recommended to set values explicitly):")
+        print("\nWarnings:")
         for param_name in sorted(data.keys()):
             default_value = data[param_name]["default_value"]
             funcs = ", ".join(sorted(data[param_name]["funcs"]))

code_loader/leaploader.py

@@ -7,7 +7,7 @@ import sys
 from contextlib import redirect_stdout
 from functools import lru_cache
 from pathlib import Path
-from typing import Dict, List, Iterable, Union, Any, Type, Optional, Callable, Tuple
+from typing import Dict, List, Iterable, Set, Union, Any, Type, Optional, Callable, Tuple
 
 import numpy as np
 import numpy.typing as npt
@@ -197,20 +197,48 @@ class LeapLoader(LeapLoaderBase):
         # `_synthetic_lookup`, so subsequent lookups for sibling sample_ids skip the hook.
         self._synthetic_populator = populator
 
-    def _resolve_synthetic(self, sample_id: Union[int, str]) -> Optional[Tuple[PreprocessResponse, Any]]:
+    def _user_additional_ids_set(self) -> Set[str]:
+        # Membership-test helper for distinguishing user-defined additional samples
+        # from synthetic ones. In consumer pods, the populator passes
+        # extend_preprocess=False to run_simulation, so additional.sample_ids stays
+        # uncontaminated and direct membership check is reliable.
+        additional = self._preprocess_result().get(DataStateEnum.additional)
+        if additional is None:
+            return set()
+        return set(additional.sample_ids)
+
+    def _resolve_synthetic(self, sample_id: Union[int, str],
+                           state: Optional[DataStateEnum] = None
+                           ) -> Optional[Tuple[PreprocessResponse, Any]]:
+        # Resolution flow for state==additional:
+        #   1. already-replayed synthetic ID (member of _synthetic_lookup) → cached synthetic flow
+        #   2. user-defined ID (member of preprocess[additional].sample_ids) → return None
+        #      so caller falls through to normal preprocess flow (no recipe lookup built)
+        #   3. populator: builds recipe index lazily on first call, replays the missing
+        #      recipe, populates _synthetic_lookup. Loud-raises on unresolvable IDs.
+        #
+        # Order rationale: _synthetic_lookup check sits before the user-response check
+        # to be robust against `_extend_additional_preprocess` mutation (producer side
+        # calls run_simulation with extend_preprocess=True, which appends synthetic IDs
+        # into preprocess[additional]). Once an ID is in _synthetic_lookup, that wins
+        # regardless of contamination in the preprocess response.
         if not isinstance(sample_id, str):
             return None
+        if state != DataStateEnum.additional:
+            return None
         if sample_id in self._synthetic_lookup:
             return self._synthetic_lookup[sample_id]
-        if self._synthetic_populator is not None:
-            self._synthetic_populator(sample_id)
-            return self._synthetic_lookup.get(sample_id)
-        return None
+        if sample_id in self._user_additional_ids_set():
+            return None
+        if self._synthetic_populator is None:
+            return None
+        self._synthetic_populator(sample_id)
+        return self._synthetic_lookup.get(sample_id)
 
     def get_sample(self, state: DataStateEnum, sample_id: Union[int, str], instance_id: int = None) -> DatasetSample:
         self.exec_script()
 
-        resolved = self._resolve_synthetic(sample_id)
+        resolved = self._resolve_synthetic(sample_id, state=state)
         if resolved is not None:
             sim_preprocess, original_local_id = resolved
             return self._get_sample_from_preprocess(
@@ -417,8 +445,13 @@ class LeapLoader(LeapLoaderBase):
             result_payloads.append(test_result)
         return result_payloads
 
-    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]
+    def run_simulation(self, sim_name, params=None, n_samples=1, seed=0,
+                       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
+        # only need _synthetic_lookup filled, so user's additional response stays uncontaminated.
         self.exec_script()
         sim = next(
             (s for s in global_leap_binder.setup_container.simulations if s.name == sim_name),
@@ -456,7 +489,8 @@ class LeapLoader(LeapLoaderBase):
                     )
             for synth_id, original_local_id in zip(sample_ids, original_sample_ids):
                 self._synthetic_lookup[synth_id] = (sim_preprocess, original_local_id)
-            self._extend_additional_preprocess(list(sample_ids))
+            if extend_preprocess:
+                self._extend_additional_preprocess(list(sample_ids))
             returned_sample_ids = list(sample_ids)
         else:
             returned_sample_ids = original_sample_ids
@@ -694,7 +728,7 @@ class LeapLoader(LeapLoaderBase):
                               state: DataStateEnum, sample_id: Union[int, str]) -> Dict[str, npt.NDArray[np.float32]]:
         result_agg = {}
         preprocess_result = self._preprocess_result()
-        resolved = self._resolve_synthetic(sample_id) if state == DataStateEnum.additional else None
+        resolved = self._resolve_synthetic(sample_id, state=state)
         if resolved is not None:
             sim_preprocess, original_local_id = resolved
             preprocess_state = sim_preprocess
@@ -714,7 +748,7 @@ class LeapLoader(LeapLoaderBase):
         if instance_id is None:
             return None
         preprocess_result = self._preprocess_result()
-        resolved = self._resolve_synthetic(sample_id) if state == DataStateEnum.additional else None
+        resolved = self._resolve_synthetic(sample_id, state=state)
         if resolved is not None:
             sim_preprocess, original_local_id = resolved
             preprocess_state = sim_preprocess
@@ -780,7 +814,7 @@ class LeapLoader(LeapLoaderBase):
         result_agg = {}
         is_none = {}
         preprocess_result = self._preprocess_result()
-        resolved = self._resolve_synthetic(sample_id) if state == DataStateEnum.additional else None
+        resolved = self._resolve_synthetic(sample_id, state=state)
         if resolved is not None:
             sim_preprocess, original_local_id = resolved
             preprocess_state = sim_preprocess

{code_loader-1.0.184.dev3.dist-info → code_loader-1.0.184.dev5.dist-info}/METADATA

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: code-loader
-Version: 1.0.184.dev3
+Version: 1.0.184.dev5
 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.184.dev3.dist-info → code_loader-1.0.184.dev5.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
@@ -22,8 +21,8 @@ code_loader/experiment_api/utils.py,sha256=XZHtxge12TS4H4-8PjV3sKuhp8Ud6ojAiIzTZ
 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=YlK51b5Ryo396f7tOA7Ole3vYCLs3f5ZLm2qDQ9K1NE,105781
-code_loader/leaploader.py,sha256=OuN53z2KCO-I0FRxwjB_mfyzNZizH5Ud4vrZyFNn1wc,42595
+code_loader/inner_leap_binder/leapbinder_decorators.py,sha256=3kcH5xeZsOGnGtmZze3fUxpVBIVRsLiVpx4v9qzTMIM,114805
+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
@@ -32,7 +31,7 @@ code_loader/plot_functions/visualize.py,sha256=gsBAYYkwMh7jIpJeDMPS8G4CW-pxwx6Lz
 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.184.dev3.dist-info/LICENSE,sha256=qIwWjdspQeSMTtnFZBC8MuT-95L02FPvzRUdWFxrwJY,1067
-code_loader-1.0.184.dev3.dist-info/METADATA,sha256=lH0fmNWqwyUFhJXXu8ATIV8vhwOhU7y6u6WfWS3ckfw,1095
-code_loader-1.0.184.dev3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-code_loader-1.0.184.dev3.dist-info/RECORD,,
+code_loader-1.0.184.dev5.dist-info/LICENSE,sha256=qIwWjdspQeSMTtnFZBC8MuT-95L02FPvzRUdWFxrwJY,1067
+code_loader-1.0.184.dev5.dist-info/METADATA,sha256=83dAfYcw1wqEAn7mzBjIYBG4xCZZBJNESjAzXLcr_ks,1107
+code_loader-1.0.184.dev5.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+code_loader-1.0.184.dev5.dist-info/RECORD,,

{code_loader-1.0.184.dev3.dist-info → code_loader-1.0.184.dev5.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.184.dev3.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.