code-loader 1.0.208.dev4__py3-none-any.whl → 1.0.208.dev6__py3-none-any.whl

code_loader/contract/datasetclasses.py

@@ -6,7 +6,7 @@ import numpy as np
 import numpy.typing as npt
 
 from code_loader.contract.enums import DataStateType, DataStateEnum, LeapDataType, ConfusionMatrixValue, \
-    MetricDirection, DatasetMetadataType, LatentSpaceReduction
+    MetricDirection, DatasetMetadataType, LatentSpaceReduction, CustomLatentSpaceComputedAt
 from code_loader.contract.visualizer_classes import LeapImage, LeapText, LeapGraph, LeapHorizontalBar, \
     LeapTextMask, LeapImageMask, LeapImageWithBBox, LeapImageWithHeatmap, LeapVideo, LeapAudio
 from code_loader.contract.sim_config import SimConfig
@@ -325,7 +325,7 @@ class CustomLatentSpaceHandler:
     name: str = 'custom_latent_space'
     use_ls_for_analysis: bool = False
     instance_aware: bool = False
-    computed_at: str = 'dataset'
+    computed_at: CustomLatentSpaceComputedAt = CustomLatentSpaceComputedAt.DATASET
     arg_names: Optional[List[str]] = None
     reduce: Optional[LatentSpaceReduction] = None
     n_components: int = 512

code_loader/contract/enums.py

@@ -73,3 +73,8 @@ class TestingSectionEnum(Enum):
 class LatentSpaceReduction(Enum):
     MEAN_POOL = 'MEAN_POOL'
     RANDOM_PROJECTION = 'RANDOM_PROJECTION'
+
+
+class CustomLatentSpaceComputedAt(Enum):
+    DATASET = 'dataset'
+    MODEL = 'model'

code_loader/inner_leap_binder/leapbinder.py

@@ -22,7 +22,7 @@ from code_loader.contract.datasetclasses import SectionCallableInterface, InputH
     AUTOREGRESSIVE_LATENT_SPACE_AGGREGATIONS, AUTOREGRESSIVE_IMPLICIT_ARG_NAMES, \
     AutoregressiveMetricHandler, AutoregressiveLossHandler, AutoregressiveVisualizerHandler
 from code_loader.contract.enums import LeapDataType, DataStateEnum, DataStateType, MetricDirection, DatasetMetadataType, \
-    TestingSectionEnum, LatentSpaceReduction
+    TestingSectionEnum, LatentSpaceReduction, CustomLatentSpaceComputedAt
 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
@@ -561,7 +561,7 @@ class LeapBinder:
                                 name: Optional[str] = None,
                                 use_ls_for_analysis: bool = False,
                                 instance_aware: bool = False,
-                                computed_at: str = 'dataset',
+                                computed_at: CustomLatentSpaceComputedAt = CustomLatentSpaceComputedAt.DATASET,
                                 arg_names: Optional[List[str]] = None,
                                 reduce: Optional[LatentSpaceReduction] = None,
                                 n_components: int = 512,

code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -18,7 +18,7 @@ import numpy.typing as npt
 from code_loader.utils import map_dict_to_metadata_types, is_absent_metadata_value, \
     validate_autoregressive_state_types, autoregressive_nests_equal, \
     simulate_engine_float16_downcast_on_call_args, ENGINE_STORAGE_DTYPE, \
-    TL_DISABLE_ENGINE_FLOAT16_SIMULATION_ENV_VAR
+    TL_DISABLE_ENGINE_FLOAT16_SIMULATION_ENV_VAR, sample_preprocess_response_arg_name
 
 logger = logging.getLogger(__name__)
 
@@ -29,7 +29,7 @@ from code_loader.contract.datasetclasses import CustomCallableInterfaceMultiArgs
     InstanceLengthCallableInterface, InstanceSectionCallableInterface, AutoregressiveStepCallableInterface, \
     MAX_CUSTOM_LATENT_SPACE_DIM, CUSTOM_LATENT_SPACE_WARN_DIM
 from code_loader.contract.enums import MetricDirection, LeapDataType, DatasetMetadataType, DataStateType, \
-    DataStateEnum, LatentSpaceReduction
+    DataStateEnum, LatentSpaceReduction, CustomLatentSpaceComputedAt
 from code_loader import leap_binder, LeapLoader
 from code_loader.contract.mapping import NodeMapping, NodeMappingType, NodeConnection
 from code_loader.contract.visualizer_classes import LeapImage, LeapImageMask, LeapTextMask, LeapText, LeapGraph, \
@@ -291,11 +291,7 @@ def _require_sample_preprocess_response_supplied(user_function: Callable, args:
     """A SamplePreprocessResponse argument is auto-injected by the platform / check_dataset
     but NOT inside integration_test, where the author calls the function directly. Fail fast
     with an actionable message instead of a raw 'missing argument' TypeError."""
-    spr_arg_name = None
-    for arg_name, arg_type in inspect.getfullargspec(user_function).annotations.items():
-        if arg_type == SamplePreprocessResponse:
-            spr_arg_name = arg_name
-            break
+    spr_arg_name = sample_preprocess_response_arg_name(user_function)
     if spr_arg_name is None:
         return
     signature = inspect.signature(user_function)
@@ -1786,16 +1782,25 @@ def _classify_custom_latent_space_signature(user_function) -> str:
 def _model_latent_space_arg_names(user_function) -> List[str]:
     argspec = inspect.getfullargspec(user_function)
     arg_names = list(argspec.args)
-    preprocess_response_arg_name = None
+    spr_count = 0
     for arg_name, arg_type in argspec.annotations.items():
+        if arg_name == 'return':
+            continue
         _reject_stringized_sample_preprocess_response(user_function, arg_name, arg_type)
         if arg_type == SamplePreprocessResponse:
-            if preprocess_response_arg_name is not None:
-                raise Exception(
-                    f"tensorleap_custom_latent_space validation failed: only one argument of "
-                    f"'{user_function.__name__}' can be of type SamplePreprocessResponse.")
-            preprocess_response_arg_name = arg_name
-            arg_names.remove(arg_name)
+            spr_count += 1
+    if spr_count > 1:
+        raise Exception(
+            f"tensorleap_custom_latent_space validation failed: only one argument of "
+            f"'{user_function.__name__}' can be of type SamplePreprocessResponse.")
+    spr_arg_name = sample_preprocess_response_arg_name(user_function)
+    if spr_arg_name is not None:
+        arg_names.remove(spr_arg_name)
+    if not arg_names:
+        raise Exception(
+            f"tensorleap_custom_latent_space validation failed: '{user_function.__name__}' is "
+            f"model-computed and expects at least one np.ndarray argument, but its signature "
+            f"declares none.")
     return arg_names
 
 
@@ -1838,6 +1843,48 @@ def _check_custom_latent_space_width(result, ls_name, reduce, n_components, chan
                 f"reduce=LatentSpaceReduction.RANDOM_PROJECTION."))
 
 
+_FLOAT16_MAX = float(np.finfo(np.float16).max)
+
+
+def _check_custom_latent_space_values(result: np.ndarray, ls_name: str, has_batch_axis: bool) -> None:
+    """Reject what no sample could store and warn about values the engine handles per sample."""
+    if isinstance(result, np.ma.MaskedArray):
+        raise Exception(
+            f"tensorleap_custom_latent_space validation failed: '{ls_name}' returned a numpy masked "
+            f"array; the mask would be ignored. Return a plain ndarray, with np.nan for a sample "
+            f"you cannot compute.")
+    if result.dtype.kind not in 'biuf':
+        raise Exception(
+            f"tensorleap_custom_latent_space validation failed: '{ls_name}' returned dtype "
+            f"{result.dtype}. Return a real-valued numeric array (bool, int or float), with np.nan "
+            f"for a sample you cannot compute.")
+    dims = result.shape[1:] if has_batch_axis else result.shape
+    if int(np.prod(dims)) == 0:
+        raise Exception(
+            f"tensorleap_custom_latent_space validation failed: '{ls_name}' returned shape "
+            f"{tuple(result.shape)}, which has no features per sample.")
+    finite = np.isfinite(result)
+    if not finite.all():
+        store_general_warning(
+            key=("tensorleap_custom_latent_space_nonfinite", ls_name),
+            message=(
+                f"Custom latent space '{ls_name}' returned NaN or inf. Those samples are left out of "
+                f"this latent space; if they exceed 5% of the evaluated samples the latent space is "
+                f"dropped."))
+    peak = 0.0
+    if result.size and result.dtype.kind == 'f':
+        peak = float(np.max(np.abs(result), where=finite, initial=0.0))
+    elif result.size and result.dtype.kind in 'iu':
+        peak = float(max(abs(int(result.min())), abs(int(result.max()))))
+    if peak > _FLOAT16_MAX:
+        store_general_warning(
+            key=("tensorleap_custom_latent_space_clipped", ls_name),
+            message=(
+                f"Custom latent space '{ls_name}' returned values beyond +-{_FLOAT16_MAX:.0f}. Latent "
+                f"spaces are stored as float16, so they are clipped to that range; scale or normalize "
+                f"them inside the function to keep their relative size."))
+
+
 def tensorleap_custom_latent_space(name: Optional[str] = None, use_ls_for_analysis: bool = False,
                                    reduce: Optional[LatentSpaceReduction] = None,
                                    n_components: int = 512, channel_axis: int = -1):
@@ -1859,6 +1906,7 @@ def tensorleap_custom_latent_space(name: Optional[str] = None, use_ls_for_analys
             assert isinstance(single_result, np.ndarray), \
                 (f'tensorleap_custom_latent_space validation failed: '
                  f'The return type should be a numpy array. Got {type(single_result)}.')
+            _check_custom_latent_space_values(single_result, ls_name, has_batch_axis=False)
             if single_result.ndim > 1:
                 flat_dim = int(np.prod(single_result.shape))
                 store_general_warning(
@@ -1911,7 +1959,7 @@ def tensorleap_custom_latent_space(name: Optional[str] = None, use_ls_for_analys
 
         leap_binder.set_custom_latent_space(inner_without_validate, ls_name,
                                             use_ls_for_analysis=use_ls_for_analysis,
-                                            computed_at='dataset', reduce=reduce,
+                                            computed_at=CustomLatentSpaceComputedAt.DATASET, reduce=reduce,
                                             n_components=n_components, channel_axis=channel_axis)
 
         def inner(sample_id, preprocess_response):
@@ -1961,6 +2009,7 @@ def _decorate_model_latent_space(user_function, ls_name, use_ls_for_analysis, re
             f"tensorleap_custom_latent_space validation failed: '{user_function.__name__}' "
             f"returned shape {tuple(result.shape)}. A model-computed latent space returns "
             f"(batch, d), so the result needs a batch axis and at least one feature axis.")
+        _check_custom_latent_space_values(result, ls_name, has_batch_axis=True)
         if leap_binder.batch_size_to_validate:
             assert result.shape[0] == leap_binder.batch_size_to_validate, (
                 f"tensorleap_custom_latent_space validation failed: '{user_function.__name__}' "
@@ -1975,6 +2024,7 @@ def _decorate_model_latent_space(user_function, ls_name, use_ls_for_analysis, re
         _called_from_inside_tl_decorator += 1
 
         try:
+            _require_sample_preprocess_response_supplied(user_function, args, kwargs)
             result = user_function(*args, **kwargs)
         finally:
             _called_from_inside_tl_decorator -= 1
@@ -1985,7 +2035,7 @@ def _decorate_model_latent_space(user_function, ls_name, use_ls_for_analysis, re
 
     leap_binder.set_custom_latent_space(inner_without_validate, ls_name,
                                         use_ls_for_analysis=use_ls_for_analysis,
-                                        computed_at='model', arg_names=arg_names, reduce=reduce,
+                                        computed_at=CustomLatentSpaceComputedAt.MODEL, arg_names=arg_names, reduce=reduce,
                                         n_components=n_components, channel_axis=channel_axis)
 
     def inner(*args, **kwargs):
@@ -2046,6 +2096,7 @@ def tensorleap_instance_custom_latent_space(name: Optional[str] = None, use_ls_f
             assert isinstance(result, np.ndarray), \
                 (f'tensorleap_instance_custom_latent_space validation failed: '
                  f'The return type should be a numpy array. Got {type(result)}.')
+            _check_custom_latent_space_values(result, ls_name, has_batch_axis=False)
             if result.ndim > 1:
                 flat_dim = int(np.prod(result.shape))
                 store_general_warning(

code_loader/leaploader.py

@@ -17,7 +17,8 @@ from code_loader.contract.datasetclasses import DatasetSample, DatasetBaseHandle
     PredictionTypeHandler, MetadataHandler, CustomLayerHandler, MetricHandler, VisualizerHandlerData, MetricHandlerData, \
     MetricCallableReturnType, CustomLossHandlerData, CustomLossHandler, RawInputsForHeatmap, SamplePreprocessResponse, \
     ElementInstance, custom_latent_space_attribute, DatasetIntegrationSetup, InstanceMetricHandler, _simulation_context
-from code_loader.contract.enums import DataStateEnum, TestingSectionEnum, DataStateType, DatasetMetadataType
+from code_loader.contract.enums import DataStateEnum, TestingSectionEnum, DataStateType, DatasetMetadataType, \
+    CustomLatentSpaceComputedAt
 from code_loader.contract.mapping import NodeMappingType
 from code_loader.contract.exceptions import DatasetScriptException
 from code_loader.contract.responsedataclasses import DatasetIntegParseResult, DatasetTestResultPayload, \
@@ -29,7 +30,8 @@ from code_loader.inner_leap_binder import global_leap_binder
 from code_loader.inner_leap_binder.leapbinder import mapping_runtime_mode_env_var_mame
 from code_loader.leaploaderbase import LeapLoaderBase
 from code_loader.utils import get_root_exception_file_and_line_number, get_metadata_type_from_variable, \
-    validate_autoregressive_state_types, autoregressive_nests_equal, is_absent_metadata_value
+    validate_autoregressive_state_types, autoregressive_nests_equal, is_absent_metadata_value, \
+    sample_preprocess_response_arg_name
 
 
 def _serialize_sim_bounds(bounds) -> dict:
@@ -53,6 +55,8 @@ class LeapLoader(LeapLoaderBase):
         self._preprocess_result_cached = None
         self._synthetic_lookup: Dict[str, Tuple[PreprocessResponse, Any]] = {}
         self._synthetic_populator: Optional[Callable[[str], None]] = None
+        # Dataset-computed custom LS the engine dropped for this job; get_sample stops computing them.
+        self._skipped_custom_latent_spaces: FrozenSet[str] = frozenset()
 
         try:
             from code_loader.mixpanel_tracker import track_code_loader_loaded
@@ -434,7 +438,7 @@ class LeapLoader(LeapLoaderBase):
     def _check_model_latent_spaces(self) -> Optional[DatasetTestResultPayload]:
         model_names = [
             name for name, handler in global_leap_binder.setup_container.custom_latent_spaces.items()
-            if handler.computed_at == 'model'
+            if handler.computed_at == CustomLatentSpaceComputedAt.MODEL
         ]
         if not model_names:
             return None
@@ -814,10 +818,7 @@ class LeapLoader(LeapLoaderBase):
     @staticmethod
     def _get_preprocess_response_arg_name(
             func: Callable) -> Optional[str]:
-        for arg_name, arg_type in inspect.getfullargspec(func).annotations.items():
-            if arg_type == SamplePreprocessResponse:
-                return arg_name
-        return None
+        return sample_preprocess_response_arg_name(func)
 
     def run_custom_loss(self, custom_loss_name: str, sample_ids: np.array, state: DataStateEnum,
                         input_tensors_by_arg_name: Dict[str, npt.NDArray[np.float32]]):
@@ -1210,6 +1211,7 @@ class LeapLoader(LeapLoaderBase):
             custom_latent_spaces = {
                 name: self._to_grouped_list(handler.function(group_ids, preprocess_state))
                 for name, handler in latent_handlers.items()
+                if name not in self._skipped_custom_latent_spaces
             }
 
         return DatasetSample(inputs=inputs, gt=gt, metadata=metadata, metadata_is_none=metadata_is_none,
@@ -1433,7 +1435,8 @@ class LeapLoader(LeapLoaderBase):
             instance_id: Optional[int] = None) -> Optional[Dict[str, npt.NDArray[np.float32]]]:
         handlers = {handler_name: handler for handler_name, handler
                     in global_leap_binder.setup_container.custom_latent_spaces.items()
-                    if handler.computed_at != 'model'}
+                    if handler.computed_at != CustomLatentSpaceComputedAt.MODEL
+                    and handler_name not in self._skipped_custom_latent_spaces}
         if not handlers:
             return None
         if preprocess.is_grouped:
@@ -1460,6 +1463,10 @@ class LeapLoader(LeapLoaderBase):
         self.exec_script()
         return len(global_leap_binder.setup_container.custom_latent_spaces) > 0
 
+    def set_skipped_custom_latent_spaces(self, names: Iterable[str]) -> None:
+        """Stop computing these dataset-computed custom latent spaces in get_sample(s)."""
+        self._skipped_custom_latent_spaces = frozenset(names)
+
     @lru_cache()
     def get_custom_latent_space_names(self) -> Tuple[str, ...]:
         """Names of all registered custom latent spaces, in registration order.
@@ -1475,20 +1482,14 @@ class LeapLoader(LeapLoaderBase):
     def get_dataset_custom_latent_space_names(self) -> Tuple[str, ...]:
         self.exec_script()
         return tuple(name for name, handler in global_leap_binder.setup_container.custom_latent_spaces.items()
-                     if handler.computed_at != 'model')
-
-    @lru_cache()
-    def get_model_custom_latent_space_names(self) -> Tuple[str, ...]:
-        self.exec_script()
-        return tuple(name for name, handler in global_leap_binder.setup_container.custom_latent_spaces.items()
-                     if handler.computed_at == 'model')
+                     if handler.computed_at != CustomLatentSpaceComputedAt.MODEL)
 
     @lru_cache()
     def get_custom_latent_space_specs(self) -> Dict[str, Dict[str, Any]]:
         self.exec_script()
         return {
             name: {
-                'computed_at': handler.computed_at,
+                'computed_at': handler.computed_at.value,
                 'arg_names': list(handler.arg_names or []),
                 'reduce': handler.reduce.value if handler.reduce is not None else None,
                 'n_components': handler.n_components,
@@ -1498,18 +1499,19 @@ class LeapLoader(LeapLoaderBase):
         }
 
     @lru_cache()
-    def get_model_latent_space_specs(self) -> Dict[str, Dict[str, Any]]:
+    def get_model_custom_latent_space_specs(self) -> Dict[str, Dict[str, Any]]:
         return {name: spec for name, spec in self.get_custom_latent_space_specs().items()
                 if spec['computed_at'] == 'model'}
 
     def run_model_latent_space(self, ls_name: str, sample_ids: np.array, state: DataStateEnum,
                                input_tensors_by_arg_name: Dict[str, npt.NDArray[np.float32]]
                                ) -> npt.NDArray[np.float32]:
-        self._preprocess_result()
-
+        self.exec_script()
         handler = global_leap_binder.setup_container.custom_latent_spaces[ls_name]
         preprocess_response_arg_name = self._get_preprocess_response_arg_name(handler.function)
 
+        # Preprocess runs only when the function asks for a SamplePreprocessResponse; the metrics
+        # pod that calls this has no other reason to pay for it.
         if preprocess_response_arg_name is not None:
             input_tensors_by_arg_name[preprocess_response_arg_name] = SamplePreprocessResponse(
                 sample_ids, self._preprocess_result()[state])

code_loader/leaploaderbase.py

@@ -234,20 +234,15 @@ class LeapLoaderBase:
         raise NotImplementedError(f'{type(self).__name__} does not implement '
                                   'get_dataset_custom_latent_space_names.')
 
-    @abstractmethod
-    def get_model_custom_latent_space_names(self) -> Tuple[str, ...]:
-        raise NotImplementedError(f'{type(self).__name__} does not implement '
-                                  'get_model_custom_latent_space_names.')
-
     @abstractmethod
     def get_custom_latent_space_specs(self) -> Dict[str, Dict[str, Any]]:
         raise NotImplementedError(f'{type(self).__name__} does not implement '
                                   'get_custom_latent_space_specs.')
 
     @abstractmethod
-    def get_model_latent_space_specs(self) -> Dict[str, Dict[str, Any]]:
+    def get_model_custom_latent_space_specs(self) -> Dict[str, Dict[str, Any]]:
         raise NotImplementedError(f'{type(self).__name__} does not implement '
-                                  'get_model_latent_space_specs.')
+                                  'get_model_custom_latent_space_specs.')
 
     @abstractmethod
     def run_model_latent_space(self, ls_name: str, sample_ids: np.array, state: DataStateEnum,

code_loader/utils.py

@@ -1,3 +1,4 @@
+import inspect
 import io
 import math
 import os
@@ -11,7 +12,7 @@ import numpy as np
 import numpy.typing as npt
 
 from code_loader.contract.datasetclasses import SectionCallableInterface, PreprocessResponse, \
-    InstanceCallableInterface, ElementInstance
+    InstanceCallableInterface, ElementInstance, SamplePreprocessResponse
 from code_loader.contract.enums import DatasetMetadataType
 
 
@@ -246,3 +247,11 @@ def autoregressive_nests_equal(a: Any, b: Any) -> bool:
             math.isnan(a) and math.isnan(b):
         return True
     return bool(a == b)
+
+
+def sample_preprocess_response_arg_name(func: Callable[..., Any]) -> Optional[str]:
+    # 'return' lives in annotations too and must never be mistaken for a parameter.
+    for arg_name, arg_type in inspect.getfullargspec(func).annotations.items():
+        if arg_name != 'return' and arg_type == SamplePreprocessResponse:
+            return arg_name
+    return None

{code_loader-1.0.208.dev4.dist-info → code_loader-1.0.208.dev6.dist-info}/METADATA

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

{code_loader-1.0.208.dev4.dist-info → code_loader-1.0.208.dev6.dist-info}/RECORD

@@ -1,8 +1,8 @@
 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=0dD7uEwUP2GJyyAP3X8WnUNBekC2rrikB7AwLhChn2w,18031
-code_loader/contract/enums.py,sha256=0c3Lg5Wti-q1wwsNqN96o2pqqa2GIscf6rSZsganmkI,1799
+code_loader/contract/datasetclasses.py,sha256=yNEPIyZqCO54fKBgmgbFIKEMVBzvpf4n8U2zmPhXv88,18110
+code_loader/contract/enums.py,sha256=R4Ge9-oSO7-GYjZAKMTB8Ws5FNsxhCQAYAJruxViJxk,1886
 code_loader/contract/exceptions.py,sha256=jWqu5i7t-0IG0jGRsKF4DjJdrsdpJjIYpUkN1F4RiyQ,51
 code_loader/contract/mapping.py,sha256=i-yVyFuGUITL5lchPNfYlu7bhwk-yuoHPacAeFhcYr8,1490
 code_loader/contract/responsedataclasses.py,sha256=5AB9uP7eJt2Oaq2grMwLQeiQLiw2gj1x04HE7gVUaRU,5112
@@ -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=j6oa6oyM04scUCmyFKB80E0MTYDBDUcF9cwiyJTj5oQ,63134
-code_loader/inner_leap_binder/leapbinder_decorators.py,sha256=F3O6OhbMQmoa_xqNq1kjhDgKiztMr7qoclbS0jzCWp8,206886
-code_loader/leaploader.py,sha256=TiO5SrRtO6SevydmYlEZFHnU-88GDSG9m7TJyeIIXjI,97060
-code_loader/leaploaderbase.py,sha256=cQwlJdx_tLJXMxTq8AURsFpyF0s3jpqkWaF5i1r8hSE,12601
+code_loader/inner_leap_binder/leapbinder.py,sha256=tvIFlSEOW4iaONJreh0EAlF_A9mpE3B13ohXhIUa1f0,63213
+code_loader/inner_leap_binder/leapbinder_decorators.py,sha256=vPbHSw51hVWdcPe1Vwta35TpW5So4ykW-qkgSuGJq_I,209787
+code_loader/leaploader.py,sha256=qi7Hbk-LyvEm_nGLmpioA4vLf1NEnhHeHj8U2Rq992o,97523
+code_loader/leaploaderbase.py,sha256=JzgpEfY-kNUWbWUb_cZ1G1zHo6oSci6QhT7hqw3E1Jg,12371
 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=Auw39lKpEQ7Ld2q1nj6S18GIDKWcjCxU0TDrur2UEko,11968
+code_loader/utils.py,sha256=v6VraCdbFADoNwNx5TH89BLnZ6yfPoWMkyJrqQ_usFc,12377
 code_loader/visualizers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 code_loader/visualizers/default_visualizers.py,sha256=grTPin_lCE9aci8i8CqA7DqQwAyXRB7_EamA3na_pls,5438
-code_loader-1.0.208.dev4.dist-info/LICENSE,sha256=qIwWjdspQeSMTtnFZBC8MuT-95L02FPvzRUdWFxrwJY,1067
-code_loader-1.0.208.dev4.dist-info/METADATA,sha256=_-4N2MXSRMXO72SbEk1kwM9UvIgKurn6cnweyPrKmCU,1095
-code_loader-1.0.208.dev4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-code_loader-1.0.208.dev4.dist-info/RECORD,,
+code_loader-1.0.208.dev6.dist-info/LICENSE,sha256=qIwWjdspQeSMTtnFZBC8MuT-95L02FPvzRUdWFxrwJY,1067
+code_loader-1.0.208.dev6.dist-info/METADATA,sha256=xkhqTPaPoJgUne7-cH7AtBDmKGGQ0aDZC7FbW2aGDsI,1095
+code_loader-1.0.208.dev6.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+code_loader-1.0.208.dev6.dist-info/RECORD,,