code-loader 1.0.184.dev4__tar.gz → 1.0.184.dev5__tar.gz

{code_loader-1.0.184.dev4 → code_loader-1.0.184.dev5}/PKG-INFO

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: code-loader
-Version: 1.0.184.dev4
+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.dev4 → code_loader-1.0.184.dev5}/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-1.0.184.dev4 → code_loader-1.0.184.dev5}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "code-loader"
 
-version = "1.0.184.dev4"
+version = "1.0.184.dev5"
 description = ""
 authors = ["dorhar <doron.harnoy@tensorleap.ai>"]
 license = "MIT"