code-loader 1.0.195.dev0__py3-none-any.whl → 1.0.196__py3-none-any.whl

code_loader/contract/datasetclasses.py

@@ -1,6 +1,6 @@
 import warnings
 from dataclasses import dataclass, field
-from typing import Any, Callable, List, Optional, Dict, Union, Type, Literal, Tuple
+from typing import Any, Callable, List, Optional, Dict, Union, Type, Literal, Tuple, cast
 import re
 import numpy as np
 import numpy.typing as npt
@@ -15,6 +15,8 @@ custom_latent_space_attribute = "custom_latent_space"
 
 _simulation_context: Dict[str, bool] = {"active": False}
 
+SampleId = Union[int, str]
+
 
 @dataclass
 class PreprocessResponse:
@@ -39,27 +41,54 @@ class PreprocessResponse:
     """
     length: Optional[int] = None  # Deprecated. Please use sample_ids instead
     data: Any = None
-    sample_ids: Optional[Union[List[str], List[int]]] = None
+    sample_ids: Optional[Union[List[SampleId], List[List[SampleId]]]] = None
     state: Optional[DataStateType] = None
     sample_id_type: Optional[Union[Type[str], Type[int]]] = None
     sample_ids_to_instance_mappings: Optional[Dict[str, List[str]]] = None # in use only for element instance
     instance_to_sample_ids_mappings: Optional[Dict[str, str]] = None # in use only for element instance
     tl_generated: bool = False
+    _grouped: bool = field(default=False, init=False, repr=False, compare=False)
+    _group_pos_cache: Optional[Dict[SampleId, Tuple[List[SampleId], int]]] = field(
+        default=None, init=False, repr=False, compare=False)
 
     def __post_init__(self) -> None:
         assert self.sample_ids_to_instance_mappings is None, f"Keep sample_ids_to_instance_mappings None when initializing PreprocessResponse"
         assert self.instance_to_sample_ids_mappings is None, f"Keep instance_to_sample_ids_mappings None when initializing PreprocessResponse"
 
         if self.length is not None and self.sample_ids is None:
-            self.sample_ids = [i for i in range(self.length)]
+            self.sample_ids = cast(List[SampleId], [i for i in range(self.length)])
             self.sample_id_type = int
-        elif self.length is None and self.sample_ids is not None:
-            self.length = len(self.sample_ids)
-            if self.sample_id_type is None:
-                self.sample_id_type = str
-            if self.sample_id_type == str:
-                for sample_id in self.sample_ids:
-                    assert isinstance(sample_id, str), f"Sample id should be of type str. Got: {type(sample_id)}"
+            self._grouped = False
+        elif self.sample_ids is not None:
+            given_length = self.length
+            self._grouped = len(self.sample_ids) > 0 and isinstance(self.sample_ids[0], list)
+            if self._grouped:
+                groups = cast(List[List[SampleId]], self.sample_ids)
+                assert len(groups) >= 1, "Grouped PreprocessResponse must have at least one group."
+                for group in groups:
+                    assert isinstance(group, list) and len(group) > 0, \
+                        "Each group in a grouped PreprocessResponse must be a non-empty list."
+                self.sample_id_type = type(groups[0][0])
+                assert issubclass(self.sample_id_type, (str, int)), \
+                    f"Sample id should be of type str or int. Got: {self.sample_id_type.__name__}"
+                for group in groups:
+                    for sample_id in group:
+                        assert isinstance(sample_id, self.sample_id_type), \
+                            f"Sample id should be of type {self.sample_id_type.__name__}. Got: {type(sample_id)}"
+                self.length = sum(len(group) for group in groups)
+            else:
+                flat_ids = cast(List[SampleId], self.sample_ids)
+                self.length = len(flat_ids)
+                if self.sample_id_type is None:
+                    self.sample_id_type = str
+                if self.sample_id_type == str:
+                    for sample_id in flat_ids:
+                        assert isinstance(sample_id, str), f"Sample id should be of type str. Got: {type(sample_id)}"
+            # dataclasses.replace() re-invokes __init__ with both fields already populated
+            # (length previously derived from sample_ids); only reject a genuine mismatch.
+            if given_length is not None:
+                assert given_length == self.length, \
+                    f"Inconsistent PreprocessResponse: length={given_length} but sample_ids implies {self.length}."
         else:
             raise Exception("length is deprecated, please use sample_ids instead.")
 
@@ -79,9 +108,36 @@ class PreprocessResponse:
         return id(self)
 
     def __len__(self) -> int:
+        assert self.length is not None
+        return self.length
+
+    @property
+    def is_grouped(self) -> bool:
+        return self._grouped
+
+    @property
+    def num_groups(self) -> int:
+        # Grouped: the number of groups. Flat: the (flat) sample count, since sample_ids is the
+        # flat id list and there is one sample per "group".
         assert self.sample_ids is not None
         return len(self.sample_ids)
 
+    @property
+    def groups(self) -> Optional[List[List[SampleId]]]:
+        # The nested list of groups when grouped, otherwise None. Callers should
+        # branch on is_grouped before relying on this.
+        return cast(List[List[SampleId]], self.sample_ids) if self._grouped else None
+
+    @property
+    def flat_sample_ids(self) -> List[SampleId]:
+        # All sample ids in order: concatenation of the groups when grouped,
+        # otherwise the flat sample_ids list as-is.
+        assert self.sample_ids is not None
+        if self._grouped:
+            groups = cast(List[List[SampleId]], self.sample_ids)
+            return [sample_id for group in groups for sample_id in group]
+        return cast(List[SampleId], self.sample_ids)
+
 @dataclass
 class ElementInstance:
     name: str

code_loader/inner_leap_binder/leapbinder.py

@@ -1,6 +1,9 @@
 
+import builtins
 import inspect
-from typing import Callable, List, Optional, Dict, Any, Type, Union, get_args
+import os
+from contextlib import contextmanager
+from typing import Callable, List, Optional, Dict, Any, Type, Union, get_args, cast, Iterator, Set
 
 import numpy as np
 import numpy.typing as npt
@@ -16,7 +19,8 @@ from code_loader.contract.datasetclasses import SectionCallableInterface, InputH
     SimulationHandler, _simulation_context, AutoregressiveStepHandler, AutoregressiveStepCallableInterface, \
     AUTOREGRESSIVE_LATENT_SPACE_AGGREGATIONS, AUTOREGRESSIVE_IMPLICIT_ARG_NAMES, \
     AutoregressiveMetricHandler, AutoregressiveLossHandler, AutoregressiveVisualizerHandler
-from code_loader.contract.enums import LeapDataType, DataStateEnum, DataStateType, MetricDirection, DatasetMetadataType
+from code_loader.contract.enums import LeapDataType, DataStateEnum, DataStateType, MetricDirection, DatasetMetadataType, \
+    TestingSectionEnum
 from code_loader.contract.mapping import NodeConnection, NodeMapping, NodeMappingType
 from code_loader.contract.responsedataclasses import DatasetTestResultPayload, LeapAnalysisConfiguration
 from code_loader.contract.visualizer_classes import map_leap_data_type_to_visualizer_class
@@ -33,6 +37,25 @@ from code_loader.visualizers.default_visualizers import DefaultVisualizer, \
 mapping_runtime_mode_env_var_mame = '__MAPPING_RUNTIME_MODE__'
 
 
+@contextmanager
+def _track_opened_files() -> Iterator[Set[str]]:
+    opened: Set[str] = set()
+    original_open = builtins.open
+
+    def tracking_open(file: Any, *args: Any, **kwargs: Any) -> Any:
+        mode = args[0] if args else kwargs.get('mode', 'r')
+        is_read_mode = isinstance(mode, str) and not any(c in mode for c in ('a', 'w', 'x'))
+        if is_read_mode and isinstance(file, (str, os.PathLike)):
+            opened.add(os.fspath(file))
+        return original_open(file, *args, **kwargs)
+
+    builtins.open = tracking_open
+    try:
+        yield opened
+    finally:
+        builtins.open = original_open
+
+
 def _stringized_annotation_type_name(annotation: Any) -> Optional[str]:
     """Bare type name if ``annotation`` is a stringized annotation (from ``from __future__
     import annotations`` or a quoted hint), else ``None``. code_loader inspects raw
@@ -549,7 +572,9 @@ class LeapBinder:
         # 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]:
+        def builtin_chain_metadata(idx: Any, preprocess: PreprocessResponse) -> Any:
+            if isinstance(idx, list):
+                return [{'length': -1, 'truncated': False} for _ in idx]
             return {'length': -1, 'truncated': False}
 
         self.set_metadata(builtin_chain_metadata, 'builtin_chain')
@@ -713,6 +738,15 @@ class LeapBinder:
             if state_enum in preprocess_result_dict:
                 preprocess_result_dict_in_correct_order[state_enum] = preprocess_result_dict[state_enum]
 
+        # All-or-none: every state must agree on grouped (nested sample_ids) vs flat.
+        if len({r.is_grouped for r in preprocess_result_dict_in_correct_order.values()}) > 1:
+            shapes = ', '.join(
+                f"{state.name}={'grouped' if r.is_grouped else 'flat'}"
+                for state, r in preprocess_result_dict_in_correct_order.items())
+            raise Exception(
+                "All preprocess states must be either all grouped (nested sample_ids) or all flat, "
+                f"but got a mix: {shapes}.")
+
         return preprocess_result_dict_in_correct_order
 
     def get_preprocess_unlabeled_result(self) -> Optional[PreprocessResponse]:
@@ -733,7 +767,34 @@ class LeapBinder:
             preprocess_response: PreprocessResponse, test_result: List[DatasetTestResultPayload],
             dataset_base_handler: Union[DatasetBaseHandler, MetadataHandler], state: DataStateEnum) -> List[DatasetTestResultPayload]:
         assert preprocess_response.sample_ids is not None
-        raw_result = dataset_base_handler.function(preprocess_response.sample_ids[0], preprocess_response)
+        opened_files: Optional[Set[str]] = None
+        if preprocess_response.is_grouped:
+            # Grouped: probe with the first group, then reduce to a single sample's result so the
+            # recorded shape/type is per-sample (matching the flat case), not the (B, *) batch.
+            # (casts: sample_ids[0] is a group list here, and the grouped result is a per-sample list.)
+            group = preprocess_response.sample_ids[0]
+            with _track_opened_files() as opened_files:
+                raw_result = cast(Any, dataset_base_handler.function(cast(Any, group), preprocess_response))[0]
+        else:
+            raw_result = dataset_base_handler.function(
+                cast(Union[int, str], preprocess_response.sample_ids[0]), preprocess_response)
+
+        def _warn_if_group_spans_multiple_files(payloads: List[DatasetTestResultPayload]) -> None:
+            if opened_files is None or len(opened_files) <= 1:
+                return
+            shown = sorted(opened_files)[:5]
+            suffix = f" (+{len(opened_files) - 5} more)" if len(opened_files) > 5 else ""
+            warning = (
+                f"Encoding declared group 0 (size {len(cast(List[Any], group))}) for '{dataset_base_handler.name}' opened "
+                f"{len(opened_files)} distinct files: {shown}{suffix}. If this group is meant to be one "
+                f"physical source (e.g. one Parquet file), it may be grouped incorrectly - check your "
+                f"preprocess grouping logic. (Only files opened via Python's open() are tracked, so this "
+                f"can miss other I/O paths or be a false positive if grouping isn't meant to reflect file "
+                f"locality.)")
+            for payload in payloads:
+                existing = payload.display.get(TestingSectionEnum.Errors.name, '')
+                payload.display[TestingSectionEnum.Errors.name] = (existing + '\n' if existing else '') + warning
+
         handler_type = 'metadata' if isinstance(dataset_base_handler, MetadataHandler) else None
         if isinstance(dataset_base_handler, MetadataHandler):
             if isinstance(raw_result, dict):
@@ -773,6 +834,7 @@ class LeapBinder:
             else:
                 if raw_result is None:
                     if state != DataStateEnum.training:
+                        _warn_if_group_spans_multiple_files(test_result)
                         return test_result
 
                     if dataset_base_handler.metadata_type is None:
@@ -794,6 +856,7 @@ class LeapBinder:
             # setting shape in setup for all encoders
             if isinstance(dataset_base_handler, (InputHandler, GroundTruthHandler)):
                 dataset_base_handler.shape = result_shape
+        _warn_if_group_spans_multiple_files(test_result)
         return test_result
 
     def check_handlers(self, preprocess_result: Dict[DataStateEnum, PreprocessResponse]) -> None:
@@ -829,10 +892,15 @@ class LeapBinder:
             preprocess_response.tl_generated = True
             if not preprocess_response.length or preprocess_response.length < 1:
                 raise Exception("Simulation '{}' returned PreprocessResponse with length < 1".format(sim.name))
-            preprocess_response.sample_ids = [0]
+            if preprocess_response.is_grouped:
+                raise Exception(
+                    "Simulation '{}' returned a grouped PreprocessResponse; simulations must "
+                    "return a flat (non-grouped) PreprocessResponse.".format(sim.name))
+            preprocess_response.sample_ids = cast(List[Union[int, str]], [0])
+            sim_sample_ids = cast(List[Union[int, str]], preprocess_response.sample_ids)
             for handler in self.setup_container.inputs:
-                out1 = handler.function(preprocess_response.sample_ids[0], preprocess_response)
-                out2 = handler.function(preprocess_response.sample_ids[0], preprocess_response)
+                out1 = handler.function(sim_sample_ids[0], preprocess_response)
+                out2 = handler.function(sim_sample_ids[0], preprocess_response)
                 if not np.allclose(out1, out2):
                     raise Exception(
                         "Simulation '{}': encoder '{}' is non-deterministic — consecutive calls with seed=0 returned different outputs".format(

code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -40,6 +40,7 @@ _called_from_inside_tl_integration_test_decorator = False
 # to tell a raise in the test body (report as code-flow failure) from a module-level crash
 # before any test ran (report as a plain script crash).
 _integration_test_started = False
+_mapping_dataset_is_grouped = False
 _call_from_tl_platform = os.environ.get('IS_TENSORLEAP_PLATFORM') == 'true'
 
 # ---- warnings store (module-level) ----
@@ -213,6 +214,53 @@ def batch_warning(result, func_name):
         )
 
 
+def _validate_id_or_group(sample_id, preprocess_response, func_name):
+    """Accept either a single sample id (flat dataset) or a group — a list of ids (grouped
+    dataset). The argument shape must match the dataset: a group requires a grouped
+    PreprocessResponse and a single id requires a flat one. Every id must match the declared
+    sample_id_type."""
+    is_group = isinstance(sample_id, list)
+    if is_group and not preprocess_response.is_grouped:
+        raise AssertionError(
+            f'{func_name}() validation failed: got a group (list of sample ids) but the '
+            f'PreprocessResponse is not grouped. Pass a single sample id for a flat dataset.')
+    if not is_group and preprocess_response.is_grouped:
+        raise AssertionError(
+            f'{func_name}() validation failed: got a single sample id but the PreprocessResponse '
+            f'is grouped. Pass a group (list of sample ids) for a grouped dataset.')
+    ids = sample_id if is_group else [sample_id]
+    for sid in ids:
+        assert type(sid) == preprocess_response.sample_id_type, \
+            (f'{func_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(sid)}.')
+
+
+def _validate_grouped_result(result, group_size, func_name, validate_single):
+    """A grouped (group) encoder result must be either a single ndarray with leading dim
+    == group_size, or a list of `group_size` per-sample results (each validated by
+    validate_single). Metadata validates its grouped result separately (list only).
+    An `(B, *)` array is validated per-sample slice (not as the whole batched array) so
+    per-sample checks (e.g. channel_dim <= rank) use the sample shape, not the batch shape."""
+    if isinstance(result, np.ndarray):
+        assert len(result.shape) > 0 and result.shape[0] == group_size, \
+            (f'{func_name}() validation failed: expected a grouped output for a group of '
+             f'{group_size}: an array with leading dim {group_size}, got shape {result.shape}.')
+        for single in result:
+            validate_single(single)
+    elif isinstance(result, list):
+        assert len(result) == group_size, \
+            (f'{func_name}() validation failed: expected a grouped output for a group of '
+             f'{group_size}: a list of {group_size} arrays, got {len(result)}.')
+        for r in result:
+            validate_single(r)
+    else:
+        raise AssertionError(
+            f'{func_name}() validation failed: expected a grouped output for a group of '
+            f'{group_size}: either an array with leading dim {group_size} or a list of '
+            f'{group_size} arrays, got {type(result)}.')
+
+
 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)]
@@ -290,11 +338,7 @@ def tensorleap_integration_test():
 
         def _validate_input_args(*args, **kwargs):
             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 "
-                f"type ({preprocess_response.sample_id_type}) from the PreprocessResponse."
-            )
+            _validate_id_or_group(sample_id, preprocess_response, 'tensorleap_integration_test')
 
         def inner(*args, **kwargs):
             if not _call_from_tl_platform:
@@ -305,7 +349,7 @@ def tensorleap_integration_test():
             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],
+            validate_args_structure(*args, types_order=[Union[int, str, list], PreprocessResponse],
                                     func_name='integration_test', expected_names=expected_names,
                                     **kwargs)
             sample_id, preprocess_response = (
@@ -329,6 +373,8 @@ def tensorleap_integration_test():
                 _reset_model_loop_state()
                 ret = integration_test_function(*args, **kwargs)
 
+                global _mapping_dataset_is_grouped
+                _mapping_dataset_is_grouped = args[1].is_grouped
                 try:
                     os.environ[mapping_runtime_mode_env_var_mame] = 'True'
                     _reset_model_loop_state()
@@ -349,6 +395,7 @@ def tensorleap_integration_test():
                                         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:
+                    _mapping_dataset_is_grouped = False
                     if mapping_runtime_mode_env_var_mame in os.environ:
                         del os.environ[mapping_runtime_mode_env_var_mame]
             finally:
@@ -639,10 +686,29 @@ def tensorleap_load_model(prediction_types: Optional[List[PredictionTypeHandler]
 
             class ModelPlaceholder:
 
+                @staticmethod
+                def _reject_reused_input_source(elem, seen):
+                    # A model input slot is wired by mutating elem.node_mapping.type, so the same
+                    # source object at two positions silently overwrites the first slot. Each input
+                    # encoder mints its own NodeMapping, so a collision means one source fed two
+                    # slots — e.g. indexing a single grouped input, model([imgs[0], imgs[1]]), where
+                    # imgs[i] returns the same node (a group is the batch dim of ONE input, not many
+                    # inputs), or the flat model([img, img]). Reject it instead of mis-wiring.
+                    if id(elem.node_mapping) in seen:
+                        raise Exception(
+                            "The same input source was passed to more than one model input slot. Each "
+                            "model input must come from a distinct input encoder. Indexing a single "
+                            "grouped input (e.g. model([imgs[0], imgs[1]])) feeds several samples of ONE "
+                            "input into separate slots — a group is the batch dimension of one input, "
+                            "not multiple inputs.")
+                    seen.add(id(elem.node_mapping))
+
                 # keras interface
                 def __call__(self, arg):
                     if isinstance(arg, list):
+                        seen: set = set()
                         for i, elem in enumerate(arg):
+                            self._reject_reused_input_source(elem, seen)
                             elem.node_mapping.type = _safe_get_item(i)
                     else:
                         arg.node_mapping.type = NodeMappingType.Input0
@@ -656,7 +722,9 @@ def tensorleap_load_model(prediction_types: Optional[List[PredictionTypeHandler]
                                                   "use model.run(None, inputs) to return all outputs.")
                     assert isinstance(input_dict, dict), \
                         f'Expected input_dict to be a dict, got {type(input_dict)} instead.'
+                    seen: set = set()
                     for i, (input_key, elem) in enumerate(input_dict.items()):
+                        self._reject_reused_input_source(elem, seen)
                         if isinstance(input_key, NodeMappingType):
                             elem.node_mapping.type = input_key
                         else:
@@ -1561,13 +1629,10 @@ def tensorleap_metadata(
                 raise Exception(f'Metadata with name {name} already exists. '
                                 f'Please choose another')
 
-        def _validate_input_args(sample_id: Union[int, str], preprocess_response: PreprocessResponse):
-            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_input_args(sample_id: Union[int, str, list], preprocess_response: PreprocessResponse):
+            _validate_id_or_group(sample_id, preprocess_response, user_function.__name__)
 
-        def _validate_result(result):
+        def _validate_single(result):
             supported_result_types = (type(None), int, str, bool, float, dict, np.floating,
                                       np.bool_, np.unsignedinteger, np.signedinteger, np.integer)
             if isinstance(result, tuple):
@@ -1585,6 +1650,20 @@ def tensorleap_metadata(
                         (f'{user_function.__name__}() validation failed: '
                          f'Values in the return dict should be of type {str(supported_result_types)}. Got {type(value)}.')
 
+        def _validate_result(result, grouped=False, group_size=None):
+            if not grouped:
+                _validate_single(result)
+                return
+            # Grouped metadata: a list of `group_size` per-sample scalars/dicts.
+            assert isinstance(result, list), \
+                (f'{user_function.__name__}() validation failed: expected a grouped output for a group '
+                 f'of {group_size}: a list of {group_size} metadata values, got {type(result)}.')
+            assert len(result) == group_size, \
+                (f'{user_function.__name__}() validation failed: expected a grouped output for a group '
+                 f'of {group_size}: a list of {group_size} metadata values, got {len(result)}.')
+            for value in result:
+                _validate_single(value)
+
         def inner_without_validate(sample_id, preprocess_response):
 
             global _called_from_inside_tl_decorator
@@ -1604,14 +1683,16 @@ def tensorleap_metadata(
                 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],
+            validate_args_structure(*args, types_order=[Union[int, str, list], PreprocessResponse],
                                     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)
 
+            grouped = isinstance(sample_id, list)
+            group_size = len(sample_id) if grouped else None
             result = inner_without_validate(sample_id, preprocess_response)
 
-            _validate_result(result)
+            _validate_result(result, grouped, group_size)
             if not _call_from_tl_platform:
                 update_env_params_func("tensorleap_metadata", "v")
             return result
@@ -1623,35 +1704,50 @@ def tensorleap_metadata(
 
 def tensorleap_custom_latent_space():
     def decorating_function(user_function: SectionCallableInterface):
-        def _validate_input_args(sample_id: Union[int, str], preprocess_response: PreprocessResponse):
-            assert isinstance(sample_id, (int, str)), \
-                (f'tensorleap_custom_latent_space validation failed: '
-                 f'Argument sample_id should be either int or str. Got {type(sample_id)}.')
-            assert isinstance(preprocess_response, PreprocessResponse), \
-                (f'tensorleap_custom_latent_space validation failed: '
-                 f'Argument preprocess_response should be a PreprocessResponse. Got {type(preprocess_response)}.')
-            assert type(sample_id) == preprocess_response.sample_id_type, \
-                (f'tensorleap_custom_latent_space 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_input_args(sample_id: Union[int, str, list], preprocess_response: PreprocessResponse):
+            _validate_id_or_group(sample_id, preprocess_response, 'tensorleap_custom_latent_space')
 
-        def _validate_result(result):
-            assert isinstance(result, np.ndarray), \
+        def _validate_single(single_result):
+            assert isinstance(single_result, np.ndarray), \
                 (f'tensorleap_custom_latent_space validation failed: '
-                 f'The return type should be a numpy array. Got {type(result)}.')
-            if result.ndim > 1:
-                flat_dim = int(np.prod(result.shape))
+                 f'The return type should be a numpy array. Got {type(single_result)}.')
+            if single_result.ndim > 1:
+                flat_dim = int(np.prod(single_result.shape))
                 store_general_warning(
-                    key=("tensorleap_custom_latent_space_flatten", tuple(result.shape)),
+                    key=("tensorleap_custom_latent_space_flatten", tuple(single_result.shape)),
                     message=(
-                        f"tensorleap_custom_latent_space returned per-sample shape {tuple(result.shape)} "
-                        f"(ndim={result.ndim}). Tensorleap assumes per-sample shape (d, ...) and will "
+                        f"tensorleap_custom_latent_space returned per-sample shape {tuple(single_result.shape)} "
+                        f"(ndim={single_result.ndim}). Tensorleap assumes per-sample shape (d, ...) and will "
                         f"flatten to ({flat_dim},) before downstream visualization and clustering. "
                         f"If you want a different aggregation (e.g. global average pooling), do it "
                         f"inside your function."
                     ),
                 )
 
+        def _validate_result(result, grouped=False, group_size=None):
+            if not grouped:
+                _validate_single(result)
+                return
+            # Grouped: (B, *) array or list of B per-sample arrays. Validate each per-sample slice so
+            # the per-sample flatten check/warning uses the sample shape, not the (B, *) batch shape.
+            if isinstance(result, np.ndarray):
+                assert result.ndim >= 1 and result.shape[0] == group_size, \
+                    (f'tensorleap_custom_latent_space validation failed: expected a grouped output for a '
+                     f'group of {group_size}: an array with leading dim {group_size}, got shape {result.shape}.')
+                for single in result:
+                    _validate_single(single)
+            elif isinstance(result, list):
+                assert len(result) == group_size, \
+                    (f'tensorleap_custom_latent_space validation failed: expected a grouped output for a '
+                     f'group of {group_size}: a list of {group_size} arrays, got {len(result)}.')
+                for single in result:
+                    _validate_single(single)
+            else:
+                raise AssertionError(
+                    f'tensorleap_custom_latent_space validation failed: expected a grouped output for a '
+                    f'group of {group_size}: either an array with leading dim {group_size} or a list of '
+                    f'{group_size} arrays, got {type(result)}.')
+
         def inner_without_validate(sample_id, preprocess_response):
             global _called_from_inside_tl_decorator
             _called_from_inside_tl_decorator += 1
@@ -1671,9 +1767,11 @@ def tensorleap_custom_latent_space():
 
             _validate_input_args(sample_id, preprocess_response)
 
+            grouped = isinstance(sample_id, list)
+            group_size = len(sample_id) if grouped else None
             result = inner_without_validate(sample_id, preprocess_response)
 
-            _validate_result(result)
+            _validate_result(result, grouped, group_size)
             return result
 
         return inner
@@ -2642,6 +2740,15 @@ def tensorleap_preprocess():
             assert len(set(result)) == len(result), \
                 (f'{user_function.__name__}() validation failed: '
                  f'The return list should not contain duplicate PreprocessResponse objects.')
+            # All-or-none: a dataset is either all grouped (nested sample_ids) or all flat.
+            if len({response.is_grouped for response in result}) != 1:
+                shapes = ', '.join(
+                    f"#{i}={'grouped' if response.is_grouped else 'flat'}"
+                    for i, response in enumerate(result))
+                raise AssertionError(
+                    f'{user_function.__name__}() validation failed: '
+                    f'All PreprocessResponses must be either all grouped (nested sample_ids) '
+                    f'or all flat, but got a mix: {shapes}.')
 
         def inner(*args, **kwargs):
             if not _call_from_tl_platform:
@@ -2979,14 +3086,10 @@ def tensorleap_input_encoder(name: str, channel_dim=_UNSET, model_input_index=No
                 f"channel axis in the batched tensor (batch = axis 0), so 0 is invalid. Use 1 "
                 f"for channel-first (NCHW) and -1 for channel-last (NHWC).")
 
-        def _validate_input_args(sample_id: Union[int, str], preprocess_response: PreprocessResponse):
-            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_input_args(sample_id: Union[int, str, list], preprocess_response: PreprocessResponse):
+            _validate_id_or_group(sample_id, preprocess_response, user_function.__name__)
 
-        def _validate_result(result):
-            validate_output_structure(result, func_name=user_function.__name__, expected_type_name="np.ndarray")
+        def _validate_single(result):
             assert isinstance(result, np.ndarray), \
                 (f'{user_function.__name__}() validation failed: '
                  f'Unsupported return type. Should be a numpy array. Got {type(result)}.')
@@ -2996,6 +3099,13 @@ def tensorleap_input_encoder(name: str, channel_dim=_UNSET, model_input_index=No
             assert channel_dim - 1 <= len(result.shape), (f'{user_function.__name__}() validation failed: '
                                                           f'The channel_dim ({channel_dim}) should be <= to the rank of the resulting input rank ({len(result.shape)}).')
 
+        def _validate_result(result, grouped=False, group_size=None):
+            if not grouped:
+                validate_output_structure(result, func_name=user_function.__name__, expected_type_name="np.ndarray")
+                _validate_single(result)
+                return
+            _validate_grouped_result(result, group_size, user_function.__name__, _validate_single)
+
         def inner_without_validate(sample_id, preprocess_response):
             global _called_from_inside_tl_decorator
             _called_from_inside_tl_decorator += 1
@@ -3012,18 +3122,29 @@ def tensorleap_input_encoder(name: str, channel_dim=_UNSET, model_input_index=No
         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],
+            validate_args_structure(*args, types_order=[Union[int, str, list], PreprocessResponse],
                                     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)
 
+            grouped = isinstance(sample_id, list)
+            group_size = len(sample_id) if grouped else None
             result = inner_without_validate(sample_id, preprocess_response)
 
-            _validate_result(result)
+            _validate_result(result, grouped, group_size)
 
             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 grouped:
+                    # A grouped result is a list of per-sample arrays (never stacked, so a
+                    # B=1-only model can be fed one sample at a time). A user may also return a
+                    # supported (B, *) array; split it back into per-sample rows first (mirrors
+                    # LeapLoader._to_grouped_list) so both forms match the runtime path. Then add
+                    # a batch dim to each sample, mirroring the flat path's single-sample expand_dims.
+                    rows = result if isinstance(result, list) else [row for row in np.asarray(result)]
+                    result = [np.expand_dims(r, axis=0) for r in rows]
+                else:
+                    batch_warning(result, user_function.__name__)
+                    result = np.expand_dims(result, axis=0)
                 # Emit integration test event once per test
                 try:
                     emit_integration_event_once(AnalyticsEvent.INPUT_ENCODER_INTEGRATION_TEST, {
@@ -3044,8 +3165,15 @@ def tensorleap_input_encoder(name: str, channel_dim=_UNSET, model_input_index=No
         inner.node_mapping = NodeMapping(name, node_mapping_type)
 
         def mapping_inner(*args, **kwargs):
-            class TempMapping:
-                pass
+            if _mapping_dataset_is_grouped:
+                class TempMapping:
+                    def __getitem__(self, key):
+                        # Indexing a grouped input group (input_list[i]) selects a sample from the
+                        # same input source; the model wiring is identical to the un-grouped input.
+                        return self
+            else:
+                class TempMapping:
+                    pass
 
             ret = TempMapping()
             ret.node_mapping = mapping_inner.node_mapping
@@ -3075,15 +3203,10 @@ def tensorleap_gt_encoder(name: str):
                 raise Exception(f'GT with name {name} already exists. '
                                 f'Please choose another')
 
-        def _validate_input_args(sample_id: Union[int, str], preprocess_response: PreprocessResponse):
-            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_input_args(sample_id: Union[int, str, list], preprocess_response: PreprocessResponse):
+            _validate_id_or_group(sample_id, preprocess_response, user_function.__name__)
 
-        def _validate_result(result):
-            validate_output_structure(result, func_name=user_function.__name__, expected_type_name="np.ndarray",
-                                      gt_flag=True)
+        def _validate_single(result):
             assert isinstance(result, np.ndarray), \
                 (f'{user_function.__name__}() validation failed: '
                  f'Unsupported return type. Should be a numpy array. Got {type(result)}.')
@@ -3091,6 +3214,14 @@ def tensorleap_gt_encoder(name: str):
                 (f'{user_function.__name__}() validation failed: '
                  f'The return type should be a numpy array of type float32. Got {result.dtype}.')
 
+        def _validate_result(result, grouped=False, group_size=None):
+            if not grouped:
+                validate_output_structure(result, func_name=user_function.__name__, expected_type_name="np.ndarray",
+                                          gt_flag=True)
+                _validate_single(result)
+                return
+            _validate_grouped_result(result, group_size, user_function.__name__, _validate_single)
+
         def inner_without_validate(sample_id, preprocess_response):
             global _called_from_inside_tl_decorator
             _called_from_inside_tl_decorator += 1
@@ -3107,18 +3238,29 @@ def tensorleap_gt_encoder(name: str):
         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],
+            validate_args_structure(*args, types_order=[Union[int, str, list], PreprocessResponse],
                                     func_name=user_function.__name__, expected_names=["idx", "preprocess"], **kwargs)
-            sample_id, preprocess_response = args
+            sample_id, preprocess_response = args if len(args) != 0 else kwargs.values()
             _validate_input_args(sample_id, preprocess_response)
 
+            grouped = isinstance(sample_id, list)
+            group_size = len(sample_id) if grouped else None
             result = inner_without_validate(sample_id, preprocess_response)
 
-            _validate_result(result)
+            _validate_result(result, grouped, group_size)
 
             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 grouped:
+                    # A grouped result is a list of per-sample arrays (never stacked, so a
+                    # B=1-only model can be fed one sample at a time). A user may also return a
+                    # supported (B, *) array; split it back into per-sample rows first (mirrors
+                    # LeapLoader._to_grouped_list) so both forms match the runtime path. Then add
+                    # a batch dim to each sample, mirroring the flat path's single-sample expand_dims.
+                    rows = result if isinstance(result, list) else [row for row in np.asarray(result)]
+                    result = [np.expand_dims(r, axis=0) for r in rows]
+                else:
+                    batch_warning(result, user_function.__name__)
+                    result = np.expand_dims(result, axis=0)
                 _register_chain_artifact(result, 'ground_truth')
                 # Emit integration test event once per test
                 try:
@@ -3134,8 +3276,15 @@ def tensorleap_gt_encoder(name: str):
         inner.node_mapping = NodeMapping(name, NodeMappingType.GroundTruth)
 
         def mapping_inner(*args, **kwargs):
-            class TempMapping:
-                pass
+            if _mapping_dataset_is_grouped:
+                class TempMapping:
+                    def __getitem__(self, key):
+                        # Indexing a grouped GT group (gt_list[i]) selects a sample from the same
+                        # ground-truth source; wiring is identical to the un-grouped GT node.
+                        return self
+            else:
+                class TempMapping:
+                    pass
 
             ret = TempMapping()
             ret.node_mapping = mapping_inner.node_mapping

code_loader/leaploader.py

@@ -60,14 +60,36 @@ class LeapLoader(LeapLoaderBase):
 
     @lru_cache()
     def exec_script(self) -> None:
+        from code_loader.inner_leap_binder import leapbinder_decorators as _leap_dec
         try:
             os.environ[mapping_runtime_mode_env_var_mame] = 'TRUE'
             self.evaluate_module()
+
+            # A grouped integration test may index a grouped input/gt (image_list[i]) to wire a
+            # single sample of a group; that indexing is only valid when the mapping graph is
+            # built in grouped mode. Detect grouped-ness so the placeholder pass below matches
+            # the dataset. Preprocess is stubbed while mapping mode is on, so run it with mapping
+            # mode momentarily disabled, and cache it so _preprocess_result() doesn't re-run it.
+            is_grouped = False
+            if global_leap_binder.integration_test_func is not None:
+                del os.environ[mapping_runtime_mode_env_var_mame]
+                try:
+                    preprocess_result = global_leap_binder.get_preprocess_result()
+                    self._preprocess_result_cached = preprocess_result
+                    is_grouped = any(r.is_grouped for r in preprocess_result.values())
+                finally:
+                    os.environ[mapping_runtime_mode_env_var_mame] = 'TRUE'
+
+            _leap_dec._mapping_dataset_is_grouped = is_grouped
             if global_leap_binder.integration_test_func is not None:
                 from code_loader.inner_leap_binder.leapbinder_decorators import \
                     _reset_model_loop_state
                 _reset_model_loop_state()
-                global_leap_binder.integration_test_func(None, PreprocessResponse(state=DataStateType.training, length=0))
+                mapping_preprocess = (
+                    PreprocessResponse(sample_ids=[["__mapping_placeholder__"]], state=DataStateType.training)
+                    if is_grouped else
+                    PreprocessResponse(state=DataStateType.training, length=0))
+                global_leap_binder.integration_test_func(None, mapping_preprocess)
         except TypeError as e:
             import traceback
             global_leap_binder.setup_container = DatasetIntegrationSetup()
@@ -80,6 +102,7 @@ class LeapLoader(LeapLoaderBase):
             raise DatasetScriptException(getattr(e, 'message', repr(e))) from e
         finally:
             # ensure that the environment variable is removed after the script execution
+            _leap_dec._mapping_dataset_is_grouped = False
             if mapping_runtime_mode_env_var_mame in os.environ:
                 del os.environ[mapping_runtime_mode_env_var_mame]
 
@@ -209,7 +232,7 @@ class LeapLoader(LeapLoaderBase):
         additional = self._preprocess_result().get(DataStateEnum.additional)
         if additional is None:
             return set()
-        return set(additional.sample_ids)
+        return set(additional.flat_sample_ids)
 
     def _resolve_synthetic(self, sample_id: Union[int, str],
                            state: Optional[DataStateEnum] = None
@@ -250,16 +273,20 @@ class LeapLoader(LeapLoaderBase):
             )
 
         preprocess_result = self._preprocess_result()
-        if state == DataStateEnum.unlabeled and sample_id not in preprocess_result[state].sample_ids:
+        if state == DataStateEnum.unlabeled and sample_id not in preprocess_result[state].flat_sample_ids:
             self._preprocess_result(update_unlabeled_preprocess=True)
 
         metadata, metadata_is_none = self.get_metadata(state, sample_id)
 
         custom_latent_space = None
         if global_leap_binder.setup_container.custom_latent_space is not None:
-            custom_latent_space = global_leap_binder.setup_container.custom_latent_space.function(sample_id,
-                                                                                                  preprocess_result[
-                                                                                                      state])
+            latent_fn = global_leap_binder.setup_container.custom_latent_space.function
+            preprocess_state = preprocess_result[state]
+            if preprocess_state.is_grouped:
+                group_ids, pos = self._locate_group(preprocess_state, sample_id)
+                custom_latent_space = self._to_grouped_list(latent_fn(group_ids, preprocess_state))[pos]
+            else:
+                custom_latent_space = latent_fn(sample_id, preprocess_state)
         instance_mask = self._get_instances_masks(state, sample_id, instance_id)
         sample = DatasetSample(inputs=self._get_inputs(state, sample_id),
                                gt=None if state == DataStateEnum.unlabeled else self._get_gt(state, sample_id),
@@ -387,10 +414,10 @@ class LeapLoader(LeapLoaderBase):
         test_result = DatasetTestResultPayload('preprocess')
         try:
             preprocess_result = self._preprocess_result()
-            if self.get_sample_id_type() is str:
+            if issubclass(self.get_sample_id_type(), str):
                 max_allowed_item_size = np.dtype('<U256').itemsize
                 for state, preprocess_response in preprocess_result.items():
-                    sample_ids_array = np.array(preprocess_response.sample_ids)
+                    sample_ids_array = np.array(preprocess_response.flat_sample_ids)
                     if sample_ids_array.dtype.itemsize > max_allowed_item_size:
                         raise Exception(f"Sample id are too long. Max allowed length is 256 charecters.")
 
@@ -451,6 +478,10 @@ class LeapLoader(LeapLoaderBase):
                 preprocess_response.tl_generated = True
                 if preprocess_response.length < 1:
                     raise ValueError("Simulation returned PreprocessResponse with length < 1")
+                if preprocess_response.is_grouped:
+                    raise ValueError(
+                        "Simulation returned a grouped PreprocessResponse; simulations must "
+                        "return a flat (non-grouped) PreprocessResponse.")
                 preprocess_response.sample_ids = [0]
                 for handler in global_leap_binder.setup_container.inputs:
                     out1 = handler.function(preprocess_response.sample_ids[0], preprocess_response)
@@ -486,7 +517,10 @@ class LeapLoader(LeapLoaderBase):
                 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]
+                # Grouped preprocess is fine: grouping only amortizes the shared base reads
+                # (GT/metadata/custom_latent) — the AR hook always drives a single scalar chain
+                # and is never handed a group.
+                sample_id = preprocess_response.flat_sample_ids[0]
                 first_result = handler.function(sample_id, None, None, None, preprocess_response)
                 second_result = handler.function(sample_id, None, None, None, preprocess_response)
                 if not isinstance(first_result, tuple) or len(first_result) != 2:
@@ -567,7 +601,7 @@ class LeapLoader(LeapLoaderBase):
         if handler.input_shapes is None:
             preprocess_result = self._preprocess_result()
             first_state_response = next(iter(preprocess_result.values()))
-            first_sample_id = first_state_response.sample_ids[0]
+            first_sample_id = first_state_response.flat_sample_ids[0]
             first_result = handler.function(first_sample_id, None, None, None,
                                             first_state_response)
             if not isinstance(first_result, tuple) or len(first_result) != 2 or \
@@ -906,6 +940,57 @@ class LeapLoader(LeapLoaderBase):
 
         return sample_ids
 
+    @staticmethod
+    def _grouped_dict_keys(rows: List[Dict[str, Any]], handler_name: str) -> List[str]:
+        """Keys for a group of dict-metadata rows, requiring every row to share the same keys.
+        A group must expose a uniform metadata schema; otherwise the per-key lists would silently
+        drop or KeyError on rows that differ from row 0."""
+        keys = list(rows[0].keys())
+        key_set = set(keys)
+        for pos, row in enumerate(rows):
+            if set(row.keys()) != key_set:
+                raise ValueError(
+                    f"Metadata handler {handler_name!r} returned inconsistent dict keys across the "
+                    f"group: row 0 has {sorted(key_set)} but row {pos} has {sorted(row.keys())}. "
+                    f"All rows in a group must share the same metadata keys.")
+        return keys
+
+    @staticmethod
+    def _to_grouped_list(raw: Any) -> List[npt.NDArray[np.float32]]:
+        """Normalize a grouped encoder result to a list of per-sample arrays.
+
+        Grouped results are NEVER stacked into a (B, *) batch. Grouping is only a storage
+        read-unit (one file load per group); assembling the model batch (B) is the engine's
+        single responsibility, so it stays the only place samples get batched. Keeping
+        per-sample arrays lets the engine batch to any B — including a B=1-only model — without
+        an intermediate stack/unstack. A user encoder that already returned a stacked (B, *)
+        array is split back into its per-sample rows so the contract is a list either way."""
+        if isinstance(raw, list):
+            return raw
+        return [row for row in np.asarray(raw)]
+
+    def _locate_group(self, preprocess_state: PreprocessResponse,
+                      sample_id: Union[int, str]) -> Tuple[List[Union[int, str]], int]:
+        """Map a sample id to (its group, its position in that group). Cached on the
+        PreprocessResponse itself (not keyed by id() on this loader) so grouped single-sample
+        fetches don't rescan the groups, and the cache can never go stale: when the response is
+        replaced (e.g. unlabeled preprocess refresh), the old object and its cache are simply
+        discarded together instead of lingering under a possibly-reused id()."""
+        mapping = preprocess_state._group_pos_cache
+        if mapping is None:
+            mapping = {}
+            for group in preprocess_state.groups:
+                for pos, sid in enumerate(group):
+                    if sid in mapping:
+                        raise ValueError(
+                            f"Duplicate sample id {sid!r} across groups in the preprocess response; "
+                            f"sample ids must be unique within and across groups.")
+                    mapping[sid] = (group, pos)
+            preprocess_state._group_pos_cache = mapping
+        if sample_id not in mapping:
+            raise KeyError(f"Sample id {sample_id!r} is not present in any group of this preprocess response.")
+        return mapping[sample_id]
+
     def _get_dataset_handlers(self, handlers: Iterable[DatasetBaseHandler],
                               state: DataStateEnum, sample_id: Union[int, str]) -> Dict[str, npt.NDArray[np.float32]]:
         result_agg = {}
@@ -917,12 +1002,101 @@ class LeapLoader(LeapLoaderBase):
             sample_id = original_local_id
         else:
             preprocess_state = preprocess_result[state]
+        if preprocess_state.is_grouped:
+            # Grouped dataset: call the encoder once with the whole group, index out the sample.
+            group_ids, pos = self._locate_group(preprocess_state, sample_id)
+            for handler in handlers:
+                grouped = self._to_grouped_list(handler.function(group_ids, preprocess_state))
+                result_agg[handler.name] = grouped[pos]
+            return result_agg
         for handler in handlers:
             handler_result = handler.function(sample_id, preprocess_state)
             handler_name = handler.name
             result_agg[handler_name] = handler_result
         return result_agg
 
+    def get_samples(self, state: DataStateEnum, group_ids: List[Union[int, str]]) -> DatasetSample:
+        """Group-aware fetch: hand the whole group to each encoder in a single call and return a
+        grouped DatasetSample (inputs/gt as per-sample lists of length B, metadata as per-key lists
+        of length B, index = the group). Grouped results are never stacked here — batching the
+        samples into the model's B is the engine's job. This is the path a group-aware engine calls
+        to read a file once per group. Row order matches group_ids exactly."""
+        self.exec_script()
+        preprocess_result = self._preprocess_result()
+        if state == DataStateEnum.unlabeled and any(
+                sid not in preprocess_result[state].flat_sample_ids for sid in group_ids):
+            # Mirrors get_sample's refresh: the unlabeled preprocess can grow between calls, so a
+            # group_id absent from the current snapshot may just not have been generated yet.
+            self._preprocess_result(update_unlabeled_preprocess=True)
+        preprocess_state = preprocess_result[state]
+        assert preprocess_state.is_grouped, (
+            "get_samples is the group-aware fetch path and requires a grouped preprocess "
+            "response; call get_sample for a flat (non-grouped) dataset.")
+        # All requested ids must belong to a single group (one file). A cross-group request
+        # would force the encoder to load multiple files, defeating the one-load-per-group
+        # contract; partitioning a scattered request by group is the engine's responsibility.
+        distinct_groups = {id(self._locate_group(preprocess_state, sid)[0]) for sid in group_ids}
+        assert len(distinct_groups) == 1, (
+            f"get_samples received sample ids spanning {len(distinct_groups)} groups; a request "
+            f"must be confined to a single group. The engine partitions cross-group requests and "
+            f"issues one get_samples call per group.")
+        inputs = {handler.name: self._to_grouped_list(handler.function(group_ids, preprocess_state))
+                  for handler in global_leap_binder.setup_container.inputs}
+        autoregressive_handler = global_leap_binder.setup_container.autoregressive_step
+        if autoregressive_handler is not None:
+            # AR integrations have no input encoders — the hook's first call supplies each
+            # chain's step-0 model inputs. The hook is strictly per-scalar-chain (never handed
+            # a group), so it is called once per flat id in the group and the per-sample results
+            # are collected into per-key lists of length B, matching the grouped (never-stacked)
+            # contract used for every other encoder here.
+            step_zero_per_sample = []
+            for sid in group_ids:
+                step_zero_result = autoregressive_handler.function(sid, None, None, None,
+                                                                    preprocess_state)
+                if not isinstance(step_zero_result, tuple) or len(step_zero_result) != 2 or \
+                        not isinstance(step_zero_result[0], dict):
+                    raise Exception(
+                        'The autoregressive step hook must return a (next_inputs, state) tuple '
+                        f'with a dict of initial model inputs on its first call, got '
+                        f'{type(step_zero_result)} for sample {sid}.')
+                self._validate_autoregressive_step_inputs(step_zero_result[0], sid)
+                step_zero_per_sample.append(step_zero_result[0])
+            if step_zero_per_sample:
+                for key in self._grouped_dict_keys(step_zero_per_sample, autoregressive_handler.name):
+                    inputs[key] = [row[key] for row in step_zero_per_sample]
+        gt = None
+        if state != DataStateEnum.unlabeled:
+            gt = {handler.name: self._to_grouped_list(handler.function(group_ids, preprocess_state))
+                  for handler in global_leap_binder.setup_container.ground_truths}
+
+        metadata: Dict[str, Any] = {}
+        metadata_is_none: Dict[str, Any] = {}
+        for handler in global_leap_binder.setup_container.metadata:
+            rows = handler.function(group_ids, preprocess_state)  # length-B sequence of scalars/dicts
+            if len(rows) > 0 and isinstance(rows[0], dict):
+                for key in self._grouped_dict_keys(rows, handler.name):
+                    name = "{}_{}".format(handler.name, key)
+                    converted = [self._convert_metadata_to_correct_type(name, row[key]) for row in rows]
+                    metadata[name] = [v for v, _ in converted]
+                    metadata_is_none[name] = [is_none for _, is_none in converted]
+            else:
+                converted = [self._convert_metadata_to_correct_type(handler.name, row) for row in rows]
+                metadata[handler.name] = [v for v, _ in converted]
+                metadata_is_none[handler.name] = [is_none for _, is_none in converted]
+
+        # custom_latent_space is group-aware like the input/GT encoders: hand it the whole group in a
+        # single call so a file-backed latent fn loads the file once, and normalize to (B, d). This
+        # keeps the mandatory group path non-lossy. instance_masks stay None here: they are a
+        # per-(sample, instance) concern that needs an instance_id the group fetch does not carry.
+        custom_latent_space = None
+        if global_leap_binder.setup_container.custom_latent_space is not None:
+            latent_fn = global_leap_binder.setup_container.custom_latent_space.function
+            custom_latent_space = self._to_grouped_list(latent_fn(group_ids, preprocess_state))
+
+        return DatasetSample(inputs=inputs, gt=gt, metadata=metadata, metadata_is_none=metadata_is_none,
+                             index=list(group_ids), state=state, custom_latent_space=custom_latent_space,
+                             instance_masks=None)
+
     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
@@ -1026,12 +1200,18 @@ class LeapLoader(LeapLoaderBase):
             sample_id = original_local_id
         else:
             preprocess_state = preprocess_result[state]
+        group_ids, pos = (None, None)
+        if preprocess_state.is_grouped:
+            group_ids, pos = self._locate_group(preprocess_state, sample_id)
         for handler in global_leap_binder.setup_container.metadata:
             if requested_metadata_names:
                 if not is_metadata_name_starts_with_handler_name(handler):
                     continue
 
-            handler_result = handler.function(sample_id, preprocess_state)
+            if preprocess_state.is_grouped:
+                handler_result = handler.function(group_ids, preprocess_state)[pos]
+            else:
+                handler_result = handler.function(sample_id, preprocess_state)
             if isinstance(handler_result, dict):
                 for single_metadata_name, single_metadata_result in handler_result.items():
                     handler_name = f'{handler.name}_{single_metadata_name}'
@@ -1050,6 +1230,66 @@ class LeapLoader(LeapLoaderBase):
 
         return result_agg, is_none
 
+    def _grouped_metadata_for_group(self, preprocess_state: PreprocessResponse,
+                                    group_ids: List[Union[int, str]],
+                                    requested_metadata_names: Optional[List[str]]
+                                    ) -> Tuple[Dict[str, List[Any]], Dict[str, List[bool]]]:
+        def is_wanted(_handler):
+            if not requested_metadata_names:
+                return True
+            for metadata_name in requested_metadata_names:
+                if metadata_name.startswith(_handler.name + '_') or metadata_name == _handler.name:
+                    return True
+            return False
+
+        results: Dict[str, List[Any]] = {}
+        is_none: Dict[str, List[bool]] = {}
+        for handler in global_leap_binder.setup_container.metadata:
+            if requested_metadata_names and not is_wanted(handler):
+                continue
+            rows = handler.function(group_ids, preprocess_state)
+            if len(rows) > 0 and isinstance(rows[0], dict):
+                for key in self._grouped_dict_keys(rows, handler.name):
+                    name = f'{handler.name}_{key}'
+                    if requested_metadata_names and name not in requested_metadata_names:
+                        continue
+                    converted = [self._convert_metadata_to_correct_type(name, row[key]) for row in rows]
+                    results[name] = [v for v, _ in converted]
+                    is_none[name] = [n for _, n in converted]
+            else:
+                name = handler.name
+                if requested_metadata_names and name not in requested_metadata_names:
+                    continue
+                converted = [self._convert_metadata_to_correct_type(name, row) for row in rows]
+                results[name] = [v for v, _ in converted]
+                is_none[name] = [n for _, n in converted]
+        return results, is_none
+
+    def get_metadata_multiple_samples(self, state: DataStateEnum, sample_ids: Union[List[int], List[str]],
+                                      requested_metadata_names: Optional[List[str]] = None
+                                      ) -> Tuple[Dict[str, Union[List[str], List[int], List[bool], List[float]]],
+                                                 Dict[str, List[bool]]]:
+        preprocess_state = self._preprocess_result().get(state)
+        if preprocess_state is None or not preprocess_state.is_grouped:
+            return super().get_metadata_multiple_samples(state, sample_ids, requested_metadata_names)
+
+        sample_id_type = self.get_sample_id_type()
+        aggregated_results: Dict[str, List[Any]] = {}
+        aggregated_is_none: Dict[str, List[bool]] = {}
+        group_cache: Dict[int, Tuple[Dict[str, List[Any]], Dict[str, List[bool]]]] = {}
+        for sample_id in sample_ids:
+            sample_id = sample_id_type(sample_id)
+            group_ids, pos = self._locate_group(preprocess_state, sample_id)
+            key = id(group_ids)
+            if key not in group_cache:
+                group_cache[key] = self._grouped_metadata_for_group(
+                    preprocess_state, group_ids, requested_metadata_names)
+            group_results, group_is_none = group_cache[key]
+            for name, values in group_results.items():
+                aggregated_results.setdefault(name, []).append(values[pos])
+                aggregated_is_none.setdefault(name, []).append(group_is_none[name][pos])
+        return aggregated_results, aggregated_is_none
+
     @lru_cache()
     def get_sample_id_type(self) -> Type:
         preprocess_results = list(self._preprocess_result().values())

code_loader/utils.py

@@ -17,6 +17,16 @@ from code_loader.contract.enums import DatasetMetadataType
 def to_numpy_return_wrapper(encoder_function: SectionCallableInterface) -> SectionCallableInterface:
     def numpy_encoder_function(idx: Union[int, str], samples: PreprocessResponse) -> npt.NDArray[np.float32]:
         result = encoder_function(idx, samples)
+        if isinstance(idx, list):
+            # Grouped call (idx is a list of sample ids): never stack the per-sample results into a
+            # (B, *) batch — grouping is only a storage read-unit; batching the group to the model's
+            # B is the engine's single responsibility. Gate on the call shape (idx is a list), not
+            # the result shape, so a flat encoder returning a list of arrays still stacks below.
+            # Normalize each sample independently (a user-stacked (B, *) array is split back into its
+            # rows) so a ragged group — variable per-sample shapes, e.g. token lists of differing
+            # length — is preserved instead of crashing np.array() on an inhomogeneous shape.
+            rows = result if isinstance(result, list) else np.asarray(result)
+            return [np.asarray(sample) for sample in rows]
         numpy_result: npt.NDArray[np.float32] = np.array(result)
         return numpy_result
 

{code_loader-1.0.195.dev0.dist-info → code_loader-1.0.196.dist-info}/METADATA

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

{code_loader-1.0.195.dev0.dist-info → code_loader-1.0.196.dist-info}/RECORD

@@ -1,7 +1,7 @@
 LICENSE,sha256=qIwWjdspQeSMTtnFZBC8MuT-95L02FPvzRUdWFxrwJY,1067
 code_loader/__init__.py,sha256=outxRQ0M-zMfV0QGVJmAed5qWfRmyD0TV6-goEGAzBw,406
 code_loader/contract/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-code_loader/contract/datasetclasses.py,sha256=jsVwxrE3X1CbR62JFR2xGNLe_Xe1O52p0kFFXkT1mSM,13751
+code_loader/contract/datasetclasses.py,sha256=qJoC2pPrVLwJiNGQlPUmnM4vgGNxEv4LHPjovVunTGc,16741
 code_loader/contract/enums.py,sha256=2q-IV_5g9lLE306DIbWA1c0tn5IhDtxsKxyV1x_Lreg,1671
 code_loader/contract/exceptions.py,sha256=jWqu5i7t-0IG0jGRsKF4DjJdrsdpJjIYpUkN1F4RiyQ,51
 code_loader/contract/mapping.py,sha256=sWJhpng-IkOzQnWQdMT5w2ZZ3X1Z_OOzSwCLXIS7oxE,1446
@@ -21,18 +21,18 @@ code_loader/experiment_api/types.py,sha256=MY8xFARHwdVA7p4dxyhD60ShmttgTvb4qdp1o
 code_loader/experiment_api/utils.py,sha256=XZHtxge12TS4H4-8PjV3sKuhp8Ud6ojAiIzTZJEqBqc,3304
 code_loader/experiment_api/workingspace_config_utils.py,sha256=DLzXQCg4dgTV_YgaSbeTVzq-2ja_SQw4zi7LXwKL9cY,990
 code_loader/inner_leap_binder/__init__.py,sha256=koOlJyMNYzGbEsoIbXathSmQ-L38N_pEXH_HvL7beXU,99
-code_loader/inner_leap_binder/leapbinder.py,sha256=4cbSEbN6vVwjFUMxDEksxk1VSCip2ntLB32RxA81_JE,53194
-code_loader/inner_leap_binder/leapbinder_decorators.py,sha256=eHdSRCYtfkHtq7NSlS4bF92TU8RGRzZ1gbb3ULeEV2c,176145
-code_loader/leaploader.py,sha256=ME1Ypq9VV3o9XXOCV6voDWWVP0gB4Z0LoJh6u79qDYY,68370
+code_loader/inner_leap_binder/leapbinder.py,sha256=RSYiWtIxrIV7a466oPTEupP5SF9eOkZZotr_rp7yCHs,56880
+code_loader/inner_leap_binder/leapbinder_decorators.py,sha256=-t1N-kFGednAjbWaIe6QtgqwI-EkYn-r868mC2_Kz8A,185311
+code_loader/leaploader.py,sha256=nOBXHRb8NHGL5YQIr4xu-a_2uxCR68ptJPO8s-cXGmU,83738
 code_loader/leaploaderbase.py,sha256=PvBU_2OQqBfJLDMsbK1s372954eYr4Y3O4r18y5S7uY,10739
 code_loader/mixpanel_tracker.py,sha256=rNwRmFifNbdUoqLQvvhhgpKczWpWiEmd8MfyJe27sxw,9131
 code_loader/plot_functions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 code_loader/plot_functions/plot_functions.py,sha256=2DC-zlVaN13P4VNx5d8csgs80C6SisaeP1-Kq2LW7iM,16075
 code_loader/plot_functions/visualize.py,sha256=gsBAYYkwMh7jIpJeDMPS8G4CW-pxwx6LznoQIvi4vpo,657
-code_loader/utils.py,sha256=gEJCKpDWf6p9_KoEz-0EGiJqxD6QfPgZN6zdKdtSAz8,6628
+code_loader/utils.py,sha256=Yj06BbS1UIjN9Cv2eQBjDfdDbpQlABAg6KwD3sB1BZ0,7496
 code_loader/visualizers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 code_loader/visualizers/default_visualizers.py,sha256=onRnLE_TXfgLN4o52hQIOOhUcFexGlqJ3xSpQDVLuZM,2604
-code_loader-1.0.195.dev0.dist-info/LICENSE,sha256=qIwWjdspQeSMTtnFZBC8MuT-95L02FPvzRUdWFxrwJY,1067
-code_loader-1.0.195.dev0.dist-info/METADATA,sha256=q8UczKAxuYThEseqP4aXcS5ET0DfpjPaRmIy4aKDl1I,1095
-code_loader-1.0.195.dev0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-code_loader-1.0.195.dev0.dist-info/RECORD,,
+code_loader-1.0.196.dist-info/LICENSE,sha256=qIwWjdspQeSMTtnFZBC8MuT-95L02FPvzRUdWFxrwJY,1067
+code_loader-1.0.196.dist-info/METADATA,sha256=4lBr3zHokWAXKIg6Re-ijpT97AvOSLhIJS4mZnDPfSc,1090
+code_loader-1.0.196.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+code_loader-1.0.196.dist-info/RECORD,,