code-loader 1.0.94.dev11__py3-none-any.whl → 1.0.153.dev3__py3-none-any.whl

code_loader/__init__.py

@@ -2,3 +2,9 @@ from code_loader.leaploader import LeapLoader
 from code_loader.inner_leap_binder import global_leap_binder as leap_binder
 from code_loader.experiment_api.experiment import init_experiment
 from code_loader.experiment_api.client import Client
+
+try:
+    from code_loader.mixpanel_tracker import track_code_loader_loaded
+    track_code_loader_loaded({'event_type': 'module_import'})
+except Exception:
+    pass

code_loader/contract/datasetclasses.py

@@ -1,5 +1,6 @@
+import warnings
 from dataclasses import dataclass, field
-from typing import Any, Callable, List, Optional, Dict, Union, Type
+from typing import Any, Callable, List, Optional, Dict, Union, Type, Literal
 import re
 import numpy as np
 import numpy.typing as npt
@@ -41,11 +42,7 @@ class PreprocessResponse:
     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"
 
@@ -59,10 +56,20 @@ class PreprocessResponse:
             if self.sample_id_type == str:
                 for sample_id in self.sample_ids:
                     assert isinstance(sample_id, str), f"Sample id should be of type str. Got: {type(sample_id)}"
-                    if not is_valid_string(sample_id):
-                        raise Exception(f"Sample id should contain only letters (A-Z, a-z), numbers or '_'. Got: {sample_id}")
         else:
-            raise Exception("length is deprecated.")
+            raise Exception("length is deprecated, please use sample_ids instead.")
+
+        if self.state is None:
+            from code_loader.inner_leap_binder.leapbinder_decorators import store_warning_by_param
+            store_warning_by_param(
+                param_name="PreprocessResponse.state",
+                user_func_name="tensorleap_preprocess",
+                default_value=str("specific order"),
+                link_to_docs="https://docs.tensorleap.ai/tensorleap-integration/writing-integration-code/preprocess-function",
+            )
+
+        else:
+            assert isinstance(self.state, DataStateType), f"PreprocessResponse.state must be of type {DataStateType.__name__} but got {type(self.state)}"
 
     def __hash__(self) -> int:
         return id(self)
@@ -75,9 +82,13 @@ class PreprocessResponse:
 class ElementInstance:
     name: str
     mask: npt.NDArray[np.float32]
+    # instance_metadata: Dict[str, Union[Optional[str], int, bool, Optional[float]]]
+
 
 SectionCallableInterface = Callable[[Union[int, str], PreprocessResponse], npt.NDArray[np.float32]]
-InstanceCallableInterface = Callable[[Union[int, str], PreprocessResponse], List[ElementInstance]]
+InstanceCallableInterface = Callable[[Union[int, str], PreprocessResponse, int], Optional[ElementInstance]]
+InstanceLengthCallableInterface = Callable[[Union[int, str], PreprocessResponse], int]
+
 
 MetadataSectionCallableInterface = Union[
     Callable[[Union[int, str], PreprocessResponse], int],
@@ -216,11 +227,17 @@ 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
     labels: List[str]
-    channel_dim: int
+    channel_dim: Union[int, Literal["tl_default_value"]]= "tl_default_value"
+
 
 
 @dataclass
@@ -245,6 +262,7 @@ 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
@@ -255,5 +273,6 @@ class DatasetSample:
     metadata_is_none: Dict[str, bool]
     index: Union[int, str]
     state: DataStateEnum
-    instance_masks: Optional[Dict[str, List[ElementInstance]]] = None
+    custom_latent_space: Optional[npt.NDArray[np.float32]] = None
+    instance_masks: Optional[Dict[str, ElementInstance]] = None
 

code_loader/contract/mapping.py

@@ -21,12 +21,22 @@ class NodeMappingType(Enum):
     Prediction1 = 'Prediction1'
     Prediction2 = 'Prediction2'
     Prediction3 = 'Prediction3'
+    Prediction4 = 'Prediction4'
+    Prediction5 = 'Prediction5'
+    Prediction6 = 'Prediction6'
+    Prediction7 = 'Prediction7'
+    Prediction8 = 'Prediction8'
+    Prediction9 = 'Prediction9'
     Input0 = 'Input0'
     Input1 = 'Input1'
     Input2 = 'Input2'
     Input3 = 'Input3'
     Input4 = 'Input4'
     Input5 = 'Input5'
+    Input6 = 'Input6'
+    Input7 = 'Input7'
+    Input8 = 'Input8'
+    Input9 = 'Input9'
     PredictionLabels = 'PredictionLabels'
 
 
@@ -39,6 +49,7 @@ class NodeMapping:
     arg_names: Optional[List[str]] = None
 
 
+
 @dataclass
 class NodeConnection:
     node: NodeMapping

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
+    ElementInstanceMasksHandler, InstanceCallableInterface, CustomLatentSpaceHandler
 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
@@ -25,6 +25,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,
@@ -46,6 +49,7 @@ class LeapBinder:
         self._extend_with_default_losses()
 
         self.mapping_connections: List[NodeConnection] = []
+        self.integration_test_func: Optional[Callable[[str, PreprocessResponse], Any]] = None
 
         self.batch_size_to_validate: Optional[int] = None
 
@@ -417,6 +421,19 @@ 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:
         """
@@ -530,9 +547,10 @@ 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)):
+                    if not isinstance(single_metadata_result, (int, str, bool, float, np.unsignedinteger,
+                                                               np.signedinteger, np.bool_, np.floating, type(None))):
                         raise Exception(f"Unsupported return type of metadata {single_metadata_name}."
-                                        f"The return type should be one of [int, float, str, bool]. Got {type(single_metadata_result)}")
+                                        f"The return type should be one of [int, float, str, bool, None]. Got {type(single_metadata_result)}")
 
                     metadata_type = None
                     if single_metadata_result is None: