code-loader 1.0.180.dev3__tar.gz → 1.0.180.dev5__tar.gz

{code_loader-1.0.180.dev3 → code_loader-1.0.180.dev5}/PKG-INFO

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

{code_loader-1.0.180.dev3 → code_loader-1.0.180.dev5}/code_loader/contract/datasetclasses.py

@@ -13,6 +13,8 @@ from code_loader.contract.sim_config import SimConfig
 
 custom_latent_space_attribute = "custom_latent_space"
 
+_simulation_context: dict = {"active": False}
+
 
 @dataclass
 class PreprocessResponse:
@@ -62,14 +64,14 @@ class PreprocessResponse:
             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",
-            )
-
+            if not _simulation_context["active"]:
+                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)}"
 

{code_loader-1.0.180.dev3 → code_loader-1.0.180.dev5}/code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -1424,7 +1424,7 @@ def tensorleap_simulation(name: str, sim_params: dict):
         leap_binder.set_simulation(user_function, name, sim_params)
 
         if not _call_from_tl_platform:
-            add_table_row(f"tensorleap_simulation:{name} (optional)")
+            register_sim(name)
 
         def _validate_input_args(*args, **kwargs):
             assert len(args) == 0, (
@@ -1442,29 +1442,40 @@ def tensorleap_simulation(name: str, sim_params: dict):
                 f"{user_function.__name__}() validation failed: "
                 f"Expected return type PreprocessResponse. Got {type(result).__name__}."
             )
-            assert result.state == DataStateType.additional, (
-                f"{user_function.__name__}() validation failed: "
-                f"Simulation must return a PreprocessResponse with state=DataStateType.additional. "
-                f"Got state={result.state!r}."
-            )
 
         def inner(*args, **kwargs):
             if not _call_from_tl_platform:
-                set_current('tensorleap_simulation')
-            _validate_input_args(*args, **kwargs)
-            result = user_function(*args, **kwargs)
-            _validate_result(result)
-            result.tl_generated = True
-            if not _call_from_tl_platform:
-                update_env_params_func(f"tensorleap_simulation:{name}", "v")
+                set_current('tensorleap simulation')
             try:
-                emit_integration_event_once(AnalyticsEvent.SIMULATION_INTEGRATION_TEST, {
-                    'simulation_name': name,
-                    'sim_params_count': len(sim_params)
-                })
-            except Exception as e:
-                logger.debug(f"Failed to emit simulation integration test event: {e}")
-            return result
+                from code_loader.contract.datasetclasses import _simulation_context
+                _validate_input_args(*args, **kwargs)
+                _simulation_context["active"] = True
+                try:
+                    result = user_function(*args, **kwargs)
+                finally:
+                    _simulation_context["active"] = False
+                _validate_result(result)
+                if result.state is not None and result.state != DataStateType.additional:
+                    logger.warning(
+                        f"{user_function.__name__}() returned state={result.state!r}; "
+                        f"overriding to DataStateType.additional."
+                    )
+                result.state = DataStateType.additional
+                result.tl_generated = True
+                try:
+                    emit_integration_event_once(AnalyticsEvent.SIMULATION_INTEGRATION_TEST, {
+                        'simulation_name': name,
+                        'sim_params_count': len(sim_params)
+                    })
+                except Exception as e:
+                    logger.debug(f"Failed to emit simulation integration test event: {e}")
+                if not _call_from_tl_platform:
+                    mark_sim_result(name, True)
+                return result
+            except Exception:
+                if not _call_from_tl_platform:
+                    mark_sim_result(name, False)
+                raise
 
         return inner
 
@@ -2092,6 +2103,9 @@ def tensorleap_status_table():
     def _print_table():
         _print_param_default_warnings()
 
+        for msg in _sim_messages:
+            print(f"\n⚠️  {msg}")
+
         if not started_from("leap_integration.py"):
             return
 
@@ -2144,12 +2158,41 @@ def tensorleap_status_table():
         else:
             _set_status(name, CROSS)
 
+    _sim_tracking: dict = {}
+    _sim_messages: list = []
+
+    def register_sim(sim_name: str):
+        if not _sim_tracking:
+            table.append({"name": "tensorleap simulation (optional)", "Added to integration": UNKNOWN})
+        _sim_tracking[sim_name] = "registered"
+
+    def mark_sim_result(sim_name: str, passed: bool):
+        _sim_tracking[sim_name] = "passed" if passed else "failed"
+
+    def _resolve_sim_row():
+        if not _sim_tracking:
+            return
+        row = _find_row("tensorleap simulation")
+        if not row:
+            return
+        failed = [n for n, s in _sim_tracking.items() if s == "failed"]
+        not_called = [n for n, s in _sim_tracking.items() if s == "registered"]
+        if failed:
+            row["Added to integration"] = CROSS
+            _sim_messages.append(f"Simulation(s) failed validation: {', '.join(sorted(failed))}")
+        elif not_called:
+            row["Added to integration"] = UNKNOWN
+            _sim_messages.append(f"Simulation(s) not called in integration test: {', '.join(sorted(not_called))}")
+        else:
+            row["Added to integration"] = CHECK
+
     def run_on_exit():
         if _finalizer_called["done"]:
             return
         _finalizer_called["done"] = True
         if not _crashed["value"]:
             _mark_unknowns_as_cross()
+        _resolve_sim_row()
 
         _print_table()
 
@@ -2164,17 +2207,14 @@ def tensorleap_status_table():
         traceback.print_exception(exc_type, exc_value, exc_traceback)
         run_on_exit()
 
-    def add_table_row(name: str):
-        table.append({"name": name, "Added to integration": UNKNOWN})
-
     atexit.register(run_on_exit)
     sys.excepthook = handle_exception
 
-    return set_current, update_env_params, add_table_row
+    return set_current, update_env_params, register_sim, mark_sim_result
 
 
 if not _call_from_tl_platform:
-    set_current, update_env_params_func, add_table_row = tensorleap_status_table()
+    set_current, update_env_params_func, register_sim, mark_sim_result = tensorleap_status_table()
 
 
 

{code_loader-1.0.180.dev3 → code_loader-1.0.180.dev5}/pyproject.toml

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