code-loader 1.0.146__tar.gz → 1.0.148__tar.gz

{code_loader-1.0.146 → code_loader-1.0.148}/PKG-INFO

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

{code_loader-1.0.146 → code_loader-1.0.148}/code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -31,9 +31,7 @@ import functools
 
 _called_from_inside_tl_decorator = 0
 _called_from_inside_tl_integration_test_decorator = False
-_call_from_tl_platform=  os.environ.get('IS_TENSORLEAP_PLATFORM') == 'true'
-
-
+_call_from_tl_platform = os.environ.get('IS_TENSORLEAP_PLATFORM') == 'true'
 
 
 def validate_args_structure(*args, types_order, func_name, expected_names, **kwargs):
@@ -94,7 +92,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(
@@ -132,6 +130,7 @@ 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:
         warnings.warn(
@@ -141,6 +140,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)]
@@ -164,7 +165,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 "
@@ -173,7 +174,7 @@ def tensorleap_integration_test():
 
         def inner(*args, **kwargs):
             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
@@ -185,7 +186,8 @@ def tensorleap_integration_test():
             try:
                 _called_from_inside_tl_integration_test_decorator = True
                 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
+                    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:
@@ -197,16 +199,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):
-                        if not _call_from_tl_platform:
-                            update_env_params_func("code_mapping", "v")
-                        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.")
+                        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:
-                        if not _call_from_tl_platform:
-                            update_env_params_func("code_mapping", "v")
-                        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')
+                        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]
@@ -214,31 +215,34 @@ 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),(
+    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__}.")
         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:
@@ -262,28 +266,39 @@ 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):
             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) or 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]:
@@ -337,11 +352,14 @@ 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()
+
+            model_placeholder = ModelPlaceholder(prediction_types)
             if not _call_from_tl_platform:
                 update_env_params_func("tensorleap_load_model", "v")
             return model_placeholder
@@ -391,7 +409,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):
@@ -412,6 +430,7 @@ def tensorleap_load_model(prediction_types: Optional[List[PredictionTypeHandler]
                 return mapping_inner()
             else:
                 return inner(*args, **kwargs)
+
         return final_inner
 
     return decorating_function
@@ -422,6 +441,7 @@ def tensorleap_custom_metric(name: str,
                              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]):
@@ -494,7 +514,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:
@@ -503,7 +522,7 @@ def tensorleap_custom_metric(name: str,
                                 f'Please choose another')
 
         def _validate_input_args(*args, **kwargs) -> None:
-            assert len(args)+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 type np.ndarray, "
                 f"but received none. "
@@ -536,7 +555,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]), (
@@ -546,7 +565,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)}]."
@@ -563,7 +582,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: '
@@ -624,7 +643,7 @@ def tensorleap_custom_metric(name: str,
 
             _validate_result(result)
             if not _call_from_tl_platform:
-                update_env_params_func("tensorleap_custom_metric","v")
+                update_env_params_func("tensorleap_custom_metric", "v")
             return result
 
         def mapping_inner(*args, **kwargs):
@@ -664,9 +683,9 @@ 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:
@@ -746,7 +765,7 @@ def tensorleap_custom_visualizer(name: str, visualizer_type: LeapDataType,
 
             _validate_result(result)
             if not _call_from_tl_platform:
-                update_env_params_func("tensorleap_custom_visualizer","v")
+                update_env_params_func("tensorleap_custom_visualizer", "v")
             return result
 
         def mapping_inner(*args, **kwargs):
@@ -824,19 +843,19 @@ def tensorleap_metadata(
 
         leap_binder.set_metadata(inner_without_validate, name, metadata_type)
 
-        def inner(*args,**kwargs):
+        def inner(*args, **kwargs):
             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 _call_from_tl_platform:
-                update_env_params_func("tensorleap_metadata","v")
+                update_env_params_func("tensorleap_metadata", "v")
             return result
 
         return inner
@@ -844,7 +863,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):
@@ -996,6 +1014,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
@@ -1078,6 +1098,7 @@ 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):
@@ -1123,6 +1144,7 @@ def tensorleap_instances_length_encoder(name: str):
 
     return decorating_function
 
+
 def tensorleap_input_encoder(name: str, channel_dim=-1, model_input_index=None):
     def decorating_function(user_function: SectionCallableInterface):
         for input_handler in leap_binder.setup_container.inputs:
@@ -1139,7 +1161,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)}.')
@@ -1162,11 +1184,10 @@ 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):
             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)
@@ -1174,7 +1195,7 @@ 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)
                 # Emit integration test event once per test
                 try:
@@ -1190,7 +1211,6 @@ def tensorleap_input_encoder(name: str, channel_dim=-1, model_input_index=None):
 
             return result
 
-
         node_mapping_type = NodeMappingType.Input
         if model_input_index is not None:
             node_mapping_type = NodeMappingType(f'Input{str(model_input_index)}')
@@ -1235,7 +1255,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)}.')
@@ -1256,7 +1277,6 @@ def tensorleap_gt_encoder(name: str):
 
         leap_binder.set_ground_truth(inner_without_validate, name)
 
-
         def inner(*args, **kwargs):
             validate_args_structure(*args, types_order=[Union[int, str], PreprocessResponse],
                                     func_name=user_function.__name__, expected_names=["idx", "preprocess"], **kwargs)
@@ -1321,26 +1341,16 @@ def tensorleap_custom_loss(name: str, connects_to=None):
         def _validate_input_args(*args, **kwargs):
             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__,
@@ -1348,8 +1358,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):
@@ -1460,7 +1470,7 @@ def tensorleap_status_table():
     import traceback
     CHECK = "✅"
     CROSS = "❌"
-    code_mapping_failure=[0]
+    code_mapping_failure = [0]
     table = [
         {"name": "tensorleap_preprocess", "Added to integration": CROSS},
         {"name": "tensorleap_integration_test", "Added to integration": CROSS},
@@ -1477,7 +1487,7 @@ def tensorleap_status_table():
     _finalizer_called = {"done": False}
 
     def _remove_suffix(s: str, suffix: str) -> str:
-        #This is needed because str.remove_suffix was presented in python3.9+
+        # This is needed because str.remove_suffix was presented in python3.9+
         if suffix and s.endswith(suffix):
             return s[:-len(suffix)]
         return s
@@ -1486,7 +1496,7 @@ def tensorleap_status_table():
         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."
+        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)
@@ -1494,32 +1504,37 @@ def tensorleap_status_table():
         sep = "-" * len(header)
         print("\n" + header)
         print(sep)
-        ready=True
+        ready = True
         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 row['Added to integration'] == CROSS and ready:
+                ready = False
+                next_step = row['name']
 
-        if code_mapping_failure:
-            print(f"\n{ CROSS + code_mapping_failure_mes}.")
+        if code_mapping_failure[0]:
+            print(f"\n{CROSS + code_mapping_failure_mes}.")
         else:
-            print(ready_mess) if ready else print(mandatory_ready_mess+next_step) if "optional" in next_step else print(not_ready_mess+next_step)
+            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 _remove_suffix(row["name"]," (optional)") == name:
-                row["Added to integration"] = CHECK if status=="v" else CROSS
+            if _remove_suffix(row["name"], " (optional)") == name:
+                row["Added to integration"] = CHECK if status == "v" else CROSS
                 break
-        if name=="code_mapping":
-            code_mapping_failure[0]=1
+        if name == "code_mapping":
+            code_mapping_failure[0] = 1
+
     def run_on_exit():
         if _finalizer_called["done"]:
             return
         _finalizer_called["done"] = True
         _print_table()
+
     def handle_exception(exc_type, exc_value, exc_traceback):
         traceback.print_exception(exc_type, exc_value, exc_traceback)
         run_on_exit()
+
     atexit.register(run_on_exit)
     sys.excepthook = handle_exception
     return update_env_params

{code_loader-1.0.146 → code_loader-1.0.148}/pyproject.toml

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