code-loader 1.0.87a2__tar.gz → 1.0.87.dev1__tar.gz

{code_loader-1.0.87a2 → code_loader-1.0.87.dev1}/PKG-INFO

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

{code_loader-1.0.87a2 → code_loader-1.0.87.dev1}/code_loader/contract/datasetclasses.py

@@ -7,7 +7,7 @@ import numpy.typing as npt
 from code_loader.contract.enums import DataStateType, DataStateEnum, LeapDataType, ConfusionMatrixValue, \
     MetricDirection, DatasetMetadataType
 from code_loader.contract.visualizer_classes import LeapImage, LeapText, LeapGraph, LeapHorizontalBar, \
-    LeapTextMask, LeapImageMask, LeapImageWithBBox, LeapImageWithHeatmap
+    LeapTextMask, LeapImageMask, LeapImageWithBBox, LeapImageWithHeatmap, LeapVideo
 
 custom_latent_space_attribute = "custom_latent_space"
 
@@ -94,6 +94,7 @@ class UnlabeledDataPreprocessHandler:
 
 VisualizerCallableInterface = Union[
     Callable[..., LeapImage],
+    Callable[..., LeapVideo],
     Callable[..., LeapText],
     Callable[..., LeapGraph],
     Callable[..., LeapHorizontalBar],
@@ -104,7 +105,7 @@ VisualizerCallableInterface = Union[
 ]
 
 LeapData = Union[LeapImage, LeapText, LeapGraph, LeapHorizontalBar, LeapImageMask, LeapTextMask, LeapImageWithBBox,
-LeapImageWithHeatmap]
+LeapImageWithHeatmap, LeapVideo]
 
 CustomCallableInterface = Callable[..., Any]
 

code_loader-1.0.87.dev1/code_loader/contract/mapping.py

@@ -0,0 +1,42 @@
+from enum import Enum
+
+from typing import Optional, Dict, Any, List
+from dataclasses import dataclass
+
+
+
+class NodeMappingType(Enum):
+    Visualizer = 'Visualizer'
+    Metric = 'Metric'
+    GroundTruth = 'GroundTruth'
+    Input = 'Input'
+    Layer = 'Layer'
+    Loss = 'Loss'
+    CustomLoss = 'CustomLoss'
+    Optimizer = 'Optimizer'
+    Prediction0 = 'Prediction0'
+    Prediction1 = 'Prediction1'
+    Prediction2 = 'Prediction2'
+    Prediction3 = 'Prediction3'
+    Input0 = 'Input0'
+    Input1 = 'Input1'
+    Input2 = 'Input2'
+    Input3 = 'Input3'
+    Input4 = 'Input4'
+    Input5 = 'Input5'
+
+
+@dataclass
+class NodeMapping:
+    name: str
+    type: NodeMappingType
+    user_unique_name: Optional[str] = None
+    sub_type: Optional[str] = None
+    arg_names: Optional[List[str]] = None
+
+
+@dataclass
+class NodeConnection:
+    node: NodeMapping
+    node_inputs: Optional[Dict[str, NodeMapping]]
+    prediction_type_name: Optional[str] = None

{code_loader-1.0.87a2 → code_loader-1.0.87.dev1}/code_loader/inner_leap_binder/leapbinder.py

@@ -12,15 +12,16 @@ from code_loader.contract.datasetclasses import SectionCallableInterface, InputH
     CustomMultipleReturnCallableInterfaceMultiArgs, DatasetBaseHandler, custom_latent_space_attribute, \
     RawInputsForHeatmap, VisualizerHandlerData, MetricHandlerData, CustomLossHandlerData, SamplePreprocessResponse
 from code_loader.contract.enums import LeapDataType, DataStateEnum, DataStateType, MetricDirection, DatasetMetadataType
+from code_loader.contract.mapping import NodeConnection
 from code_loader.contract.responsedataclasses import DatasetTestResultPayload
 from code_loader.contract.visualizer_classes import map_leap_data_type_to_visualizer_class
 from code_loader.default_losses import loss_name_to_function
 from code_loader.default_metrics import metrics_names_to_functions_and_direction
-from code_loader.utils import to_numpy_return_wrapper, get_shape, flatten
+from code_loader.utils import to_numpy_return_wrapper, get_shape
 from code_loader.visualizers.default_visualizers import DefaultVisualizer, \
     default_graph_visualizer, \
     default_image_visualizer, default_horizontal_bar_visualizer, default_word_visualizer, \
-    default_image_mask_visualizer, default_text_mask_visualizer, default_raw_data_visualizer
+    default_image_mask_visualizer, default_text_mask_visualizer, default_raw_data_visualizer, default_video_visualizer
 
 
 class LeapBinder:
@@ -43,11 +44,15 @@ class LeapBinder:
         self._extend_with_default_metrics()
         self._extend_with_default_losses()
 
+        self.mapping_connections: List[NodeConnection] = []
+
         self.batch_size_to_validate: Optional[int] = None
 
     def _extend_with_default_visualizers(self) -> None:
         self.set_visualizer(function=default_image_visualizer, name=DefaultVisualizer.Image.value,
                             visualizer_type=LeapDataType.Image)
+        self.set_visualizer(function=default_video_visualizer, name=DefaultVisualizer.Video.value,
+                            visualizer_type=LeapDataType.Video)
         self.set_visualizer(function=default_graph_visualizer, name=DefaultVisualizer.Graph.value,
                             visualizer_type=LeapDataType.Graph)
         self.set_visualizer(function=default_raw_data_visualizer, name=DefaultVisualizer.RawData.value,
@@ -353,8 +358,7 @@ class LeapBinder:
         self._encoder_names.append(name)
 
     def set_metadata(self, function: MetadataSectionCallableInterface, name: str,
-                     metadata_type: Optional[
-                         Union[DatasetMetadataType, Dict[str, DatasetMetadataType]]] = None) -> None:
+                     metadata_type: Optional[Union[DatasetMetadataType, Dict[str, DatasetMetadataType]]] = None) -> None:
         """
         Set the metadata handler function. This function is used for measuring and analyzing external variable values per sample, which is recommended for analysis within the Tensorleap platform.
 
@@ -491,41 +495,39 @@ class LeapBinder:
     @staticmethod
     def check_handler(
             preprocess_response: PreprocessResponse, test_result: List[DatasetTestResultPayload],
-            dataset_base_handler: Union[DatasetBaseHandler, MetadataHandler], state: DataStateEnum) -> List[
-        DatasetTestResultPayload]:
+            dataset_base_handler: Union[DatasetBaseHandler, MetadataHandler], state: DataStateEnum) -> List[DatasetTestResultPayload]:
         assert preprocess_response.sample_ids is not None
         raw_result = dataset_base_handler.function(preprocess_response.sample_ids[0], preprocess_response)
         handler_type = 'metadata' if isinstance(dataset_base_handler, MetadataHandler) else None
         if isinstance(dataset_base_handler, MetadataHandler):
             if isinstance(raw_result, dict):
-                metadata_test_result_payloads = []
-                for i, (flat_name, flat_result) in enumerate(flatten(raw_result, prefix=dataset_base_handler.name)):
-                    result_payload = DatasetTestResultPayload(flat_name)
+                metadata_test_result_payloads = [
+                    DatasetTestResultPayload(f'{dataset_base_handler.name}_{single_metadata_name}')
+                    for single_metadata_name, single_metadata_result in raw_result.items()
+                ]
+                for i, (single_metadata_name, single_metadata_result) in enumerate(raw_result.items()):
+                    metadata_test_result = metadata_test_result_payloads[i]
 
                     metadata_type = None
-                    if flat_result is None:
-                        if state != DataStateEnum.training and test_result[i].name == flat_name:
-                            result_payload = test_result[i]
-                            metadata_test_result_payloads.append(result_payload)
+                    if single_metadata_result is None:
+                        if state != DataStateEnum.training and test_result[i].name == f'{dataset_base_handler.name}_{single_metadata_name}':
+                            metadata_test_result_payloads[i] = test_result[i]
                             continue
 
                         if dataset_base_handler.metadata_type is None:
-                            raise Exception(f"Metadata {flat_name} is None and no metadata type is provided")
+                            raise Exception(f"Metadata {single_metadata_name} is None and no metadata type is provided")
                         elif isinstance(dataset_base_handler.metadata_type, dict):
-                            if flat_name not in dataset_base_handler.metadata_type:
-                                raise Exception(
-                                    f"Metadata {flat_name} is None and was not found in the provided metadata type")
-                            metadata_type = dataset_base_handler.metadata_type[flat_name]
+                            if single_metadata_name not in dataset_base_handler.metadata_type:
+                                raise Exception(f"Metadata {single_metadata_name} is None and no metadata type is provided")
+                            metadata_type = dataset_base_handler.metadata_type[single_metadata_name]
                         else:
-                            raise Exception(f"Metadata {flat_name} is None and was not found in the provided metadata "
-                                            f"type, metadata_type: {dataset_base_handler.metadata_type}")
-
-                    result_shape = get_shape(flat_result)
-                    result_payload.shape = result_shape
-                    result_payload.raw_result = flat_result if flat_result is not None else metadata_type
-                    result_payload.handler_type = handler_type
-                    metadata_test_result_payloads.append(result_payload)
+                            raise Exception(f"Metadata {single_metadata_name} is None and metadata type is not a dict")
 
+                    result_shape = get_shape(single_metadata_result)
+                    metadata_test_result.shape = result_shape
+                    metadata_test_result.raw_result = (
+                        single_metadata_result) if single_metadata_result is not None else metadata_type
+                    metadata_test_result.handler_type = handler_type
                 test_result = metadata_test_result_payloads
             else:
                 if raw_result is None:
@@ -533,11 +535,9 @@ class LeapBinder:
                         return test_result
 
                     if dataset_base_handler.metadata_type is None:
-                        raise Exception(
-                            f"Metadata {dataset_base_handler.name} is None and no metadata type is provided")
+                        raise Exception(f"Metadata {dataset_base_handler.name} is None and no metadata type is provided")
                     elif isinstance(dataset_base_handler.metadata_type, dict):
-                        raise Exception(
-                            f"Metadata {dataset_base_handler.name} is None and no metadata type is provided")
+                        raise Exception(f"Metadata {dataset_base_handler.name} is None and no metadata type is provided")
                     metadata_type = dataset_base_handler.metadata_type
 
                 result_shape = get_shape(raw_result)

{code_loader-1.0.87a2 → code_loader-1.0.87.dev1}/code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -11,13 +11,15 @@ from code_loader.contract.datasetclasses import CustomCallableInterfaceMultiArgs
     ConfusionMatrixElement, SamplePreprocessResponse
 from code_loader.contract.enums import MetricDirection, LeapDataType, DatasetMetadataType
 from code_loader import leap_binder
+from code_loader.contract.mapping import NodeMapping, NodeMappingType, NodeConnection
 from code_loader.contract.visualizer_classes import LeapImage, LeapImageMask, LeapTextMask, LeapText, LeapGraph, \
     LeapHorizontalBar, LeapImageWithBBox, LeapImageWithHeatmap
 
 
 def tensorleap_custom_metric(name: str,
                              direction: Union[MetricDirection, Dict[str, MetricDirection]] = MetricDirection.Downward,
-                             compute_insights: Optional[Union[bool, Dict[str, bool]]] = None):
+                             compute_insights: Optional[Union[bool, Dict[str, bool]]] = None,
+                             connects_to=None):
     def decorating_function(user_function: Union[CustomCallableInterfaceMultiArgs,
     CustomMultipleReturnCallableInterfaceMultiArgs,
     ConfusionMatrixCallableInterfaceMultiArgs]):
@@ -28,6 +30,18 @@ def tensorleap_custom_metric(name: str,
 
         leap_binder.add_custom_metric(user_function, name, direction, compute_insights)
 
+        if connects_to is not None:
+            arg_names = leap_binder.setup_container.metrics[-1].metric_handler_data.arg_names
+            for user_unique_name, connection_destinations in connects_to.items():
+                main_node_mapping = NodeMapping(name, NodeMappingType.Metric, user_unique_name, arg_names=arg_names)
+                node_inputs = {}
+                for arg_name, destination in zip(arg_names, connection_destinations):
+                    node_inputs[arg_name] = destination.node_mapping
+
+                leap_binder.mapping_connections.append(NodeConnection(main_node_mapping, node_inputs))
+
+
+
         def _validate_input_args(*args, **kwargs) -> None:
             for i, arg in enumerate(args):
                 assert isinstance(arg, (np.ndarray, SamplePreprocessResponse)), (
@@ -354,8 +368,12 @@ def tensorleap_gt_encoder(name: str):
             _validate_result(result)
             return result
 
+        inner.node_mapping = NodeMapping(name, NodeMappingType.GroundTruth)
+
         return inner
 
+
+
     return decorating_function
 
 

{code_loader-1.0.87a2 → code_loader-1.0.87.dev1}/code_loader/leaploader.py

@@ -22,7 +22,7 @@ from code_loader.contract.responsedataclasses import DatasetIntegParseResult, Da
     VisualizerInstance, PredictionTypeInstance, ModelSetup, CustomLayerInstance, MetricInstance, CustomLossInstance
 from code_loader.inner_leap_binder import global_leap_binder
 from code_loader.leaploaderbase import LeapLoaderBase
-from code_loader.utils import get_root_exception_file_and_line_number, flatten
+from code_loader.utils import get_root_exception_file_and_line_number
 
 
 class LeapLoader(LeapLoaderBase):
@@ -447,10 +447,6 @@ class LeapLoader(LeapLoaderBase):
 
     def _convert_metadata_to_correct_type(self, metadata_name: str, value: Any) -> Tuple[Any, bool]:
         metadata_name_to_type = self._metadata_name_to_type()
-        if metadata_name not in metadata_name_to_type:
-            raise Exception(f"metadata {metadata_name} not found in metadata type map, "
-                            f"metadata_name_to_type:{metadata_name_to_type}")
-
         metadata_type_to_python_type = {
             DatasetMetadataType.float: float,
             DatasetMetadataType.string: str,
@@ -475,18 +471,22 @@ class LeapLoader(LeapLoaderBase):
 
         return converted_value, is_none
 
-    def _get_metadata(self, state: DataStateEnum, sample_id: Union[int, str]) -> Tuple[
-        Dict[str, Union[str, int, bool, float]], Dict[str, bool]]:
+    def _get_metadata(self, state: DataStateEnum, sample_id: Union[int, str]) -> Tuple[Dict[str, Union[str, int, bool, float]], Dict[str, bool]]:
         result_agg = {}
         is_none = {}
         preprocess_result = self._preprocess_result()
         preprocess_state = preprocess_result[state]
         for handler in global_leap_binder.setup_container.metadata:
             handler_result = handler.function(sample_id, preprocess_state)
-
-            for flat_name, flat_result in flatten(handler_result, prefix=handler.name):
-                result_agg[flat_name], is_none[flat_name] = self._convert_metadata_to_correct_type(
-                    flat_name, flat_result)
+            if isinstance(handler_result, dict):
+                for single_metadata_name, single_metadata_result in handler_result.items():
+                    handler_name = f'{handler.name}_{single_metadata_name}'
+                    result_agg[handler_name], is_none[handler_name] = self._convert_metadata_to_correct_type(
+                        handler_name, single_metadata_result)
+            else:
+                handler_name = handler.name
+                result_agg[handler_name], is_none[handler_name] = self._convert_metadata_to_correct_type(
+                    handler_name, handler_result)
 
         return result_agg, is_none
 

{code_loader-1.0.87a2 → code_loader-1.0.87.dev1}/code_loader/utils.py

@@ -1,7 +1,7 @@
 import sys
 from pathlib import Path
 from types import TracebackType
-from typing import List, Union, Tuple, Any, Iterator
+from typing import List, Union, Tuple, Any
 import traceback
 import numpy as np
 import numpy.typing as npt
@@ -66,28 +66,3 @@ def rescale_min_max(image: npt.NDArray[np.float32]) -> npt.NDArray[np.float32]:
     return image
 
 
-def flatten(
-    value: Any,
-    *,
-    prefix: str = "",
-    list_token: str = "e",
-) -> Iterator[Tuple[str, Any]]:
-    """
-    Recursively walk `value` and yield (flat_key, leaf_value) pairs.
-
-    • Dicts → descend with   new_prefix = f"{prefix}_{key}" (or just key if top level)
-    • Sequences → descend with new_prefix = f"{prefix}_{list_token}{idx}"
-    • Leaf scalars → yield the accumulated flat key and the scalar itself
-    """
-    if isinstance(value, dict):
-        for k, v in value.items():
-            new_prefix = f"{prefix}_{k}" if prefix else k
-            yield from flatten(v, prefix=new_prefix, list_token=list_token)
-
-    elif isinstance(value, (list, tuple)):
-        for idx, v in enumerate(value):
-            new_prefix = f"{prefix}_{list_token}{idx}"
-            yield from flatten(v, prefix=new_prefix, list_token=list_token)
-
-    else:  # primitive leaf (str, int, float, bool, None…)
-        yield prefix, value

{code_loader-1.0.87a2 → code_loader-1.0.87.dev1}/code_loader/visualizers/default_visualizers.py

@@ -4,12 +4,13 @@ import numpy as np
 import numpy.typing as npt
 
 from code_loader.contract.visualizer_classes import LeapImage, LeapGraph, LeapHorizontalBar, LeapText, \
-    LeapImageMask, LeapTextMask
+    LeapImageMask, LeapTextMask, LeapVideo
 from code_loader.utils import rescale_min_max
 
 
 class DefaultVisualizer(Enum):
     Image = 'Image'
+    Video = 'Video'
     Graph = 'Graph'
     HorizontalBar = 'HorizontalBar'
     Text = 'Text'
@@ -23,6 +24,10 @@ def default_image_visualizer(data: npt.NDArray[np.float32]) -> LeapImage:
     return LeapImage(rescaled_data)
 
 
+def default_video_visualizer(data: npt.NDArray[np.float32]) -> LeapVideo:
+    return LeapVideo(data)
+
+
 def default_graph_visualizer(data: npt.NDArray[np.float32]) -> LeapGraph:
     return LeapGraph(data)
 

{code_loader-1.0.87a2 → code_loader-1.0.87.dev1}/pyproject.toml

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