code-loader 1.0.94__tar.gz → 1.0.94.dev1__tar.gz

{code_loader-1.0.94 → code_loader-1.0.94.dev1}/PKG-INFO

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

{code_loader-1.0.94 → code_loader-1.0.94.dev1}/code_loader/contract/datasetclasses.py

@@ -38,14 +38,17 @@ class PreprocessResponse:
     sample_ids: Optional[Union[List[str], List[int]]] = None
     state: Optional[DataStateType] = None
     sample_id_type: Optional[Union[Type[str], Type[int]]] = None
-    sample_ids_to_instance_mappings: Optional[Dict[Union[str, int], Union[List[str], List[int]]]] = None # in use only for element instance
-    instance_to_sample_ids_mappings: Optional[Dict[Union[str, int], Union[str, int]]] = None # in use only for element instance
+    sample_ids_to_instance_mappings: Optional[Dict[str, List[str]]] = None # in use only for element instance
+    instance_to_sample_ids_mappings: Optional[Dict[str, str]] = None # in use only for element instance
 
 
     def __post_init__(self) -> None:
         def is_valid_string(s: str) -> bool:
             return bool(re.match(r'^[A-Za-z0-9_]+$', s))
 
+        assert self.sample_ids_to_instance_mappings is None, f"Keep sample_ids_to_instance_mappings None when initializing PreprocessResponse"
+        assert self.instance_to_sample_ids_mappings is None, f"Keep instance_to_sample_ids_mappings None when initializing PreprocessResponse"
+
         if self.length is not None and self.sample_ids is None:
             self.sample_ids = [i for i in range(self.length)]
             self.sample_id_type = int
@@ -72,10 +75,9 @@ class PreprocessResponse:
 class ElementInstance:
     name: str
     mask: npt.NDArray[np.float32]
-    # instance_filling_type: InstanceFillingType # TODO: implement InstanceFillingType
 
 SectionCallableInterface = Callable[[Union[int, str], PreprocessResponse], npt.NDArray[np.float32]]
-InstanceCallableInterface = Callable[[int, PreprocessResponse], List[ElementInstance]]
+InstanceCallableInterface = Callable[[Union[int, str], PreprocessResponse], List[ElementInstance]]
 
 MetadataSectionCallableInterface = Union[
     Callable[[Union[int, str], PreprocessResponse], int],

{code_loader-1.0.94 → code_loader-1.0.94.dev1}/code_loader/inner_leap_binder/leapbinder.py

@@ -238,22 +238,14 @@ class LeapBinder:
 
     def set_instance_masks(self, function: InstanceCallableInterface, name: str) -> None:
         """
-        Set the input handler function.
+        Set the instance mask handler function.
 
         Args:
         function (SectionCallableInterface): The input handler function.
-        name (str): The name of the input section.
-        channel_dim (int): The dimension of the channels axis
+        name (str): The name of the instance mask section.
 
         Example:
-            def input_encoder(subset: PreprocessResponse, index: int) -> np.ndarray:
-                # Return the processed input data for the given index and given subset response
-                img_path = subset.`data["images"][idx]
-                img = read_img(img_path)
-                img = normalize(img)
-                return img
-
-            leap_binder.set_input(input_encoder, name='input_encoder', channel_dim=-1)
+            leap_binder.set_input(input_encoder, name='input_encoder')
         """
         function = to_numpy_return_masks_wrapper(function)
         self.setup_container.instance_masks.append(ElementInstanceMasksHandler(name, function))

{code_loader-1.0.94 → code_loader-1.0.94.dev1}/code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -291,27 +291,26 @@ def tensorleap_element_instance_preprocess(instance_mask_encoder: Callable[[int,
                 preprocess_response.sample_ids = all_sample_ids
             return result
 
-
-        def metadata_is_instance(idx: str, preprocess: PreprocessResponse) -> str:
-            return "0"
+        def metadata_is_instance(idx: str, preprocess: PreprocessResponse) -> Dict[str, str]:
+            return {'is_instance': '0', 'orig_sample_id': preprocess.instance_to_sample_ids_mappings[idx]}
         leap_binder.set_preprocess(user_function_instance)
         leap_binder.set_metadata(metadata_is_instance, "metadata_is_instance")
 
         def _validate_input_args(*args, **kwargs):
             assert len(args) == 0 and len(kwargs) == 0, \
-                (f'tensorleap_preprocess validation failed: '
+                (f'tensorleap_element_instance_preprocess validation failed: '
                  f'The function should not take any arguments. Got {args} and {kwargs}.')
 
         def _validate_result(result):
             assert isinstance(result, list), \
-                (f'tensorleap_preprocess validation failed: '
+                (f'tensorleap_element_instance_preprocess validation failed: '
                  f'The return type should be a list. Got {type(result)}.')
             for i, response in enumerate(result):
                 assert isinstance(response, PreprocessResponse), \
-                    (f'tensorleap_preprocess validation failed: '
+                    (f'tensorleap_element_instance_preprocess validation failed: '
                      f'Element #{i} in the return list should be a PreprocessResponse. Got {type(response)}.')
             assert len(set(result)) == len(result), \
-                (f'tensorleap_preprocess validation failed: '
+                (f'tensorleap_element_instance_preprocess validation failed: '
                  f'The return list should not contain duplicate PreprocessResponse objects.')
 
         def inner(*args, **kwargs):
@@ -354,21 +353,21 @@ def tensorleap_instances_masks_encoder(name: str):
     def decorating_function(user_function: InstanceCallableInterface):
         leap_binder.set_instance_masks(user_function, name)
 
-        def _validate_input_args(sample_id: Union[int, str], preprocess_response: PreprocessResponse):
-            assert isinstance(sample_id, (int, str)), \
-                (f'tensorleap_input_encoder validation failed: '
-                 f'Argument sample_id should be either int or str. Got {type(sample_id)}.')
+        def _validate_input_args(sample_id: str, preprocess_response: PreprocessResponse):
+            assert isinstance(sample_id, str), \
+                (f'tensorleap_instances_masks_encoder validation failed: '
+                 f'Argument sample_id should be str. Got {type(sample_id)}.')
             assert isinstance(preprocess_response, PreprocessResponse), \
-                (f'tensorleap_input_encoder validation failed: '
+                (f'tensorleap_instances_masks_encoder validation failed: '
                  f'Argument preprocess_response should be a PreprocessResponse. Got {type(preprocess_response)}.')
             assert type(sample_id) == preprocess_response.sample_id_type, \
-                (f'tensorleap_input_encoder validation failed: '
+                (f'tensorleap_instances_masks_encoder validation failed: '
                  f'Argument sample_id should be as the same type as defined in the preprocess response '
                  f'{preprocess_response.sample_id_type}. Got {type(sample_id)}.')
 
         def _validate_result(result):
             assert isinstance(result, list), \
-                (f'tensorleap_input_encoder validation failed: '
+                (f'tensorleap_instances_masks_encoder validation failed: '
                  f'Unsupported return type. Should be a numpy array. Got {type(result)}.')
 
         def inner(sample_id, preprocess_response):

{code_loader-1.0.94 → code_loader-1.0.94.dev1}/code_loader/leaploader.py

@@ -164,7 +164,7 @@ class LeapLoader(LeapLoaderBase):
                                metadata_is_none=metadata_is_none,
                                index=sample_id,
                                state=state,
-                               instance_masks=self._get_masks(state, sample_id))
+                               instance_masks=self._get_instances_masks(state, sample_id))
         return sample
 
     def check_dataset(self) -> DatasetIntegParseResult:
@@ -454,7 +454,7 @@ class LeapLoader(LeapLoaderBase):
     def _get_inputs(self, state: DataStateEnum, sample_id: Union[int, str]) -> Dict[str, npt.NDArray[np.float32]]:
         return self._get_dataset_handlers(global_leap_binder.setup_container.inputs, state, sample_id)
 
-    def _get_masks(self, state: DataStateEnum, sample_id: Union[int, str]) -> Dict[str, List[ElementInstance]]:
+    def _get_instances_masks(self, state: DataStateEnum, sample_id: Union[int, str]) -> Dict[str, List[ElementInstance]]:
         preprocess_result = self._preprocess_result()
         preprocess_state = preprocess_result[state]
         result_agg = {}

{code_loader-1.0.94 → code_loader-1.0.94.dev1}/pyproject.toml

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