code-loader 1.0.193.dev3__tar.gz → 1.0.194__tar.gz

{code_loader-1.0.193.dev3 → code_loader-1.0.194}/PKG-INFO

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

{code_loader-1.0.193.dev3 → code_loader-1.0.194}/code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -299,8 +299,19 @@ def tensorleap_integration_test():
         def inner(*args, **kwargs):
             if not _call_from_tl_platform:
                 set_current('tensorleap_integration_test')
+            # Keyword calls must work with the user function's OWN parameter names — the local
+            # run template calls integration_test(sample_id=..., preprocess=...) against a
+            # signature the user chose, not the canonical placeholder names.
+            expected_names = inspect.getfullargspec(integration_test_function)[0][:2]
+            if len(expected_names) < 2:
+                expected_names = ['idx', 'preprocess']
             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=expected_names,
+                                    **kwargs)
+            sample_id, preprocess_response = (
+                args[i] if i < len(args) else kwargs[name]
+                for i, name in enumerate(expected_names))
+            args, kwargs = (sample_id, preprocess_response), {}
             _validate_input_args(*args, **kwargs)
 
             global _called_from_inside_tl_integration_test_decorator, _integration_test_started
@@ -433,7 +444,7 @@ def tensorleap_load_model(prediction_types: Optional[List[PredictionTypeHandler]
             pass
 
         @lru_cache()
-        def inner(*args, **kwargs):
+        def _cached_inner(*args, **kwargs):
             if not _call_from_tl_platform:
                 set_current('tensorleap_load_model')
             validate_args_structure(*args, types_order=[],
@@ -587,12 +598,20 @@ def tensorleap_load_model(prediction_types: Optional[List[PredictionTypeHandler]
                     return self.model.get_inputs()
 
             model_placeholder = ModelPlaceholder(prediction_types)
-            global _last_loaded_model
-            _last_loaded_model = model_placeholder
             if not _call_from_tl_platform:
                 update_env_params_func("tensorleap_load_model", "v")
             return model_placeholder
 
+        def inner(*args, **kwargs):
+            model_placeholder = _cached_inner(*args, **kwargs)
+            # Re-assert on every call, outside the cache: each mapping rerun's load_model
+            # overwrites this global with its mapping placeholder, and on a cache hit the
+            # body above never runs — a second integration test would otherwise fail the
+            # model loop's identity check against the stale mapping placeholder.
+            global _last_loaded_model
+            _last_loaded_model = model_placeholder
+            return model_placeholder
+
         def mapping_inner():
             class ModelOutputPlaceholder:
                 def __init__(self):
@@ -1711,6 +1730,8 @@ def _ndarray_leaves(value):
 
 
 def _squeeze_leading_batch_axis(tensors_dict):
+    if tensors_dict is None:
+        return None
     squeezed = {}
     for key, value in tensors_dict.items():
         if isinstance(value, np.ndarray) and value.ndim > 0 and value.shape[0] == 1:
@@ -2058,21 +2079,6 @@ def tensorleap_autoregressive_step(latent_space_aggregation: str = 'last_step'):
                     assert _nest_equal(value, second_inputs[key]), error_message
             assert _nest_equal(first_state, second_state), error_message
 
-        def _squeeze_test_batch_dim(tensors_dict):
-            # Inside the integration test the model works on batch-1 tensors (this wrapper adds the
-            # batch axis to returned inputs, and model outputs come back batched). The user's hook
-            # body must see the same unbatched per-sample tensors it will see at engine runtime, so
-            # strip the leading batch-1 axis before calling it.
-            if tensors_dict is None:
-                return None
-            squeezed = {}
-            for key, value in tensors_dict.items():
-                if isinstance(value, np.ndarray) and value.ndim > 0 and value.shape[0] == 1:
-                    squeezed[key] = value[0]
-                else:
-                    squeezed[key] = value
-            return squeezed
-
         def inner_without_validate(sample_id, prev_inputs, prev_outputs, state, preprocess_response):
             global _called_from_inside_tl_decorator
             _called_from_inside_tl_decorator += 1
@@ -2110,8 +2116,11 @@ def tensorleap_autoregressive_step(latent_space_aggregation: str = 'last_step'):
                 loop_context.on_hook_call(sample_id, prev_inputs, prev_outputs, state,
                                           preprocess_response)
             if is_top_level_in_test:
-                prev_inputs = _squeeze_test_batch_dim(prev_inputs)
-                prev_outputs = _squeeze_test_batch_dim(prev_outputs)
+                # The wrapper adds the batch axis to returned inputs and model outputs come back
+                # batched; the hook body must see the same unbatched per-sample tensors it will
+                # see at engine runtime.
+                prev_inputs = _squeeze_leading_batch_axis(prev_inputs)
+                prev_outputs = _squeeze_leading_batch_axis(prev_outputs)
 
             _validate_input_args(sample_id, prev_inputs, prev_outputs, state, preprocess_response)
 
@@ -3376,6 +3385,12 @@ def tensorleap_status_table():
         if not started_from("leap_integration.py"):
             return
 
+        if leap_binder.setup_container.autoregressive_step is not None:
+            # Input encoders are forbidden in autoregressive integrations — the step hook is
+            # the sole source of model inputs — so the row is not applicable: it must not be
+            # printed, gate readiness, or be recommended as a next step.
+            table[:] = [row for row in table if row["name"] != "tensorleap_input_encoder"]
+
         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_loader-1.0.193.dev3 → code_loader-1.0.194}/code_loader/leaploader.py

@@ -581,8 +581,8 @@ class LeapLoader(LeapLoaderBase):
         return handler.input_shapes
 
     def run_simulation(self, sim_name, params=None, n_samples=1, seed=0,
-                       sample_ids=None, extend_preprocess=True):
-        # type: (str, Optional[Dict[str, Any]], int, int, Optional[List[str]], bool) -> Dict[str, Any]
+                       sample_ids=None, extend_preprocess=True, allow_partial=False):
+        # type: (str, Optional[Dict[str, Any]], int, int, Optional[List[str]], bool, bool) -> Dict[str, Any]
         # extend_preprocess=True (default): also extend preprocess_result[additional] with the
         # new synthetic sample_ids (producer-side behavior — synthetic worker needs this for
         # enumeration / data_length tracking). Pass False from consumer-side populators that
@@ -609,19 +609,30 @@ class LeapLoader(LeapLoaderBase):
         for sample_id in original_sample_ids:
             for handler in global_leap_binder.setup_container.inputs:
                 per_encoder[handler.name].append(handler.function(sample_id, sim_preprocess))
-        encoded = {name: np.stack(arrays) for name, arrays in per_encoder.items()}
+        encoded = {
+            name: np.stack(arrays) if arrays else np.empty((0,), dtype=np.float32)
+            for name, arrays in per_encoder.items()
+        }
         if sample_ids is not None:
-            if len(sample_ids) != len(original_sample_ids):
-                raise ValueError(
-                    "sample_ids length ({}) does not match simulation output length ({})".format(
-                        len(sample_ids), len(original_sample_ids)
-                    )
-                )
             for sid in sample_ids:
                 if not isinstance(sid, str):
                     raise TypeError(
                         "All sample_ids must be of type str. Got: {}".format(type(sid))
                     )
+            if len(sample_ids) != len(original_sample_ids):
+                if not allow_partial:
+                    raise ValueError(
+                        "sample_ids length ({}) does not match simulation output length ({})".format(
+                            len(sample_ids), len(original_sample_ids)
+                        )
+                    )
+                n_bound = min(len(sample_ids), len(original_sample_ids))
+                sample_ids = list(sample_ids)[:n_bound]
+                original_sample_ids = original_sample_ids[:n_bound]
+                # Over-generation trims sample_ids/original_sample_ids above but encoded was
+                # stacked from the full simulation output; slice it too so the encoded batch dim
+                # stays 1:1 with the returned sample_ids.
+                encoded = {name: arr[:n_bound] for name, arr in encoded.items()}
             for synth_id, original_local_id in zip(sample_ids, original_sample_ids):
                 self._synthetic_lookup[synth_id] = (sim_preprocess, original_local_id)
             if extend_preprocess:
@@ -631,6 +642,19 @@ class LeapLoader(LeapLoaderBase):
             returned_sample_ids = original_sample_ids
         return {"encoded": encoded, "sample_ids": returned_sample_ids}
 
+    def prune_synthetic_lookup(self, keep_ids):
+        # type: (List[str]) -> None
+        # Keep only the given synthetic sample_ids in the in-memory lookup and
+        # drop the rest, so preprocess responses don't accumulate across many
+        # run_simulation calls (e.g. a synthetic calibration loop keeps only its
+        # running top-K trials). Keep-set semantics (rather than evict-list) so
+        # the caller can bound the lookup to a known-good set each iteration
+        # without tracking everything it ever generated.
+        keep = set(keep_ids)
+        self._synthetic_lookup = {
+            sid: entry for sid, entry in self._synthetic_lookup.items() if sid in keep
+        }
+
     def _extend_additional_preprocess(self, new_sample_ids: List[str]) -> None:
         if self._preprocess_result_cached is None:
             self._preprocess_result()

{code_loader-1.0.193.dev3 → code_loader-1.0.194}/code_loader/leaploaderbase.py

@@ -223,8 +223,13 @@ class LeapLoaderBase:
         pass
 
     @abstractmethod
-    def run_simulation(self, sim_name, params=None, n_samples=1, seed=0, sample_ids=None):
-        # type: (str, Optional[Dict[str, Any]], int, int, Optional[List[str]]) -> Dict[str, Any]
+    def run_simulation(self, sim_name, params=None, n_samples=1, seed=0, sample_ids=None,
+                       extend_preprocess=True, allow_partial=False):
+        # type: (str, Optional[Dict[str, Any]], int, int, Optional[List[str]], bool, bool) -> Dict[str, Any]
+        pass
+
+    def prune_synthetic_lookup(self, keep_ids):
+        # type: (List[str]) -> None
         pass
 
     def is_custom_latent_space(self) -> bool:

{code_loader-1.0.193.dev3 → code_loader-1.0.194}/pyproject.toml

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