code-loader 1.0.151a2__tar.gz → 1.0.151.dev2__tar.gz

{code_loader-1.0.151a2 → code_loader-1.0.151.dev2}/PKG-INFO

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

{code_loader-1.0.151a2 → code_loader-1.0.151.dev2}/code_loader/contract/datasetclasses.py

@@ -218,7 +218,6 @@ class MetadataHandler:
     name: str
     function: MetadataSectionCallableInterface
     metadata_type: Optional[Union[DatasetMetadataType, Dict[str, DatasetMetadataType]]] = None
-    use_for_semantic_ls: Optional[bool] = None
 
 
 @dataclass

{code_loader-1.0.151a2 → code_loader-1.0.151.dev2}/code_loader/inner_leap_binder/leapbinder.py

@@ -24,6 +24,7 @@ from code_loader.visualizers.default_visualizers import DefaultVisualizer, \
     default_image_visualizer, default_horizontal_bar_visualizer, default_word_visualizer, \
     default_image_mask_visualizer, default_text_mask_visualizer, default_raw_data_visualizer, default_video_visualizer
 
+
 mapping_runtime_mode_env_var_mame = '__MAPPING_RUNTIME_MODE__'
 
 
@@ -238,6 +239,7 @@ class LeapBinder:
 
         self._encoder_names.append(name)
 
+
     def set_instance_masks(self, function: InstanceCallableInterface, name: str) -> None:
         """
         Set the instance mask handler function.
@@ -252,6 +254,7 @@ class LeapBinder:
         function = to_numpy_return_masks_wrapper(function)
         self.setup_container.instance_masks.append(ElementInstanceMasksHandler(name, function))
 
+
     def add_custom_loss(self, function: CustomCallableInterface, name: str) -> None:
         """
         Add a custom loss function to the setup.
@@ -265,7 +268,7 @@ class LeapBinder:
                 - A numeric value representing the loss.
         name (str): The name of the custom loss function.
 
-        Example:
+        Example:get_metadata
             def custom_loss_function(y_true, y_pred):
                 # Calculate mean squared error as custom loss
                 return np.mean(np.square(y_true - y_pred))
@@ -328,8 +331,7 @@ class LeapBinder:
         metric_handler_data = MetricHandlerData(name, regular_arg_names, direction, compute_insights)
         self.setup_container.metrics.append(MetricHandler(metric_handler_data, function))
 
-    def add_prediction(self, name: str, labels: List[str], channel_dim: int = -1,
-                       prediction_index: Optional[int] = None) -> None:
+    def add_prediction(self, name: str, labels: List[str], channel_dim: int = -1, prediction_index: Optional[int]=None) -> None:
         """
         Add prediction labels to the setup.
 
@@ -346,8 +348,7 @@ class LeapBinder:
         self.setup_container.prediction_types.append(PredictionTypeHandler(name, labels, channel_dim))
         if prediction_index is not None:
             node_connection = NodeConnection(NodeMapping(name, NodeMappingType.PredictionLabels),
-                                             {'temp': NodeMapping('',
-                                                                  NodeMappingType(f'Prediction{prediction_index}'))})
+                                             {'temp': NodeMapping('', NodeMappingType(f'Prediction{prediction_index}'))})
 
             self.mapping_connections.append(node_connection)
 
@@ -383,8 +384,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,
-                     use_for_semantic_ls: Optional[bool] = 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.
 
@@ -419,7 +419,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, use_for_semantic_ls))
+        self.setup_container.metadata.append(MetadataHandler(name, function, metadata_type))
 
     def set_custom_latent_space(self, function: SectionCallableInterface) -> None:
         """
@@ -534,8 +534,7 @@ 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
@@ -555,8 +554,7 @@ class LeapBinder:
 
                     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}':
+                        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
 
@@ -564,8 +562,7 @@ class LeapBinder:
                             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")
+                                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 metadata type is not a dict")
@@ -582,11 +579,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.151a2 → code_loader-1.0.151.dev2}/code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -799,17 +799,13 @@ def tensorleap_custom_visualizer(name: str, visualizer_type: LeapDataType,
 
 
 def tensorleap_metadata(
-        name: str, metadata_type: Optional[Union[DatasetMetadataType, Dict[str, DatasetMetadataType]]] = None,
-        use_for_semantic_ls: Optional[bool] = None):
+        name: str, metadata_type: Optional[Union[DatasetMetadataType, Dict[str, DatasetMetadataType]]] = None):
     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')
 
-        if not type(use_for_semantic_ls) in (type(None), bool):
-            raise Exception(f'use_for_semantic_ls must be either None or a boolean')
-
         def _validate_input_args(sample_id: Union[int, str], preprocess_response: PreprocessResponse):
             assert type(sample_id) == preprocess_response.sample_id_type, \
                 (f'{user_function.__name__}() validation failed: '
@@ -845,7 +841,7 @@ def tensorleap_metadata(
 
             return result
 
-        leap_binder.set_metadata(inner_without_validate, name, metadata_type, use_for_semantic_ls)
+        leap_binder.set_metadata(inner_without_validate, name, metadata_type)
 
         def inner(*args, **kwargs):
             if os.environ.get(mapping_runtime_mode_env_var_mame):

{code_loader-1.0.151a2 → code_loader-1.0.151.dev2}/code_loader/leaploader.py

@@ -163,7 +163,7 @@ 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)
+        metadata, metadata_is_none = self.get_metadata(state, sample_id)
 
         custom_latent_space = None
         if global_leap_binder.setup_container.custom_latent_space is not None:
@@ -521,13 +521,24 @@ class LeapLoader(LeapLoaderBase):
 
         return converted_value, is_none
 
-    def _get_metadata(self, state: DataStateEnum, sample_id: Union[int, str]) -> Tuple[
+    def get_metadata(self, state: DataStateEnum, sample_id: Union[int, str], only_metadata_names: Optional[List[str]] = None) -> Tuple[
         Dict[str, Union[str, int, bool, float]], Dict[str, bool]]:
+
+        def is_metadata_name_starts_with_handler_name(_handler):
+            for metadata_name in only_metadata_names:
+                if metadata_name.startswith(_handler.name + '_') or metadata_name == _handler.name:
+                    return True
+            return False
+
         result_agg = {}
         is_none = {}
         preprocess_result = self._preprocess_result()
         preprocess_state = preprocess_result[state]
         for handler in global_leap_binder.setup_container.metadata:
+            if only_metadata_names:
+                if not is_metadata_name_starts_with_handler_name(handler):
+                    continue
+
             handler_result = handler.function(sample_id, preprocess_state)
             if isinstance(handler_result, dict):
                 for single_metadata_name, single_metadata_result in handler_result.items():

{code_loader-1.0.151a2 → code_loader-1.0.151.dev2}/code_loader/leaploaderbase.py

@@ -87,6 +87,13 @@ class LeapLoaderBase:
                         input_tensors_by_arg_name: Dict[str, npt.NDArray[np.float32]]):
         pass
 
+    @abstractmethod
+    def get_metadata(
+            self, state: DataStateEnum, sample_id: Union[int, str],
+            only_metadata_names: Optional[List[str]] = None
+    ) -> Tuple[Dict[str, Union[str, int, bool, float]], Dict[str, bool]]:
+        pass
+
     @abstractmethod
     def run_heatmap_visualizer(self, visualizer_name: str, sample_ids: np.array, state: DataStateEnum,
                                input_tensors_by_arg_name: Dict[str, npt.NDArray[np.float32]]

{code_loader-1.0.151a2 → code_loader-1.0.151.dev2}/pyproject.toml

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