code-loader 1.0.96__tar.gz → 1.0.99.dev1__tar.gz

{code_loader-1.0.96 → code_loader-1.0.99.dev1}/PKG-INFO

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

{code_loader-1.0.96 → code_loader-1.0.99.dev1}/code_loader/contract/datasetclasses.py

@@ -205,7 +205,7 @@ class MetadataHandler:
 class PredictionTypeHandler:
     name: str
     labels: List[str]
-    channel_dim: int
+    channel_dim: int = -1
 
 
 @dataclass

{code_loader-1.0.96 → code_loader-1.0.99.dev1}/code_loader/contract/visualizer_classes.py

@@ -121,23 +121,19 @@ class LeapGraph:
         x_label = 'Frequency [Seconds]'
         y_label = 'Amplitude [Voltage]'
         x_range = (0.1, 3.0)
-        legend = ['experiment1', 'experiment2', 'experiment3']
-        leap_graph = LeapGraph(data=graph_data, x_label=x_label, y_label=y_label, x_range=x_range, legend=legend)
+        leap_graph = LeapGraph(data=graph_data, x_label=x_label, y_label=y_label, x_range=x_range)
     """
     data: npt.NDArray[np.float32]
     type: LeapDataType = LeapDataType.Graph
     x_label: Optional[str] = None
     y_label: Optional[str] = None
     x_range: Optional[Tuple[float,float]] = None
-    legend: Optional[List[str]] = None
 
     def __post_init__(self) -> None:
         validate_type(self.type, LeapDataType.Graph)
         validate_type(type(self.data), np.ndarray)
         validate_type(self.data.dtype, np.float32)
-        validate_type(len(self.data.shape), 2, f'Graph must be of shape 2')
-        if self.legend:
-            validate_type(self.data.shape[1], len(self.legend), 'Number of labels supplied should equal the number of graphs')
+        validate_type(len(self.data.shape), 2, 'Graph must be of shape 2')
         validate_type(type(self.x_label), [str, type(None)], 'x_label must be a string or None')
         validate_type(type(self.y_label), [str, type(None)], 'y_label must be a string or None')
         validate_type(type(self.x_range), [tuple, type(None)], 'x_range must be a tuple or None')

{code_loader-1.0.96 → code_loader-1.0.99.dev1}/code_loader/inner_leap_binder/leapbinder.py

@@ -24,6 +24,9 @@ from code_loader.visualizers.default_visualizers import DefaultVisualizer, \
     default_image_mask_visualizer, default_text_mask_visualizer, default_raw_data_visualizer, default_video_visualizer
 
 
+mapping_runtime_mode_env_var_mame = '__MAPPING_RUNTIME_MODE__'
+
+
 class LeapBinder:
     """
     Interface to the Tensorleap platform. Provides methods to set up preprocessing,
@@ -513,10 +516,9 @@ class LeapBinder:
                 for i, (single_metadata_name, single_metadata_result) in enumerate(raw_result.items()):
                     metadata_test_result = metadata_test_result_payloads[i]
 
-                    if not isinstance(single_metadata_result, (int, str, bool, float, np.unsignedinteger,
-                                                               np.signedinteger, np.bool_, np.floating, type(None))):
+                    if not isinstance(single_metadata_result, (int, str, bool, float, np.unsignedinteger, np.signedinteger, np.bool_, np.floating)):
                         raise Exception(f"Unsupported return type of metadata {single_metadata_name}."
-                                        f"The return type should be one of [int, float, str, bool, None]. Got {type(single_metadata_result)}")
+                                        f"The return type should be one of [int, float, str, bool]. Got {type(single_metadata_result)}")
 
                     metadata_type = None
                     if single_metadata_result is None:

{code_loader-1.0.96 → code_loader-1.0.99.dev1}/code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -1,5 +1,5 @@
 # mypy: ignore-errors
-
+import os
 from typing import Optional, Union, Callable, List, Dict
 
 import numpy as np
@@ -8,22 +8,83 @@ import numpy.typing as npt
 from code_loader.contract.datasetclasses import CustomCallableInterfaceMultiArgs, \
     CustomMultipleReturnCallableInterfaceMultiArgs, ConfusionMatrixCallableInterfaceMultiArgs, CustomCallableInterface, \
     VisualizerCallableInterface, MetadataSectionCallableInterface, PreprocessResponse, SectionCallableInterface, \
-    ConfusionMatrixElement, SamplePreprocessResponse
+    ConfusionMatrixElement, SamplePreprocessResponse, PredictionTypeHandler
 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
+from code_loader.inner_leap_binder.leapbinder import mapping_runtime_mode_env_var_mame
+
+
+def _add_mapping_connection(user_unique_name, connection_destinations, arg_names, name, node_mapping_type):
+    main_node_mapping = NodeMapping(name, node_mapping_type, 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 _add_mapping_connections(connects_to, arg_names, node_mapping_type, name):
     for user_unique_name, connection_destinations in connects_to.items():
-        main_node_mapping = NodeMapping(name, node_mapping_type, 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
+        _add_mapping_connection(user_unique_name, connection_destinations, arg_names, name, node_mapping_type)
+
+
+
+
+def tensorleap_load_model(prediction_types: Optional[List[PredictionTypeHandler]] = None):
+    for i, prediction_type in enumerate(prediction_types):
+        leap_binder.add_prediction(prediction_type.name, prediction_type.labels, prediction_type.channel_dim, i)
+
+    def decorating_function(load_model_func):
+        class TempMapping:
+            pass
+
+        def mapping_inner():
+            class ModelOutputPlaceholder:
+                def __init__(self):
+                    self.node_mapping = NodeMapping('', NodeMappingType.Prediction0)
+
+                def __getitem__(self, key):
+                    assert isinstance(key, int), \
+                        f'Expected key to be an int, got {type(key)} instead.'
+
+                    ret = TempMapping()
+                    ret.node_mapping = NodeMapping('', NodeMappingType(f'Prediction{str(key)}'))
+                    return ret
+
+            class ModelPlaceholder:
+                #keras interface
+                def __call__(self, arg):
+                    if isinstance(arg, list):
+                        for i, elem in enumerate(arg):
+                            elem.node_mapping.type = NodeMappingType[f'Input{str(i)}']
+                    else:
+                        arg.node_mapping.type = NodeMappingType.Input0
+
+                    return ModelOutputPlaceholder()
+
+                # onnx runtime interface
+                def run(self, output_names, input_dict):
+                    assert output_names is None
+                    assert isinstance(input_dict, dict), \
+                        f'Expected input_dict to be a dict, got {type(input_dict)} instead.'
+                    for i, elem in enumerate(input_dict.values()):
+                        elem.node_mapping.type = NodeMappingType[f'Input{str(i)}']
+
+                    return ModelOutputPlaceholder()
+
+            return ModelPlaceholder()
+
+
+        if os.environ[mapping_runtime_mode_env_var_mame]:
+            return mapping_inner
+        else:
+            return load_model_func
+
+    return decorating_function
 
-        leap_binder.mapping_connections.append(NodeConnection(main_node_mapping, node_inputs))
 
 
 def tensorleap_custom_metric(name: str,
@@ -31,8 +92,8 @@ def tensorleap_custom_metric(name: str,
                              compute_insights: Optional[Union[bool, Dict[str, bool]]] = None,
                              connects_to=None):
     def decorating_function(user_function: Union[CustomCallableInterfaceMultiArgs,
-    CustomMultipleReturnCallableInterfaceMultiArgs,
-    ConfusionMatrixCallableInterfaceMultiArgs]):
+            CustomMultipleReturnCallableInterfaceMultiArgs,
+            ConfusionMatrixCallableInterfaceMultiArgs]):
         for metric_handler in leap_binder.setup_container.metrics:
             if metric_handler.metric_handler_data.name == name:
                 raise Exception(f'Metric with name {name} already exists. '
@@ -119,14 +180,31 @@ def tensorleap_custom_metric(name: str,
                         (f'tensorleap_custom_metric validation failed: '
                          f'compute_insights should be boolean. Got {type(compute_insights)}.')
 
-
         def inner(*args, **kwargs):
             _validate_input_args(*args, **kwargs)
             result = user_function(*args, **kwargs)
             _validate_result(result)
             return result
 
-        return inner
+        def mapping_inner(*args, **kwargs):
+            user_unique_name = mapping_inner.name
+            if 'user_unique_name' in kwargs:
+                user_unique_name = kwargs['user_unique_name']
+
+            ordered_connections = [kwargs[n] for n in mapping_inner.arg_names if n in kwargs]
+            ordered_connections = list(args) + ordered_connections
+            _add_mapping_connection(user_unique_name, ordered_connections, mapping_inner.arg_names,
+                                    mapping_inner.name,  NodeMappingType.Metric)
+
+            return None
+
+        mapping_inner.arg_names = leap_binder.setup_container.metrics[-1].metric_handler_data.arg_names
+        mapping_inner.name = name
+
+        if os.environ[mapping_runtime_mode_env_var_mame]:
+            return mapping_inner
+        else:
+            return inner
 
     return decorating_function
 
@@ -186,7 +264,25 @@ def tensorleap_custom_visualizer(name: str, visualizer_type: LeapDataType,
             _validate_result(result)
             return result
 
-        return inner
+        def mapping_inner(*args, **kwargs):
+            user_unique_name = mapping_inner.name
+            if 'user_unique_name' in kwargs:
+                user_unique_name = kwargs['user_unique_name']
+
+            ordered_connections = [kwargs[n] for n in mapping_inner.arg_names if n in kwargs]
+            ordered_connections = list(args) + ordered_connections
+            _add_mapping_connection(user_unique_name, ordered_connections, mapping_inner.arg_names,
+                                    mapping_inner.name, NodeMappingType.Visualizer)
+
+            return None
+
+        mapping_inner.arg_names = leap_binder.setup_container.visualizers[-1].visualizer_handler_data.arg_names
+        mapping_inner.name = name
+
+        if os.environ[mapping_runtime_mode_env_var_mame]:
+            return mapping_inner
+        else:
+            return inner
 
     return decorating_function
 
@@ -340,7 +436,21 @@ def tensorleap_input_encoder(name: str, channel_dim=-1, model_input_index=None):
             node_mapping_type = NodeMappingType(f'Input{str(model_input_index)}')
         inner.node_mapping = NodeMapping(name, node_mapping_type)
 
-        return inner
+
+        def mapping_inner(*args, **kwargs):
+            class TempMapping:
+                pass
+            ret = TempMapping()
+            ret.node_mapping = mapping_inner.node_mapping
+
+            return ret
+
+        mapping_inner.node_mapping = NodeMapping(name, node_mapping_type)
+
+        if os.environ[mapping_runtime_mode_env_var_mame]:
+            return mapping_inner
+        else:
+            return inner
 
     return decorating_function
 
@@ -382,9 +492,20 @@ def tensorleap_gt_encoder(name: str):
 
         inner.node_mapping = NodeMapping(name, NodeMappingType.GroundTruth)
 
-        return inner
+        def mapping_inner(*args, **kwargs):
+            class TempMapping:
+                pass
+            ret = TempMapping()
+            ret.node_mapping = mapping_inner.node_mapping
+
+            return ret
 
+        mapping_inner.node_mapping = NodeMapping(name, NodeMappingType.GroundTruth)
 
+        if os.environ[mapping_runtime_mode_env_var_mame]:
+            return mapping_inner
+        else:
+            return inner
 
     return decorating_function
 
@@ -440,7 +561,25 @@ def tensorleap_custom_loss(name: str, connects_to=None):
             _validate_result(result)
             return result
 
-        return inner
+        def mapping_inner(*args, **kwargs):
+            user_unique_name = mapping_inner.name
+            if 'user_unique_name' in kwargs:
+                user_unique_name = kwargs['user_unique_name']
+
+            ordered_connections = [kwargs[n] for n in mapping_inner.arg_names if n in kwargs]
+            ordered_connections = list(args) + ordered_connections
+            _add_mapping_connection(user_unique_name, ordered_connections, mapping_inner.arg_names,
+                                    mapping_inner.name, NodeMappingType.CustomLoss)
+
+            return None
+
+        mapping_inner.arg_names = leap_binder.setup_container.custom_loss_handlers[-1].custom_loss_handler_data.arg_names
+        mapping_inner.name = name
+
+        if os.environ[mapping_runtime_mode_env_var_mame]:
+            return mapping_inner
+        else:
+            return inner
 
     return decorating_function
 

{code_loader-1.0.96 → code_loader-1.0.99.dev1}/code_loader/leaploader.py

@@ -2,6 +2,7 @@
 import importlib.util
 import inspect
 import io
+import os
 import sys
 from contextlib import redirect_stdout
 from functools import lru_cache
@@ -22,6 +23,7 @@ from code_loader.contract.responsedataclasses import DatasetIntegParseResult, Da
     VisualizerInstance, PredictionTypeInstance, ModelSetup, CustomLayerInstance, MetricInstance, CustomLossInstance, \
     EngineFileContract
 from code_loader.inner_leap_binder import global_leap_binder
+from code_loader.inner_leap_binder.leapbinder import mapping_runtime_mode_env_var_mame
 from code_loader.leaploaderbase import LeapLoaderBase
 from code_loader.utils import get_root_exception_file_and_line_number
 
@@ -157,7 +159,23 @@ class LeapLoader(LeapLoaderBase):
         stdout_steam = io.StringIO()
         with redirect_stdout(stdout_steam):
             try:
+                # generate mapping
+                os.environ[mapping_runtime_mode_env_var_mame] = 'TRUE'
                 self.exec_script()
+                mapping_connections = global_leap_binder.mapping_connections
+                del os.environ[mapping_runtime_mode_env_var_mame]
+
+                # init global leap binder
+                global_leap_binder.__init__()
+                self.exec_script.cache_clear()
+
+                # run parse without mapping
+                self.exec_script()
+
+                # set mapping connections
+                if not global_leap_binder.mapping_connections:
+                    global_leap_binder.mapping_connections = mapping_connections
+
                 preprocess_test_payload = self._check_preprocess()
                 test_payloads.append(preprocess_test_payload)
                 handlers_test_payloads = self._check_handlers()
@@ -173,6 +191,8 @@ class LeapLoader(LeapLoaderBase):
                 general_error = f"Something went wrong. {repr(e.__cause__)} in file {file_name}, line_number:  {line_number}\nStacktrace:\n{stacktrace}"
                 is_valid = False
 
+
+
         print_log = stdout_steam.getvalue()
         is_valid_for_model = bool(global_leap_binder.setup_container.custom_layers)
         model_setup = self.get_model_setup_response()

{code_loader-1.0.96 → code_loader-1.0.99.dev1}/pyproject.toml

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