code-loader 1.0.40a1__tar.gz → 1.0.41__tar.gz

{code_loader-1.0.40a1 → code_loader-1.0.41}/PKG-INFO

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

{code_loader-1.0.40a1 → code_loader-1.0.41}/code_loader/contract/datasetclasses.py

@@ -4,9 +4,9 @@ from typing import Any, Callable, List, Optional, Dict, Union, Type
 import numpy as np
 import numpy.typing as npt
 
-from code_loader.contract.enums import DataStateType, DataStateEnum, LeapDataType, ConfusionMatrixValue, MetricDirection, InstanceAnalysisType
+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
+    LeapTextMask, LeapImageMask, LeapImageWithBBox, LeapImageWithHeatmap
 
 custom_latent_space_attribute = "custom_latent_space"
 
@@ -17,16 +17,8 @@ class PreprocessResponse:
     data: Any
 
 
-@dataclass
-class ElementInstance:
-    name: str
-    mask: npt.NDArray[np.float32]
-
-
 SectionCallableInterface = Callable[[int, PreprocessResponse], npt.NDArray[np.float32]]
 
-InstanceCallableInterface = Callable[[int, PreprocessResponse], List[ElementInstance]]
-
 MetadataSectionCallableInterface = Union[
     Callable[[int, PreprocessResponse], int],
     Callable[[int, PreprocessResponse], Dict[str, int]],
@@ -58,11 +50,12 @@ VisualizerCallableInterface = Union[
     Callable[..., LeapHorizontalBar],
     Callable[..., LeapImageMask],
     Callable[..., LeapTextMask],
-    Callable[..., LeapImageWithBBox]
+    Callable[..., LeapImageWithBBox],
+    Callable[..., LeapImageWithHeatmap]
 ]
 
 VisualizerCallableReturnType = Union[LeapImage, LeapText, LeapGraph, LeapHorizontalBar,
-LeapImageMask, LeapTextMask, LeapImageWithBBox]
+LeapImageMask, LeapTextMask, LeapImageWithBBox, LeapImageWithHeatmap]
 
 CustomCallableInterface = Callable[..., Any]
 
@@ -97,7 +90,6 @@ class MetricHandler:
     arg_names: List[str]
     direction: Optional[MetricDirection] = MetricDirection.Downward
 
-
 @dataclass
 class RawInputsForHeatmap:
     raw_input_by_vizualizer_arg_name: Dict[str, npt.NDArray[np.float32]]
@@ -123,14 +115,6 @@ class InputHandler(DatasetBaseHandler):
     shape: Optional[List[int]] = None
 
 
-@dataclass
-class ElementInstanceHandler:
-    input_name: str
-    instance_function: InstanceCallableInterface
-    analysis_type: InstanceAnalysisType
-
-
-
 @dataclass
 class GroundTruthHandler(DatasetBaseHandler):
     shape: Optional[List[int]] = None
@@ -164,7 +148,6 @@ class DatasetIntegrationSetup:
     unlabeled_data_preprocess: Optional[UnlabeledDataPreprocessHandler] = None
     visualizers: List[VisualizerHandler] = field(default_factory=list)
     inputs: List[InputHandler] = field(default_factory=list)
-    element_instances: List[ElementInstanceHandler] = field(default_factory=list)
     ground_truths: List[GroundTruthHandler] = field(default_factory=list)
     metadata: List[MetadataHandler] = field(default_factory=list)
     prediction_types: List[PredictionTypeHandler] = field(default_factory=list)

{code_loader-1.0.40a1 → code_loader-1.0.41}/code_loader/contract/enums.py

@@ -26,6 +26,7 @@ class LeapDataType(Enum):
     ImageMask = 'ImageMask'
     TextMask = 'TextMask'
     ImageWithBBox = 'ImageWithBBox'
+    ImageWithHeatmap = 'ImageWithHeatmap'
 
 
 class MetricDirection(Enum):
@@ -63,9 +64,3 @@ class ConfusionMatrixValue(Enum):
 class TestingSectionEnum(Enum):
     Warnings = "Warnings"
     Errors = "Errors"
-
-
-
-class InstanceAnalysisType(Enum):
-    MaskInput = "MaskInput"
-    MaskLatentSpace = "MaskLatentSpace"

{code_loader-1.0.40a1 → code_loader-1.0.41}/code_loader/contract/responsedataclasses.py

@@ -1,4 +1,4 @@
-from typing import List, Optional, Dict, Any
+from typing import List, Optional, Dict, Any, Union
 
 from dataclasses import dataclass, field
 from code_loader.contract.enums import DatasetMetadataType, LeapDataType
@@ -104,6 +104,7 @@ class BoundingBox:
     confidence: float
     label: str
     rotation: float = 0.0  # value between [0, 360], represent the degree of rotation.
+    metadata: Optional[Dict[str, Union[str, int, float]]] = None
 
 
 @dataclass

{code_loader-1.0.40a1 → code_loader-1.0.41}/code_loader/contract/visualizer_classes.py

@@ -135,6 +135,27 @@ class LeapTextMask:
             validate_type(type(label), str)
 
 
+@dataclass
+class LeapImageWithHeatmap:
+    image: npt.NDArray[np.float32]
+    heatmaps: npt.NDArray[np.float32]
+    labels: List[str]
+    type: LeapDataType = LeapDataType.ImageWithHeatmap
+
+    def __post_init__(self) -> None:
+        validate_type(self.type, LeapDataType.ImageWithHeatmap)
+        validate_type(type(self.heatmaps), np.ndarray)
+        validate_type(self.heatmaps.dtype, np.float32)
+        validate_type(type(self.image), np.ndarray)
+        validate_type(self.image.dtype, np.float32)
+        validate_type(type(self.labels), list)
+        for label in self.labels:
+            validate_type(type(label), str)
+        if self.heatmaps.shape[0] != len(self.labels):
+            raise LeapValidationError(
+                'Number of heatmaps and labels must be equal')
+
+
 map_leap_data_type_to_visualizer_class = {
     LeapDataType.Image.value: LeapImage,
     LeapDataType.Graph.value: LeapGraph,
@@ -142,5 +163,6 @@ map_leap_data_type_to_visualizer_class = {
     LeapDataType.HorizontalBar.value: LeapHorizontalBar,
     LeapDataType.ImageMask.value: LeapImageMask,
     LeapDataType.TextMask.value: LeapTextMask,
-    LeapDataType.ImageWithBBox.value: LeapImageWithBBox
+    LeapDataType.ImageWithBBox.value: LeapImageWithBBox,
+    LeapDataType.ImageWithHeatmap.value: LeapImageWithHeatmap
 }

{code_loader-1.0.40a1 → code_loader-1.0.41}/code_loader/inner_leap_binder/leapbinder.py

@@ -9,9 +9,8 @@ from code_loader.contract.datasetclasses import SectionCallableInterface, InputH
     PreprocessHandler, VisualizerCallableInterface, CustomLossHandler, CustomCallableInterface, PredictionTypeHandler, \
     MetadataSectionCallableInterface, UnlabeledDataPreprocessHandler, CustomLayerHandler, MetricHandler, \
     CustomCallableInterfaceMultiArgs, ConfusionMatrixCallableInterfaceMultiArgs, VisualizerCallableReturnType, \
-    CustomMultipleReturnCallableInterfaceMultiArgs, DatasetBaseHandler, custom_latent_space_attribute, \
-    RawInputsForHeatmap, InstanceCallableInterface, ElementInstanceHandler
-from code_loader.contract.enums import LeapDataType, DataStateEnum, DataStateType, MetricDirection, InstanceAnalysisType
+    CustomMultipleReturnCallableInterfaceMultiArgs, DatasetBaseHandler, custom_latent_space_attribute, RawInputsForHeatmap
+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.utils import to_numpy_return_wrapper, get_shape
@@ -102,10 +101,6 @@ class LeapBinder:
 
         self._encoder_names.append(name)
 
-    def set_instance_element(self, input_name: str, instance_function: Optional[InstanceCallableInterface] = None,
-                             analysis_type: InstanceAnalysisType = InstanceAnalysisType.MaskInput) -> None:
-        self.setup_container.element_instances.append(ElementInstanceHandler(input_name, instance_function, analysis_type))
-
     def add_custom_loss(self, function: CustomCallableInterface, name: str) -> None:
         arg_names = inspect.getfullargspec(function)[0]
         self.setup_container.custom_loss_handlers.append(CustomLossHandler(name, function, arg_names))
@@ -137,8 +132,7 @@ class LeapBinder:
             custom_layer.kernel_index = kernel_index
 
         if use_custom_latent_space and not hasattr(custom_layer, custom_latent_space_attribute):
-            raise Exception(
-                f"{custom_latent_space_attribute} function has not been set for custom layer: {custom_layer.__name__}")
+            raise Exception(f"{custom_latent_space_attribute} function has not been set for custom layer: {custom_layer.__name__}")
 
         init_args = inspect.getfullargspec(custom_layer.__init__)[0][1:]
         call_args = inspect.getfullargspec(custom_layer.call)[0][1:]

{code_loader-1.0.40a1 → code_loader-1.0.41}/code_loader/leaploader.py

@@ -5,14 +5,14 @@ import sys
 from contextlib import redirect_stdout
 from functools import lru_cache
 from pathlib import Path
-from typing import Dict, List, Iterable, Union, Any, Optional
+from typing import Dict, List, Iterable, Union, Any
 
 import numpy as np
 import numpy.typing as npt
 
 from code_loader.contract.datasetclasses import DatasetSample, DatasetBaseHandler, GroundTruthHandler, \
     PreprocessResponse, VisualizerHandler, VisualizerCallableReturnType, CustomLossHandler, \
-    PredictionTypeHandler, MetadataHandler, CustomLayerHandler, MetricHandler, ElementInstance
+    PredictionTypeHandler, MetadataHandler, CustomLayerHandler, MetricHandler
 from code_loader.contract.enums import DataStateEnum, TestingSectionEnum, DataStateType, DatasetMetadataType
 from code_loader.contract.exceptions import DatasetScriptException
 from code_loader.contract.responsedataclasses import DatasetIntegParseResult, DatasetTestResultPayload, \
@@ -30,6 +30,7 @@ class LeapLoader:
     @lru_cache()
     def exec_script(self) -> None:
         try:
+            print("executing script")
             self.evaluate_module()
         except TypeError as e:
             import traceback
@@ -41,25 +42,34 @@ class LeapLoader:
             raise DatasetScriptException(getattr(e, 'message', repr(e))) from e
 
     def evaluate_module(self) -> None:
+        print("evaluate_module")
+
         def append_path_recursively(full_path: str) -> None:
             if '/' not in full_path or full_path == '/':
                 return
 
             parent_path = str(Path(full_path).parent)
+            print(f"evaluate_module.append_path_recursively full_path: {full_path}, parent_path: {parent_path}")
             append_path_recursively(parent_path)
+
             sys.path.append(parent_path)
 
         file_path = Path(self.code_path, self.code_entry_name)
+        print(f"evaluate_module: self.code_path: {self.code_path} self.code_entry_name: {self.code_entry_name}, "
+              f"file_path for append_path_recursively: {str(file_path)}")
         append_path_recursively(str(file_path))
 
         spec = importlib.util.spec_from_file_location(self.code_path, file_path)
+        print(f"evaluate_module: spec: {str(spec)}")
         if spec is None or spec.loader is None:
             raise DatasetScriptException(f'Something is went wrong with spec file from: {file_path}')
 
         file = importlib.util.module_from_spec(spec)
+        print(f"evaluate_module: file module_from_spec: {str(file)}")
         if file is None:
             raise DatasetScriptException(f'Something is went wrong with import module from: {file_path}')
 
+        print(f"evaluate_module: spec.loader.exec_module")
         spec.loader.exec_module(file)
 
     @lru_cache()
@@ -171,7 +181,8 @@ class LeapLoader:
                         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[state_name] = f"{repr(e)} in file {file_name}, line_number:  {line_number}\nStacktrace:\n{stacktrace}"
+                    test_result[0].display[
+                        state_name] = f"{repr(e)} in file {file_name}, line_number:  {line_number}\nStacktrace:\n{stacktrace}"
                     test_result[0].is_passed = False
 
             result_payloads.extend(test_result)
@@ -298,17 +309,6 @@ class LeapLoader:
     def _get_inputs(self, state: DataStateEnum, idx: int) -> Dict[str, npt.NDArray[np.float32]]:
         return self._get_dataset_handlers(global_leap_binder.setup_container.inputs, state, idx)
 
-    def get_instance_elements(self, state: DataStateEnum, idx: int, input_name: str) \
-            -> Tuple[Optional[List[ElementInstance]], Optional[InstanceAnalysisType]]:
-        preprocess_result = self._preprocess_result()
-        preprocess_state = preprocess_result[state]
-        for element_instance in global_leap_binder.setup_container.element_instances:
-            if element_instance.input_name == input_name:
-                return element_instance.instance_function(idx, preprocess_state), element_instance.analysis_type
-
-        return None, None
-
-
     def _get_gt(self, state: DataStateEnum, idx: int) -> Dict[str, npt.NDArray[np.float32]]:
         return self._get_dataset_handlers(global_leap_binder.setup_container.ground_truths, state, idx)
 
@@ -354,7 +354,8 @@ class LeapLoader:
             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] = 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] = self._convert_metadata_to_correct_type(handler_name, handler_result)

{code_loader-1.0.40a1 → code_loader-1.0.41}/code_loader/visualizers/default_visualizers.py

@@ -1,4 +1,5 @@
 from enum import Enum
+from typing import List
 
 import numpy as np
 import numpy.typing as npt
@@ -16,7 +17,7 @@ class DefaultVisualizer(Enum):
     ImageMask = 'ImageMask'
     TextMask = 'TextMask'
     RawData = 'RawData'
-
+    
 
 def default_image_visualizer(data: npt.NDArray[np.float32]) -> LeapImage:
     rescaled_data = rescale_min_max(data)

{code_loader-1.0.40a1 → code_loader-1.0.41}/pyproject.toml

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