code-loader 1.0.77.dev4__py3-none-any.whl → 1.0.77.dev30__py3-none-any.whl

code_loader/contract/datasetclasses.py

@@ -4,8 +4,7 @@ import re
 import numpy as np
 import numpy.typing as npt
 
-from code_loader.contract.enums import DataStateType, DataStateEnum, LeapDataType, ConfusionMatrixValue, \
-    MetricDirection, DatasetMetadataType
+from code_loader.contract.enums import DataStateType, DataStateEnum, LeapDataType, ConfusionMatrixValue, MetricDirection
 from code_loader.contract.visualizer_classes import LeapImage, LeapText, LeapGraph, LeapHorizontalBar, \
     LeapTextMask, LeapImageMask, LeapImageWithBBox, LeapImageWithHeatmap
 
@@ -197,7 +196,6 @@ class GroundTruthHandler(DatasetBaseHandler):
 class MetadataHandler:
     name: str
     function: MetadataSectionCallableInterface
-    metadata_type: Optional[Union[DatasetMetadataType, Dict[str, DatasetMetadataType]]] = None
 
 
 @dataclass
@@ -234,7 +232,6 @@ class DatasetIntegrationSetup:
 class DatasetSample:
     inputs: Dict[str, npt.NDArray[np.float32]]
     gt: Optional[Dict[str, npt.NDArray[np.float32]]]
-    metadata: Dict[str, Union[Optional[str], int, bool, Optional[float]]]
-    metadata_is_none: Dict[str, bool]
+    metadata: Dict[str, Union[str, int, bool, float]]
     index: Union[int, str]
     state: DataStateEnum

code_loader/inner_leap_binder/inner_classes.py

@@ -0,0 +1,34 @@
+
+from typing import List, Dict, Union, Callable
+from enum import Enum, IntEnum
+from dataclasses import dataclass, field
+from typing import Union
+
+class FunctionType(IntEnum):
+    gt = 0
+    visualizer = 1
+    input = 2
+    metric = 3
+    loss = 4
+    model_input = 5
+    model_output = 6
+
+@dataclass(frozen=True)
+class TLFunction:
+    FuncType: FunctionType
+    FuncName: str
+
+MappingList = List[Dict[TLFunction, Dict[str, Union[Callable, int]]]]
+
+def leap_input(idx):
+    def dummy():
+        return None
+    dummy.tl_func = TLFunction(FunctionType.model_input, idx)
+    return dummy
+
+def leap_output(idx):
+    def dummy():
+        return None
+    dummy.tl_func = TLFunction(FunctionType.model_output, idx)
+    return dummy
+

code_loader/inner_leap_binder/leapbinder.py

@@ -1,5 +1,5 @@
 import inspect
-from typing import Callable, List, Optional, Dict, Any, Type, Union
+from typing import Callable, List, Optional, Dict, Any, Type, Union, Tuple
 
 import numpy as np
 import numpy.typing as npt
@@ -11,7 +11,7 @@ from code_loader.contract.datasetclasses import SectionCallableInterface, InputH
     CustomCallableInterfaceMultiArgs, ConfusionMatrixCallableInterfaceMultiArgs, LeapData, \
     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.enums import LeapDataType, DataStateEnum, DataStateType, MetricDirection
 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
@@ -21,6 +21,7 @@ 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
+from code_loader.inner_leap_binder.inner_classes import FunctionType, TLFunction, MappingList, leap_output, leap_input
 
 
 class LeapBinder:
@@ -37,6 +38,7 @@ class LeapBinder:
     def __init__(self) -> None:
         self.setup_container = DatasetIntegrationSetup()
         self.cache_container: Dict[str, Any] = {"word_to_index": {}}
+        self._mappings: MappingList = list()
         self._visualizer_names: List[str] = list()
         self._encoder_names: List[str] = list()
         self._extend_with_default_visualizers()
@@ -72,7 +74,8 @@ class LeapBinder:
     def set_visualizer(self, function: VisualizerCallableInterface,
                        name: str,
                        visualizer_type: LeapDataType,
-                       heatmap_visualizer: Optional[Callable[..., npt.NDArray[np.float32]]] = None) -> None:
+                       heatmap_visualizer: Optional[Callable[..., npt.NDArray[np.float32]]] = None,
+                       connects_to = None) -> None: #TODO add types
         """
         Set a visualizer for a specific data type.
 
@@ -139,10 +142,11 @@ class LeapBinder:
                 raise Exception(
                     f'The return type of function {function.__name__} is invalid. current return type: {return_type}, '
                     f'should be {expected_return_type}')
-
         self.setup_container.visualizers.append(
             VisualizerHandler(VisualizerHandlerData(name, visualizer_type, arg_names), function, heatmap_visualizer))
         self._visualizer_names.append(name)
+        if connects_to is not None:
+            self._mappings.append({TLFunction(FunctionType.visualizer, name): connects_to})
 
     def set_preprocess(self, function: Callable[[], List[PreprocessResponse]]) -> None:
         """
@@ -259,7 +263,8 @@ class LeapBinder:
                           name: str,
                           direction: Optional[
                               Union[MetricDirection, Dict[str, MetricDirection]]] = MetricDirection.Downward,
-                          compute_insights: Union[bool, Dict[str, bool]] = True) -> None:
+                          compute_insights: Union[bool, Dict[str, bool]] = True,
+                          connects_to = None) -> None: #TODO TOM add types
         """
         Add a custom metric to the setup.
 
@@ -285,6 +290,8 @@ class LeapBinder:
         arg_names = inspect.getfullargspec(function)[0]
         metric_handler_data = MetricHandlerData(name, arg_names, direction, compute_insights)
         self.setup_container.metrics.append(MetricHandler(metric_handler_data, function))
+        if connects_to is not None:
+            self._mappings.append({TLFunction(FunctionType.metric, name): connects_to})
 
     def add_prediction(self, name: str, labels: List[str], channel_dim: int = -1) -> None:
         """
@@ -333,8 +340,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:
+    def set_metadata(self, function: MetadataSectionCallableInterface, name: str) -> 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.
 
@@ -369,7 +375,7 @@ class LeapBinder:
             leap_binder.set_metadata(metadata_handler_index, name='metadata_index')
             leap_binder.set_metadata(metadata_handler_image_mean, name='metadata_image_mean')
         """
-        self.setup_container.metadata.append(MetadataHandler(name, function, metadata_type))
+        self.setup_container.metadata.append(MetadataHandler(name, function))
 
     def set_custom_layer(self, custom_layer: Type[Any], name: str, inspect_layer: bool = False,
                          kernel_index: Optional[int] = None, use_custom_latent_space: bool = False) -> None:
@@ -466,55 +472,23 @@ 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]) -> 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 = [
-                    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 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 {single_metadata_name} is None and no metadata type is provided")
-                        elif isinstance(dataset_base_handler.metadata_type, dict):
-                            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 {single_metadata_name} is None and no metadata type is provided")
-
-                    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:
-                    if state != DataStateEnum.training:
-                        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")
-                    elif isinstance(dataset_base_handler.metadata_type, dict):
-                        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)
-                test_result[0].shape = result_shape
-                test_result[0].raw_result = raw_result if raw_result is not None else metadata_type
-                test_result[0].handler_type = handler_type
+        if isinstance(dataset_base_handler, MetadataHandler) and isinstance(raw_result, dict):
+            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]
+
+                result_shape = get_shape(single_metadata_result)
+                metadata_test_result.shape = result_shape
+                metadata_test_result.raw_result = single_metadata_result
+                metadata_test_result.handler_type = handler_type
+            test_result = metadata_test_result_payloads
         else:
             result_shape = get_shape(raw_result)
             test_result[0].shape = result_shape
@@ -535,6 +509,9 @@ class LeapBinder:
                     continue
                 self.check_handler(preprocess_response, test_result, dataset_base_handler)
 
+    def set_model_inputs(self, connections: Tuple[Callable[..., Any], ...]):
+        self._mappings.append({TLFunction(FunctionType.model_input, "model"): {str(i): (connections[i], ) for i in range(len(connections))}})
+
     def check(self) -> None:
         preprocess_result = self.get_preprocess_result()
         self.check_preprocess(preprocess_result)

code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -9,15 +9,16 @@ from code_loader.contract.datasetclasses import CustomCallableInterfaceMultiArgs
     CustomMultipleReturnCallableInterfaceMultiArgs, ConfusionMatrixCallableInterfaceMultiArgs, CustomCallableInterface, \
     VisualizerCallableInterface, MetadataSectionCallableInterface, PreprocessResponse, SectionCallableInterface, \
     ConfusionMatrixElement, SamplePreprocessResponse
-from code_loader.contract.enums import MetricDirection, LeapDataType, DatasetMetadataType
+from code_loader.contract.enums import MetricDirection, LeapDataType
 from code_loader import leap_binder
 from code_loader.contract.visualizer_classes import LeapImage, LeapImageMask, LeapTextMask, LeapText, LeapGraph, \
     LeapHorizontalBar, LeapImageWithBBox, LeapImageWithHeatmap
-
+from code_loader.inner_leap_binder.inner_classes import TLFunction, FunctionType
 
 def tensorleap_custom_metric(name: str,
                              direction: Union[MetricDirection, Dict[str, MetricDirection]] = MetricDirection.Downward,
-                             compute_insights: Union[bool, Dict[str, bool]] = True):
+                             compute_insights: Union[bool, Dict[str, bool]] = True,
+                             connects_to = None):
     def decorating_function(user_function: Union[CustomCallableInterfaceMultiArgs,
     CustomMultipleReturnCallableInterfaceMultiArgs,
     ConfusionMatrixCallableInterfaceMultiArgs]):
@@ -26,7 +27,7 @@ def tensorleap_custom_metric(name: str,
                 raise Exception(f'Metric with name {name} already exists. '
                                 f'Please choose another')
 
-        leap_binder.add_custom_metric(user_function, name, direction, compute_insights)
+        leap_binder.add_custom_metric(user_function, name, direction, compute_insights, connects_to=connects_to)
 
         def _validate_input_args(*args, **kwargs) -> None:
             for i, arg in enumerate(args):
@@ -106,14 +107,15 @@ def tensorleap_custom_metric(name: str,
 
 
 def tensorleap_custom_visualizer(name: str, visualizer_type: LeapDataType,
-                                 heatmap_function: Optional[Callable[..., npt.NDArray[np.float32]]] = None):
+                                 heatmap_function: Optional[Callable[..., npt.NDArray[np.float32]]] = None,
+                                 connects_to = None): #TODO TOM ADD TYPES
     def decorating_function(user_function: VisualizerCallableInterface):
         for viz_handler in leap_binder.setup_container.visualizers:
             if viz_handler.visualizer_handler_data.name == name:
                 raise Exception(f'Visualizer with name {name} already exists. '
                                 f'Please choose another')
 
-        leap_binder.set_visualizer(user_function, name, visualizer_type, heatmap_function)
+        leap_binder.set_visualizer(user_function, name, visualizer_type, heatmap_function, connects_to)
 
         def _validate_input_args(*args, **kwargs):
             for i, arg in enumerate(args):
@@ -154,21 +156,21 @@ def tensorleap_custom_visualizer(name: str, visualizer_type: LeapDataType,
             result = user_function(*args, **kwargs)
             _validate_result(result)
             return result
+        inner.tl_func = TLFunction(FunctionType.visualizer, name)
 
         return inner
 
     return decorating_function
 
 
-def tensorleap_metadata(
-        name: str, metadata_type: Optional[Union[DatasetMetadataType, Dict[str, DatasetMetadataType]]] = None):
+def tensorleap_metadata(name: str):
     def decorating_function(user_function: MetadataSectionCallableInterface):
         for metadata_handler in leap_binder.setup_container.metadata:
             if metadata_handler.name == name:
                 raise Exception(f'Metadata with name {name} already exists. '
                                 f'Please choose another')
 
-        leap_binder.set_metadata(user_function, name, metadata_type)
+        leap_binder.set_metadata(user_function, name)
 
         def _validate_input_args(sample_id: Union[int, str], preprocess_response: PreprocessResponse):
             assert isinstance(sample_id, (int, str)), \
@@ -183,7 +185,7 @@ def tensorleap_metadata(
                  f'{preprocess_response.sample_id_type}. Got {type(sample_id)}.')
 
         def _validate_result(result):
-            supported_result_types = (type(None), int, str, bool, float, dict, np.floating,
+            supported_result_types = (int, str, bool, float, dict, np.floating,
                                       np.bool_, np.unsignedinteger, np.signedinteger, np.integer)
             assert isinstance(result, supported_result_types), \
                 (f'tensorleap_metadata validation failed: '
@@ -303,6 +305,7 @@ def tensorleap_input_encoder(name: str, channel_dim=-1):
             result = user_function(sample_id, preprocess_response)
             _validate_result(result)
             return result
+        inner.tl_func = TLFunction(FunctionType.input, name)
 
         return inner
 
@@ -343,7 +346,7 @@ def tensorleap_gt_encoder(name: str):
             result = user_function(sample_id, preprocess_response)
             _validate_result(result)
             return result
-
+        inner.tl_func = TLFunction(FunctionType.gt, name)
         return inner
 
     return decorating_function
@@ -395,6 +398,7 @@ def tensorleap_custom_loss(name: str):
             _validate_result(result)
             return result
 
+        inner.tl_func = TLFunction(FunctionType.loss, name)
         return inner
 
     return decorating_function

code_loader/inner_leap_binder/mapping.py

@@ -0,0 +1,219 @@
+from typing import Optional, Callable, Any, Dict, List, Set, OrderedDict
+from copy import deepcopy
+import numpy as np
+from collections import OrderedDict as od
+from code_loader.inner_leap_binder.inner_classes import FunctionType, TLFunction, MappingList
+from code_loader.contract.datasetclasses import DatasetIntegrationSetup, VisualizerHandler, MetricHandler
+from code_loader.contract.datasetclasses import DatasetBaseHandler, GroundTruthHandler, InputHandler
+
+
+class LeapMapping:
+
+    def __init__(self, setup_container: DatasetIntegrationSetup, mapping: MappingList):
+        self.container : DatasetIntegrationSetup = setup_container
+        self.mapping: MappingList = mapping
+        self.max_id = 20000
+        self.current_id = self.max_id
+        self.mapping_json = []
+        self.handle_dict = {
+            FunctionType.gt : self.container.ground_truths,
+            FunctionType.metric : self.container.metrics,
+            FunctionType.visualizer: self.container.visualizers,
+            FunctionType.input: self.container.inputs,
+        }
+        self.handle_to_op_type = {
+            GroundTruthHandler: "GroundTruth",
+            InputHandler: "Input",
+            VisualizerHandler: "Visualizer"
+
+        }
+        self.function_to_json : Dict[TLFunction, List[Dict[str, Any]]] = {}
+
+    def create_mapping_list(self, connections_list): #TODO add types
+        pass
+
+    def create_connect_nodes(self):
+        for element in self.mapping:
+            for sink in element.keys():
+                for node_name, connected_func_list in element[sink].items():
+                    tl_connected_functions = [ connected_func.tl_func for connected_func in connected_func_list
+                                               if not isinstance(connected_func, int)]
+                    for i, source in enumerate(tl_connected_functions):
+                        print(sink, source, node_name)
+                        sink_node = self.create_node(sink, name=node_name)
+                        self.add_connections(sink_node, source, input_idx=i)
+        print(1)
+        import yaml
+        with open('temp.yaml', 'w') as yf:
+            yaml.safe_dump(({'decoder': self.mapping_json}), yf, default_flow_style=False, sort_keys=False)
+
+    def create_partial_mapping(self): #TODO add types
+        referenced = self._get_referenced_sinks()
+        for func in referenced:
+            kwargs = {}
+            if func.FuncType == FunctionType.model_output:
+                kwargs = {'name': func.FuncName}
+            self.create_node(func, **kwargs)
+        self.create_connect_nodes()
+
+    def _get_referenced_sinks(self) -> Set[TLFunction]:
+        referenced : Set[TLFunction] = set()
+        references_types = {FunctionType.input, FunctionType.gt, FunctionType.model_output}
+        for element in self.mapping:
+            for func in element.keys():
+                for node_name, connected_func_list in element[func].items():
+                    tl_connected_functions = [ connected_func.tl_func for connected_func in connected_func_list
+                                               if not isinstance(connected_func, int)]
+                    for connected_func in tl_connected_functions:
+                        if connected_func.FuncType in references_types:
+                            referenced.add(connected_func)
+        return referenced
+
+    def create_gt_input(self, handle: DatasetBaseHandler, **kwargs) -> Dict[str, Any]:
+        op_type = self.handle_to_op_type[type(handle)]
+        json_node = {'operation': op_type,
+                     'data': {'type': op_type, 'output_name': handle.name},
+                     'id': f'{str(self.current_id)}',
+                     'inputs': {},
+                     'outputs': {handle.name: []}}
+        return json_node
+
+    def create_visualize(self, visualize_handle: VisualizerHandler ,**kwargs) -> Dict[str, Any]:
+        op_type = "Visualizer"
+        json_node = {'operation': op_type,
+                     'data': {'type': op_type,
+                              'name': visualize_handle.name,
+                              'visualizer_name': visualize_handle.name,
+                              'visualizer_type': visualize_handle.type.name,
+                              'arg_names': deepcopy(visualize_handle.arg_names),
+                              'user_unique_name': kwargs['name']},
+                     'id': f'{str(self.current_id)}',
+                     'inputs': {arg: [] for arg in visualize_handle.arg_names},
+                     'outputs': {} }
+        return json_node
+
+    def create_metric(self, metric_handle: MetricHandler, **kwargs) -> Dict[str, Any]:
+        op_type = "Metric"
+        json_node = {'operation': op_type,
+                     'data': {'type': op_type,
+                              'name': metric_handle.name,
+                              'metric_name': metric_handle.name,
+                              'arg_names': deepcopy(metric_handle.arg_names),
+                              'user_unique_name': kwargs['name']},
+                     'id': f'{str(self.current_id)}',
+                     'inputs': {arg: [] for arg in metric_handle.arg_names},
+                     'outputs': {} }
+        return  json_node
+
+
+    def create_temp_model_node(self, node_type: TLFunction, **kwargs) -> Dict[str, Any]:
+        default_name = self.get_default_name(node_type.FuncType, kwargs['name'])
+        op_type = "PlaceHolder"
+        json_node = {'operation': op_type,
+                     'data': {'type': op_type,
+                              'name': default_name,
+                              'arg_names': [default_name],
+                              'user_unique_name': default_name},
+                     'id': f'{default_name}',
+                     'inputs': {},
+                     'outputs': {} }
+        if node_type.FuncType == FunctionType.model_input:
+            json_node['inputs'] = {default_name: []}
+        else:
+            json_node['outputs'] = {default_name: []}
+        return json_node
+
+    def _find_handle(self, node: TLFunction) -> DatasetBaseHandler:
+        handle_list = self.handle_dict[node.FuncType]
+        chosen_handle: Optional[DatasetBaseHandler] = None
+        for handle in handle_list:
+            if handle.name == node.FuncName:
+                chosen_handle = handle
+        assert chosen_handle is not None
+        return chosen_handle
+
+    def _find_json_node(self, node: TLFunction, **kwargs) -> Dict[str, Any]:
+        candidates = self.function_to_json[node]
+        if len(candidates) == 1:
+            return candidates[0]
+        elif len(candidates) > 1:
+            raise Exception("More than 1 candidate - solve")
+        else:
+            raise Exception(f"No json node creted for node {node}")
+
+    def _get_node_id(self, node: TLFunction, **kwargs):
+        node = self._find_json_node(node, **kwargs)
+        return node['id']
+
+    def create_node(self, node_type: TLFunction, **kwargs) -> Dict[str, Any]:
+        if node_type.FuncType in [FunctionType.model_output, FunctionType.model_input]:
+            json_node = self.create_temp_model_node(node_type, **kwargs)
+        else:
+            node_creator_map: Dict[FunctionType, Callable[..., Any]] = { FunctionType.gt : self.create_gt_input,
+                                                                         FunctionType.input: self.create_gt_input,
+                                                                         FunctionType.visualizer: self.create_visualize,
+                                                                         FunctionType.metric: self.create_metric}
+            handle = self._find_handle(node_type)
+            json_node = node_creator_map[node_type.FuncType](handle, **kwargs)
+            self.current_id += 1
+        self.function_to_json[node_type] =  self.function_to_json.get(node_type, []) + [json_node]
+        self.mapping_json.append(json_node)
+        return  json_node
+
+    def get_default_name(self, f_type: FunctionType, name: str):
+        return f"{str(f_type)}_{name}"
+
+    def _get_node_output_name(self, node: TLFunction):
+        if node.FuncType not in {FunctionType.model_output, FunctionType.model_input}:
+            from_handle = self._find_handle(node)
+            output_name = from_handle.name
+        else:
+            output_name = self.get_default_name(node.FuncType, node.FuncName)
+        return output_name
+
+
+    def add_connections(self, to_json: Dict[str, Any], from_node: TLFunction, input_idx: int):
+        try:
+            input_name = to_json['data']['arg_names'][input_idx]
+        except Exception as e:
+            raise Exception(f"arg names mismatch when adding input for {to_json['operation']}")
+        output_key = self._get_node_output_name(from_node)
+        from_json = self._find_json_node(from_node)
+        operation = from_json['operation']
+        from_id = from_json['id']
+        # Add Input
+        to_json['inputs'][input_name].append({'outputKey': output_key,
+                                              'operation': operation,
+                                              'id': from_id
+                                              })
+        # Add Output
+        from_json['outputs'][output_key].append({'inputKey': input_name,
+                                              'operation': to_json['operation'],
+                                              'id': to_json['id']
+                                              })
+
+    def add_output(self, input_node, output_node):
+        pass
+
+def create_mapping(model_parser_map, connections_list):
+
+    referenced_gt = []
+    referenced_inputs = []
+    for element in connections_list:
+        for func in element.keys():
+            for node_name, connected_func_list in element[func].items():
+                tl_connected_functions = [ connected_func.tl_func if not isinstance(connected_func, int) else connected_func
+                                      for connected_func in connected_func_list ]
+
+
+
+
+
+    # Check Max Node ID
+    # Get Preds Node ID
+
+    # TODO Create Inputs (if referenced)
+    # TODO Create Gts (if referenced)
+    # TODO Create Visualizers
+    # TODO Create Metrics
+    # TODO Create losses

code_loader/leaploader.py

@@ -6,7 +6,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, Union, Any, Type, Optional, Callable
 
 import numpy as np
 import numpy.typing as npt
@@ -46,7 +46,7 @@ class LeapLoader(LeapLoaderBase):
 
     def evaluate_module(self) -> None:
         def append_path_recursively(full_path: str) -> None:
-            if '/' not in full_path or full_path == '/':
+            if self.code_path not in full_path or full_path == '/':
                 return
 
             parent_path = str(Path(full_path).parent)
@@ -140,11 +140,9 @@ class LeapLoader(LeapLoaderBase):
         if state == DataStateEnum.unlabeled and sample_id not in preprocess_result[state].sample_ids:
             self._preprocess_result(update_unlabeled_preprocess=True)
 
-        metadata, metadata_is_none = self._get_metadata(state, sample_id)
         sample = DatasetSample(inputs=self._get_inputs(state, sample_id),
                                gt=None if state == DataStateEnum.unlabeled else self._get_gt(state, sample_id),
-                               metadata=metadata,
-                               metadata_is_none=metadata_is_none,
+                               metadata=self._get_metadata(state, sample_id),
                                index=sample_id,
                                state=state)
         return sample
@@ -212,7 +210,7 @@ class LeapLoader(LeapLoaderBase):
                 state_name = state.name
                 try:
                     test_result = global_leap_binder.check_handler(
-                        preprocess_response, test_result, dataset_base_handler, state)
+                        preprocess_response, test_result, dataset_base_handler)
                 except Exception as e:
                     line_number, file_name, stacktrace = get_root_exception_file_and_line_number()
                     test_result[0].display[
@@ -341,11 +339,6 @@ class LeapLoader(LeapLoaderBase):
                 continue
             if hasattr(handler_test_payload.raw_result, 'tolist'):
                 handler_test_payload.raw_result = handler_test_payload.raw_result.tolist()
-            if isinstance(handler_test_payload.raw_result, DatasetMetadataType):
-                dataset_metadata_type = handler_test_payload.raw_result
-                metadata_instances.append(DatasetMetadataInstance(name=handler_test_payload.name,
-                                                                  type=dataset_metadata_type))
-                continue
             metadata_type = type(handler_test_payload.raw_result)
             if metadata_type == int or isinstance(handler_test_payload.raw_result,
                                                   (np.unsignedinteger, np.signedinteger)):
@@ -445,7 +438,7 @@ class LeapLoader(LeapLoaderBase):
         }
         return metadata_name_to_type
 
-    def _convert_metadata_to_correct_type(self, metadata_name: str, value: Any) -> Tuple[Any, bool]:
+    def _convert_metadata_to_correct_type(self, metadata_name: str, value: Any) -> Any:
         metadata_name_to_type = self._metadata_name_to_type()
         metadata_type_to_python_type = {
             DatasetMetadataType.float: float,
@@ -454,26 +447,22 @@ class LeapLoader(LeapLoaderBase):
             DatasetMetadataType.int: int
         }
         metadata_type_to_default_value = {
-            DatasetMetadataType.float: -1.0,
-            DatasetMetadataType.string: 'None',
+            DatasetMetadataType.float: -1,
+            DatasetMetadataType.string: "",
             DatasetMetadataType.boolean: False,
             DatasetMetadataType.int: -1
         }
 
         try:
-            is_none = False
-            if value is None:
-                raise ValueError()
             converted_value = metadata_type_to_python_type[metadata_name_to_type[metadata_name]](value)
         except ValueError:
-            is_none = True
             converted_value = metadata_type_to_default_value[metadata_name_to_type[metadata_name]]
 
-        return converted_value, is_none
+        return converted_value
 
-    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]) -> Dict[
+        str, Union[str, int, bool, float]]:
         result_agg = {}
-        is_none = {}
         preprocess_result = self._preprocess_result()
         preprocess_state = preprocess_result[state]
         for handler in global_leap_binder.setup_container.metadata:
@@ -481,14 +470,13 @@ class LeapLoader(LeapLoaderBase):
             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)
+                    result_agg[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)
+                result_agg[handler_name] = self._convert_metadata_to_correct_type(handler_name, handler_result)
 
-        return result_agg, is_none
+        return result_agg
 
     @lru_cache()
     def get_sample_id_type(self) -> Type:

{code_loader-1.0.77.dev4.dist-info → code_loader-1.0.77.dev30.dist-info}/METADATA

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

{code_loader-1.0.77.dev4.dist-info → code_loader-1.0.77.dev30.dist-info}/RECORD

@@ -1,7 +1,7 @@
 LICENSE,sha256=qIwWjdspQeSMTtnFZBC8MuT-95L02FPvzRUdWFxrwJY,1067
 code_loader/__init__.py,sha256=6MMWr0ObOU7hkqQKgOqp4Zp3I28L7joGC9iCbQYtAJg,241
 code_loader/contract/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-code_loader/contract/datasetclasses.py,sha256=BjT7NoOBgWtBXtMRedKwwnC-vbHg-KHKqFL11GdgUx8,7902
+code_loader/contract/datasetclasses.py,sha256=t1pvW68dVIbYB0bllqxHXO6jOgHCJI5NGn9rSrYC6Vw,7722
 code_loader/contract/enums.py,sha256=6Lo7p5CUog68Fd31bCozIuOgIp_IhSiPqWWph2k3OGU,1602
 code_loader/contract/exceptions.py,sha256=jWqu5i7t-0IG0jGRsKF4DjJdrsdpJjIYpUkN1F4RiyQ,51
 code_loader/contract/responsedataclasses.py,sha256=RSx9m_R3LawhK5o1nAcO3hfp2F9oJYtxZr_bpP3bTmw,4005
@@ -19,14 +19,16 @@ 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=bn7H99bjttzAv3UaXR4cRludctUyTjeOk1-0-qDV8mw,29360
-code_loader/inner_leap_binder/leapbinder_decorators.py,sha256=HUIVrI-I0aB-nQl7lZErE5vuhml7A8MMGaw_R4U4QCk,22053
-code_loader/leaploader.py,sha256=JfQsKjXWiy6K6ANj_HOqcb8_dcuagetmeoCVZ4MajE0,25668
+code_loader/inner_leap_binder/inner_classes.py,sha256=DHaIaRUdplQPCaukKLG8RboW9KIkdO6kekeGw9PCmT4,726
+code_loader/inner_leap_binder/leapbinder.py,sha256=jkSsoJwnNEmn8vlibjT4GczNuj4NAIM3_v-KZCLjPuw,27832
+code_loader/inner_leap_binder/leapbinder_decorators.py,sha256=1oUrEbcY3GZkkaxVAdzlV4Vl3Y5XQ4aGwPWvSUb2hWM,22388
+code_loader/inner_leap_binder/mapping.py,sha256=WD3p_dNMp8SQckUq62Yl0bpIBxoaZAkJszCl4IzWSms,10198
+code_loader/leaploader.py,sha256=KkAPKyzZxZYI135_67q63ICVVERu7WH60liB0pboA-c,24983
 code_loader/leaploaderbase.py,sha256=VH0vddRmkqLtcDlYPCO7hfz1_VbKo43lUdHDAbd4iJc,4198
 code_loader/utils.py,sha256=aw2i_fqW_ADjLB66FWZd9DfpCQ7mPdMyauROC5Nd51I,2197
 code_loader/visualizers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 code_loader/visualizers/default_visualizers.py,sha256=Ffx5VHVOe5ujBOsjBSxN_aIEVwFSQ6gbhTMG5aUS-po,2305
-code_loader-1.0.77.dev4.dist-info/LICENSE,sha256=qIwWjdspQeSMTtnFZBC8MuT-95L02FPvzRUdWFxrwJY,1067
-code_loader-1.0.77.dev4.dist-info/METADATA,sha256=2RGRvw7LlvX2szuGL2WqQYctTeINmq98iaf1NzUCkiA,854
-code_loader-1.0.77.dev4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-code_loader-1.0.77.dev4.dist-info/RECORD,,
+code_loader-1.0.77.dev30.dist-info/LICENSE,sha256=qIwWjdspQeSMTtnFZBC8MuT-95L02FPvzRUdWFxrwJY,1067
+code_loader-1.0.77.dev30.dist-info/METADATA,sha256=ntsmieF-9tHybrMeZ_YqnkSvI5k9Pp3eUKi0uO-GZ0w,855
+code_loader-1.0.77.dev30.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+code_loader-1.0.77.dev30.dist-info/RECORD,,