code-loader 1.0.198__tar.gz → 1.0.199__tar.gz

{code_loader-1.0.198 → code_loader-1.0.199}/PKG-INFO

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

{code_loader-1.0.198 → code_loader-1.0.199}/code_loader/contract/datasetclasses.py

@@ -308,7 +308,6 @@ class MetadataHandler:
 class CustomLatentSpaceHandler:
     function: SectionCallableInterface
     name: str = 'custom_latent_space'
-    use_ls_for_analysis: bool = False
 
 
 # How a chain's latent-space vectors are derived from its per-step forward passes.
@@ -391,7 +390,7 @@ class DatasetIntegrationSetup:
     metrics: List[MetricHandler] = field(default_factory=list)
     instance_metrics: List[InstanceMetricHandler] = field(default_factory=list)
     custom_layers: Dict[str, CustomLayerHandler] = field(default_factory=dict)
-    custom_latent_spaces: Dict[str, CustomLatentSpaceHandler] = field(default_factory=dict)
+    custom_latent_space: Optional[CustomLatentSpaceHandler] = None
     simulations: List[SimulationHandler] = field(default_factory=list)
     autoregressive_step: Optional[AutoregressiveStepHandler] = None
     autoregressive_metrics: List[AutoregressiveMetricHandler] = field(default_factory=list)
@@ -407,6 +406,6 @@ class DatasetSample:
     metadata_is_none: Dict[str, bool]
     index: Union[int, str]
     state: DataStateEnum
-    custom_latent_spaces: Optional[Dict[str, npt.NDArray[np.float32]]] = None
+    custom_latent_space: Optional[npt.NDArray[np.float32]] = None
     instance_masks: Optional[Dict[str, ElementInstance]] = None
 

{code_loader-1.0.198 → code_loader-1.0.199}/code_loader/contract/enums.py

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

{code_loader-1.0.198 → code_loader-1.0.199}/code_loader/contract/visualizer_classes.py

@@ -343,6 +343,47 @@ class LeapImageWithHeatmap:
                 'Number of heatmaps and labels must be equal')
 
 
+@dataclass
+class LeapAudio:
+    """
+    Visualizer representing a playable audio sample for Tensorleap.
+
+    The user plays the sample in the right panel while a playhead tick runs
+    through `visual` — either a spectrogram (a LeapImage) or a time-series
+    waveform (a LeapGraph). Build one with `default_audio_visualizer`.
+
+    Attributes:
+    audio (npt.NDArray): Mono waveform samples, shaped [N]. Multi-channel input
+        should be mixed down before constructing LeapAudio.
+    sample_rate (int): Samples per second — needed to encode the clip and to map
+        the playhead position to time.
+    visual (Union[LeapImage, LeapGraph]): The thing you look at.
+    x_range (Optional[Tuple[float, float]]): Time extent (in seconds) that the
+        visual's horizontal axis spans, used to align the tick. Defaults to
+        (0, N / sample_rate).
+    type (LeapDataType): The data type, default is LeapDataType.Audio.
+    """
+    audio: npt.NDArray
+    sample_rate: int
+    visual: Union[LeapImage, LeapGraph]
+    x_range: Optional[Tuple[float, float]] = None
+    type: LeapDataType = LeapDataType.Audio
+
+    def __post_init__(self) -> None:
+        validate_type(self.type, LeapDataType.Audio)
+        validate_type(type(self.audio), np.ndarray)
+        validate_type(len(self.audio.shape), 1, 'Audio must be mono, of shape 1 [N]')
+        validate_type(type(self.visual), [LeapImage, LeapGraph],
+                      'Audio visual must be a LeapImage (spectrogram) or LeapGraph (waveform)')
+        if not isinstance(self.sample_rate, int) or self.sample_rate <= 0:
+            raise LeapValidationError(f'sample_rate must be a positive int, got {self.sample_rate}')
+        if self.x_range is not None:
+            if len(self.x_range) != 2:
+                raise LeapValidationError('x_range must be a tuple of length 2')
+            validate_type(type(self.x_range[0]), [float, int], 'x_range must be a tuple of floats or integers')
+            validate_type(type(self.x_range[1]), [float, int], 'x_range must be a tuple of floats or integers')
+
+
 map_leap_data_type_to_visualizer_class = {
     LeapDataType.Image.value: LeapImage,
     LeapDataType.Graph.value: LeapGraph,
@@ -352,5 +393,6 @@ map_leap_data_type_to_visualizer_class = {
     LeapDataType.ImageMask.value: LeapImageMask,
     LeapDataType.TextMask.value: LeapTextMask,
     LeapDataType.ImageWithBBox.value: LeapImageWithBBox,
-    LeapDataType.ImageWithHeatmap.value: LeapImageWithHeatmap
+    LeapDataType.ImageWithHeatmap.value: LeapImageWithHeatmap,
+    LeapDataType.Audio.value: LeapAudio
 }

{code_loader-1.0.198 → code_loader-1.0.199}/code_loader/inner_leap_binder/leapbinder.py

@@ -536,54 +536,18 @@ class LeapBinder:
         """
         self.setup_container.metadata.append(MetadataHandler(name, function, metadata_type))
 
-    def set_custom_latent_space(self, function: SectionCallableInterface,
-                                name: Optional[str] = None,
-                                use_ls_for_analysis: bool = False) -> None:
+    def set_custom_latent_space(self, function: SectionCallableInterface) -> None:
         """
-        Register a custom latent space function.
-
-        Multiple custom latent spaces may be registered as long as each has a
-        unique name. They are stored name-keyed (insertion order preserved), so a
-        later registration no longer overrides an earlier one.
+        Set a custom latent space function.
 
         Args:
-        function (SectionCallableInterface): The latent-space handler function.
+        function (SectionCallableInterface): The metadata handler function.
             This function receives:
                 subset (PreprocessResponse): The subset of the data.
                 index (int): The index of the sample within the subset.
-            This function should return a numpy float32 array containing the latent
-            space vec of the sample.
-        name (Optional[str]): Unique name for this custom latent space. Defaults to
-            the reserved single-LS name for backward compatibility.
-        use_ls_for_analysis (bool): When True, the engine uses this custom latent
-            space for the Out-Of-Distribution and Domain-Gap insights instead of the
-            built-in defaults. At most one registered custom latent space may set this;
-            registering a second one with the flag raises.
+            This function should numpy float32 array contains the latent space vec of the sample.
         """
-        if name is None:
-            name = custom_latent_space_attribute
-        if name in self.setup_container.custom_latent_spaces:
-            raise Exception(
-                f"A custom latent space named '{name}' is already registered. Each "
-                f"@tensorleap_custom_latent_space must have a unique name "
-                f"(pass name='...' to distinguish them)."
-            )
-        if use_ls_for_analysis:
-            already_flagged = [
-                existing_name
-                for existing_name, handler in self.setup_container.custom_latent_spaces.items()
-                if handler.use_ls_for_analysis
-            ]
-            if already_flagged:
-                raise Exception(
-                    f"use_ls_for_analysis=True is already set on custom latent space "
-                    f"'{already_flagged[0]}'. Only one custom latent space may set "
-                    f"use_ls_for_analysis=True (it selects the latent space used for the "
-                    f"Out-Of-Distribution and Domain-Gap insights). Set it on '{name}' "
-                    f"or '{already_flagged[0]}', not both."
-                )
-        self.setup_container.custom_latent_spaces[name] = CustomLatentSpaceHandler(
-            function, name, use_ls_for_analysis)
+        self.setup_container.custom_latent_space = CustomLatentSpaceHandler(function)
 
     def set_autoregressive_step(self, function: AutoregressiveStepCallableInterface,
                                 latent_space_aggregation: str = 'last_step') -> None:
@@ -994,7 +958,7 @@ class LeapBinder:
                 "Element instances are not supported together with tensorleap_autoregressive_step: "
                 "instance generation masks the sample's encoded inputs, which do not exist in an "
                 "autoregressive integration. Remove the instance encoders or the autoregressive hook.")
-        if self.setup_container.custom_latent_spaces:
+        if self.setup_container.custom_latent_space is not None:
             raise Exception(
                 "tensorleap_custom_latent_space is not supported together with "
                 "tensorleap_autoregressive_step: the custom latent space function only sees "

{code_loader-1.0.198 → code_loader-1.0.199}/code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -29,7 +29,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, LeapValidationError, \
+    LeapHorizontalBar, LeapImageWithBBox, LeapImageWithHeatmap, LeapVideo, LeapAudio, LeapValidationError, \
     map_leap_data_type_to_visualizer_class
 from code_loader.inner_leap_binder.leapbinder import mapping_runtime_mode_env_var_mame
 from code_loader.mixpanel_tracker import clear_integration_events, AnalyticsEvent, emit_integration_event_once
@@ -1543,7 +1543,8 @@ def tensorleap_custom_visualizer(name: str, visualizer_type: LeapDataType,
                 LeapDataType.HorizontalBar: LeapHorizontalBar,
                 LeapDataType.ImageWithBBox: LeapImageWithBBox,
                 LeapDataType.ImageWithHeatmap: LeapImageWithHeatmap,
-                LeapDataType.Video: LeapVideo
+                LeapDataType.Video: LeapVideo,
+                LeapDataType.Audio: LeapAudio
             }
             validate_output_structure(result, func_name=user_function.__name__,
                                       expected_type_name=result_type_map[visualizer_type])
@@ -1702,14 +1703,8 @@ def tensorleap_metadata(
     return decorating_function
 
 
-def tensorleap_custom_latent_space(name: Optional[str] = None, use_ls_for_analysis: bool = False):
-    assert isinstance(use_ls_for_analysis, bool), \
-        ("tensorleap_custom_latent_space validation failed: use_ls_for_analysis must be a bool. "
-         f"Got {type(use_ls_for_analysis)}.")
-
+def tensorleap_custom_latent_space():
     def decorating_function(user_function: SectionCallableInterface):
-        ls_name = name if name is not None else user_function.__name__
-
         def _validate_input_args(sample_id: Union[int, str, list], preprocess_response: PreprocessResponse):
             _validate_id_or_group(sample_id, preprocess_response, 'tensorleap_custom_latent_space')
 
@@ -1720,9 +1715,9 @@ def tensorleap_custom_latent_space(name: Optional[str] = None, use_ls_for_analys
             if single_result.ndim > 1:
                 flat_dim = int(np.prod(single_result.shape))
                 store_general_warning(
-                    key=("tensorleap_custom_latent_space_flatten", ls_name, tuple(single_result.shape)),
+                    key=("tensorleap_custom_latent_space_flatten", tuple(single_result.shape)),
                     message=(
-                        f"tensorleap_custom_latent_space '{ls_name}' returned per-sample shape {tuple(single_result.shape)} "
+                        f"tensorleap_custom_latent_space returned per-sample shape {tuple(single_result.shape)} "
                         f"(ndim={single_result.ndim}). Tensorleap assumes per-sample shape (d, ...) and will "
                         f"flatten to ({flat_dim},) before downstream visualization and clustering. "
                         f"If you want a different aggregation (e.g. global average pooling), do it "
@@ -1765,8 +1760,7 @@ def tensorleap_custom_latent_space(name: Optional[str] = None, use_ls_for_analys
 
             return result
 
-        leap_binder.set_custom_latent_space(inner_without_validate, ls_name,
-                                            use_ls_for_analysis=use_ls_for_analysis)
+        leap_binder.set_custom_latent_space(inner_without_validate)
 
         def inner(sample_id, preprocess_response):
             if os.environ.get(mapping_runtime_mode_env_var_mame):

{code_loader-1.0.198 → code_loader-1.0.199}/code_loader/leaploader.py

@@ -283,7 +283,17 @@ class LeapLoader(LeapLoaderBase):
 
         metadata, metadata_is_none = self.get_metadata(state, sample_id)
 
-        custom_latent_spaces = self._get_custom_latent_spaces(sample_id, preprocess_result[state])
+        custom_latent_space = None
+        if global_leap_binder.setup_container.custom_latent_space is not None:
+            latent_fn = global_leap_binder.setup_container.custom_latent_space.function
+            preprocess_state = preprocess_result[state]
+            if preprocess_state.is_grouped:
+                # Single-sample fetch: encode this sample only, not the whole group (same
+                # memory rationale as _get_dataset_handlers; see grouped-fetch-oom-bug.md).
+                self._locate_group(preprocess_state, sample_id)  # validates group membership
+                custom_latent_space = self._to_grouped_list(latent_fn([sample_id], preprocess_state))[0]
+            else:
+                custom_latent_space = latent_fn(sample_id, preprocess_state)
         instance_mask = self._get_instances_masks(state, sample_id, instance_id)
         sample = DatasetSample(inputs=self._get_inputs(state, sample_id),
                                gt=None if state == DataStateEnum.unlabeled else self._get_gt(state, sample_id),
@@ -291,7 +301,7 @@ class LeapLoader(LeapLoaderBase):
                                metadata_is_none=metadata_is_none,
                                index=sample_id,
                                state=state,
-                               custom_latent_spaces=custom_latent_spaces,
+                               custom_latent_space=custom_latent_space,
                                instance_masks=instance_mask)
         return sample
 
@@ -322,7 +332,11 @@ class LeapLoader(LeapLoaderBase):
                     handler.name, handler_result
                 )
 
-        custom_latent_spaces = self._get_custom_latent_spaces(original_sample_id, preprocess)
+        custom_latent_space = None
+        if global_leap_binder.setup_container.custom_latent_space is not None:
+            custom_latent_space = global_leap_binder.setup_container.custom_latent_space.function(
+                original_sample_id, preprocess
+            )
 
         return DatasetSample(
             inputs=inputs,
@@ -331,7 +345,7 @@ class LeapLoader(LeapLoaderBase):
             metadata_is_none=metadata_is_none,
             index=synthetic_index,
             state=DataStateEnum.additional,
-            custom_latent_spaces=custom_latent_spaces,
+            custom_latent_space=custom_latent_space,
             instance_masks=None,
         )
 
@@ -1100,20 +1114,17 @@ class LeapLoader(LeapLoaderBase):
                 metadata[handler.name] = [v for v, _ in converted]
                 metadata_is_none[handler.name] = [is_none for _, is_none in converted]
 
-        # custom_latent_spaces are group-aware like the input/GT encoders: hand each the whole group
-        # in a single call so a file-backed latent fn loads the file once, and normalize to per-sample
-        # lists. This keeps the mandatory group path non-lossy. instance_masks stay None here: they are
-        # a per-(sample, instance) concern that needs an instance_id the group fetch does not carry.
-        latent_handlers = global_leap_binder.setup_container.custom_latent_spaces
-        custom_latent_spaces = None
-        if latent_handlers:
-            custom_latent_spaces = {
-                name: self._to_grouped_list(handler.function(group_ids, preprocess_state))
-                for name, handler in latent_handlers.items()
-            }
+        # custom_latent_space is group-aware like the input/GT encoders: hand it the whole group in a
+        # single call so a file-backed latent fn loads the file once, and normalize to (B, d). This
+        # keeps the mandatory group path non-lossy. instance_masks stay None here: they are a
+        # per-(sample, instance) concern that needs an instance_id the group fetch does not carry.
+        custom_latent_space = None
+        if global_leap_binder.setup_container.custom_latent_space is not None:
+            latent_fn = global_leap_binder.setup_container.custom_latent_space.function
+            custom_latent_space = self._to_grouped_list(latent_fn(group_ids, preprocess_state))
 
         return DatasetSample(inputs=inputs, gt=gt, metadata=metadata, metadata_is_none=metadata_is_none,
-                             index=list(group_ids), state=state, custom_latent_spaces=custom_latent_spaces,
+                             index=list(group_ids), state=state, custom_latent_space=custom_latent_space,
                              instance_masks=None)
 
     def _get_inputs(self, state: DataStateEnum, sample_id: Union[int, str]) -> Dict[str, npt.NDArray[np.float32]]:
@@ -1326,48 +1337,10 @@ class LeapLoader(LeapLoaderBase):
 
         return id_type
 
-    def _get_custom_latent_spaces(
-            self,
-            sample_id: Union[int, str],
-            preprocess: "PreprocessResponse") -> Optional[Dict[str, npt.NDArray[np.float32]]]:
-        handlers = global_leap_binder.setup_container.custom_latent_spaces
-        if not handlers:
-            return None
-        if preprocess.is_grouped:
-            # Single-sample fetch: encode this sample only, not the whole group (same
-            # memory rationale as _get_dataset_handlers; see grouped-fetch-oom-bug.md).
-            self._locate_group(preprocess, sample_id)  # validates group membership
-            return {name: self._to_grouped_list(handler.function([sample_id], preprocess))[0]
-                    for name, handler in handlers.items()}
-        return {name: handler.function(sample_id, preprocess) for name, handler in handlers.items()}
-
     @lru_cache()
     def has_custom_latent_space_decorator(self) -> bool:
         self.exec_script()
-        return len(global_leap_binder.setup_container.custom_latent_spaces) > 0
-
-    @lru_cache()
-    def get_custom_latent_space_names(self) -> Tuple[str, ...]:
-        """Ordered names of all registered custom latent spaces.
-
-        Registration order is the canonical index mapping consumed by the engine
-        (name i -> user_custom_i). Returns a tuple so the lru_cache value is hashable.
-        """
-        self.exec_script()
-        return tuple(global_leap_binder.setup_container.custom_latent_spaces.keys())
-
-    @lru_cache()
-    def get_custom_latent_space_for_analysis(self) -> Optional[str]:
-        """Name of the custom latent space flagged with use_ls_for_analysis=True, if any.
-
-        The engine uses this latent space for the Out-Of-Distribution and Domain-Gap
-        insights instead of the built-in defaults. Returns None when no custom latent
-        space set the flag. At most one is flagged (enforced at registration time)."""
-        self.exec_script()
-        for name, handler in global_leap_binder.setup_container.custom_latent_spaces.items():
-            if handler.use_ls_for_analysis:
-                return name
-        return None
+        return global_leap_binder.setup_container.custom_latent_space is not None
 
     @lru_cache()
     def has_autoregressive_step(self) -> bool:

{code_loader-1.0.198 → code_loader-1.0.199}/code_loader/leaploaderbase.py

@@ -218,14 +218,6 @@ class LeapLoaderBase:
         raise NotImplementedError(f'{type(self).__name__} does not implement '
                                   'autoregressive_visualizer_by_name.')
 
-    @abstractmethod
-    def get_custom_latent_space_names(self) -> Tuple[str, ...]:
-        pass
-
-    @abstractmethod
-    def get_custom_latent_space_for_analysis(self) -> Optional[str]:
-        pass
-
     @abstractmethod
     def get_heatmap_visualizer_raw_vis_input_arg_name(self, visualizer_name: str) -> Optional[str]:
         pass

code_loader-1.0.199/code_loader/visualizers/default_visualizers.py

@@ -0,0 +1,156 @@
+from enum import Enum
+from typing import Optional
+
+import numpy as np
+import numpy.typing as npt
+
+from code_loader.contract.visualizer_classes import LeapImage, LeapGraph, LeapHorizontalBar, LeapText, \
+    LeapImageMask, LeapTextMask, LeapVideo, LeapAudio
+from code_loader.utils import rescale_min_max
+
+
+class DefaultVisualizer(Enum):
+    Image = 'Image'
+    Video = 'Video'
+    Audio = 'Audio'
+    Graph = 'Graph'
+    HorizontalBar = 'HorizontalBar'
+    Text = 'Text'
+    ImageMask = 'ImageMask'
+    TextMask = 'TextMask'
+    RawData = 'RawData'
+
+
+def default_image_visualizer(data: npt.NDArray[np.float32]) -> LeapImage:
+    rescaled_data = rescale_min_max(data[0])
+    return LeapImage(rescaled_data)
+
+
+def default_video_visualizer(data: npt.NDArray[np.float32]) -> LeapVideo:
+    return LeapVideo(data[0])
+
+
+_MAX_WAVEFORM_POINTS = 2000
+_VISUAL_KINDS = ('waveform', 'spectrogram', 'image')
+
+
+def _to_mono(audio: npt.NDArray) -> npt.NDArray:
+    a = np.squeeze(np.asarray(audio))
+    if a.ndim == 2:  # mix down: channels are the shorter axis
+        a = a.mean(axis=int(np.argmin(a.shape)))
+    if a.ndim != 1:
+        raise ValueError(f'audio must be reducible to a mono 1-D signal, got shape {np.asarray(audio).shape}')
+    return a.astype(np.float32)
+
+
+def _waveform_graph(series: npt.NDArray, duration: float) -> LeapGraph:
+    s = np.squeeze(np.asarray(series)).astype(np.float32)
+    # ponytail: recharts chokes on 100k+ points; stride down for the default view. x_range keeps full time span.
+    step = max(1, s.shape[0] // _MAX_WAVEFORM_POINTS)
+    s = s[::step].reshape(-1, 1)
+    return LeapGraph(s, x_label='Time [s]', y_label='Amplitude', x_range=(0.0, duration))
+
+
+def default_audio_visualizer(audio: npt.NDArray,
+                             sample_rate: int,
+                             visual: Optional[npt.NDArray] = None,
+                             visual_kind: Optional[str] = None,
+                             time_axis_index: int = -1) -> LeapAudio:
+    """Package a playable audio sample plus the visual a playhead runs through.
+
+    audio: waveform samples (mono [N], or multi-channel that is mixed down).
+    sample_rate: samples per second.
+    visual: the array to display. For 'waveform' a 1-D series; for 'spectrogram'
+        a raw 2-D [freq, time] (or [time, freq]) array to be rendered grayscale;
+        for 'image' an already-rendered [H, W, 1] or [H, W, 3] image (e.g. a
+        spectrogram the caller already ran through their own colormap).
+        If omitted, a waveform graph is built from `audio` itself.
+    visual_kind: 'waveform', 'spectrogram', or 'image'. The caller states this
+        explicitly; the shape of `visual` is never inspected to guess it.
+        Required when `visual` is given; ignored when `visual` is omitted.
+    time_axis_index: for 'spectrogram', which axis of `visual` is time (moved to columns).
+        Unused for 'waveform'/'image'.
+    """
+    mono = _to_mono(audio)
+    duration = mono.shape[0] / float(sample_rate)
+    x_range = (0.0, duration)
+
+    if visual is None:  # no visual given: show the raw signal as a waveform
+        return LeapAudio(mono, sample_rate, _waveform_graph(mono, duration), x_range)
+
+    if visual_kind not in _VISUAL_KINDS:
+        raise ValueError(f"visual_kind must be one of {_VISUAL_KINDS}, got {visual_kind!r}")
+
+    v = np.asarray(visual)
+
+    if visual_kind == 'waveform':
+        return LeapAudio(mono, sample_rate, _waveform_graph(v, duration), x_range)
+
+    if visual_kind == 'image':
+        return LeapAudio(mono, sample_rate, LeapImage(v), x_range)
+
+    # spectrogram
+    spec = np.squeeze(v)
+    if spec.ndim != 2:
+        raise ValueError(f'spectrogram visual must be 2-D (freq x time), got shape {v.shape}')
+    if time_axis_index % spec.ndim == 0:  # move time onto the horizontal axis (columns)
+        spec = spec.T
+    img = rescale_min_max(spec.astype(np.float32))[..., None]  # [freq, time, 1]
+    return LeapAudio(mono, sample_rate, LeapImage(img), x_range)
+
+
+def default_graph_visualizer(data: npt.NDArray[np.float32]) -> LeapGraph:
+    return LeapGraph(data[0])
+
+
+def default_horizontal_bar_visualizer(data: npt.NDArray[np.float32]) -> LeapHorizontalBar:
+    labels = [str(index) for index in range(data.shape[-1])]
+    return LeapHorizontalBar(data[0], labels)
+
+
+def default_word_visualizer(data: npt.NDArray[np.float32]) -> LeapText:
+    if len(data.shape) == 2 and data.shape[0] == 1:
+        data = data[0]
+    if hasattr(data, 'tolist'):
+        data = data.tolist()
+    words = [str(index[0]) if type(index) is list else str(index) for index in data]
+    return LeapText(words)
+
+
+def default_raw_data_visualizer(data: npt.NDArray[np.float32]) -> LeapText:
+    return LeapText([str(data)])
+
+
+def default_image_mask_visualizer(mask: npt.NDArray[np.float32], image: npt.NDArray[np.float32]) -> LeapImageMask:
+    if image.shape[0] == 1:
+        image = image[0]
+    if mask.shape[0] == 1:
+        mask = mask[0]
+
+    n_different_labels = mask.shape[-1]
+    labels = [str(i) for i in range(n_different_labels)]
+
+    if len(mask.shape) > 2:
+        if mask.shape[-1] == 1:
+            mask = np.squeeze(mask, axis=-1)
+        else:
+            mask = np.argmax(mask, axis=-1)
+
+    return LeapImageMask(mask.astype(np.uint8), image.astype(np.float32), labels)
+
+
+def default_text_mask_visualizer(mask: npt.NDArray[np.float32], text_data: npt.NDArray[np.float32]) -> LeapTextMask:
+    mask = mask[0]
+    text_data = text_data[0]
+
+    words = default_word_visualizer(text_data).data
+    n_different_labels = mask.shape[-1]
+    labels = [str(i) for i in range(n_different_labels)]
+
+    if len(mask.shape) > 1:
+        if mask.shape[-1] == 1:
+            mask = np.squeeze(mask, axis=-1)
+        else:
+            mask = np.argmax(mask, axis=-1)
+
+    return LeapTextMask(mask.astype(np.uint8), words, labels)

{code_loader-1.0.198 → code_loader-1.0.199}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "code-loader"
-version = "1.0.198"
+version = "1.0.199"
 description = ""
 authors = ["dorhar <doron.harnoy@tensorleap.ai>"]
 license = "MIT"

code_loader-1.0.198/code_loader/visualizers/default_visualizers.py

@@ -1,85 +0,0 @@
-from enum import Enum
-
-import numpy as np
-import numpy.typing as npt
-
-from code_loader.contract.visualizer_classes import LeapImage, LeapGraph, LeapHorizontalBar, LeapText, \
-    LeapImageMask, LeapTextMask, LeapVideo
-from code_loader.utils import rescale_min_max
-
-
-class DefaultVisualizer(Enum):
-    Image = 'Image'
-    Video = 'Video'
-    Graph = 'Graph'
-    HorizontalBar = 'HorizontalBar'
-    Text = 'Text'
-    ImageMask = 'ImageMask'
-    TextMask = 'TextMask'
-    RawData = 'RawData'
-    
-
-def default_image_visualizer(data: npt.NDArray[np.float32]) -> LeapImage:
-    rescaled_data = rescale_min_max(data[0])
-    return LeapImage(rescaled_data)
-
-
-def default_video_visualizer(data: npt.NDArray[np.float32]) -> LeapVideo:
-    return LeapVideo(data[0])
-
-
-def default_graph_visualizer(data: npt.NDArray[np.float32]) -> LeapGraph:
-    return LeapGraph(data[0])
-
-
-def default_horizontal_bar_visualizer(data: npt.NDArray[np.float32]) -> LeapHorizontalBar:
-    labels = [str(index) for index in range(data.shape[-1])]
-    return LeapHorizontalBar(data[0], labels)
-
-
-def default_word_visualizer(data: npt.NDArray[np.float32]) -> LeapText:
-    if len(data.shape) == 2 and data.shape[0] == 1:
-        data = data[0]
-    if hasattr(data, 'tolist'):
-        data = data.tolist()
-    words = [str(index[0]) if type(index) is list else str(index) for index in data]
-    return LeapText(words)
-
-
-def default_raw_data_visualizer(data: npt.NDArray[np.float32]) -> LeapText:
-    return LeapText([str(data)])
-
-
-def default_image_mask_visualizer(mask: npt.NDArray[np.float32], image: npt.NDArray[np.float32]) -> LeapImageMask:
-    if image.shape[0] == 1:
-        image = image[0]
-    if mask.shape[0] == 1:
-        mask = mask[0]
-
-    n_different_labels = mask.shape[-1]
-    labels = [str(i) for i in range(n_different_labels)]
-
-    if len(mask.shape) > 2:
-        if mask.shape[-1] == 1:
-            mask = np.squeeze(mask, axis=-1)
-        else:
-            mask = np.argmax(mask, axis=-1)
-
-    return LeapImageMask(mask.astype(np.uint8), image.astype(np.float32), labels)
-
-
-def default_text_mask_visualizer(mask: npt.NDArray[np.float32], text_data: npt.NDArray[np.float32]) -> LeapTextMask:
-    mask = mask[0]
-    text_data = text_data[0]
-
-    words = default_word_visualizer(text_data).data
-    n_different_labels = mask.shape[-1]
-    labels = [str(i) for i in range(n_different_labels)]
-
-    if len(mask.shape) > 1:
-        if mask.shape[-1] == 1:
-            mask = np.squeeze(mask, axis=-1)
-        else:
-            mask = np.argmax(mask, axis=-1)
-
-    return LeapTextMask(mask.astype(np.uint8), words, labels)