code-loader 1.0.189.dev0__tar.gz → 1.0.190__tar.gz

{code_loader-1.0.189.dev0 → code_loader-1.0.190}/PKG-INFO

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

{code_loader-1.0.189.dev0 → code_loader-1.0.190}/code_loader/contract/datasetclasses.py

@@ -92,16 +92,6 @@ SectionCallableInterface = Callable[[Union[int, str], PreprocessResponse], npt.N
 InstanceCallableInterface = Callable[[Union[int, str], PreprocessResponse, int], Optional[ElementInstance]]
 InstanceLengthCallableInterface = Callable[[Union[int, str], PreprocessResponse], int]
 
-# (sample_id, prev_inputs, prev_outputs, preprocess) -> next model inputs, or None to end the chain.
-# First call per chain receives prev_inputs=None, prev_outputs=None and returns the initial inputs.
-# Keys starting with '_' are passthrough state: never fed to the model, handed back verbatim in
-# prev_inputs on the next call. The hook must be stateless and deterministically seeded (the engine
-# may replay a step after crash recovery and relies on identical results).
-AutoregressiveStepCallableInterface = Callable[
-    [Union[int, str], Optional[Dict[str, npt.NDArray[np.float32]]], Optional[Dict[str, npt.NDArray[np.float32]]],
-     PreprocessResponse],
-    Optional[Dict[str, npt.NDArray[np.float32]]]]
-
 MetadataSectionCallableInterface = Union[
     Callable[[Union[int, str], PreprocessResponse], int],
     Callable[[Union[int, str], PreprocessResponse], Dict[str, int]],
@@ -249,15 +239,6 @@ class CustomLatentSpaceHandler:
     function: SectionCallableInterface
     name: str = 'custom_latent_space'
 
-
-@dataclass
-class AutoregressiveStepHandler:
-    function: AutoregressiveStepCallableInterface
-    name: str = 'autoregressive_step'
-    # Per-model-input shapes (unbatched, underscore passthrough keys excluded), discovered by running
-    # the hook's first call at parse time. Fills the role InputHandler.shape plays for input encoders.
-    input_shapes: Optional[Dict[str, List[int]]] = None
-
 @dataclass
 class PredictionTypeHandler:
     name: str
@@ -298,7 +279,6 @@ class DatasetIntegrationSetup:
     custom_layers: Dict[str, CustomLayerHandler] = field(default_factory=dict)
     custom_latent_space: Optional[CustomLatentSpaceHandler] = None
     simulations: List[SimulationHandler] = field(default_factory=list)
-    autoregressive_step: Optional[AutoregressiveStepHandler] = None
 
 
 @dataclass

{code_loader-1.0.189.dev0 → code_loader-1.0.190}/code_loader/inner_leap_binder/leapbinder.py

@@ -13,7 +13,7 @@ from code_loader.contract.datasetclasses import SectionCallableInterface, InputH
     CustomMultipleReturnCallableInterfaceMultiArgs, DatasetBaseHandler, custom_latent_space_attribute, \
     RawInputsForHeatmap, VisualizerHandlerData, MetricHandlerData, CustomLossHandlerData, SamplePreprocessResponse, \
     ElementInstanceMasksHandler, InstanceCallableInterface, CustomLatentSpaceHandler, InstanceMetricHandler, \
-    SimulationHandler, _simulation_context, AutoregressiveStepHandler, AutoregressiveStepCallableInterface
+    SimulationHandler, _simulation_context
 from code_loader.contract.enums import LeapDataType, DataStateEnum, DataStateType, MetricDirection, DatasetMetadataType
 from code_loader.contract.mapping import NodeConnection, NodeMapping, NodeMappingType
 from code_loader.contract.responsedataclasses import DatasetTestResultPayload, LeapAnalysisConfiguration
@@ -524,26 +524,6 @@ class LeapBinder:
         """
         self.setup_container.custom_latent_space = CustomLatentSpaceHandler(function)
 
-    def set_autoregressive_step(self, function: AutoregressiveStepCallableInterface) -> None:
-        """
-        Set the autoregressive step hook — the feedback function that drives a chain:
-        it supplies the model's initial inputs on its first call (prev_inputs=None, prev_outputs=None)
-        and turns each step's inputs/outputs into the next step's inputs until it returns None.
-        An autoregressive integration has no input encoders; the hook is the sole input source.
-        """
-        if self.setup_container.autoregressive_step is not None:
-            raise Exception('tensorleap_autoregressive_step is already defined. '
-                            'Only one autoregressive step hook is allowed per integration.')
-        self.setup_container.autoregressive_step = AutoregressiveStepHandler(function)
-
-        # Builtin chain metadata, declared at parse time so it survives the reporter's
-        # metadata type mapping; the placeholder values are overwritten by the engine when a
-        # chain finalizes (realized length, truncated-by-safety-cap flag).
-        def builtin_chain_metadata(idx: Any, preprocess: PreprocessResponse) -> Dict[str, Any]:
-            return {'length': -1, 'truncated': False}
-
-        self.set_metadata(builtin_chain_metadata, 'builtin_chain')
-
     def set_custom_layer(self, custom_layer: Type[Any], name: str, inspect_layer: bool = False,
                          kernel_index: Optional[int] = None, use_custom_latent_space: bool = False) -> None:
         """
@@ -754,7 +734,6 @@ class LeapBinder:
                     )
 
     def check(self) -> None:
-        self.validate_autoregressive_setup()
         preprocess_result = self.get_preprocess_result()
         self.check_preprocess(preprocess_result)
         self.check_handlers(preprocess_result)
@@ -762,32 +741,6 @@ class LeapBinder:
         self.validate_ignore_latent_spaces()
         print("Successful!")
 
-    def validate_autoregressive_setup(self) -> None:
-        """Structural rules for autoregressive integrations (no-op when the hook is absent).
-
-        Order-independent: runs after the whole script registered, because decorators may
-        appear in any order in the integration file.
-        """
-        if self.setup_container.autoregressive_step is None:
-            return
-        if self.setup_container.inputs:
-            raise Exception(
-                "An autoregressive integration must not declare input encoders — "
-                "tensorleap_autoregressive_step is the sole source of model inputs "
-                "(its first call returns the initial inputs). Found input encoders: "
-                f"{[handler.name for handler in self.setup_container.inputs]}.")
-        if self.setup_container.instance_masks:
-            raise Exception(
-                "Element instances are not supported together with tensorleap_autoregressive_step: "
-                "instance generation masks the sample's encoded inputs, which do not exist in an "
-                "autoregressive integration. Remove the instance encoders or the autoregressive hook.")
-        if self.setup_container.custom_latent_space is not None:
-            raise Exception(
-                "tensorleap_custom_latent_space is not supported together with "
-                "tensorleap_autoregressive_step: the custom latent space function only sees "
-                "(sample_id, preprocess) — it runs before generation and cannot observe the chain. "
-                "The chain's latent is the final step's model latent.")
-
     def validate_ignore_latent_spaces(self) -> None:
         """Validate leap_analysis_configuration.ignore_latent_spaces against this binder.
 

{code_loader-1.0.189.dev0 → code_loader-1.0.190}/code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -21,7 +21,7 @@ from code_loader.contract.datasetclasses import CustomCallableInterfaceMultiArgs
     CustomMultipleReturnCallableInterfaceMultiArgs, ConfusionMatrixCallableInterfaceMultiArgs, CustomCallableInterface, \
     VisualizerCallableInterface, MetadataSectionCallableInterface, PreprocessResponse, SectionCallableInterface, \
     ConfusionMatrixElement, SamplePreprocessResponse, PredictionTypeHandler, InstanceCallableInterface, ElementInstance, \
-    InstanceLengthCallableInterface, AutoregressiveStepCallableInterface
+    InstanceLengthCallableInterface
 from code_loader.contract.enums import MetricDirection, LeapDataType, DatasetMetadataType, DataStateType
 from code_loader import leap_binder, LeapLoader
 from code_loader.contract.mapping import NodeMapping, NodeMappingType, NodeConnection
@@ -1628,232 +1628,6 @@ def tensorleap_custom_latent_space():
     return decorating_function
 
 
-def tensorleap_autoregressive_step():
-    """The feedback hook that drives an autoregressive chain.
-
-    Signature of the decorated function:
-        (sample_id, prev_inputs, prev_outputs, preprocess) -> Optional[Dict[str, np.ndarray]]
-
-    First call per chain: prev_inputs=None, prev_outputs=None — returns the initial model inputs.
-    Later calls receive the previous step's model inputs and outputs (unbatched, per-sample) and
-    return the next step's full input dict; returning None ends the chain. Keys starting with '_'
-    are passthrough state: never fed to the model, handed back verbatim in prev_inputs next call.
-    The hook must be stateless and deterministically seeded (seed stochasticity from sample_id) —
-    the engine replays steps after crash recovery and relies on identical results.
-    """
-    def decorating_function(user_function: AutoregressiveStepCallableInterface):
-        # Contract: shapes and key set are fixed across all calls AND all chains (compiled graphs
-        # need static shapes), so one record shared across samples is the correct scope.
-        first_call_record: Dict[str, Any] = {'keys': None, 'shapes': None}
-
-        def _normalize_args(args, kwargs):
-            expected_names = ["sample_id", "prev_inputs", "prev_outputs", "preprocess"]
-            validate_args_structure(
-                *args,
-                types_order=[Union[int, str], Union[dict, type(None)], Union[dict, type(None)],
-                             PreprocessResponse],
-                func_name=user_function.__name__, expected_names=expected_names, **kwargs)
-            normalized = []
-            for i, name in enumerate(expected_names):
-                normalized.append(args[i] if i < len(args) else kwargs[name])
-            return normalized
-
-        def _validate_input_args(sample_id, prev_inputs, prev_outputs, preprocess_response):
-            assert (prev_inputs is None) == (prev_outputs is None), \
-                (f'{user_function.__name__}() validation failed: '
-                 f'prev_inputs and prev_outputs must both be None (first call) or both be dicts '
-                 f'(subsequent calls). Got prev_inputs={type(prev_inputs).__name__}, '
-                 f'prev_outputs={type(prev_outputs).__name__}.')
-            assert type(sample_id) == preprocess_response.sample_id_type, \
-                (f'{user_function.__name__}() validation failed: '
-                 f'Argument sample_id should be as the same type as defined in the preprocess response '
-                 f'{preprocess_response.sample_id_type}. Got {type(sample_id)}.')
-
-        def _validate_result(result, is_first_call):
-            if result is None:
-                assert not is_first_call, \
-                    (f'{user_function.__name__}() validation failed: '
-                     f'the first call (prev_inputs=None, prev_outputs=None) must return the initial '
-                     f'model inputs dict — returning None on the first call would produce an empty chain.')
-                return
-            assert isinstance(result, dict), \
-                (f'{user_function.__name__}() validation failed: '
-                 f'the return value must be a dict of named model input tensors, or None to end the '
-                 f'chain. Got {type(result)}.')
-            model_input_keys = [key for key in result if not key.startswith('_')]
-            assert model_input_keys, \
-                (f'{user_function.__name__}() validation failed: '
-                 f'the returned dict contains no model inputs — every key starts with "_" '
-                 f'(underscore keys are passthrough state, never fed to the model).')
-            for key, value in result.items():
-                assert isinstance(key, str), \
-                    (f'{user_function.__name__}() validation failed: '
-                     f'all keys in the returned dict must be strings. Got {type(key)}.')
-                if key.startswith('_'):
-                    continue
-                assert isinstance(value, np.ndarray), \
-                    (f'{user_function.__name__}() validation failed: '
-                     f'value for model input "{key}" must be a numpy array. Got {type(value)}.')
-
-        def _validate_consistency(result):
-            # Rules 2-3 of the autoregressive contract: identical key set and identical
-            # (non-passthrough) shapes on every call — compiled graphs need static shapes.
-            if result is None:
-                return
-            keys = set(result.keys())
-            shapes = {key: tuple(value.shape) for key, value in result.items()
-                      if not key.startswith('_') and isinstance(value, np.ndarray)}
-            if first_call_record['keys'] is None:
-                first_call_record['keys'] = keys
-                first_call_record['shapes'] = shapes
-                return
-            assert keys == first_call_record['keys'], \
-                (f'{user_function.__name__}() validation failed: '
-                 f'every call must return the same key set as the first call. '
-                 f'First call keys: {sorted(first_call_record["keys"])}, this call: {sorted(keys)}.')
-            for key, shape in shapes.items():
-                assert shape == first_call_record['shapes'][key], \
-                    (f'{user_function.__name__}() validation failed: '
-                     f'tensor shapes must be identical on every call (fixed-length padding + mask for '
-                     f'growing sequences). Input "{key}" was {first_call_record["shapes"][key]} on the '
-                     f'first call and {shape} now.')
-
-        def _assert_deterministic(first_result, second_result):
-            error_message = (
-                f'{user_function.__name__}() validation failed: '
-                f'the hook is not deterministic — two calls with identical arguments returned different '
-                f'outputs. Seed any stochasticity (e.g. initial noise) from sample_id: the engine '
-                f'replays steps after crash recovery and relies on identical results.')
-            if first_result is None or second_result is None:
-                assert first_result is None and second_result is None, error_message
-                return
-            assert set(first_result.keys()) == set(second_result.keys()), error_message
-            for key, value in first_result.items():
-                if key.startswith('_') or not isinstance(value, np.ndarray):
-                    continue
-                assert np.array_equal(value, second_result[key]), 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 not key.startswith('_') and 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, preprocess_response):
-            global _called_from_inside_tl_decorator
-            _called_from_inside_tl_decorator += 1
-            try:
-                result = user_function(sample_id, prev_inputs, prev_outputs, preprocess_response)
-            finally:
-                _called_from_inside_tl_decorator -= 1
-            return result
-
-        leap_binder.set_autoregressive_step(inner_without_validate)
-
-        def inner(*args, **kwargs):
-            if not _call_from_tl_platform:
-                set_current('tensorleap_autoregressive_step')
-            sample_id, prev_inputs, prev_outputs, preprocess_response = _normalize_args(args, kwargs)
-
-            is_top_level_in_test = (_called_from_inside_tl_decorator == 0
-                                    and _called_from_inside_tl_integration_test_decorator)
-            if is_top_level_in_test:
-                prev_inputs = _squeeze_test_batch_dim(prev_inputs)
-                prev_outputs = _squeeze_test_batch_dim(prev_outputs)
-
-            _validate_input_args(sample_id, prev_inputs, prev_outputs, preprocess_response)
-
-            result = inner_without_validate(sample_id, prev_inputs, prev_outputs, preprocess_response)
-
-            if is_top_level_in_test:
-                # Rule 7: determinism double-call. An unseeded sampler fails here, on the user's
-                # machine, instead of silently forking a chain on engine crash-replay.
-                second_result = inner_without_validate(sample_id, prev_inputs, prev_outputs,
-                                                       preprocess_response)
-                _assert_deterministic(result, second_result)
-
-            _validate_result(result, is_first_call=prev_inputs is None)
-            _validate_consistency(result)
-
-            if is_top_level_in_test and result is not None:
-                result = {key: (np.expand_dims(value, axis=0)
-                                if not key.startswith('_') and isinstance(value, np.ndarray) else value)
-                          for key, value in result.items()}
-
-            if not _call_from_tl_platform:
-                update_env_params_func("tensorleap_autoregressive_step", "v")
-            return result
-
-        class _MappingInputsPlaceholder:
-            """Mapping-mode stand-in for the hook's returned dict.
-
-            Indexing it by a model-input name yields a placeholder whose node_mapping the model
-            placeholder tags Input0/Input1/... — exactly how input encoders wire the graph. One
-            NodeConnection is recorded per non-passthrough key, once.
-            """
-            def __init__(self):
-                self._items: Dict[str, Any] = {}
-
-            def __getitem__(self, key):
-                assert isinstance(key, str), \
-                    f'Expected a string model input name, got {type(key)} instead.'
-                if key not in self._items:
-                    class TempMapping:
-                        pass
-                    ret = TempMapping()
-                    ret.node_mapping = NodeMapping(key, NodeMappingType.Input)
-                    if not key.startswith('_'):
-                        leap_binder.mapping_connections.append(NodeConnection(ret.node_mapping, None))
-                    self._items[key] = ret
-                return self._items[key]
-
-            def get(self, key, default=None):
-                return self[key]
-
-            def _unsupported_iteration(self):
-                raise Exception(
-                    'Iterating over the autoregressive hook result is not supported inside the '
-                    'integration test. Pass the model its inputs with explicit keys, e.g. '
-                    "model.run(None, {'x': inputs['x'], 't': inputs['t']}).")
-
-            def items(self):
-                self._unsupported_iteration()
-
-            def keys(self):
-                self._unsupported_iteration()
-
-            def values(self):
-                self._unsupported_iteration()
-
-        mapping_placeholder = _MappingInputsPlaceholder()
-
-        def mapping_inner(*args, **kwargs):
-            return mapping_placeholder
-
-        def final_inner(*args, **kwargs):
-            if os.environ.get(mapping_runtime_mode_env_var_mame):
-                return mapping_inner(*args, **kwargs)
-            else:
-                return inner(*args, **kwargs)
-
-        if not _call_from_tl_platform:
-            register_decorator_row("tensorleap_autoregressive_step")
-
-        return final_inner
-
-    return decorating_function
-
-
 def tensorleap_preprocess():
     def decorating_function(user_function: Callable[[], List[PreprocessResponse]]):
         leap_binder.set_preprocess(user_function)
@@ -2684,12 +2458,6 @@ def tensorleap_status_table():
             table.append({"name": "tensorleap simulation (optional)", "Added to integration": UNKNOWN})
         _sim_tracking[sim_name] = "registered"
 
-    def register_decorator_row(name: str):
-        # Rows for decorators that only apply to some integration kinds (e.g. the autoregressive
-        # step hook) are appended on registration, so unrelated integrations never show them.
-        if _find_row(_remove_suffix(name, " (optional)")) is None:
-            table.append({"name": name, "Added to integration": UNKNOWN})
-
     def mark_sim_result(sim_name: str, passed: bool):
         _sim_tracking[sim_name] = "passed" if passed else "failed"
 
@@ -2736,12 +2504,11 @@ def tensorleap_status_table():
     atexit.register(run_on_exit)
     sys.excepthook = handle_exception
 
-    return set_current, update_env_params, register_sim, mark_sim_result, register_decorator_row
+    return set_current, update_env_params, register_sim, mark_sim_result
 
 
 if not _call_from_tl_platform:
-    set_current, update_env_params_func, register_sim, mark_sim_result, register_decorator_row = \
-        tensorleap_status_table()
+    set_current, update_env_params_func, register_sim, mark_sim_result = tensorleap_status_table()
 
 
 

{code_loader-1.0.189.dev0 → code_loader-1.0.190}/code_loader/leaploader.py

@@ -320,16 +320,14 @@ class LeapLoader(LeapLoaderBase):
             try:
                 self.exec_script()
 
-                global_leap_binder.validate_autoregressive_setup()
+                integration_test_test_payload = self._check_integration_test_exists()
+                test_payloads.append(integration_test_test_payload)
                 preprocess_test_payload = self._check_preprocess()
                 test_payloads.append(preprocess_test_payload)
                 handlers_test_payloads = self._check_handlers()
                 test_payloads.extend(handlers_test_payloads)
                 simulation_test_payloads = self._check_simulations()
                 test_payloads.extend(simulation_test_payloads)
-                autoregressive_test_payload = self._check_autoregressive_step()
-                if autoregressive_test_payload is not None:
-                    test_payloads.append(autoregressive_test_payload)
                 is_valid = all([payload.is_passed for payload in test_payloads])
                 setup_response = self.get_dataset_setup_response(handlers_test_payloads)
 
@@ -360,6 +358,23 @@ class LeapLoader(LeapLoaderBase):
                                        engine_file_contract=EngineFileContract(global_leap_binder.mapping_connections,
                                                                                global_leap_binder.leap_analysis_configuration))
 
+    def _check_integration_test_exists(self) -> DatasetTestResultPayload:
+        test_result = DatasetTestResultPayload('integration_test')
+        # Only enforced on the Tensorleap platform (i.e. during a push / inspection,
+        # where IS_TENSORLEAP_PLATFORM=true). Running code-loader locally or in unit
+        # tests must not require the decorator, so pre-decorator integrations and
+        # local check runs keep working unchanged.
+        is_on_platform = os.environ.get('IS_TENSORLEAP_PLATFORM') == 'true'
+        if is_on_platform and global_leap_binder.integration_test_func is None:
+            test_result.is_passed = False
+            test_result.display[TestingSectionEnum.Errors.name] = (
+                "No integration test was found in your integration file. A valid Tensorleap "
+                "integration file must define an integration test function decorated with "
+                "@tensorleap_integration_test. Without it the integration cannot be validated "
+                "and the push is aborted. See the mnist leap_integration.py for a valid example."
+            )
+        return test_result
+
     def _check_preprocess(self) -> DatasetTestResultPayload:
         test_result = DatasetTestResultPayload('preprocess')
         try:
@@ -449,69 +464,6 @@ class LeapLoader(LeapLoaderBase):
             result_payloads.append(test_result)
         return result_payloads
 
-    def _check_autoregressive_step(self) -> Optional[DatasetTestResultPayload]:
-        handler = global_leap_binder.setup_container.autoregressive_step
-        if handler is None:
-            return None
-        test_result = DatasetTestResultPayload(handler.name)
-        try:
-            preprocess_result = self._preprocess_result()
-            input_shapes: Dict[str, List[int]] = {}
-            for state, preprocess_response in preprocess_result.items():
-                if preprocess_response.sample_ids_to_instance_mappings:
-                    raise Exception('Element instances are not supported together with '
-                                    'tensorleap_autoregressive_step.')
-                sample_id = preprocess_response.sample_ids[0]
-                first_result = handler.function(sample_id, None, None, preprocess_response)
-                second_result = handler.function(sample_id, None, None, preprocess_response)
-                if not isinstance(first_result, dict):
-                    raise Exception('The autoregressive step hook must return a dict of initial model '
-                                    f'inputs on its first call, got {type(first_result)} '
-                                    f'(state: {state.name}).')
-                model_input_items = {key: value for key, value in first_result.items()
-                                     if not key.startswith('_')}
-                if not model_input_items:
-                    raise Exception('The autoregressive step hook returned no model inputs on its first '
-                                    'call — every key starts with "_" (underscore keys are passthrough '
-                                    f'state, never fed to the model). State: {state.name}.')
-                for key, value in model_input_items.items():
-                    if not isinstance(value, np.ndarray):
-                        raise Exception(f'The autoregressive step hook returned a non-numpy value for '
-                                        f'model input "{key}" ({type(value)}). State: {state.name}.')
-                    if key in input_shapes and input_shapes[key] != list(value.shape):
-                        raise Exception(f'The autoregressive step hook returned different shapes for '
-                                        f'model input "{key}" across states: {input_shapes[key]} vs '
-                                        f'{list(value.shape)}. Shapes must be fixed.')
-                    input_shapes[key] = list(value.shape)
-                    if not np.array_equal(value, second_result[key]):
-                        raise Exception('The autoregressive step hook is not deterministic — two calls '
-                                        'with identical arguments returned different outputs for model '
-                                        f'input "{key}". Seed any stochasticity from sample_id: the '
-                                        'engine replays steps after crash recovery and relies on '
-                                        'identical results.')
-            handler.input_shapes = input_shapes
-        except Exception as e:
-            line_number, file_name, stacktrace = get_root_exception_file_and_line_number()
-            test_result.display[TestingSectionEnum.Errors.name] = \
-                f"{repr(e)} in file {file_name}, line_number:  {line_number}\nStacktrace:\n{stacktrace}"
-            test_result.is_passed = False
-        return test_result
-
-    def _ensure_autoregressive_input_shapes(self) -> Dict[str, List[int]]:
-        handler = global_leap_binder.setup_container.autoregressive_step
-        assert handler is not None
-        if handler.input_shapes is None:
-            preprocess_result = self._preprocess_result()
-            first_state_response = next(iter(preprocess_result.values()))
-            first_result = handler.function(first_state_response.sample_ids[0], None, None,
-                                            first_state_response)
-            if not isinstance(first_result, dict):
-                raise Exception('The autoregressive step hook must return a dict of initial model '
-                                f'inputs on its first call, got {type(first_result)}.')
-            handler.input_shapes = {key: list(value.shape) for key, value in first_result.items()
-                                    if not key.startswith('_') and isinstance(value, np.ndarray)}
-        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]
@@ -702,12 +654,6 @@ class LeapLoader(LeapLoaderBase):
                 raise Exception(f"cant calculate shape for input, input name:{inp.name}")
             inputs.append(DatasetInputInstance(name=inp.name, shape=inp.shape, channel_dim=inp.channel_dim))
 
-        if setup.autoregressive_step is not None:
-            # The hook is the sole input source; report its step-0 inputs as the dataset inputs so
-            # graph building, input-coverage validation and type dictionaries see real specs.
-            for input_name, input_shape in self._ensure_autoregressive_input_shapes().items():
-                inputs.append(DatasetInputInstance(name=input_name, shape=input_shape, channel_dim=-1))
-
         ground_truths = []
         for gt in setup.ground_truths:
             if gt.shape is None:
@@ -815,21 +761,7 @@ class LeapLoader(LeapLoaderBase):
         return result_agg
 
     def _get_inputs(self, state: DataStateEnum, sample_id: Union[int, str]) -> Dict[str, npt.NDArray[np.float32]]:
-        inputs = self._get_dataset_handlers(global_leap_binder.setup_container.inputs, state, sample_id)
-        autoregressive_handler = global_leap_binder.setup_container.autoregressive_step
-        if autoregressive_handler is not None:
-            # Autoregressive integrations have no input encoders — the hook's first call supplies
-            # the sample's (step-0) model inputs, so every sample-fetching flow (graph validation,
-            # analysis, import checks) sees a fully-populated inputs dict.
-            preprocess_response = self._preprocess_result()[state]
-            step_zero_inputs = autoregressive_handler.function(sample_id, None, None, preprocess_response)
-            if not isinstance(step_zero_inputs, dict):
-                raise Exception(
-                    'The autoregressive step hook must return a dict of initial model inputs on its '
-                    f'first call, got {type(step_zero_inputs)} for sample {sample_id}.')
-            inputs.update({key: value for key, value in step_zero_inputs.items()
-                           if not key.startswith('_')})
-        return inputs
+        return self._get_dataset_handlers(global_leap_binder.setup_container.inputs, state, sample_id)
 
     def _get_instances_masks(self, state: DataStateEnum, sample_id: Union[int, str], instance_id: int) -> Optional[Dict[str, ElementInstance]]:
         if instance_id is None:
@@ -852,12 +784,6 @@ class LeapLoader(LeapLoaderBase):
     def _get_gt(self, state: DataStateEnum, sample_id: Union[int, str]) -> Dict[str, npt.NDArray[np.float32]]:
         return self._get_dataset_handlers(global_leap_binder.setup_container.ground_truths, state, sample_id)
 
-    def get_gt(self, state: DataStateEnum, sample_id: Union[int, str]) -> Dict[str, npt.NDArray[np.float32]]:
-        """Ground-truth tensors only ({} when no GT encoders are declared) — lets the engine's
-        rollout fetch a chain's GT without re-running the autoregressive hook via get_sample."""
-        self.exec_script()
-        return self._get_gt(state, sample_id)
-
     @lru_cache()
     def _metadata_name_to_type(self) -> Dict[str, DatasetMetadataType]:
         global_leap_binder.check_preprocess(self._preprocess_result())
@@ -953,36 +879,6 @@ class LeapLoader(LeapLoaderBase):
         self.exec_script()
         return global_leap_binder.setup_container.custom_latent_space is not None
 
-    @lru_cache()
-    def has_autoregressive_step(self) -> bool:
-        self.exec_script()
-        return global_leap_binder.setup_container.autoregressive_step is not None
-
-    def run_autoregressive_step(self, sample_id: Union[int, str],
-                                prev_inputs: Optional[Dict[str, npt.NDArray[np.float32]]],
-                                prev_outputs: Optional[Dict[str, npt.NDArray[np.float32]]],
-                                state: DataStateEnum) -> Optional[Dict[str, npt.NDArray[np.float32]]]:
-        """Execute the user's autoregressive step hook against the in-process preprocess result.
-
-        This is the engine rollout's per-step entry point (invoked on the generic pod). The first
-        call per chain passes prev_inputs=None, prev_outputs=None and returns the initial model
-        inputs; a None return ends the chain.
-        """
-        self.exec_script()
-        handler = global_leap_binder.setup_container.autoregressive_step
-        if handler is None:
-            raise Exception('run_autoregressive_step was called but the integration has no '
-                            'tensorleap_autoregressive_step hook.')
-        preprocess_response = self._preprocess_result()[state]
-        return handler.function(sample_id, prev_inputs, prev_outputs, preprocess_response)
-
-    def get_prediction_names_in_order(self) -> List[str]:
-        """Model output names by declared prediction-type order (validated against the model's
-        output count at integration-test time), used to key prev_outputs for the hook."""
-        self.exec_script()
-        return [prediction_type.name for prediction_type in
-                global_leap_binder.setup_container.prediction_types]
-
     def get_instances_data(self, state: DataStateEnum) -> Tuple[Dict[str, List[str]], Dict[str, str]]:
         preprocess_result = self._preprocess_result()
         preprocess_state = preprocess_result.get(state)

{code_loader-1.0.189.dev0 → code_loader-1.0.190}/code_loader/leaploaderbase.py

@@ -149,11 +149,6 @@ class LeapLoaderBase:
     def has_custom_latent_space_decorator(self) -> bool:
         pass
 
-    def has_autoregressive_step(self) -> bool:
-        # Default False so existing LeapLoaderBase implementations stay valid; the concrete
-        # loaders that can answer (LeapLoader in-process, LeapLoaderWithRedis via RPC) override.
-        return False
-
     @abstractmethod
     def get_heatmap_visualizer_raw_vis_input_arg_name(self, visualizer_name: str) -> Optional[str]:
         pass

{code_loader-1.0.189.dev0 → code_loader-1.0.190}/pyproject.toml

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