code-loader 1.0.117__py3-none-any.whl → 1.0.153.dev4__py3-none-any.whl

code_loader/leaploader.py

@@ -16,7 +16,7 @@ from code_loader.contract.datasetclasses import DatasetSample, DatasetBaseHandle
     PreprocessResponse, VisualizerHandler, LeapData, \
     PredictionTypeHandler, MetadataHandler, CustomLayerHandler, MetricHandler, VisualizerHandlerData, MetricHandlerData, \
     MetricCallableReturnType, CustomLossHandlerData, CustomLossHandler, RawInputsForHeatmap, SamplePreprocessResponse, \
-    ElementInstance
+    ElementInstance, custom_latent_space_attribute
 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, \
@@ -34,7 +34,7 @@ class LeapLoader(LeapLoaderBase):
         super().__init__(code_path, code_entry_name)
 
         self._preprocess_result_cached = None
-        
+
         try:
             from code_loader.mixpanel_tracker import track_code_loader_loaded
             track_code_loader_loaded({
@@ -51,7 +51,7 @@ class LeapLoader(LeapLoaderBase):
             os.environ[mapping_runtime_mode_env_var_mame] = 'TRUE'
             self.evaluate_module()
             if global_leap_binder.integration_test_func is not None:
-                global_leap_binder.integration_test_func(None, None)
+                global_leap_binder.integration_test_func(None, PreprocessResponse(state=DataStateType.training, length=0))
         except TypeError as e:
             import traceback
             if "leap_binder.set_metadata(" in traceback.format_exc(5):
@@ -77,13 +77,15 @@ class LeapLoader(LeapLoaderBase):
         file_path = Path(self.code_path, self.code_entry_name)
         append_path_recursively(str(file_path))
 
+        importlib.invalidate_caches()
+
         spec = importlib.util.spec_from_file_location(self.code_path, file_path)
         if spec is None or spec.loader is None:
-            raise DatasetScriptException(f'Something is went wrong with spec file from: {file_path}')
+            raise DatasetScriptException(f'Something went wrong with spec file from: {file_path}')
 
         file = importlib.util.module_from_spec(spec)
         if file is None:
-            raise DatasetScriptException(f'Something is went wrong with import module from: {file_path}')
+            raise DatasetScriptException(f'Something went wrong with import module from: {file_path}')
 
         spec.loader.exec_module(file)
 
@@ -155,35 +157,28 @@ class LeapLoader(LeapLoaderBase):
             for prediction_type in setup.prediction_types
         }
 
-    def get_sample(self, state: DataStateEnum, sample_id: Union[int, str]) -> DatasetSample:
+    def get_sample(self, state: DataStateEnum, sample_id: Union[int, str], instance_id: int = None) -> 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)
-        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)
 
-        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])
+        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),
                                metadata=metadata,
                                metadata_is_none=metadata_is_none,
                                index=sample_id,
                                state=state,
-                               instance_masks=self._get_instances_masks(state, sample_id))
+                               custom_latent_space=custom_latent_space,
+                               instance_masks=instance_mask)
         return sample
 
     def check_dataset(self) -> DatasetIntegParseResult:
@@ -210,8 +205,6 @@ class LeapLoader(LeapLoaderBase):
                 general_error = f"Something went wrong. {repr(e.__cause__)} in file {file_name}, line_number:  {line_number}\nStacktrace:\n{stacktrace}"
                 is_valid = False
 
-
-
         print_log = stdout_steam.getvalue()
         is_valid_for_model = bool(global_leap_binder.setup_container.custom_layers)
         model_setup = self.get_model_setup_response()
@@ -476,12 +469,14 @@ 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]]:
+    def _get_instances_masks(self, state: DataStateEnum, sample_id: Union[int, str], instance_id: int) -> Optional[Dict[str, ElementInstance]]:
+        if instance_id is None:
+            return None
         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_result = handler.function(sample_id, preprocess_state, instance_id)
             handler_name = handler.name
             result_agg[handler_name] = handler_result
         return result_agg
@@ -526,20 +521,38 @@ 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], requested_metadata_names: Optional[List[str]] = None) -> Tuple[
+        Dict[str, Union[str, int, bool, float]], Dict[str, bool]]:
+
+        def is_metadata_name_starts_with_handler_name(_handler):
+            for metadata_name in requested_metadata_names:
+                if metadata_name.startswith(_handler.name + '_') or metadata_name == _handler.name:
+                    return True
+            return False
+
         result_agg = {}
         is_none = {}
         preprocess_result = self._preprocess_result()
         preprocess_state = preprocess_result[state]
         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 isinstance(handler_result, dict):
                 for single_metadata_name, single_metadata_result in handler_result.items():
                     handler_name = f'{handler.name}_{single_metadata_name}'
+                    if requested_metadata_names:
+                        if handler_name not in requested_metadata_names:
+                            continue
                     result_agg[handler_name], is_none[handler_name] = self._convert_metadata_to_correct_type(
                         handler_name, single_metadata_result)
             else:
                 handler_name = handler.name
+                if requested_metadata_names:
+                    if handler_name not in requested_metadata_names:
+                        continue
                 result_agg[handler_name], is_none[handler_name] = self._convert_metadata_to_correct_type(
                     handler_name, handler_result)
 
@@ -555,7 +568,12 @@ class LeapLoader(LeapLoaderBase):
 
         return id_type
 
-    def get_instances_data(self, state: DataStateEnum) -> Tuple[Dict[str, List[str]], Dict[str, str], Dict[str, str]]:
+    @lru_cache()
+    def has_custom_latent_space_decorator(self) -> bool:
+        self.exec_script()
+        return global_leap_binder.setup_container.custom_latent_space is not None
+
+    def get_instances_data(self, state: DataStateEnum) -> Tuple[Dict[str, List[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.
@@ -568,4 +586,4 @@ class LeapLoader(LeapLoaderBase):
         """
         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
+        return preprocess_state.sample_ids_to_instance_mappings, preprocess_state.instance_to_sample_ids_mappings

code_loader/leaploaderbase.py

@@ -61,16 +61,30 @@ class LeapLoaderBase:
         pass
 
     @abstractmethod
-    def get_sample(self, state: DataStateEnum, sample_id: Union[int, str]) -> DatasetSample:
+    def get_sample(self, state: DataStateEnum, sample_id: Union[int, str], instance_id: int = None) -> DatasetSample:
         pass
 
     @abstractmethod
-    def get_sample_with_masks(self, state: DataStateEnum, sample_id: Union[int, str]) -> DatasetSample:
+    def get_instances_data(self, state: DataStateEnum) -> Tuple[Dict[str, List[str]], Dict[str, str]]:
         pass
 
-    @abstractmethod
-    def get_instances_data(self, state: DataStateEnum) -> Tuple[Dict[str, List[str]], Dict[str, str], Dict[str, str]]:
-        pass
+    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]]]:
+        aggregated_results: Dict[str, List[Union[str, int, bool, float]]] = {}
+        aggregated_is_none: Dict[str, List[bool]] = {}
+        sample_id_type = self.get_sample_id_type()
+        for sample_id in sample_ids:
+            sample_id = sample_id_type(sample_id)
+            metadata_result, is_none_result = self.get_metadata(state, sample_id, requested_metadata_names)
+            for metadata_name, metadata_value in metadata_result.items():
+                if metadata_name not in aggregated_results:
+                    aggregated_results[metadata_name] = []
+                    aggregated_is_none[metadata_name] = []
+                aggregated_results[metadata_name].append(metadata_value)
+                aggregated_is_none[metadata_name].append(is_none_result[metadata_name])
+        return aggregated_results, aggregated_is_none
 
     @abstractmethod
     def check_dataset(self) -> DatasetIntegParseResult:
@@ -91,6 +105,13 @@ class LeapLoaderBase:
                         input_tensors_by_arg_name: Dict[str, npt.NDArray[np.float32]]):
         pass
 
+    @abstractmethod
+    def get_metadata(
+            self, state: DataStateEnum, sample_id: Union[int, str],
+            requested_metadata_names: Optional[List[str]] = None
+    ) -> Tuple[Dict[str, Union[str, int, bool, float]], Dict[str, bool]]:
+        pass
+
     @abstractmethod
     def run_heatmap_visualizer(self, visualizer_name: str, sample_ids: np.array, state: DataStateEnum,
                                input_tensors_by_arg_name: Dict[str, npt.NDArray[np.float32]]
@@ -114,6 +135,10 @@ class LeapLoaderBase:
     def get_sample_id_type(self) -> Type:
         pass
 
+    @abstractmethod
+    def has_custom_latent_space_decorator(self) -> bool:
+        pass
+
     @abstractmethod
     def get_heatmap_visualizer_raw_vis_input_arg_name(self, visualizer_name: str) -> Optional[str]:
         pass

code_loader/mixpanel_tracker.py

@@ -5,14 +5,57 @@ import os
 import sys
 import getpass
 import uuid
-from typing import Optional, Dict, Any
+import logging
+from enum import Enum
+from typing import Optional, Dict, Any, Set, Union, TypedDict
 import mixpanel  # type: ignore[import]
 
+logger = logging.getLogger(__name__)
+
+TRACKING_VERSION = '1'
+
+
+class AnalyticsEvent(str, Enum):
+    """Enumeration of all tracked analytics events."""
+    CODE_LOADER_LOADED = "code_loader_loaded"
+    LOAD_MODEL_INTEGRATION_TEST = "load_model_integration_test"
+    PREPROCESS_INTEGRATION_TEST = "preprocess_integration_test"
+    INPUT_ENCODER_INTEGRATION_TEST = "input_encoder_integration_test"
+    GT_ENCODER_INTEGRATION_TEST = "gt_encoder_integration_test"
+
+
+class CodeLoaderLoadedProps(TypedDict, total=False):
+    """Properties for code_loader_loaded event."""
+    event_type: str
+    code_path: str
+    code_entry_name: str
+
+
+class LoadModelEventProps(TypedDict, total=False):
+    """Properties for load_model_integration_test event."""
+    prediction_types_count: int
+
+
+class PreprocessEventProps(TypedDict, total=False):
+    """Properties for preprocess_integration_test event."""
+    preprocess_responses_count: int
+
+
+class InputEncoderEventProps(TypedDict, total=False):
+    """Properties for input_encoder_integration_test event."""
+    encoder_name: str
+    channel_dim: int
+
+
+class GtEncoderEventProps(TypedDict, total=False):
+    """Properties for gt_encoder_integration_test event."""
+    encoder_name: str
+
 
 class MixpanelTracker:
     """Handles Mixpanel event tracking for code-loader."""
     
-    def __init__(self, token: str = "f1bf46fb339d8c2930cde8c1acf65491"):
+    def __init__(self, token: str = "0c1710c9656bbfb1056bb46093e23ca1"):
         self.token = token
         self.mp = mixpanel.Mixpanel(token)
         self._user_id: Optional[str] = None
@@ -26,7 +69,8 @@ class MixpanelTracker:
         if self._user_id is None:
             try:
                 self._user_id = getpass.getuser()
-            except Exception:
+            except Exception as e:
+                logger.debug(f"Failed to get username via getpass: {e}")
                 # Fallback to environment variables or default
                 self._user_id = os.environ.get('USER', os.environ.get('USERNAME', 'unknown'))
         return self._user_id or 'unknown'
@@ -41,8 +85,8 @@ class MixpanelTracker:
                     user_id = f.read().strip()
                     if user_id:
                         return user_id
-        except Exception:
-            pass
+        except Exception as e:
+            logger.debug(f"Failed to read TensorLeap user ID: {e}")
         return None
     
     def _get_or_create_device_id(self) -> str:
@@ -71,7 +115,8 @@ class MixpanelTracker:
                 f.write(device_id)
             
             return device_id
-        except Exception:
+        except Exception as e:
+            logger.debug(f"Failed to read/write device ID file: {e}")
             # Fallback to generating a new UUID if file operations fail
             return str(uuid.uuid4())
     
@@ -88,12 +133,17 @@ class MixpanelTracker:
         
         return self._get_or_create_device_id()
     
-    def track_code_loader_loaded(self, event_properties: Optional[Dict[str, Any]] = None) -> None:
-        """Track code loader loaded event with device identification.
+    def _track_event(self, event_name: Union[str, AnalyticsEvent], event_properties: Optional[Dict[str, Any]] = None) -> None:
+        """Internal method to track any event with device identification.
         
         Args:
+            event_name: The name of the event to track (string or AnalyticsEvent enum)
             event_properties: Optional additional properties to include in the event
         """
+        # Skip tracking if IS_TENSORLEAP_PLATFORM environment variable is set to 'true'
+        if os.environ.get('IS_TENSORLEAP_PLATFORM') == 'true':
+            return
+            
         try:
             distinct_id = self._get_distinct_id()
             
@@ -102,6 +152,8 @@ class MixpanelTracker:
             device_id = self._get_or_create_device_id()
             
             properties = {
+                'tracking_version': TRACKING_VERSION,
+                'service': 'code-loader',
                 'whoami': whoami,
                 '$device_id': device_id,  # Always use device_id for $device_id
                 'python_version': f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
@@ -114,9 +166,26 @@ class MixpanelTracker:
             if event_properties:
                 properties.update(event_properties)
             
-            self.mp.track(distinct_id, 'code_loader_loaded', properties)
+            self.mp.track(distinct_id, str(event_name), properties)
         except Exception as e:
-            pass
+            logger.debug(f"Failed to track event '{event_name}': {e}")
+
+    def track_code_loader_loaded(self, event_properties: Optional[Dict[str, Any]] = None) -> None:
+        """Track code loader loaded event with device identification.
+        
+        Args:
+            event_properties: Optional additional properties to include in the event
+        """
+        self._track_event(AnalyticsEvent.CODE_LOADER_LOADED, event_properties)
+
+    def track_integration_test_event(self, event_name: Union[str, AnalyticsEvent], event_properties: Optional[Dict[str, Any]] = None) -> None:
+        """Track an integration test event with device identification.
+        
+        Args:
+            event_name: The name of the event to track (string or AnalyticsEvent enum)
+            event_properties: Optional additional properties to include in the event
+        """
+        self._track_event(event_name, event_properties)
 
 
 # Global tracker instance
@@ -132,3 +201,30 @@ def get_tracker() -> MixpanelTracker:
 
 def track_code_loader_loaded(event_properties: Optional[Dict[str, Any]] = None) -> None:
     get_tracker().track_code_loader_loaded(event_properties)
+
+
+def track_integration_test_event(event_name: Union[str, AnalyticsEvent], event_properties: Optional[Dict[str, Any]] = None) -> None:
+    get_tracker().track_integration_test_event(event_name, event_properties)
+
+
+# Module-level set to track which integration test events have been emitted
+_integration_events_emitted: Set[str] = set()
+
+
+def emit_integration_event_once(event_name: Union[str, AnalyticsEvent], props: Dict[str, Any]) -> None:
+    """Emit an integration test event only once per test run."""
+    event_name_str = str(event_name)
+    if event_name_str in _integration_events_emitted:
+        return
+    
+    try:
+        track_integration_test_event(event_name, props)
+        _integration_events_emitted.add(event_name_str)
+    except Exception as e:
+        logger.debug(f"Failed to emit integration event once '{event_name}': {e}")
+
+
+def clear_integration_events() -> None:
+    """Clear the integration events set for a new test run."""
+    global _integration_events_emitted
+    _integration_events_emitted.clear()

code_loader/plot_functions/plot_functions.py

@@ -29,7 +29,6 @@ def run_only_on_non_mapping_mode():
     def decorator(func):
         def wrapper(*args, **kwargs):
             if os.environ.get(mapping_runtime_mode_env_var_mame):
-                print(f"Skipping {func.__name__} in mapping mode.")
                 return
             return func(*args, **kwargs)
         return wrapper
@@ -325,7 +324,7 @@ def plot_image_mask(leap_data: LeapImageMask, title: str) -> None:
 
         # fill the instance mask with a translucent color
         overlayed_image[instance_mask] = (
-                overlayed_image[instance_mask] * (1 - 0.5) + np.array(colors[i][:image.shape[-1]], dtype=np.uint8) * 0.5)
+                overlayed_image[instance_mask] * (1 - 0.5) + np.array(colors[i][:image.shape[-1]], dtype=image.dtype) * 0.5)
 
     # Display the result using matplotlib
     fig, ax = plt.subplots(1)

code_loader/utils.py

@@ -18,12 +18,12 @@ 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)
+def to_numpy_return_masks_wrapper(encoder_function: InstanceCallableInterface) -> InstanceCallableInterface:
+    def numpy_encoder_function(idx: Union[int, str], samples: PreprocessResponse, element_idx: int) -> Union[ElementInstance, None]:
+        result = encoder_function(idx, samples, element_idx)
+        if result is None:
+            return None
+        result.mask = np.array(result.mask)
         return result
     return numpy_encoder_function
 

code_loader-1.0.153.dev4.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.117.dist-info → code_loader-1.0.153.dev4.dist-info}/METADATA

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: code-loader
-Version: 1.0.117
+Version: 1.0.153.dev4
 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.117.dist-info → code_loader-1.0.153.dev4.dist-info}/RECORD

@@ -1,9 +1,10 @@
+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=gJsXu4zVAaiBlq6GJwPxfTD2e0gICTtI_6Ir61MRL48,8838
+code_loader/contract/datasetclasses.py,sha256=IyUwwvu1c53KfUeTiVOYN20ak7aCo-26HYhm5seO6v8,9799
 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
+code_loader/contract/mapping.py,sha256=sWJhpng-IkOzQnWQdMT5w2ZZ3X1Z_OOzSwCLXIS7oxE,1446
 code_loader/contract/responsedataclasses.py,sha256=6-5DJkYBdXb3UB1eNidTTPPBIYxMjEoMdYDkp9VhH8o,4223
 code_loader/contract/visualizer_classes.py,sha256=Wz9eItmoRaKEHa3p0aW0Ypxx4_xUmaZyLBznnTuxwi0,15425
 code_loader/default_losses.py,sha256=NoOQym1106bDN5dcIk56Elr7ZG5quUHArqfP5-Nyxyo,1139
@@ -19,18 +20,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=0iHVHxC2NjfH7F0vQFVGy1e0llgKEyUHUHh3DdtqL70,32602
-code_loader/inner_leap_binder/leapbinder_decorators.py,sha256=wjtk3TflrjJ8Y-OeuedVBD-09ZuOjIKGUjL7sMBU0fQ,41017
-code_loader/leaploader.py,sha256=rQRK1lyUPSpZiRs6lKUUxVJBCe3grEY_UxEMxSIpuxI,29709
-code_loader/leaploaderbase.py,sha256=lKdw2pd6H9hFsxVmc7jJMoZd_vlG5He1ooqT-cR_yq8,4496
-code_loader/mixpanel_tracker.py,sha256=U20vQXH8G7XIVXxcpQcVEZSuIwwGnyH5RMHXWZZG8HI,4639
+code_loader/inner_leap_binder/leapbinder.py,sha256=Q3D9yVM-GNEJfYRFvMV__BoZbcWOgnWKhrZXAv6Tu7o,33232
+code_loader/inner_leap_binder/leapbinder_decorators.py,sha256=aVMVjZjRmJy8-3_qyQ42RAcVfvajUZ-SupwcmNwhdaI,82000
+code_loader/leaploader.py,sha256=oxtlf7NhWuiUPeIwAO699JaD-mK_7fGM55okKLyKaJg,30582
+code_loader/leaploaderbase.py,sha256=NXCDIIF7-ziGJccKIE9NszMSYKEE-3bn4Z4Xa3oYYOc,5909
+code_loader/mixpanel_tracker.py,sha256=eKvymkw7X2Ht6iw-a0V9VQm6OnB9kW7hYy35YtwRAvU,8457
 code_loader/plot_functions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-code_loader/plot_functions/plot_functions.py,sha256=xg6Gi4myTN9crq6JtyrhYI38HLXjPVJcbnI7CIy8f7w,14625
+code_loader/plot_functions/plot_functions.py,sha256=OGFLfbL31N2wuwcXIxxQ14f0Kuuvv1BZkAuFi2c0ma4,14560
 code_loader/plot_functions/visualize.py,sha256=gsBAYYkwMh7jIpJeDMPS8G4CW-pxwx6LznoQIvi4vpo,657
-code_loader/utils.py,sha256=_j8b60pimoNAvWMRj7hEkkT6C76qES6cZoBFHpXHMxA,2698
+code_loader/utils.py,sha256=gXENTYpjdidq2dx0gVbXlErPeHoNs-4TYAZbLRe0y2c,2712
 code_loader/visualizers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 code_loader/visualizers/default_visualizers.py,sha256=onRnLE_TXfgLN4o52hQIOOhUcFexGlqJ3xSpQDVLuZM,2604
-code_loader-1.0.117.dist-info/LICENSE,sha256=qIwWjdspQeSMTtnFZBC8MuT-95L02FPvzRUdWFxrwJY,1067
-code_loader-1.0.117.dist-info/METADATA,sha256=du8-T5bFdFlkZj7rC-z9ZczxH_fCPrKjQCAjfKs3QGU,1102
-code_loader-1.0.117.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-code_loader-1.0.117.dist-info/RECORD,,
+code_loader-1.0.153.dev4.dist-info/LICENSE,sha256=qIwWjdspQeSMTtnFZBC8MuT-95L02FPvzRUdWFxrwJY,1067
+code_loader-1.0.153.dev4.dist-info/METADATA,sha256=B4nPV_w3AFdba4SVtC-d03HSfaw_-MobZquctbpytbM,1095
+code_loader-1.0.153.dev4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+code_loader-1.0.153.dev4.dist-info/RECORD,,

{code_loader-1.0.117.dist-info → code_loader-1.0.153.dev4.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