code-loader 1.0.97.dev0__py3-none-any.whl → 1.0.98__py3-none-any.whl

code_loader/contract/datasetclasses.py

@@ -38,8 +38,18 @@ class PreprocessResponse:
     sample_ids: Optional[Union[List[str], List[int]]] = 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
+    instance_ids_to_names: Optional[Dict[str, str]] = None # in use only for element instance
 
     def __post_init__(self) -> None:
+        def is_valid_string(s: str) -> bool:
+            return bool(re.match(r'^[A-Za-z0-9_]+$', s))
+
+        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"
+        assert self.instance_ids_to_names is None, f"Keep instance_ids_to_names 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_id_type = int
@@ -50,6 +60,8 @@ class PreprocessResponse:
             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)}"
+                    if not is_valid_string(sample_id):
+                        raise Exception(f"Sample id should contain only letters (A-Z, a-z), numbers or '_'. Got: {sample_id}")
         else:
             raise Exception("length is deprecated.")
 
@@ -60,8 +72,13 @@ class PreprocessResponse:
         assert self.sample_ids is not None
         return len(self.sample_ids)
 
+@dataclass
+class ElementInstance:
+    name: str
+    mask: npt.NDArray[np.float32]
 
 SectionCallableInterface = Callable[[Union[int, str], PreprocessResponse], npt.NDArray[np.float32]]
+InstanceCallableInterface = Callable[[Union[int, str], PreprocessResponse], List[ElementInstance]]
 
 MetadataSectionCallableInterface = Union[
     Callable[[Union[int, str], PreprocessResponse], int],
@@ -183,6 +200,10 @@ class InputHandler(DatasetBaseHandler):
     shape: Optional[List[int]] = None
     channel_dim: Optional[int] = -1
 
+@dataclass
+class ElementInstanceMasksHandler:
+    name: str
+    function: InstanceCallableInterface
 
 @dataclass
 class GroundTruthHandler(DatasetBaseHandler):
@@ -218,6 +239,7 @@ class DatasetIntegrationSetup:
     unlabeled_data_preprocess: Optional[UnlabeledDataPreprocessHandler] = None
     visualizers: List[VisualizerHandler] = field(default_factory=list)
     inputs: List[InputHandler] = field(default_factory=list)
+    instance_masks: List[ElementInstanceMasksHandler] = field(default_factory=list)
     ground_truths: List[GroundTruthHandler] = field(default_factory=list)
     metadata: List[MetadataHandler] = field(default_factory=list)
     prediction_types: List[PredictionTypeHandler] = field(default_factory=list)
@@ -234,3 +256,5 @@ class DatasetSample:
     metadata_is_none: Dict[str, bool]
     index: Union[int, str]
     state: DataStateEnum
+    instance_masks: Optional[Dict[str, List[ElementInstance]]] = None
+

code_loader/inner_leap_binder/leapbinder.py

@@ -10,14 +10,15 @@ from code_loader.contract.datasetclasses import SectionCallableInterface, InputH
     MetadataSectionCallableInterface, UnlabeledDataPreprocessHandler, CustomLayerHandler, MetricHandler, \
     CustomCallableInterfaceMultiArgs, ConfusionMatrixCallableInterfaceMultiArgs, LeapData, \
     CustomMultipleReturnCallableInterfaceMultiArgs, DatasetBaseHandler, custom_latent_space_attribute, \
-    RawInputsForHeatmap, VisualizerHandlerData, MetricHandlerData, CustomLossHandlerData, SamplePreprocessResponse
+    RawInputsForHeatmap, VisualizerHandlerData, MetricHandlerData, CustomLossHandlerData, SamplePreprocessResponse, \
+    ElementInstanceMasksHandler, InstanceCallableInterface
 from code_loader.contract.enums import LeapDataType, DataStateEnum, DataStateType, MetricDirection, DatasetMetadataType
 from code_loader.contract.mapping import NodeConnection, NodeMapping, NodeMappingType
 from code_loader.contract.responsedataclasses import DatasetTestResultPayload
 from code_loader.contract.visualizer_classes import map_leap_data_type_to_visualizer_class
 from code_loader.default_losses import loss_name_to_function
 from code_loader.default_metrics import metrics_names_to_functions_and_direction
-from code_loader.utils import to_numpy_return_wrapper, get_shape
+from code_loader.utils import to_numpy_return_wrapper, get_shape, to_numpy_return_masks_wrapper
 from code_loader.visualizers.default_visualizers import DefaultVisualizer, \
     default_graph_visualizer, \
     default_image_visualizer, default_horizontal_bar_visualizer, default_word_visualizer, \
@@ -234,6 +235,22 @@ class LeapBinder:
 
         self._encoder_names.append(name)
 
+
+    def set_instance_masks(self, function: InstanceCallableInterface, name: str) -> None:
+        """
+        Set the instance mask handler function.
+
+        Args:
+        function (SectionCallableInterface): The input handler function.
+        name (str): The name of the instance mask section.
+
+        Example:
+            leap_binder.set_input(input_encoder, name='input_encoder')
+        """
+        function = to_numpy_return_masks_wrapper(function)
+        self.setup_container.instance_masks.append(ElementInstanceMasksHandler(name, function))
+
+
     def add_custom_loss(self, function: CustomCallableInterface, name: str) -> None:
         """
         Add a custom loss function to the setup.

code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -8,7 +8,7 @@ import numpy.typing as npt
 from code_loader.contract.datasetclasses import CustomCallableInterfaceMultiArgs, \
     CustomMultipleReturnCallableInterfaceMultiArgs, ConfusionMatrixCallableInterfaceMultiArgs, CustomCallableInterface, \
     VisualizerCallableInterface, MetadataSectionCallableInterface, PreprocessResponse, SectionCallableInterface, \
-    ConfusionMatrixElement, SamplePreprocessResponse
+    ConfusionMatrixElement, SamplePreprocessResponse, InstanceCallableInterface, ElementInstance
 from code_loader.contract.enums import MetricDirection, LeapDataType, DatasetMetadataType
 from code_loader import leap_binder
 from code_loader.contract.mapping import NodeMapping, NodeMappingType, NodeConnection
@@ -270,6 +270,64 @@ def tensorleap_preprocess():
 
     return decorating_function
 
+def tensorleap_element_instance_preprocess(instance_mask_encoder: Callable[[str, PreprocessResponse], List[ElementInstance]]):
+    def decorating_function(user_function: Callable[[], List[PreprocessResponse]]):
+        def user_function_instance() -> List[PreprocessResponse]:
+            result = user_function()
+            for preprocess_response in result:
+                sample_ids_to_instance_mappings = {}
+                instance_to_sample_ids_mappings = {}
+                instance_ids_to_names = {}
+                all_sample_ids = preprocess_response.sample_ids.copy()
+                for sample_id in preprocess_response.sample_ids:
+                    instances_masks = instance_mask_encoder(sample_id, preprocess_response)
+                    instances_ids = [f'{sample_id}_{instance_id}' for instance_id in range(len(instances_masks))]
+                    sample_ids_to_instance_mappings[sample_id] = instances_ids
+                    instance_to_sample_ids_mappings[sample_id] = sample_id
+                    instance_names = [instance.name for instance in instances_masks]
+                    instance_ids_to_names[sample_id] = 'none'
+                    for instance_id, instance_name in zip(instances_ids, instance_names):
+                        instance_to_sample_ids_mappings[instance_id] = sample_id
+                        instance_ids_to_names[instance_id] = instance_name
+                    all_sample_ids.extend(instances_ids)
+                preprocess_response.sample_ids_to_instance_mappings = sample_ids_to_instance_mappings
+                preprocess_response.instance_to_sample_ids_mappings = instance_to_sample_ids_mappings
+                preprocess_response.instance_ids_to_names = instance_ids_to_names
+                preprocess_response.sample_ids = all_sample_ids
+            return result
+
+        def builtin_instance_metadata(idx: str, preprocess: PreprocessResponse) -> Dict[str, str]:
+            return {'is_instance': '0', 'original_sample_id': idx, 'instance_name': 'none'}
+        leap_binder.set_preprocess(user_function_instance)
+        leap_binder.set_metadata(builtin_instance_metadata, "builtin_instance_metadata")
+
+        def _validate_input_args(*args, **kwargs):
+            assert len(args) == 0 and len(kwargs) == 0, \
+                (f'tensorleap_element_instance_preprocess validation failed: '
+                 f'The function should not take any arguments. Got {args} and {kwargs}.')
+
+        def _validate_result(result):
+            assert isinstance(result, list), \
+                (f'tensorleap_element_instance_preprocess validation failed: '
+                 f'The return type should be a list. Got {type(result)}.')
+            for i, response in enumerate(result):
+                assert isinstance(response, PreprocessResponse), \
+                    (f'tensorleap_element_instance_preprocess validation failed: '
+                     f'Element #{i} in the return list should be a PreprocessResponse. Got {type(response)}.')
+            assert len(set(result)) == len(result), \
+                (f'tensorleap_element_instance_preprocess validation failed: '
+                 f'The return list should not contain duplicate PreprocessResponse objects.')
+
+        def inner(*args, **kwargs):
+            _validate_input_args(*args, **kwargs)
+            result = user_function_instance()
+            _validate_result(result)
+            return result
+
+        return inner
+
+    return decorating_function
+
 
 def tensorleap_unlabeled_preprocess():
     def decorating_function(user_function: Callable[[], PreprocessResponse]):
@@ -296,6 +354,38 @@ def tensorleap_unlabeled_preprocess():
     return decorating_function
 
 
+def tensorleap_instances_masks_encoder(name: str):
+    def decorating_function(user_function: InstanceCallableInterface):
+        leap_binder.set_instance_masks(user_function, name)
+
+        def _validate_input_args(sample_id: str, preprocess_response: PreprocessResponse):
+            assert isinstance(sample_id, str), \
+                (f'tensorleap_instances_masks_encoder validation failed: '
+                 f'Argument sample_id should be str. Got {type(sample_id)}.')
+            assert isinstance(preprocess_response, PreprocessResponse), \
+                (f'tensorleap_instances_masks_encoder 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_instances_masks_encoder validation failed: '
+                 f'Argument sample_id should be as the same type as defined in the preprocess response '
+                 f'{preprocess_response.sample_id_type}. Got {type(sample_id)}.')
+
+        def _validate_result(result):
+            assert isinstance(result, list), \
+                (f'tensorleap_instances_masks_encoder validation failed: '
+                 f'Unsupported return type. Should be a numpy array. Got {type(result)}.')
+
+        def inner(sample_id, preprocess_response):
+            _validate_input_args(sample_id, preprocess_response)
+            result = user_function(sample_id, preprocess_response)
+            _validate_result(result)
+            return result
+
+        return inner
+
+    return decorating_function
+
+
 def tensorleap_input_encoder(name: str, channel_dim=-1, model_input_index=None):
     def decorating_function(user_function: SectionCallableInterface):
         for input_handler in leap_binder.setup_container.inputs:

code_loader/leaploader.py

@@ -14,7 +14,8 @@ import numpy.typing as npt
 from code_loader.contract.datasetclasses import DatasetSample, DatasetBaseHandler, GroundTruthHandler, \
     PreprocessResponse, VisualizerHandler, LeapData, \
     PredictionTypeHandler, MetadataHandler, CustomLayerHandler, MetricHandler, VisualizerHandlerData, MetricHandlerData, \
-    MetricCallableReturnType, CustomLossHandlerData, CustomLossHandler, RawInputsForHeatmap, SamplePreprocessResponse
+    MetricCallableReturnType, CustomLossHandlerData, CustomLossHandler, RawInputsForHeatmap, SamplePreprocessResponse, \
+    ElementInstance
 from code_loader.contract.enums import DataStateEnum, TestingSectionEnum, DataStateType, DatasetMetadataType
 from code_loader.contract.exceptions import DatasetScriptException
 from code_loader.contract.responsedataclasses import DatasetIntegParseResult, DatasetTestResultPayload, \
@@ -23,7 +24,7 @@ from code_loader.contract.responsedataclasses import DatasetIntegParseResult, Da
     EngineFileContract
 from code_loader.inner_leap_binder import global_leap_binder
 from code_loader.leaploaderbase import LeapLoaderBase
-from code_loader.utils import get_root_exception_file_and_line_number, flatten
+from code_loader.utils import get_root_exception_file_and_line_number
 
 
 class LeapLoader(LeapLoaderBase):
@@ -150,6 +151,22 @@ class LeapLoader(LeapLoaderBase):
                                state=state)
         return sample
 
+    def get_sample_with_masks(self, state: DataStateEnum, sample_id: Union[int, str]) -> DatasetSample:
+        self.exec_script()
+        preprocess_result = self._preprocess_result()
+        if state == DataStateEnum.unlabeled and sample_id not in preprocess_result[state].sample_ids:
+            self._preprocess_result(update_unlabeled_preprocess=True)
+
+        metadata, metadata_is_none = self._get_metadata(state, sample_id)
+        sample = DatasetSample(inputs=self._get_inputs(state, sample_id),
+                               gt=None if state == DataStateEnum.unlabeled else self._get_gt(state, sample_id),
+                               metadata=metadata,
+                               metadata_is_none=metadata_is_none,
+                               index=sample_id,
+                               state=state,
+                               instance_masks=self._get_instances_masks(state, sample_id))
+        return sample
+
     def check_dataset(self) -> DatasetIntegParseResult:
         test_payloads: List[DatasetTestResultPayload] = []
         setup_response = None
@@ -437,6 +454,16 @@ class LeapLoader(LeapLoaderBase):
     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)
 
+    def _get_instances_masks(self, state: DataStateEnum, sample_id: Union[int, str]) -> Dict[str, List[ElementInstance]]:
+        preprocess_result = self._preprocess_result()
+        preprocess_state = preprocess_result[state]
+        result_agg = {}
+        for handler in global_leap_binder.setup_container.instance_masks:
+            handler_result = handler.function(sample_id, preprocess_state)
+            handler_name = handler.name
+            result_agg[handler_name] = handler_result
+        return result_agg
+
     def _get_gt(self, state: DataStateEnum, sample_id: Union[int, str]) -> Dict[str, npt.NDArray[np.float32]]:
         return self._get_dataset_handlers(global_leap_binder.setup_container.ground_truths, state, sample_id)
 
@@ -477,18 +504,22 @@ class LeapLoader(LeapLoaderBase):
 
         return converted_value, is_none
 
-    def _get_metadata(self, state: DataStateEnum, sample_id: Union[int, str]) -> Tuple[
-        Dict[str, Union[str, int, bool, float]], Dict[str, bool]]:
+    def _get_metadata(self, state: DataStateEnum, sample_id: Union[int, str]) -> Tuple[Dict[str, Union[str, int, bool, float]], Dict[str, bool]]:
         result_agg = {}
         is_none = {}
         preprocess_result = self._preprocess_result()
         preprocess_state = preprocess_result[state]
         for handler in global_leap_binder.setup_container.metadata:
             handler_result = handler.function(sample_id, preprocess_state)
-
-            for flat_name, flat_result in flatten(handler_result, prefix=handler.name):
-                result_agg[flat_name], is_none[flat_name] = self._convert_metadata_to_correct_type(
-                    flat_name, flat_result)
+            if isinstance(handler_result, dict):
+                for single_metadata_name, single_metadata_result in handler_result.items():
+                    handler_name = f'{handler.name}_{single_metadata_name}'
+                    result_agg[handler_name], is_none[handler_name] = self._convert_metadata_to_correct_type(
+                        handler_name, single_metadata_result)
+            else:
+                handler_name = handler.name
+                result_agg[handler_name], is_none[handler_name] = self._convert_metadata_to_correct_type(
+                    handler_name, handler_result)
 
         return result_agg, is_none
 
@@ -501,3 +532,18 @@ class LeapLoader(LeapLoaderBase):
                 raise Exception("Different id types in preprocess results")
 
         return id_type
+
+    def get_instances_data(self, state: DataStateEnum) -> Tuple[Dict[str, List[str]], Dict[str, str], Dict[str, str]]:
+        """
+        This Method get the data state and returns two dictionaries that holds the mapping of the sample ids to their
+         instances and the other way around and the sample ids array.
+        Args:
+            state: DataStateEnum state
+        Returns:
+            sample_ids_to_instance_mappings: sample id to instance mappings
+            instance_to_sample_ids_mappings: instance to sample ids mappings
+            sample_ids: sample ids array
+        """
+        preprocess_result = self._preprocess_result()
+        preprocess_state = preprocess_result[state]
+        return preprocess_state.sample_ids_to_instance_mappings, preprocess_state.instance_to_sample_ids_mappings, preprocess_state.instance_ids_to_names

code_loader/leaploaderbase.py

@@ -2,7 +2,7 @@
 
 from abc import abstractmethod
 
-from typing import Dict, List, Union, Type, Optional
+from typing import Dict, List, Union, Type, Optional, Tuple
 
 import numpy as np
 import numpy.typing as npt
@@ -64,6 +64,14 @@ class LeapLoaderBase:
     def get_sample(self, state: DataStateEnum, sample_id: Union[int, str]) -> DatasetSample:
         pass
 
+    @abstractmethod
+    def get_sample_with_masks(self, state: DataStateEnum, sample_id: Union[int, str]) -> DatasetSample:
+        pass
+
+    @abstractmethod
+    def get_instances_data(self, state: DataStateEnum) -> Tuple[Dict[str, List[str]], Dict[str, str], Dict[str, str]]:
+        pass
+
     @abstractmethod
     def check_dataset(self) -> DatasetIntegParseResult:
         pass

code_loader/utils.py

@@ -1,12 +1,13 @@
 import sys
 from pathlib import Path
 from types import TracebackType
-from typing import List, Union, Tuple, Any, Iterator
+from typing import List, Union, Tuple, Any, Callable
 import traceback
 import numpy as np
 import numpy.typing as npt
 
-from code_loader.contract.datasetclasses import SectionCallableInterface, PreprocessResponse
+from code_loader.contract.datasetclasses import SectionCallableInterface, PreprocessResponse, \
+    InstanceCallableInterface, ElementInstance
 
 
 def to_numpy_return_wrapper(encoder_function: SectionCallableInterface) -> SectionCallableInterface:
@@ -17,6 +18,15 @@ def to_numpy_return_wrapper(encoder_function: SectionCallableInterface) -> Secti
 
     return numpy_encoder_function
 
+def to_numpy_return_masks_wrapper(encoder_function: InstanceCallableInterface) -> Callable[
+    [Union[int, str], PreprocessResponse], List[ElementInstance]]:
+    def numpy_encoder_function(idx: Union[int, str], samples: PreprocessResponse) -> List[ElementInstance]:
+        result = encoder_function(idx, samples)
+        for res in result:
+            res.mask = np.array(res.mask)
+        return result
+    return numpy_encoder_function
+
 
 def get_root_traceback(exc_tb: TracebackType) -> TracebackType:
     return_traceback = exc_tb
@@ -66,28 +76,3 @@ def rescale_min_max(image: npt.NDArray[np.float32]) -> npt.NDArray[np.float32]:
     return image
 
 
-def flatten(
-    value: Any,
-    *,
-    prefix: str = "",
-    list_token: str = "e",
-) -> Iterator[Tuple[str, Any]]:
-    """
-    Recursively walk `value` and yield (flat_key, leaf_value) pairs.
-
-    • Dicts → descend with   new_prefix = f"{prefix}_{key}" (or just key if top level)
-    • Sequences → descend with new_prefix = f"{prefix}_{list_token}{idx}"
-    • Leaf scalars → yield the accumulated flat key and the scalar itself
-    """
-    if isinstance(value, dict):
-        for k, v in value.items():
-            new_prefix = f"{prefix}_{k}" if prefix else k
-            yield from flatten(v, prefix=new_prefix, list_token=list_token)
-
-    elif isinstance(value, (list, tuple)):
-        for idx, v in enumerate(value):
-            new_prefix = f"{prefix}_{list_token}{idx}"
-            yield from flatten(v, prefix=new_prefix, list_token=list_token)
-
-    else:  # primitive leaf (str, int, float, bool, None…)
-        yield prefix, value

{code_loader-1.0.97.dev0.dist-info → code_loader-1.0.98.dist-info}/METADATA

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

{code_loader-1.0.97.dev0.dist-info → code_loader-1.0.98.dist-info}/RECORD

@@ -1,7 +1,7 @@
 LICENSE,sha256=qIwWjdspQeSMTtnFZBC8MuT-95L02FPvzRUdWFxrwJY,1067
 code_loader/__init__.py,sha256=6MMWr0ObOU7hkqQKgOqp4Zp3I28L7joGC9iCbQYtAJg,241
 code_loader/contract/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-code_loader/contract/datasetclasses.py,sha256=3BWSCHaKtNWlKucMkPKSMiuvZosnnQgXFq2R-GbVOgg,7679
+code_loader/contract/datasetclasses.py,sha256=eioYa_gXpiFsRoGhkvQ7RMBfhFL6t9WsqKBddUlmnYA,9118
 code_loader/contract/enums.py,sha256=GEFkvUMXnCNt-GOoz7NJ9ecQZ2PPDettJNOsxsiM0wk,1622
 code_loader/contract/exceptions.py,sha256=jWqu5i7t-0IG0jGRsKF4DjJdrsdpJjIYpUkN1F4RiyQ,51
 code_loader/contract/mapping.py,sha256=e11h_sprwOyE32PcqgRq9JvyahQrPzwqgkhmbQLKLQY,1165
@@ -20,14 +20,14 @@ 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=Acg5C8pMlQHSCTNmTXlMiLdS7P_k6sBUahD5ffr6mN4,31794
-code_loader/inner_leap_binder/leapbinder_decorators.py,sha256=y5TuhJe-J3xEE0Oj7bxIfhyN1lXiLJgfgy3ZiAs-yic,24364
-code_loader/leaploader.py,sha256=qUV-MmxZzESxi8zciKiitGObgks_5d58tgrZyJwRpuU,26125
-code_loader/leaploaderbase.py,sha256=VH0vddRmkqLtcDlYPCO7hfz1_VbKo43lUdHDAbd4iJc,4198
-code_loader/utils.py,sha256=4tXLum2AT3Z1ldD6BeYScNg0ATyE4oM8cuIGQxrXyjM,3163
+code_loader/inner_leap_binder/leapbinder.py,sha256=mOEo0kkfQA1OYLWvoOOsnDdP9_itLPCPAvsfE2Xx0yQ,32443
+code_loader/inner_leap_binder/leapbinder_decorators.py,sha256=n0S0L6YGMxgxTliQeQAiWIK9SMrj5ZjOl9wXqD_Tvjw,29521
+code_loader/leaploader.py,sha256=FiENUvp_TvnPXyX9n5QDQCdUQ_stWv_LazaKnCesCQ4,28822
+code_loader/leaploaderbase.py,sha256=lKdw2pd6H9hFsxVmc7jJMoZd_vlG5He1ooqT-cR_yq8,4496
+code_loader/utils.py,sha256=_j8b60pimoNAvWMRj7hEkkT6C76qES6cZoBFHpXHMxA,2698
 code_loader/visualizers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 code_loader/visualizers/default_visualizers.py,sha256=669lBpLISLO6my5Qcgn1FLDDeZgHumPf252m4KHY4YM,2555
-code_loader-1.0.97.dev0.dist-info/LICENSE,sha256=qIwWjdspQeSMTtnFZBC8MuT-95L02FPvzRUdWFxrwJY,1067
-code_loader-1.0.97.dev0.dist-info/METADATA,sha256=VjlJJJzJiQXZgcE2dzItxMz4B2mrry2W3GSEK_YkFyk,854
-code_loader-1.0.97.dev0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-code_loader-1.0.97.dev0.dist-info/RECORD,,
+code_loader-1.0.98.dist-info/LICENSE,sha256=qIwWjdspQeSMTtnFZBC8MuT-95L02FPvzRUdWFxrwJY,1067
+code_loader-1.0.98.dist-info/METADATA,sha256=D6yEtbhJsxugq22Wk9bAEv890unZJLXus6cTBOL0eP0,849
+code_loader-1.0.98.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+code_loader-1.0.98.dist-info/RECORD,,