code-loader 1.0.190.dev0__py3-none-any.whl → 1.0.191.dev1__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
+from typing import Any, Callable, List, Optional, Dict, Union, Type, Literal, 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,44 @@ 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)
 
     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
+            self._grouped = False
         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 = 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])
+                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)}"
         else:
             raise Exception("length is deprecated, please use sample_ids instead.")
 
@@ -79,9 +98,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

@@ -606,6 +606,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]:
@@ -626,7 +635,13 @@ 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)
+        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.
+            group = preprocess_response.sample_ids[0]
+            raw_result = dataset_base_handler.function(group, preprocess_response)[0]
+        else:
+            raw_result = dataset_base_handler.function(preprocess_response.sample_ids[0], preprocess_response)
         handler_type = 'metadata' if isinstance(dataset_base_handler, MetadataHandler) else None
         if isinstance(dataset_base_handler, MetadataHandler):
             if isinstance(raw_result, dict):

code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -32,6 +32,7 @@ from code_loader.mixpanel_tracker import clear_integration_events, AnalyticsEven
 
 _called_from_inside_tl_decorator = 0
 _called_from_inside_tl_integration_test_decorator = False
+_mapping_dataset_is_grouped = False
 _call_from_tl_platform = os.environ.get('IS_TENSORLEAP_PLATFORM') == 'true'
 
 # ---- warnings store (module-level) ----
@@ -197,14 +198,58 @@ def validate_output_structure(result, func_name: str, expected_type_name="np.nda
 def batch_warning(result, func_name):
     if len(result.shape) > 0 and result.shape[0] == 1:
         warnings.warn(
-            f"{func_name} warning: Tensorleap will add a batch dimension at axis 0 of "
-            f"{func_name}'s output, but axis 0 is already size 1 — this can produce a "
-            f"doubly-batched shape (e.g. (1, 1, ...)). If axis 0 is a real dimension "
-            f"(e.g. a single channel) and not an accidental batch, you can ignore this; "
-            f"only fix it if you pre-batched the output."
+            f"{func_name} warning: Tensorleap will add a batch dimension at axis 0 to the output of {func_name}, "
+            f"although the detected size of axis 0 is already 1. "
+            f"This may lead to an extra batch dimension (e.g., shape (1, 1, ...)). "
+            f"Please ensure that the output of '{func_name}' is not already batched "
+            f"to avoid computation errors."
         )
 
 
+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)."""
+    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}.')
+        validate_single(result)
+    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)]
@@ -282,16 +327,12 @@ 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:
                 set_current('tensorleap_integration_test')
-            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=["idx", "preprocess"], **kwargs)
             _validate_input_args(*args, **kwargs)
 
@@ -308,6 +349,8 @@ def tensorleap_integration_test():
                                            "v")  # put here because otherwise it will become  v only if it finishes all the script
                 ret = integration_test_function(*args, **kwargs)
 
+                global _mapping_dataset_is_grouped
+                _mapping_dataset_is_grouped = args[1].is_grouped
                 try:
                     os.environ[mapping_runtime_mode_env_var_mame] = 'True'
                     integration_test_function(None, PreprocessResponse(state=DataStateType.training, length=0))
@@ -318,15 +361,16 @@ def tensorleap_integration_test():
                     line_number = first_tb.lineno
                     if isinstance(e, TypeError) and 'is not subscriptable' in str(e):
                         update_env_params_func("code_mapping", "x")
-                        raise (f'Invalid integration code. File {file_name}, line {line_number}: '
+                        raise Exception(f'Invalid integration code. File {file_name}, line {line_number}: '
                                f"indexing is supported only on the model's predictions inside the integration test. Please remove this indexing operation usage from the integration test code.")
                     else:
                         update_env_params_func("code_mapping", "x")
 
-                        raise (f'Invalid integration code. File {file_name}, line {line_number}: '
+                        raise Exception(f'Invalid integration code. File {file_name}, line {line_number}: '
                                f'Integration test is only allowed to call Tensorleap decorators. '
                                f'Ensure any arithmetics, external library use, Python logic is placed within Tensorleap decoders')
                 finally:
+                    _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:
@@ -349,14 +393,6 @@ def _safe_get_item(key):
 
 
 def tensorleap_load_model(prediction_types: Optional[List[PredictionTypeHandler]] = _UNSET):
-    """Register the model-loading function.
-
-    ``prediction_types``: declare one ``PredictionTypeHandler`` per model output, in
-    output order. Multi-output models must declare an entry for EVERY output — the
-    count is validated against the model's outputs — so for an output you don't consume
-    as a prediction, pass a throwaway handler to satisfy the count. Omit the argument
-    only when the model has a single prediction output.
-    """
     prediction_types_was_provided = prediction_types is not _UNSET
 
     if not prediction_types_was_provided:
@@ -575,9 +611,6 @@ def tensorleap_load_model(prediction_types: Optional[List[PredictionTypeHandler]
                 def get_inputs(self):
                     return self.model.get_inputs()
 
-                def get_outputs(self):
-                    return self.model.get_outputs()
-
             model_placeholder = ModelPlaceholder(prediction_types)
             if not _call_from_tl_platform:
                 update_env_params_func("tensorleap_load_model", "v")
@@ -642,13 +675,6 @@ def tensorleap_load_model(prediction_types: Optional[List[PredictionTypeHandler]
 
                     return FollowInputIndex()
 
-                def get_outputs(self):
-                    # Mapping-mode counterpart of the ONNX-run get_outputs(): in mapping
-                    # mode outputs are reached by index, and get_outputs()[i] resolves to
-                    # Prediction{i} — exactly like run()/__call__, which also return a
-                    # ModelOutputPlaceholder. Reusing it keeps the mapping unchanged.
-                    return ModelOutputPlaceholder()
-
             return ModelPlaceholder()
 
         def final_inner(*args, **kwargs):
@@ -1526,13 +1552,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):
@@ -1550,6 +1573,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
@@ -1569,14 +1606,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
@@ -1588,35 +1627,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
@@ -1636,9 +1690,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
@@ -1676,6 +1732,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:
@@ -2013,14 +2078,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)}.')
@@ -2030,6 +2091,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
@@ -2046,16 +2114,18 @@ 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:
+            if not grouped and _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)
                 # Emit integration test event once per test
@@ -2078,8 +2148,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
@@ -2109,15 +2186,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)}.')
@@ -2125,6 +2197,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
@@ -2141,16 +2221,18 @@ 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
             _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:
+            if not grouped and _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)
                 # Emit integration test event once per test
@@ -2167,8 +2249,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

@@ -246,16 +246,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_array(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),
@@ -320,6 +324,8 @@ class LeapLoader(LeapLoaderBase):
             try:
                 self.exec_script()
 
+                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()
@@ -356,6 +362,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:
@@ -363,7 +386,7 @@ class LeapLoader(LeapLoaderBase):
             if self.get_sample_id_type() is 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.")
 
@@ -724,6 +747,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_array(raw: Any) -> Union[npt.NDArray[np.float32], List[npt.NDArray[np.float32]]]:
+        """Normalize a grouped encoder result. A list of uniformly-shaped per-sample arrays is
+        stacked into a single (B, *) array; a list whose samples differ in shape is kept as a
+        list of per-sample arrays (variable-dim groups); an already-grouped array is returned
+        as-is."""
+        if isinstance(raw, list):
+            shapes = {np.asarray(sample).shape for sample in raw}
+            if len(shapes) == 1:
+                return np.stack(raw, axis=0)
+            return raw
+        return 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 per
+        PreprocessResponse so grouped single-sample fetches don't rescan the groups."""
+        cache = getattr(self, '_group_pos_cache', None)
+        if cache is None:
+            cache = {}
+            self._group_pos_cache = cache
+        mapping = cache.get(id(preprocess_state))
+        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)
+            cache[id(preprocess_state)] = 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 = {}
@@ -735,12 +809,70 @@ 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_array(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 (B, *), metadata as per-key lists of length B, index =
+        the group). 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_state = self._preprocess_result()[state]
+        if preprocess_state.is_grouped:
+            # 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_array(handler.function(group_ids, preprocess_state))
+                  for handler in global_leap_binder.setup_container.inputs}
+        gt = None
+        if state != DataStateEnum.unlabeled:
+            gt = {handler.name: self._to_grouped_array(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)  # list of B scalars/dicts
+            if rows 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_array(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]]:
         return self._get_dataset_handlers(global_leap_binder.setup_container.inputs, state, sample_id)
 
@@ -821,12 +953,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}'
@@ -845,6 +983,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 rows 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

@@ -14,6 +14,11 @@ 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(result, list) and len(result) > 0 and all(isinstance(sample, np.ndarray) for sample in result):
+            if len({sample.shape for sample in result}) > 1:
+                # Variable per-sample shapes within a group: keep the per-sample arrays as a list
+                # instead of forcing a stack that would raise an inhomogeneous-shape error.
+                return result
         numpy_result: npt.NDArray[np.float32] = np.array(result)
         return numpy_result
 

code_loader-1.0.191.dev1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 TensorLeap
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{code_loader-1.0.190.dev0.dist-info → code_loader-1.0.191.dev1.dist-info}/METADATA

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: code-loader
-Version: 1.0.190.dev0
+Version: 1.0.191.dev1
 Summary: 
+Home-page: https://github.com/tensorleap/code-loader
 License: MIT
 Author: dorhar
 Author-email: doron.harnoy@tensorleap.ai
@@ -19,7 +20,6 @@ Requires-Dist: numpy (>=2.3.2,<3.0.0) ; python_version >= "3.11" and python_vers
 Requires-Dist: psutil (>=5.9.5,<6.0.0)
 Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
-Project-URL: Homepage, https://github.com/tensorleap/code-loader
 Project-URL: Repository, https://github.com/tensorleap/code-loader
 Description-Content-Type: text/markdown
 

{code_loader-1.0.190.dev0.dist-info → code_loader-1.0.191.dev1.dist-info}/RECORD

@@ -1,6 +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=RYZcnX7vLMYhyQtCbX2PscVFNAYULxgAA9U4DRRfLqA,10456
+code_loader/contract/datasetclasses.py,sha256=xkem0ONbgsTWEG_4G-hdkFLJie-xSXSQZBzsZcSjQbU,12724
 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
@@ -20,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=PAX9cmT1QQV7PWsbY9rMRWktpM7KryfFlwBiSwSskzg,42654
-code_loader/inner_leap_binder/leapbinder_decorators.py,sha256=lgKJ9cJDuDABscDqLvnqRt7ViU6YeZFcm9996EUosGA,123107
-code_loader/leaploader.py,sha256=K9Q5kiCZ_A2GkS5qOEantAMvWGaz3bmO1X8buXDSpgg,44682
+code_loader/inner_leap_binder/leapbinder.py,sha256=pds20IP5s1iBXUIGbweDxiq77x4DIRjNu110a7Xgpc4,43590
+code_loader/inner_leap_binder/leapbinder_decorators.py,sha256=w29kFpQydGtdBE8joHW0lCKhsMF91PyeodoXgqsR_rw,128103
+code_loader/leaploader.py,sha256=WhaV4TI2fRPdo72NrK0y3NaaXStBaKviGTsoSADyom4,56652
 code_loader/leaploaderbase.py,sha256=l36qDA00GhZEG5NLKpEtAXgWJA-UQQIhNFGxywK7mUA,6530
 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=YecipkdTA-VcE9F0RQcY9cFnY8P3AksPnHM2Db7xUSk,3972
+code_loader/utils.py,sha256=PXRsmzFt_iPQIOQ2DyuyNnIdFW0tJElE5GsTnwY4Enk,4371
 code_loader/visualizers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 code_loader/visualizers/default_visualizers.py,sha256=onRnLE_TXfgLN4o52hQIOOhUcFexGlqJ3xSpQDVLuZM,2604
-code_loader-1.0.190.dev0.dist-info/LICENSE,sha256=qIwWjdspQeSMTtnFZBC8MuT-95L02FPvzRUdWFxrwJY,1067
-code_loader-1.0.190.dev0.dist-info/METADATA,sha256=2Tqb-fK_hBKdjefZN31fYytgQdg3VS9rgcPiwqLsLkc,1107
-code_loader-1.0.190.dev0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-code_loader-1.0.190.dev0.dist-info/RECORD,,
+code_loader-1.0.191.dev1.dist-info/LICENSE,sha256=qIwWjdspQeSMTtnFZBC8MuT-95L02FPvzRUdWFxrwJY,1067
+code_loader-1.0.191.dev1.dist-info/METADATA,sha256=MM9kKQMqR6Uo7iZ8ca6ZYNAZmUGtGxvTr6cjWwEhlkU,1095
+code_loader-1.0.191.dev1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+code_loader-1.0.191.dev1.dist-info/RECORD,,

{code_loader-1.0.190.dev0.dist-info → code_loader-1.0.191.dev1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.3
+Generator: poetry-core 1.9.0
 Root-Is-Purelib: true
 Tag: py3-none-any