code-loader 1.0.139.dev5__py3-none-any.whl → 1.0.153.dev3__py3-none-any.whl

code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -1,14 +1,18 @@
 # mypy: ignore-errors
 import os
 import warnings
+import logging
 from collections import defaultdict
 from functools import lru_cache
 from pathlib import Path
-from typing import Optional, Union, Callable, List, Dict, get_args, get_origin
+from typing import Optional, Union, Callable, List, Dict, Set, Any
+from typing import Optional, Union, Callable, List, Dict, get_args, get_origin, DefaultDict
 
 import numpy as np
 import numpy.typing as npt
 
+logger = logging.getLogger(__name__)
+
 from code_loader.contract.datasetclasses import CustomCallableInterfaceMultiArgs, \
     CustomMultipleReturnCallableInterfaceMultiArgs, ConfusionMatrixCallableInterfaceMultiArgs, CustomCallableInterface, \
     VisualizerCallableInterface, MetadataSectionCallableInterface, PreprocessResponse, SectionCallableInterface, \
@@ -20,15 +24,70 @@ from code_loader.contract.mapping import NodeMapping, NodeMappingType, NodeConne
 from code_loader.contract.visualizer_classes import LeapImage, LeapImageMask, LeapTextMask, LeapText, LeapGraph, \
     LeapHorizontalBar, LeapImageWithBBox, LeapImageWithHeatmap
 from code_loader.inner_leap_binder.leapbinder import mapping_runtime_mode_env_var_mame
+from code_loader.mixpanel_tracker import clear_integration_events, AnalyticsEvent, emit_integration_event_once
 
 import inspect
 import functools
+from pathlib import Path
 
 _called_from_inside_tl_decorator = 0
 _called_from_inside_tl_integration_test_decorator = False
-_update_env_status = None
+_call_from_tl_platform = os.environ.get('IS_TENSORLEAP_PLATFORM') == 'true'
+
+# ---- warnings store (module-level) ----
+_UNSET = object()
+_STORED_WARNINGS: List[Dict[str, Any]] = []
+_STORED_WARNING_KEYS: Set[tuple] = set()
+# param_name -> set(user_func_name)
+_PARAM_DEFAULT_FUNCS: DefaultDict[str, Set[str]] = defaultdict(set)
+# param_name -> default_value used (repr-able)
+_PARAM_DEFAULT_VALUE: Dict[str, Any] = {}
+_PARAM_DEFAULT_DOCS: Dict[str, str] = {}
+
+
+def get_entry_script_path() -> str:
+    import sys
+    argv0 = sys.argv[0] if sys.argv else ""
+    if argv0:
+        return str(Path(argv0).resolve())
+    import __main__
+    main_file = getattr(__main__, "__file__", "") or ""
+    return str(Path(main_file).resolve()) if main_file else ""
+
+def started_from(filename: str) -> bool:
+    entry = get_entry_script_path()
+    return bool(entry) and Path(entry).name == filename
 
 
+def store_warning_by_param(
+        *,
+        param_name: str,
+        user_func_name: str,
+        default_value: Any,
+        link_to_docs: str = None,
+) -> None:
+    _PARAM_DEFAULT_FUNCS[param_name].add(user_func_name)
+
+    if param_name not in _PARAM_DEFAULT_VALUE:
+        _PARAM_DEFAULT_VALUE[param_name] = default_value
+
+    if link_to_docs and param_name not in _PARAM_DEFAULT_DOCS:
+        _PARAM_DEFAULT_DOCS[param_name] = link_to_docs
+
+
+def _get_param_default_warnings() -> Dict[str, Dict[str, Any]]:
+    out: Dict[str, Dict[str, Any]] = {}
+    for p, funcs in _PARAM_DEFAULT_FUNCS.items():
+        out[p] = {
+            "default_value": _PARAM_DEFAULT_VALUE.get(p, None),
+            "funcs": set(funcs),
+            "link_to_docs": _PARAM_DEFAULT_DOCS.get(p),
+        }
+    return out
+
+
+def _get_stored_warnings() -> List[Dict[str, Any]]:
+    return list(_STORED_WARNINGS)
 
 
 def validate_args_structure(*args, types_order, func_name, expected_names, **kwargs):
@@ -89,7 +148,7 @@ def validate_args_structure(*args, types_order, func_name, expected_names, **kwa
             )
 
 
-def validate_output_structure(result, func_name: str, expected_type_name="np.ndarray",gt_flag=False):
+def validate_output_structure(result, func_name: str, expected_type_name="np.ndarray", gt_flag=False):
     if result is None or (isinstance(result, float) and np.isnan(result)):
         if gt_flag:
             raise AssertionError(
@@ -127,8 +186,9 @@ def validate_output_structure(result, func_name: str, expected_type_name="np.nda
             f"{expected_type_name} (e.g., by concatenation or stacking)."
         )
 
+
 def batch_warning(result, func_name):
-    if result.shape[0] == 1:
+    if len(result.shape) > 0 and result.shape[0] == 1:
         warnings.warn(
             f"{func_name} warning: Tensorleap will add a batch dimension at axis 0 to the output of {func_name}, "
             f"although the detected size of axis 0 is already 1. "
@@ -136,6 +196,8 @@ def batch_warning(result, func_name):
             f"Please ensure that the output of '{func_name}' is not already batched "
             f"to avoid computation errors."
         )
+
+
 def _add_mapping_connection(user_unique_name, connection_destinations, arg_names, name, node_mapping_type):
     connection_destinations = [connection_destination for connection_destination in connection_destinations
                                if not isinstance(connection_destination, SamplePreprocessResponse)]
@@ -159,7 +221,7 @@ def tensorleap_integration_test():
         leap_binder.integration_test_func = integration_test_function
 
         def _validate_input_args(*args, **kwargs):
-            sample_id,preprocess_response=args
+            sample_id, preprocess_response = args
             assert type(sample_id) == preprocess_response.sample_id_type, (
                 f"tensorleap_integration_test validation failed: "
                 f"sample_id type ({type(sample_id).__name__}) does not match the expected "
@@ -167,15 +229,23 @@ def tensorleap_integration_test():
             )
 
         def inner(*args, **kwargs):
+            if not _call_from_tl_platform:
+                set_current('tensorleap_integration_test')
             validate_args_structure(*args, types_order=[Union[int, str], PreprocessResponse],
-                                    func_name='integration_test',expected_names=["idx", "preprocess"],**kwargs)
+                                    func_name='integration_test', expected_names=["idx", "preprocess"], **kwargs)
             _validate_input_args(*args, **kwargs)
 
             global _called_from_inside_tl_integration_test_decorator
+            # Clear integration test events for new test
+            try:
+                clear_integration_events()
+            except Exception as e:
+                logger.debug(f"Failed to clear integration events: {e}")
             try:
                 _called_from_inside_tl_integration_test_decorator = True
-                if not _update_env_status is None:
-                    _update_env_status("tensorleap_integration_test", "v")#put here because otherwise it will become  v only if it finishes all the script
+                if not _call_from_tl_platform:
+                    update_env_params_func("tensorleap_integration_test",
+                                           "v")  # put here because otherwise it will become  v only if it finishes all the script
                 ret = integration_test_function(*args, **kwargs)
 
                 try:
@@ -187,12 +257,15 @@ def tensorleap_integration_test():
                     file_name = Path(first_tb.filename).name
                     line_number = first_tb.lineno
                     if isinstance(e, TypeError) and 'is not subscriptable' in str(e):
-                        print(f'Invalid integration code. File {file_name}, line {line_number}: '
-                              f"indexing is supported only on the model's predictions inside the integration test. Please remove this indexing operation usage from the integration test code.")
+                        update_env_params_func("code_mapping", "x")
+                        raise (f'Invalid integration code. File {file_name}, line {line_number}: '
+                               f"indexing is supported only on the model's predictions inside the integration test. Please remove this indexing operation usage from the integration test code.")
                     else:
-                        print(f'Invalid integration code. File {file_name}, line {line_number}: '
-                              f'Integration test is only allowed to call Tensorleap decorators. '
-                              f'Ensure any arithmetics, external library use, Python logic is placed within Tensorleap decoders')
+                        update_env_params_func("code_mapping", "x")
+
+                        raise (f'Invalid integration code. File {file_name}, line {line_number}: '
+                               f'Integration test is only allowed to call Tensorleap decorators. '
+                               f'Ensure any arithmetics, external library use, Python logic is placed within Tensorleap decoders')
                 finally:
                     if mapping_runtime_mode_env_var_mame in os.environ:
                         del os.environ[mapping_runtime_mode_env_var_mame]
@@ -200,31 +273,55 @@ def tensorleap_integration_test():
                 _called_from_inside_tl_integration_test_decorator = False
 
             leap_binder.check()
-        return inner
 
+        return inner
 
     return decorating_function
 
+
 def _safe_get_item(key):
     try:
         return NodeMappingType[f'Input{str(key)}']
     except ValueError:
         raise Exception(f'Tensorleap currently supports models with no more then 10 inputs')
 
-def tensorleap_load_model(prediction_types: Optional[List[PredictionTypeHandler]] = []):
-    assert isinstance(prediction_types, list),(
+
+def tensorleap_load_model(prediction_types: Optional[List[PredictionTypeHandler]] = _UNSET):
+    prediction_types_was_provided = prediction_types is not _UNSET
+
+    if not prediction_types_was_provided:
+        prediction_types = []
+        if not _call_from_tl_platform:
+            store_warning_by_param(
+                param_name="prediction_types",
+                user_func_name="tensorleap_load_model",
+                default_value=prediction_types,
+                link_to_docs="https://docs.tensorleap.ai/tensorleap-integration/integration-test#tensorleap_load_model"
+            )
+    assert isinstance(prediction_types, list), (
         f"tensorleap_load_model validation failed: "
-                f" prediction_types is an optional argument of type List[PredictionTypeHandler]] but got {type(prediction_types).__name__}."
+        f" prediction_types is an optional argument of type List[PredictionTypeHandler]] but got {type(prediction_types).__name__}."
     )
     for i, prediction_type in enumerate(prediction_types):
-        assert isinstance(prediction_type, PredictionTypeHandler),(f"tensorleap_load_model validation failed: "
-                f" prediction_types at position {i} must be of type PredictionTypeHandler but got {type(prediction_types[i]).__name__}.")
+        assert isinstance(prediction_type, PredictionTypeHandler), (f"tensorleap_load_model validation failed: "
+                                                                    f" prediction_types at position {i} must be of type PredictionTypeHandler but got {type(prediction_types[i]).__name__}.")
+        prediction_type_channel_dim_was_provided = prediction_type.channel_dim != "tl_default_value"
+        if not prediction_type_channel_dim_was_provided:
+            prediction_types[i].channel_dim = -1
+            if not _call_from_tl_platform:
+                store_warning_by_param(
+                    param_name=f"prediction_types[{i}].channel_dim",
+                    user_func_name="tensorleap_load_model",
+                    default_value=prediction_types[i].channel_dim,
+                    link_to_docs="https://docs.tensorleap.ai/tensorleap-integration/integration-test#tensorleap_load_model"
+                )
         leap_binder.add_prediction(prediction_type.name, prediction_type.labels, prediction_type.channel_dim, i)
 
     def _validate_result(result) -> None:
-        valid_types=["onnxruntime","keras"]
-        err_message=f"tensorleap_load_model validation failed:\nSupported models are Keras and onnxruntime only and non of them was returned."
-        validate_output_structure(result, func_name="tensorleap_load_model", expected_type_name= [" | ".join(t for t in valid_types)][0])
+        valid_types = ["onnxruntime", "keras"]
+        err_message = f"tensorleap_load_model validation failed:\nSupported models are Keras and onnxruntime only and non of them was returned."
+        validate_output_structure(result, func_name="tensorleap_load_model",
+                                  expected_type_name=[" | ".join(t for t in valid_types)][0])
         try:
             import keras
         except ImportError:
@@ -248,28 +345,41 @@ def tensorleap_load_model(prediction_types: Optional[List[PredictionTypeHandler]
         is_onnx_model = bool(onnxruntime and isinstance(result, onnxruntime.InferenceSession))
 
         if not any([is_keras_model, is_onnx_model]):
-            raise AssertionError( err_message)
-
-
+            raise AssertionError(err_message)
 
-    def decorating_function(load_model_func):
+    def decorating_function(load_model_func, prediction_types=prediction_types):
         class TempMapping:
             pass
 
         @lru_cache()
         def inner(*args, **kwargs):
+            if not _call_from_tl_platform:
+                set_current('tensorleap_load_model')
             validate_args_structure(*args, types_order=[],
-                                    func_name='tensorleap_load_model',expected_names=[],**kwargs)
+                                    func_name='tensorleap_load_model', expected_names=[], **kwargs)
+
             class ModelPlaceholder:
-                def __init__(self):
-                    self.model = load_model_func() #TODO- check why this fails on onnx model
+                def __init__(self, prediction_types):
+                    self.model = load_model_func()  # TODO- check why this fails on onnx model
+                    self.prediction_types = prediction_types
                     _validate_result(self.model)
 
                 # keras interface
                 def __call__(self, arg):
                     ret = self.model(arg)
+                    self.validate_declared_prediction_types(ret)
+                    if isinstance(ret, list):
+                        return [r.numpy() for r in ret]
                     return ret.numpy()
 
+                def validate_declared_prediction_types(self, ret):
+                    if not (len(self.prediction_types) == len(ret) if isinstance(ret, list) else 1) and len(
+                            self.prediction_types) != 0:
+                        if not _call_from_tl_platform:
+                            update_env_params_func("tensorleap_load_model", "x")
+                        raise Exception(
+                            f"tensorleap_load_model validation failed: number of declared prediction types({len(prediction_types)}) != number of model outputs({len(ret) if isinstance(ret, list) else 1})")
+
                 def _convert_onnx_inputs_to_correct_type(
                         self, float_arrays_inputs: Dict[str, np.ndarray]
                 ) -> Dict[str, np.ndarray]:
@@ -323,13 +433,16 @@ def tensorleap_load_model(prediction_types: Optional[List[PredictionTypeHandler]
                 # onnx runtime interface
                 def run(self, output_names, input_dict):
                     corrected_type_inputs = self._convert_onnx_inputs_to_correct_type(input_dict)
-                    return self.model.run(output_names, corrected_type_inputs)
+                    ret = self.model.run(output_names, corrected_type_inputs)
+                    self.validate_declared_prediction_types(ret)
+                    return ret
 
                 def get_inputs(self):
                     return self.model.get_inputs()
-            model_placeholder=ModelPlaceholder()
-            if not _update_env_status is None:
-                _update_env_status("tensorleap_load_model", "v")
+
+            model_placeholder = ModelPlaceholder(prediction_types)
+            if not _call_from_tl_platform:
+                update_env_params_func("tensorleap_load_model", "v")
             return model_placeholder
 
         def mapping_inner():
@@ -377,7 +490,7 @@ def tensorleap_load_model(prediction_types: Optional[List[PredictionTypeHandler]
                 def get_inputs(self):
                     class FollowIndex:
                         def __init__(self, index):
-                            self.name =  _safe_get_item(index)
+                            self.name = _safe_get_item(index)
 
                     class FollowInputIndex:
                         def __init__(self):
@@ -398,19 +511,35 @@ def tensorleap_load_model(prediction_types: Optional[List[PredictionTypeHandler]
                 return mapping_inner()
             else:
                 return inner(*args, **kwargs)
+
         return final_inner
 
     return decorating_function
 
 
 def tensorleap_custom_metric(name: str,
-                             direction: Union[MetricDirection, Dict[str, MetricDirection]] = MetricDirection.Downward,
+                             direction: Union[MetricDirection, Dict[str, MetricDirection]] = _UNSET,
                              compute_insights: Optional[Union[bool, Dict[str, bool]]] = None,
                              connects_to=None):
     name_to_unique_name = defaultdict(set)
+
     def decorating_function(
             user_function: Union[CustomCallableInterfaceMultiArgs, CustomMultipleReturnCallableInterfaceMultiArgs,
             ConfusionMatrixCallableInterfaceMultiArgs]):
+        nonlocal direction
+
+        direction_was_provided = direction is not _UNSET
+
+        if not direction_was_provided:
+            direction = MetricDirection.Downward
+            if not _call_from_tl_platform:
+                store_warning_by_param(
+                    param_name="direction",
+                    user_func_name=user_function.__name__,
+                    default_value=direction,
+                    link_to_docs="https://docs.tensorleap.ai/tensorleap-integration/writing-integration-code/custom-metrics"
+
+                )
 
         def _validate_decorators_signature():
             err_message = f"{user_function.__name__} validation failed.\n"
@@ -480,7 +609,6 @@ def tensorleap_custom_metric(name: str,
                             f"but found element types: {invalid_elems}."
                         )
 
-
         _validate_decorators_signature()
 
         for metric_handler in leap_binder.setup_container.metrics:
@@ -489,7 +617,7 @@ def tensorleap_custom_metric(name: str,
                                 f'Please choose another')
 
         def _validate_input_args(*args, **kwargs) -> None:
-            assert len(args) > 0, (
+            assert len(args) + len(kwargs) > 0, (
                 f"{user_function.__name__}() validation failed: "
                 f"Expected at least one positional|key-word argument of type np.ndarray, "
                 f"but received none. "
@@ -522,7 +650,7 @@ def tensorleap_custom_metric(name: str,
                                        f'{user_function.__name__}() has returned unsupported type.\nSupported types are List[float|int|None], '
                                        f'List[List[ConfusionMatrixElement]], NDArray[np.float32] or dictonary with one of these types as its values types. ')
 
-            def _validate_single_metric(single_metric_result,key=None):
+            def _validate_single_metric(single_metric_result, key=None):
                 if isinstance(single_metric_result, list):
                     if isinstance(single_metric_result[0], list):
                         assert all(isinstance(cm, ConfusionMatrixElement) for cm in single_metric_result[0]), (
@@ -532,7 +660,7 @@ def tensorleap_custom_metric(name: str,
                         )
 
                     else:
-                        assert all(isinstance(v, (float,int,type(None),np.float32)) for v in single_metric_result), (
+                        assert all(isinstance(v, (float, int, type(None), np.float32)) for v in single_metric_result), (
                             f"{supported_types_message}\n"
                             f"Got {'a dict where the value of ' + str(key) + ' is of type ' if key is not None else ''}"
                             f"List[{', '.join(type(v).__name__ for v in single_metric_result)}]."
@@ -549,7 +677,7 @@ def tensorleap_custom_metric(name: str,
 
             if isinstance(result, dict):
                 for key, value in result.items():
-                    _validate_single_metric(value,key)
+                    _validate_single_metric(value, key)
 
                     assert isinstance(key, str), \
                         (f'{user_function.__name__}() validation failed: '
@@ -604,13 +732,15 @@ def tensorleap_custom_metric(name: str,
             _add_mapping_connections(connects_to, arg_names, NodeMappingType.Metric, name)
 
         def inner(*args, **kwargs):
+            if not _call_from_tl_platform:
+                set_current('tensorleap_custom_metric')
             _validate_input_args(*args, **kwargs)
 
             result = inner_without_validate(*args, **kwargs)
 
             _validate_result(result)
-            if not _update_env_status is None:
-                _update_env_status("tensorleap_custom_metric","v")
+            if not _call_from_tl_platform:
+                update_env_params_func("tensorleap_custom_metric", "v")
             return result
 
         def mapping_inner(*args, **kwargs):
@@ -650,17 +780,16 @@ def tensorleap_custom_visualizer(name: str, visualizer_type: LeapDataType,
     name_to_unique_name = defaultdict(set)
 
     def decorating_function(user_function: VisualizerCallableInterface):
-        assert isinstance(visualizer_type,LeapDataType),(f"{user_function.__name__} validation failed: "
-                f"visualizer_type should be of type {LeapDataType.__name__} but got {type(visualizer_type)}"
-                                                         )
-
+        assert isinstance(visualizer_type, LeapDataType), (f"{user_function.__name__} validation failed: "
+                                                           f"visualizer_type should be of type {LeapDataType.__name__} but got {type(visualizer_type)}"
+                                                           )
         for viz_handler in leap_binder.setup_container.visualizers:
             if viz_handler.visualizer_handler_data.name == name:
                 raise Exception(f'Visualizer with name {name} already exists. '
                                 f'Please choose another')
 
         def _validate_input_args(*args, **kwargs):
-            assert len(args) > 0, (
+            assert len(args) + len(kwargs) > 0, (
                 f"{user_function.__name__}() validation failed: "
                 f"Expected at least one positional|key-word argument of type np.ndarray, "
                 f"but received none. "
@@ -726,13 +855,15 @@ def tensorleap_custom_visualizer(name: str, visualizer_type: LeapDataType,
             _add_mapping_connections(connects_to, arg_names, NodeMappingType.Visualizer, name)
 
         def inner(*args, **kwargs):
+            if not _call_from_tl_platform:
+                set_current('tensorleap_custom_visualizer')
             _validate_input_args(*args, **kwargs)
 
             result = inner_without_validate(*args, **kwargs)
 
             _validate_result(result)
-            if not _update_env_status is None:
-                _update_env_status("tensorleap_custom_visualizer","v")
+            if not _call_from_tl_platform:
+                update_env_params_func("tensorleap_custom_visualizer", "v")
             return result
 
         def mapping_inner(*args, **kwargs):
@@ -810,19 +941,21 @@ def tensorleap_metadata(
 
         leap_binder.set_metadata(inner_without_validate, name, metadata_type)
 
-        def inner(*args,**kwargs):
+        def inner(*args, **kwargs):
+            if not _call_from_tl_platform:
+                set_current('tensorleap_metadata')
             if os.environ.get(mapping_runtime_mode_env_var_mame):
                 return None
             validate_args_structure(*args, types_order=[Union[int, str], PreprocessResponse],
-                                    func_name=user_function.__name__, expected_names=["idx", "preprocess"],**kwargs)
-            sample_id, preprocess_response = args if len(args)!=0 else  kwargs.values()
+                                    func_name=user_function.__name__, expected_names=["idx", "preprocess"], **kwargs)
+            sample_id, preprocess_response = args if len(args) != 0 else kwargs.values()
             _validate_input_args(sample_id, preprocess_response)
 
             result = inner_without_validate(sample_id, preprocess_response)
 
             _validate_result(result)
-            if not _update_env_status is None:
-                _update_env_status("tensorleap_metadata","v")
+            if not _call_from_tl_platform:
+                update_env_params_func("tensorleap_metadata", "v")
             return result
 
         return inner
@@ -830,7 +963,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):
@@ -884,7 +1016,7 @@ def tensorleap_preprocess():
         leap_binder.set_preprocess(user_function)
 
         def _validate_input_args(*args, **kwargs):
-            assert len(args) == 0 and len(kwargs) == 0, \
+            assert len(args) + len(kwargs) == 0, \
                 (f'{user_function.__name__}() validation failed: '
                  f'The function should not take any arguments. Got {args} and {kwargs}.')
 
@@ -905,14 +1037,24 @@ def tensorleap_preprocess():
                  f'The return list should not contain duplicate PreprocessResponse objects.')
 
         def inner(*args, **kwargs):
+            if not _call_from_tl_platform:
+                set_current('tensorleap_metadata')
             if os.environ.get(mapping_runtime_mode_env_var_mame):
                 return [None, None, None, None]
 
             _validate_input_args(*args, **kwargs)
             result = user_function()
             _validate_result(result)
-            if not _update_env_status is None:
-                _update_env_status("tensorleap_preprocess", "v")
+
+            # Emit integration test event once per test
+            try:
+                emit_integration_event_once(AnalyticsEvent.PREPROCESS_INTEGRATION_TEST, {
+                    'preprocess_responses_count': len(result)
+                })
+            except Exception as e:
+                logger.debug(f"Failed to emit preprocess integration test event: {e}")
+            if not _call_from_tl_platform:
+                update_env_params_func("tensorleap_preprocess", "v")
             return result
 
         return inner
@@ -943,11 +1085,33 @@ def tensorleap_element_instance_preprocess(
                 preprocess_response.sample_ids = all_sample_ids
             return result
 
+        # def extract_extra_instance_metadata():
+        #     result = user_function()
+        #     for preprocess_response in result:
+        #         for sample_id in preprocess_response.sample_ids:
+        #             instances_length = instance_length_encoder(sample_id, preprocess_response)
+        #             if instances_length > 0:
+        #                 element_instance = instance_mask_encoder(sample_id, preprocess_response, 0)
+        #                 instance_metadata = element_instance.instance_metadata
+        #                 if instance_metadata is None:
+        #                     return {}
+        #                 return instance_metadata
+        #     return {}
+
+
         def builtin_instance_metadata(idx: str, preprocess: PreprocessResponse) -> Dict[str, str]:
             return {'is_instance': '0', 'original_sample_id': idx, 'instance_name': 'none'}
 
+        # def builtin_instance_extra_metadata(idx: str, preprocess: PreprocessResponse) -> Dict[str, str]:
+        #     instance_metadata = extract_extra_instance_metadata()
+        #     for key, value in instance_metadata.items():
+        #         instance_metadata[key] = 'unset'
+        #     return instance_metadata
+
         leap_binder.set_preprocess(user_function_instance)
         leap_binder.set_metadata(builtin_instance_metadata, "builtin_instance_metadata")
+        # leap_binder.set_metadata(builtin_instance_extra_metadata, "builtin_instance_extra_metadata")
+
 
         def _validate_input_args(*args, **kwargs):
             assert len(args) == 0 and len(kwargs) == 0, \
@@ -974,6 +1138,8 @@ def tensorleap_element_instance_preprocess(
 
             result = user_function_instance()
             _validate_result(result)
+            if not _call_from_tl_platform:
+                update_env_params_func("tensorleap_preprocess", "v")
             return result
 
         return inner
@@ -1056,10 +1222,11 @@ def tensorleap_instances_masks_encoder(name: str):
 
     return decorating_function
 
+
 def tensorleap_instances_length_encoder(name: str):
     def decorating_function(user_function: InstanceLengthCallableInterface):
         def _validate_input_args(sample_id: str, preprocess_response: PreprocessResponse):
-            assert isinstance(sample_id, str), \
+            assert isinstance(sample_id, (str, int)), \
                 (f'tensorleap_instances_length_encoder validation failed: '
                  f'Argument sample_id should be str. Got {type(sample_id)}.')
             assert isinstance(preprocess_response, PreprocessResponse), \
@@ -1101,12 +1268,28 @@ def tensorleap_instances_length_encoder(name: str):
 
     return decorating_function
 
-def tensorleap_input_encoder(name: str, channel_dim=-1, model_input_index=None):
+
+def tensorleap_input_encoder(name: str, channel_dim=_UNSET, model_input_index=None):
     def decorating_function(user_function: SectionCallableInterface):
         for input_handler in leap_binder.setup_container.inputs:
             if input_handler.name == name:
                 raise Exception(f'Input with name {name} already exists. '
                                 f'Please choose another')
+        nonlocal channel_dim
+
+        channel_dim_was_provided = channel_dim is not _UNSET
+
+        if not channel_dim_was_provided:
+            channel_dim = -1
+            if not _call_from_tl_platform:
+                store_warning_by_param(
+                    param_name="channel_dim",
+                    user_func_name=user_function.__name__,
+                    default_value=channel_dim,
+                    link_to_docs="https://docs.tensorleap.ai/tensorleap-integration/writing-integration-code/input-encoder"
+
+                )
+
         if channel_dim <= 0 and channel_dim != -1:
             raise Exception(f"Channel dim for input {name} is expected to be either -1 or positive")
 
@@ -1117,7 +1300,7 @@ def tensorleap_input_encoder(name: str, channel_dim=-1, model_input_index=None):
                  f'{preprocess_response.sample_id_type}. Got {type(sample_id)}.')
 
         def _validate_result(result):
-            validate_output_structure(result, func_name=user_function.__name__, expected_type_name = "np.ndarray")
+            validate_output_structure(result, func_name=user_function.__name__, expected_type_name="np.ndarray")
             assert isinstance(result, np.ndarray), \
                 (f'{user_function.__name__}() validation failed: '
                  f'Unsupported return type. Should be a numpy array. Got {type(result)}.')
@@ -1140,11 +1323,12 @@ def tensorleap_input_encoder(name: str, channel_dim=-1, model_input_index=None):
 
         leap_binder.set_input(inner_without_validate, name, channel_dim=channel_dim)
 
-
         def inner(*args, **kwargs):
+            if not _call_from_tl_platform:
+                set_current("tensorleap_input_encoder")
             validate_args_structure(*args, types_order=[Union[int, str], PreprocessResponse],
-                                    func_name=user_function.__name__,    expected_names=["idx", "preprocess"], **kwargs)
-            sample_id, preprocess_response = args if len(args)!=0 else  kwargs.values()
+                                    func_name=user_function.__name__, expected_names=["idx", "preprocess"], **kwargs)
+            sample_id, preprocess_response = args if len(args) != 0 else kwargs.values()
             _validate_input_args(sample_id, preprocess_response)
 
             result = inner_without_validate(sample_id, preprocess_response)
@@ -1152,14 +1336,22 @@ def tensorleap_input_encoder(name: str, channel_dim=-1, model_input_index=None):
             _validate_result(result)
 
             if _called_from_inside_tl_decorator == 0 and _called_from_inside_tl_integration_test_decorator:
-                batch_warning(result,user_function.__name__)
+                batch_warning(result, user_function.__name__)
                 result = np.expand_dims(result, axis=0)
-            if not _update_env_status is None:
-                _update_env_status("tensorleap_input_encoder", "v")
+                # Emit integration test event once per test
+                try:
+                    emit_integration_event_once(AnalyticsEvent.INPUT_ENCODER_INTEGRATION_TEST, {
+                        'encoder_name': name,
+                        'channel_dim': channel_dim,
+                        'model_input_index': model_input_index
+                    })
+                except Exception as e:
+                    logger.debug(f"Failed to emit input_encoder integration test event: {e}")
+            if not _call_from_tl_platform:
+                update_env_params_func("tensorleap_input_encoder", "v")
 
             return result
 
-
         node_mapping_type = NodeMappingType.Input
         if model_input_index is not None:
             node_mapping_type = NodeMappingType(f'Input{str(model_input_index)}')
@@ -1204,7 +1396,8 @@ def tensorleap_gt_encoder(name: str):
                  f'{preprocess_response.sample_id_type}. Got {type(sample_id)}.')
 
         def _validate_result(result):
-            validate_output_structure(result, func_name=user_function.__name__, expected_type_name = "np.ndarray",gt_flag=True)
+            validate_output_structure(result, func_name=user_function.__name__, expected_type_name="np.ndarray",
+                                      gt_flag=True)
             assert isinstance(result, np.ndarray), \
                 (f'{user_function.__name__}() validation failed: '
                  f'Unsupported return type. Should be a numpy array. Got {type(result)}.')
@@ -1225,8 +1418,9 @@ def tensorleap_gt_encoder(name: str):
 
         leap_binder.set_ground_truth(inner_without_validate, name)
 
-
         def inner(*args, **kwargs):
+            if not _call_from_tl_platform:
+                set_current("tensorleap_gt_encoder")
             validate_args_structure(*args, types_order=[Union[int, str], PreprocessResponse],
                                     func_name=user_function.__name__, expected_names=["idx", "preprocess"], **kwargs)
             sample_id, preprocess_response = args
@@ -1239,8 +1433,15 @@ def tensorleap_gt_encoder(name: str):
             if _called_from_inside_tl_decorator == 0 and _called_from_inside_tl_integration_test_decorator:
                 batch_warning(result, user_function.__name__)
                 result = np.expand_dims(result, axis=0)
-            if not _update_env_status is None:
-                _update_env_status("tensorleap_gt_encoder", "v")
+                # Emit integration test event once per test
+                try:
+                    emit_integration_event_once(AnalyticsEvent.GT_ENCODER_INTEGRATION_TEST, {
+                        'encoder_name': name
+                    })
+                except Exception as e:
+                    logger.debug(f"Failed to emit gt_encoder integration test event: {e}")
+            if not _call_from_tl_platform:
+                update_env_params_func("tensorleap_gt_encoder", "v")
             return result
 
         inner.node_mapping = NodeMapping(name, NodeMappingType.GroundTruth)
@@ -1281,28 +1482,18 @@ def tensorleap_custom_loss(name: str, connects_to=None):
         valid_types = (np.ndarray, SamplePreprocessResponse)
 
         def _validate_input_args(*args, **kwargs):
-            assert len(args) > 0 and len(kwargs)==0, (
+            assert len(args) + len(kwargs) > 0, (
                 f"{user_function.__name__}() validation failed: "
-                f"Expected at least one positional|key-word argument of the allowed types (np.ndarray|SamplePreprocessResponse|list(np.ndarray|SamplePreprocessResponse)). "
+                f"Expected at least one positional|key-word argument of the allowed types (np.ndarray|SamplePreprocessResponse|). "
                 f"but received none. "
                 f"Correct usage example: {user_function.__name__}(input_array: np.ndarray, ...)"
             )
             for i, arg in enumerate(args):
-                if isinstance(arg, list):
-                    for y, elem in enumerate(arg):
-                        assert isinstance(elem, valid_types), (f'{user_function.__name__}() validation failed: '
-                                                               f'Element #{y} of list should be a numpy array. Got {type(elem)}.')
-                else:
-                    assert isinstance(arg, valid_types), (f'{user_function.__name__}() validation failed: '
-                                                          f'Argument #{i} should be a numpy array. Got {type(arg)}.')
+                assert isinstance(arg, valid_types), (f'{user_function.__name__}() validation failed: '
+                                                      f'Argument #{i} should be a numpy array. Got {type(arg)}.')
             for _arg_name, arg in kwargs.items():
-                if isinstance(arg, list):
-                    for y, elem in enumerate(arg):
-                        assert isinstance(elem, valid_types), (f'{user_function.__name__}() validation failed: '
-                                                               f'Element #{y} of list should be a numpy array. Got {type(elem)}.')
-                else:
-                    assert isinstance(arg, valid_types), (f'{user_function.__name__}() validation failed: '
-                                                          f'Argument #{_arg_name} should be a numpy array. Got {type(arg)}.')
+                assert isinstance(arg, valid_types), (f'{user_function.__name__}() validation failed: '
+                                                      f'Argument #{_arg_name} should be a numpy array. Got {type(arg)}.')
 
         def _validate_result(result):
             validate_output_structure(result, func_name=user_function.__name__,
@@ -1310,8 +1501,8 @@ def tensorleap_custom_loss(name: str, connects_to=None):
             assert isinstance(result, np.ndarray), \
                 (f'{user_function.__name__} validation failed: '
                  f'The return type should be a numpy array. Got {type(result)}.')
-            assert  result.ndim<2 ,(f'{user_function.__name__}  validation failed: '
-                 f'The return type should be a 1Dim numpy array but got {result.ndim}Dim.')
+            assert result.ndim < 2, (f'{user_function.__name__}  validation failed: '
+                                     f'The return type should be a 1Dim numpy array but got {result.ndim}Dim.')
 
         @functools.wraps(user_function)
         def inner_without_validate(*args, **kwargs):
@@ -1337,13 +1528,15 @@ def tensorleap_custom_loss(name: str, connects_to=None):
             _add_mapping_connections(connects_to, arg_names, NodeMappingType.CustomLoss, name)
 
         def inner(*args, **kwargs):
+            if not _call_from_tl_platform:
+                set_current("tensorleap_custom_loss")
             _validate_input_args(*args, **kwargs)
 
             result = inner_without_validate(*args, **kwargs)
 
             _validate_result(result)
-            if not _update_env_status is None:
-                _update_env_status("tensorleap_custom_loss", "v")
+            if not _call_from_tl_platform:
+                update_env_params_func("tensorleap_custom_loss", "v")
 
             return result
 
@@ -1404,80 +1597,172 @@ def tensorleap_custom_layer(name: str):
 
 
 def tensorleap_status_table():
-    '''
-    Usage example:
-    ###################
-    leap_integration.py
-    ###################
-    from code_loader.inner_leap_binder.leapbinder_decorators import tensorleap_status_table
-    ...
-    ...
-    ...
-    if __name__ == '__main__':
-        tensorleap_status_table()
-        ...
-    '''
     import atexit
     import sys
     import traceback
+    from typing import Any
+
     CHECK = "✅"
     CROSS = "❌"
+    UNKNOWN = "❔"
 
-    table = [
-        {"name": "tensorleap_preprocess", "Added to integration": CROSS},
-        {"name": "tensorleap_integration_test", "Added to integration": CROSS},
-        {"name": "tensorleap_input_encoder", "Added to integration": CROSS},
-        {"name": "tensorleap_gt_encoder", "Added to integration": CROSS},
-        {"name": "tensorleap_load_model", "Added to integration": CROSS},
-        {"name": "tensorleap_custom_loss", "Added to integration": CROSS},
-        {"name": "tensorleap_custom_metric (optional)", "Added to integration": CROSS},
-        {"name": "tensorleap_metadata (optional)", "Added to integration": CROSS},
-        {"name": "tensorleap_custom_visualizer (optional)", "Added to integration": CROSS},
+    code_mapping_failure = [0]
 
+    table = [
+        {"name": "tensorleap_preprocess", "Added to integration": UNKNOWN},
+        {"name": "tensorleap_integration_test", "Added to integration": UNKNOWN},
+        {"name": "tensorleap_input_encoder", "Added to integration": UNKNOWN},
+        {"name": "tensorleap_gt_encoder", "Added to integration": UNKNOWN},
+        {"name": "tensorleap_load_model", "Added to integration": UNKNOWN},
+        {"name": "tensorleap_custom_loss", "Added to integration": UNKNOWN},
+        {"name": "tensorleap_custom_metric (optional)", "Added to integration": UNKNOWN},
+        {"name": "tensorleap_metadata (optional)", "Added to integration": UNKNOWN},
+        {"name": "tensorleap_custom_visualizer (optional)", "Added to integration": UNKNOWN},
     ]
 
     _finalizer_called = {"done": False}
+    _crashed = {"value": False}
+    _current_func = {"name": None}
+
+    def _link(url: str) -> str:
+        return f"\033{url}\033"
+
+    def _remove_suffix(s: str, suffix: str) -> str:
+        if suffix and s.endswith(suffix):
+            return s[:-len(suffix)]
+        return s
+
+    def _find_row(name: str):
+        for row in table:
+            if _remove_suffix(row["name"], " (optional)") == name:
+                return row
+        return None
+
+    def _set_status(name: str, status_symbol: str):
+        row = _find_row(name)
+        if not row:
+            return
+
+        cur = row["Added to integration"]
+        if status_symbol == UNKNOWN:
+            return
+        if cur == CHECK and status_symbol != CHECK:
+            return
+
+        row["Added to integration"] = status_symbol
+
+    def _mark_unknowns_as_cross():
+        for row in table:
+            if row["Added to integration"] == UNKNOWN:
+                row["Added to integration"] = CROSS
+
+    def _format_default_value(v: Any) -> str:
+        if hasattr(v, "name"):
+            return str(v.name)
+        if isinstance(v, str):
+            return v
+        s = repr(v)
+        return s if len(s) <= 120 else s[:120] + "..."
+
+    def _print_param_default_warnings():
+        data = _get_param_default_warnings()
+        if not data:
+            return
+
+        print("\nWarnings (Default use. It is recommended to set values explicitly):")
+        for param_name in sorted(data.keys()):
+            default_value = data[param_name]["default_value"]
+            funcs = ", ".join(sorted(data[param_name]["funcs"]))
+            dv = _format_default_value(default_value)
+
+            docs_link = data[param_name].get("link_to_docs")
+            docs_part = f" {_link(docs_link)}" if docs_link else ""
+            print(
+                f" ⚠️ Parameter '{param_name}' defaults to {dv} in the following functions: [{funcs}]. "
+                f"For more information, check {docs_part}")
+        print("\nIf this isn’t the intended behaviour, set them explicitly.")
 
     def _print_table():
+        _print_param_default_warnings()
+
+        if not started_from("leap_integration.py"):
+            return
+
         ready_mess = "\nAll parts have been successfully set. If no errors accured, you can now push the project to the Tensorleap system."
         not_ready_mess = "\nSome mandatory components have not yet been added to the Integration test. Recommended next interface to add is: "
         mandatory_ready_mess = "\nAll mandatory parts have been successfully set. If no errors accured, you can now push the project to the Tensorleap system or continue to the next optional reccomeded interface,adding: "
+        code_mapping_failure_mes = "Tensorleap_integration_test code flow failed, check raised exception."
 
         name_width = max(len(row["name"]) for row in table)
         status_width = max(len(row["Added to integration"]) for row in table)
+
         header = f"{'Decorator Name'.ljust(name_width)} | {'Added to integration'.ljust(status_width)}"
         sep = "-" * len(header)
+
         print("\n" + header)
         print(sep)
-        ready=True
+
+        ready = True
+        next_step = None
+
         for row in table:
             print(f"{row['name'].ljust(name_width)} | {row['Added to integration'].ljust(status_width)}")
-            if row['Added to integration']==CROSS and ready:
-                ready=False
-                next_step=row['name']
+            if not _crashed["value"] and ready:
+                if row["Added to integration"] != CHECK:
+                    ready = False
+                    next_step = row["name"]
 
+        if _crashed["value"]:
+            print(f"\nScript crashed before completing all steps. crashed at function '{_current_func['name']}'.")
+            return
+
+        if code_mapping_failure[0]:
+            print(f"\n{CROSS + code_mapping_failure_mes}.")
+            return
+
+        print(ready_mess) if ready else print(
+            mandatory_ready_mess + next_step
+        ) if (next_step and "optional" in next_step) else print(not_ready_mess + (next_step or ""))
+
+    def set_current(name: str):
+        _current_func["name"] = name
+
+    def update_env_params(name: str, status: str = "v"):
+        if name == "code_mapping":
+            code_mapping_failure[0] = 1
+        if status == "v":
+            _set_status(name, CHECK)
+        else:
+            _set_status(name, CROSS)
 
-        print(ready_mess) if ready else print(mandatory_ready_mess+next_step) if "optional" in next_step else print(not_ready_mess+next_step)
-    def update_env_params(name: str, status: str = "✓"):
-        for row in table:
-            if row["name"].removesuffix(" (optional)") == name:
-                row["Added to integration"] = CHECK if status=="v" else CROSS
-                break
     def run_on_exit():
         if _finalizer_called["done"]:
             return
         _finalizer_called["done"] = True
+        if not _crashed["value"]:
+            _mark_unknowns_as_cross()
+
         _print_table()
+
     def handle_exception(exc_type, exc_value, exc_traceback):
+        _crashed["value"] = True
+        crashed_name = _current_func["name"]
+        if crashed_name:
+            row = _find_row(crashed_name)
+            if row and row["Added to integration"] != CHECK:
+                row["Added to integration"] = CROSS
+
         traceback.print_exception(exc_type, exc_value, exc_traceback)
         run_on_exit()
+
     atexit.register(run_on_exit)
     sys.excepthook = handle_exception
-    global _update_env_status
-    _update_env_status = update_env_params
-    return update_env_params
+
+    return set_current, update_env_params
 
 
+if not _call_from_tl_platform:
+    set_current, update_env_params_func = tensorleap_status_table()