code-loader 1.0.118.dev3__tar.gz → 1.0.119.dev2__tar.gz

{code_loader-1.0.118.dev3 → code_loader-1.0.119.dev2}/PKG-INFO

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

{code_loader-1.0.118.dev3 → code_loader-1.0.119.dev2}/code_loader/contract/datasetclasses.py

@@ -212,11 +212,6 @@ class MetadataHandler:
     metadata_type: Optional[Union[DatasetMetadataType, Dict[str, DatasetMetadataType]]] = None
 
 
-@dataclass
-class CustomLatentSpaceHandler:
-    function: SectionCallableInterface
-    name: str = 'custom_latent_space'
-
 @dataclass
 class PredictionTypeHandler:
     name: str
@@ -246,7 +241,6 @@ class DatasetIntegrationSetup:
     custom_loss_handlers: List[CustomLossHandler] = field(default_factory=list)
     metrics: List[MetricHandler] = field(default_factory=list)
     custom_layers: Dict[str, CustomLayerHandler] = field(default_factory=dict)
-    custom_latent_space: Optional[CustomLatentSpaceHandler] = None
 
 
 @dataclass
@@ -258,5 +252,4 @@ class DatasetSample:
     index: Union[int, str]
     state: DataStateEnum
     instance_masks: Optional[Dict[str, List[ElementInstance]]] = None
-    custom_latent_space: Optional[npt.NDArray[np.float32]] = None
 

{code_loader-1.0.118.dev3 → code_loader-1.0.119.dev2}/code_loader/inner_leap_binder/leapbinder.py

@@ -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, \
-    ElementInstanceMasksHandler, InstanceCallableInterface, CustomLatentSpaceHandler
+    ElementInstanceMasksHandler, InstanceCallableInterface
 from code_loader.contract.enums import LeapDataType, DataStateEnum, DataStateType, MetricDirection, DatasetMetadataType
 from code_loader.contract.mapping import NodeConnection, NodeMapping, NodeMappingType
 from code_loader.contract.responsedataclasses import DatasetTestResultPayload
@@ -421,19 +421,6 @@ class LeapBinder:
         """
         self.setup_container.metadata.append(MetadataHandler(name, function, metadata_type))
 
-    def set_custom_latent_space(self, function: SectionCallableInterface) -> None:
-        """
-        Set a custom latent space function.
-
-        Args:
-        function (SectionCallableInterface): The metadata handler function.
-            This function receives:
-                subset (PreprocessResponse): The subset of the data.
-                index (int): The index of the sample within the subset.
-            This function should numpy float32 array contains the latent space vec of the sample.
-        """
-        self.setup_container.custom_latent_space = CustomLatentSpaceHandler(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:
         """

{code_loader-1.0.118.dev3 → code_loader-1.0.119.dev2}/code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -443,55 +443,6 @@ def tensorleap_metadata(
     return decorating_function
 
 
-
-def tensorleap_custom_latent_space():
-    def decorating_function(user_function: SectionCallableInterface):
-        def _validate_input_args(sample_id: Union[int, str], preprocess_response: PreprocessResponse):
-            assert isinstance(sample_id, (int, str)), \
-                (f'tensorleap_custom_latent_space validation failed: '
-                 f'Argument sample_id should be either int or str. Got {type(sample_id)}.')
-            assert isinstance(preprocess_response, PreprocessResponse), \
-                (f'tensorleap_custom_latent_space 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_custom_latent_space 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, np.ndarray), \
-                (f'tensorleap_custom_loss validation failed: '
-                 f'The return type should be a numpy array. Got {type(result)}.')
-
-        def inner_without_validate(sample_id, preprocess_response):
-            global _called_from_inside_tl_decorator
-            _called_from_inside_tl_decorator += 1
-
-            try:
-                result = user_function(sample_id, preprocess_response)
-            finally:
-                _called_from_inside_tl_decorator -= 1
-
-            return result
-
-        leap_binder.set_custom_latent_space(inner_without_validate)
-
-        def inner(sample_id, preprocess_response):
-            if os.environ.get(mapping_runtime_mode_env_var_mame):
-                return None
-
-            _validate_input_args(sample_id, preprocess_response)
-
-            result = inner_without_validate(sample_id, preprocess_response)
-
-            _validate_result(result)
-            return result
-
-        return inner
-
-    return decorating_function
-
-
 def tensorleap_preprocess():
     def decorating_function(user_function: Callable[[], List[PreprocessResponse]]):
         leap_binder.set_preprocess(user_function)
@@ -809,8 +760,14 @@ def tensorleap_custom_loss(name: str, connects_to=None):
                                 f'Please choose another')
 
         valid_types = (np.ndarray, SamplePreprocessResponse)
+        try:
+            import tensorflow as tf
+            valid_types = (np.ndarray, SamplePreprocessResponse, tf.Tensor)
+        except ImportError:
+            pass
 
         def _validate_input_args(*args, **kwargs):
+
             for i, arg in enumerate(args):
                 if isinstance(arg, list):
                     for y, elem in enumerate(arg):
@@ -829,11 +786,10 @@ def tensorleap_custom_loss(name: str, connects_to=None):
                                                           f'Argument #{_arg_name} should be a numpy array. Got {type(arg)}.')
 
         def _validate_result(result):
-            assert isinstance(result, np.ndarray), \
+            assert isinstance(result, valid_types), \
                 (f'tensorleap_custom_loss validation failed: '
                  f'The return type should be a numpy array. Got {type(result)}.')
 
-
         @functools.wraps(user_function)
         def inner_without_validate(*args, **kwargs):
             global _called_from_inside_tl_decorator

{code_loader-1.0.118.dev3 → code_loader-1.0.119.dev2}/code_loader/leaploader.py

@@ -16,7 +16,7 @@ from code_loader.contract.datasetclasses import DatasetSample, DatasetBaseHandle
     PreprocessResponse, VisualizerHandler, LeapData, \
     PredictionTypeHandler, MetadataHandler, CustomLayerHandler, MetricHandler, VisualizerHandlerData, MetricHandlerData, \
     MetricCallableReturnType, CustomLossHandlerData, CustomLossHandler, RawInputsForHeatmap, SamplePreprocessResponse, \
-    ElementInstance, custom_latent_space_attribute
+    ElementInstance
 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, \
@@ -34,7 +34,7 @@ class LeapLoader(LeapLoaderBase):
         super().__init__(code_path, code_entry_name)
 
         self._preprocess_result_cached = None
-
+        
         try:
             from code_loader.mixpanel_tracker import track_code_loader_loaded
             track_code_loader_loaded({
@@ -162,20 +162,12 @@ class LeapLoader(LeapLoaderBase):
             self._preprocess_result(update_unlabeled_preprocess=True)
 
         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:
-            custom_latent_space = global_leap_binder.setup_container.custom_latent_space.function(sample_id,
-                                                                                                  preprocess_result[
-                                                                                                      state])
-
         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,
                                index=sample_id,
-                               state=state,
-                               custom_latent_space=custom_latent_space)
+                               state=state)
         return sample
 
     def get_sample_with_masks(self, state: DataStateEnum, sample_id: Union[int, str]) -> DatasetSample:
@@ -218,6 +210,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()
@@ -482,8 +476,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_instances_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 = {}
@@ -533,8 +526,7 @@ class LeapLoader(LeapLoaderBase):
 
         return converted_value, is_none
 
-    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]) -> Tuple[Dict[str, Union[str, int, bool, float]], Dict[str, bool]]:
         result_agg = {}
         is_none = {}
         preprocess_result = self._preprocess_result()
@@ -563,11 +555,6 @@ class LeapLoader(LeapLoaderBase):
 
         return id_type
 
-    @lru_cache()
-    def has_custom_latent_space_decorator(self) -> bool:
-        self.exec_script()
-        return global_leap_binder.setup_container.custom_latent_space is not None
-
     def get_instances_data(self, state: DataStateEnum) -> Tuple[Dict[str, List[str]], Dict[str, str], Dict[str, str]]:
         """
         This Method get the data state and returns two dictionaries that holds the mapping of the sample ids to their

{code_loader-1.0.118.dev3 → code_loader-1.0.119.dev2}/code_loader/leaploaderbase.py

@@ -114,10 +114,6 @@ class LeapLoaderBase:
     def get_sample_id_type(self) -> Type:
         pass
 
-    @abstractmethod
-    def has_custom_latent_space_decorator(self) -> bool:
-        pass
-
     @abstractmethod
     def get_heatmap_visualizer_raw_vis_input_arg_name(self, visualizer_name: str) -> Optional[str]:
         pass

{code_loader-1.0.118.dev3 → code_loader-1.0.119.dev2}/code_loader/mixpanel_tracker.py

@@ -94,6 +94,10 @@ class MixpanelTracker:
         Args:
             event_properties: Optional additional properties to include in the event
         """
+
+        if os.environ.get('IS_TENSORLEAP_PLATFORM') == 'true':
+            return
+            
         try:
             distinct_id = self._get_distinct_id()
             
@@ -106,6 +110,8 @@ class MixpanelTracker:
                 '$device_id': device_id,  # Always use device_id for $device_id
                 'python_version': f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
                 'platform': os.name,
+                'code_loader_version': '1.0',
+                'is_tensorleap_platform': os.environ.get('IS_TENSORLEAP_PLATFORM'),
             }
             
             if tensorleap_user_id:

{code_loader-1.0.118.dev3 → code_loader-1.0.119.dev2}/pyproject.toml

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