code-loader 1.0.207.dev0__py3-none-any.whl → 1.0.208__py3-none-any.whl

code_loader/contract/datasetclasses.py

@@ -6,13 +6,21 @@ import numpy as np
 import numpy.typing as npt
 
 from code_loader.contract.enums import DataStateType, DataStateEnum, LeapDataType, ConfusionMatrixValue, \
-    MetricDirection, DatasetMetadataType
+    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
 
 custom_latent_space_attribute = "custom_latent_space"
 
+# Hard cap on a custom latent space's per-sample width, applied AFTER any reduction. The
+# soft threshold only warns. MAX_CUSTOM_LATENT_SPACES mirrors the engine's
+# src_tensorleap/common/types.py (source of truth) so an over-budget registration fails
+# locally instead of being silently dropped at eval time; keep the two in sync.
+MAX_CUSTOM_LATENT_SPACE_DIM = 4096
+CUSTOM_LATENT_SPACE_WARN_DIM = 1024
+MAX_CUSTOM_LATENT_SPACES = 10
+
 _simulation_context: Dict[str, bool] = {"active": False}
 
 SampleId = Union[int, str]
@@ -317,6 +325,11 @@ class CustomLatentSpaceHandler:
     name: str = 'custom_latent_space'
     use_ls_for_analysis: bool = False
     instance_aware: bool = False
+    computed_at: CustomLatentSpaceComputedAt = CustomLatentSpaceComputedAt.DATASET
+    arg_names: Optional[List[str]] = None
+    reduce: Optional[LatentSpaceReduction] = None
+    n_components: int = 512
+    channel_axis: int = -1
 
 
 # How a chain's latent-space vectors are derived from its per-step forward passes.

code_loader/contract/enums.py

@@ -68,3 +68,13 @@ class ConfusionMatrixValue(Enum):
 class TestingSectionEnum(Enum):
     Warnings = "Warnings"
     Errors = "Errors"
+
+
+class LatentSpaceReduction(Enum):
+    MEAN_POOL = 'MEAN_POOL'
+    RANDOM_PROJECTION = 'RANDOM_PROJECTION'
+
+
+class CustomLatentSpaceComputedAt(Enum):
+    DATASET = 'dataset'
+    MODEL = 'model'

code_loader/contract/mapping.py

@@ -38,6 +38,7 @@ class NodeMappingType(Enum):
     Input8 = 'Input8'
     Input9 = 'Input9'
     PredictionLabels = 'PredictionLabels'
+    CustomLatentSpace = 'CustomLatentSpace'
 
 
 @dataclass

code_loader/inner_leap_binder/leapbinder.py

@@ -17,12 +17,12 @@ from code_loader.contract.datasetclasses import SectionCallableInterface, InputH
     CustomMultipleReturnCallableInterfaceMultiArgs, DatasetBaseHandler, custom_latent_space_attribute, \
     RawInputsForHeatmap, VisualizerHandlerData, MetricHandlerData, CustomLossHandlerData, SamplePreprocessResponse, \
     ElementInstanceMasksHandler, InstanceCallableInterface, InstanceSectionCallableInterface, \
-    CustomLatentSpaceHandler, InstanceMetricHandler, \
+    CustomLatentSpaceHandler, InstanceMetricHandler, MAX_CUSTOM_LATENT_SPACES, \
     SimulationHandler, _simulation_context, AutoregressiveStepHandler, AutoregressiveStepCallableInterface, \
     AUTOREGRESSIVE_LATENT_SPACE_AGGREGATIONS, AUTOREGRESSIVE_IMPLICIT_ARG_NAMES, \
     AutoregressiveMetricHandler, AutoregressiveLossHandler, AutoregressiveVisualizerHandler
 from code_loader.contract.enums import LeapDataType, DataStateEnum, DataStateType, MetricDirection, DatasetMetadataType, \
-    TestingSectionEnum
+    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
@@ -67,16 +67,24 @@ def _stringized_annotation_type_name(annotation: Any) -> Optional[str]:
     return None
 
 
-def _reject_stringized_sample_preprocess_response(function: Callable[..., Any], arg_name: str, annotation: Any) -> None:
-    """Fail fast on a stringized SamplePreprocessResponse arg (otherwise it silently
-    mis-wires as a regular input, surfacing only on the platform)."""
-    if _stringized_annotation_type_name(annotation) == SamplePreprocessResponse.__name__:
+def _reject_stringized_annotation(function: Callable[..., Any], arg_name: str, annotation: Any,
+                                  expected_cls: type, why: str) -> None:
+    """Fail fast on a stringized `expected_cls` arg (otherwise it silently mis-wires,
+    surfacing only on the platform)."""
+    if _stringized_annotation_type_name(annotation) == expected_cls.__name__:
         raise Exception(
             f"Argument '{arg_name}' of function '{function.__name__}' is annotated with a string "
-            f"('{annotation}') instead of the SamplePreprocessResponse type. This usually means the "
+            f"('{annotation}') instead of the {expected_cls.__name__} type. This usually means the "
             f"file uses 'from __future__ import annotations' (or a quoted hint), which stringizes "
-            f"annotations and breaks Tensorleap type detection. Remove that import (or the quotes) so "
-            f"SamplePreprocessResponse is referenced as a real type.")
+            f"annotations. {why} Remove that import (or the quotes).")
+
+
+def _reject_stringized_sample_preprocess_response(function: Callable[..., Any], arg_name: str, annotation: Any) -> None:
+    _reject_stringized_annotation(
+        function, arg_name, annotation, SamplePreprocessResponse,
+        "This breaks Tensorleap type detection, so it must be referenced as a real type.")
+
+
 
 
 
@@ -546,7 +554,12 @@ class LeapBinder:
     def set_custom_latent_space(self, function: Union[SectionCallableInterface, InstanceSectionCallableInterface],
                                 name: Optional[str] = None,
                                 use_ls_for_analysis: bool = False,
-                                instance_aware: bool = False) -> None:
+                                instance_aware: bool = False,
+                                computed_at: CustomLatentSpaceComputedAt = CustomLatentSpaceComputedAt.DATASET,
+                                arg_names: Optional[List[str]] = None,
+                                reduce: Optional[LatentSpaceReduction] = None,
+                                n_components: int = 512,
+                                channel_axis: int = -1) -> None:
         """
         Register a custom latent space function.
 
@@ -579,6 +592,14 @@ class LeapBinder:
                 f"@tensorleap_custom_latent_space must have a unique name "
                 f"(pass name='...' to distinguish them)."
             )
+        if len(self.setup_container.custom_latent_spaces) >= MAX_CUSTOM_LATENT_SPACES:
+            raise Exception(
+                f"Cannot register custom latent space '{name}': Tensorleap supports at most "
+                f"{MAX_CUSTOM_LATENT_SPACES} custom latent spaces, and "
+                f"{len(self.setup_container.custom_latent_spaces)} are already registered "
+                f"({sorted(self.setup_container.custom_latent_spaces)}). Dataset-computed and "
+                f"model-computed latent spaces share this budget."
+            )
         # use_ls_for_analysis is not currently wired for instance-aware latent spaces (OOD /
         # Domain-Gap analyze the sample-level population, not instance rows) — force it off rather
         # than silently accepting a flag that has no effect.
@@ -602,8 +623,25 @@ class LeapBinder:
                     f"Out-Of-Distribution and Domain-Gap insights). Set it on '{name}' "
                     f"or '{already_flagged[0]}', not both."
                 )
+        if reduce is not None:
+            if not isinstance(reduce, LatentSpaceReduction):
+                raise Exception(
+                    f"Custom latent space '{name}': reduce must be a LatentSpaceReduction, got "
+                    f"{type(reduce).__name__}.")
+            if reduce is LatentSpaceReduction.RANDOM_PROJECTION and (
+                    not isinstance(n_components, int) or isinstance(n_components, bool) or n_components <= 0):
+                raise Exception(
+                    f"Custom latent space '{name}': n_components must be a positive int for "
+                    f"LatentSpaceReduction.RANDOM_PROJECTION, got {n_components!r}.")
+            if reduce is LatentSpaceReduction.MEAN_POOL and (
+                    not isinstance(channel_axis, int) or isinstance(channel_axis, bool)):
+                raise Exception(
+                    f"Custom latent space '{name}': channel_axis must be an int for "
+                    f"LatentSpaceReduction.MEAN_POOL, got {channel_axis!r}.")
         self.setup_container.custom_latent_spaces[name] = CustomLatentSpaceHandler(
-            function=function, name=name, use_ls_for_analysis=use_ls_for_analysis, instance_aware=instance_aware)
+            function=function, name=name, use_ls_for_analysis=use_ls_for_analysis, instance_aware=instance_aware,
+            computed_at=computed_at, arg_names=arg_names, reduce=reduce, n_components=n_components,
+            channel_axis=channel_axis)
 
     def set_autoregressive_step(self, function: AutoregressiveStepCallableInterface,
                                 latent_space_aggregation: str = 'last_step') -> None:

code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -7,6 +7,7 @@ import warnings
 import logging
 from collections import defaultdict
 import functools
+import typing
 from functools import lru_cache
 from pathlib import Path
 from typing import Optional, Union, Callable, List, Dict, Set, Any
@@ -18,7 +19,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__)
 
@@ -26,15 +27,17 @@ from code_loader.contract.datasetclasses import CustomCallableInterfaceMultiArgs
     CustomMultipleReturnCallableInterfaceMultiArgs, ConfusionMatrixCallableInterfaceMultiArgs, CustomCallableInterface, \
     VisualizerCallableInterface, MetadataSectionCallableInterface, PreprocessResponse, SectionCallableInterface, \
     ConfusionMatrixElement, SamplePreprocessResponse, PredictionTypeHandler, InstanceCallableInterface, ElementInstance, \
-    InstanceLengthCallableInterface, InstanceSectionCallableInterface, AutoregressiveStepCallableInterface
+    InstanceLengthCallableInterface, InstanceSectionCallableInterface, AutoregressiveStepCallableInterface, \
+    MAX_CUSTOM_LATENT_SPACE_DIM, CUSTOM_LATENT_SPACE_WARN_DIM
 from code_loader.contract.enums import MetricDirection, LeapDataType, DatasetMetadataType, DataStateType, \
-    DataStateEnum
+    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, \
     LeapHorizontalBar, LeapImageWithBBox, LeapImageWithHeatmap, LeapVideo, LeapAudio, LeapValidationError, \
     map_leap_data_type_to_visualizer_class
-from code_loader.inner_leap_binder.leapbinder import mapping_runtime_mode_env_var_mame
+from code_loader.inner_leap_binder.leapbinder import mapping_runtime_mode_env_var_mame, \
+    _reject_stringized_sample_preprocess_response
 from code_loader.mixpanel_tracker import clear_integration_events, AnalyticsEvent, emit_integration_event_once
 
 _called_from_inside_tl_decorator = 0
@@ -264,7 +267,8 @@ def _validate_grouped_result(result, group_size, func_name, validate_single):
             f'{group_size} arrays, got {type(result)}.')
 
 
-def _add_mapping_connection(user_unique_name, connection_destinations, arg_names, name, node_mapping_type):
+def _add_mapping_connection(user_unique_name, connection_destinations, arg_names, name, node_mapping_type,
+                            target_list=None):
     connection_destinations = [connection_destination for connection_destination in connection_destinations
                                if not isinstance(connection_destination, SamplePreprocessResponse)]
 
@@ -274,7 +278,9 @@ def _add_mapping_connection(user_unique_name, connection_destinations, arg_names
     for arg_name, destination in zip(arg_names, connection_destinations):
         node_inputs[arg_name] = destination.node_mapping
 
-    leap_binder.mapping_connections.append(NodeConnection(main_node_mapping, node_inputs))
+    if target_list is None:
+        target_list = leap_binder.mapping_connections
+    target_list.append(NodeConnection(main_node_mapping, node_inputs))
 
 
 def _add_mapping_connections(connects_to, arg_names, node_mapping_type, name):
@@ -286,11 +292,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)
@@ -1750,7 +1752,175 @@ def tensorleap_metadata(
     return decorating_function
 
 
-def tensorleap_custom_latent_space(name: Optional[str] = None, use_ls_for_analysis: bool = False):
+def _is_preprocess_response_type(annotation: Any) -> bool:
+    if isinstance(annotation, type):
+        return issubclass(annotation, PreprocessResponse)
+    return any(_is_preprocess_response_type(arg) for arg in get_args(annotation))
+
+
+def _classify_custom_latent_space_signature(user_function) -> str:
+    """Dataset-computed when a parameter is typed PreprocessResponse (a subclass or an
+    Optional[...] of it included), model-computed otherwise."""
+    params = list(inspect.signature(user_function).parameters.values())
+    try:
+        hints = typing.get_type_hints(user_function)
+    except NameError as e:
+        raise Exception(
+            f"tensorleap_custom_latent_space validation failed: could not resolve the type "
+            f"annotations of '{user_function.__name__}' ({e}). Tensorleap reads them to tell a "
+            f"dataset-computed latent space from a model-computed one, so every annotation, the "
+            f"return type included, must be resolvable when the function is decorated. Import the "
+            f"annotated types at module level (not only under TYPE_CHECKING) or remove the "
+            f"annotation.") from e
+    preprocess_params = [p.name for p in params if _is_preprocess_response_type(hints.get(p.name))]
+    if preprocess_params:
+        positional = [p.name for p in params
+                      if p.kind in (inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD)]
+        if positional[1:2] != preprocess_params[:1] or len(preprocess_params) > 1:
+            raise Exception(
+                f"tensorleap_custom_latent_space validation failed: '{user_function.__name__}' is "
+                f"dataset-computed (it takes a PreprocessResponse), so it is called as "
+                f"{user_function.__name__}(sample_id, preprocess) and its PreprocessResponse must be "
+                f"the second positional parameter, and the only one. Got parameters "
+                f"{[p.name for p in params]} with PreprocessResponse on {preprocess_params}.")
+        return 'dataset'
+
+    if len(params) == 2 and params[1].name not in hints:
+        first, second = params[0].name, params[1].name
+        raise Exception(
+            f"tensorleap_custom_latent_space validation failed: '{user_function.__name__}' has "
+            f"exactly two parameters ('{first}', '{second}') and '{second}' has no type "
+            f"annotation, so Tensorleap cannot tell whether this is a dataset-computed latent "
+            f"space (one sample at a time) or a model-computed one (a batch of model tensors). "
+            f"Please annotate the second parameter '{second}' to disambiguate:\n"
+            f"  dataset-computed: def {user_function.__name__}({first}, {second}: PreprocessResponse) -> (d,)\n"
+            f"  model-computed:   def {user_function.__name__}({first}: np.ndarray, {second}: np.ndarray) -> (batch, d)\n"
+            f"If you are upgrading an existing project, this signature used to be accepted "
+            f"unannotated as dataset-computed; add ': PreprocessResponse' to '{second}' to keep "
+            f"the previous behavior.")
+    if len(params) > 2 and not any(p.name in hints for p in params):
+        names = [p.name for p in params]
+        raise Exception(
+            f"tensorleap_custom_latent_space validation failed: '{user_function.__name__}' has "
+            f"parameters {names} and none of them has a type annotation, so Tensorleap cannot "
+            f"tell whether this is a dataset-computed latent space (one sample at a time) or a "
+            f"model-computed one (a batch of model tensors). Please annotate them:\n"
+            f"  dataset-computed: def {user_function.__name__}({names[0]}, {names[1]}: PreprocessResponse, ...) -> (d,)\n"
+            f"  model-computed:   def {user_function.__name__}({names[0]}: np.ndarray, {names[1]}: np.ndarray, ...) -> (batch, d)")
+    return 'model'
+
+
+def _model_latent_space_arg_names(user_function) -> List[str]:
+    # inspect.signature follows functools.wraps' __wrapped__, as the classifier does.
+    params = inspect.signature(user_function).parameters.values()
+    arg_names = [p.name for p in params
+                 if p.kind in (inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD)]
+    spr_count = 0
+    for param in params:
+        if param.annotation is inspect.Parameter.empty:
+            continue
+        _reject_stringized_sample_preprocess_response(user_function, param.name, param.annotation)
+        if param.annotation == SamplePreprocessResponse:
+            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
+
+
+def _custom_latent_space_width(result, ls_name, reduce, n_components, channel_axis,
+                               has_batch_axis: bool) -> int:
+    if reduce is LatentSpaceReduction.RANDOM_PROJECTION:
+        return n_components
+    if reduce is LatentSpaceReduction.MEAN_POOL:
+        axis = channel_axis if channel_axis >= 0 else result.ndim + channel_axis
+        min_axis = 1 if has_batch_axis else 0
+        if axis < min_axis or axis >= result.ndim:
+            raise Exception(
+                f"tensorleap_custom_latent_space validation failed: '{ls_name}' uses "
+                f"LatentSpaceReduction.MEAN_POOL with channel_axis={channel_axis}, which does not "
+                f"select a non-batch axis of the returned shape {tuple(result.shape)}."
+                + (" Axis 0 is the batch." if has_batch_axis else ""))
+        return int(result.shape[axis])
+    dims = result.shape[1:] if has_batch_axis else result.shape
+    return int(np.prod(dims))
+
+
+def _check_custom_latent_space_width(result, ls_name, reduce, n_components, channel_axis,
+                                     has_batch_axis: bool) -> None:
+    width = _custom_latent_space_width(result, ls_name, reduce, n_components, channel_axis,
+                                       has_batch_axis)
+    if width > MAX_CUSTOM_LATENT_SPACE_DIM:
+        raise Exception(
+            f"tensorleap_custom_latent_space validation failed: '{ls_name}' produces "
+            f"{width} dimensions per sample, above the {MAX_CUSTOM_LATENT_SPACE_DIM} limit. "
+            f"Pass reduce=LatentSpaceReduction.RANDOM_PROJECTION (with n_components) to "
+            f"project it down, or reduce=LatentSpaceReduction.MEAN_POOL (with channel_axis) "
+            f"to average the non-channel axes, or return a smaller array.")
+    if width > CUSTOM_LATENT_SPACE_WARN_DIM:
+        store_general_warning(
+            key=("tensorleap_custom_latent_space_width", ls_name, width),
+            message=(
+                f"Custom latent space '{ls_name}' produces {width} dimensions per sample. "
+                f"Wide latent spaces are slow to transit and store. Consider "
+                f"reduce=LatentSpaceReduction.MEAN_POOL or "
+                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 15% 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):
     assert isinstance(use_ls_for_analysis, bool), \
         ("tensorleap_custom_latent_space validation failed: use_ls_for_analysis must be a bool. "
          f"Got {type(use_ls_for_analysis)}.")
@@ -1758,6 +1928,10 @@ def tensorleap_custom_latent_space(name: Optional[str] = None, use_ls_for_analys
     def decorating_function(user_function: SectionCallableInterface):
         ls_name = name if name is not None else user_function.__name__
 
+        if _classify_custom_latent_space_signature(user_function) == 'model':
+            return _decorate_model_latent_space(user_function, ls_name, use_ls_for_analysis,
+                                                reduce, n_components, channel_axis)
+
         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')
 
@@ -1765,6 +1939,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(
@@ -1777,6 +1952,8 @@ def tensorleap_custom_latent_space(name: Optional[str] = None, use_ls_for_analys
                         f"inside your function."
                     ),
                 )
+            _check_custom_latent_space_width(single_result, ls_name, reduce, n_components, channel_axis,
+                                             has_batch_axis=False)
 
         def _validate_result(result, grouped=False, group_size=None):
             if not grouped:
@@ -1814,7 +1991,9 @@ def tensorleap_custom_latent_space(name: Optional[str] = None, use_ls_for_analys
             return result
 
         leap_binder.set_custom_latent_space(inner_without_validate, ls_name,
-                                            use_ls_for_analysis=use_ls_for_analysis)
+                                            use_ls_for_analysis=use_ls_for_analysis,
+                                            computed_at=CustomLatentSpaceComputedAt.DATASET, reduce=reduce,
+                                            n_components=n_components, channel_axis=channel_axis)
 
         def inner(sample_id, preprocess_response):
             if os.environ.get(mapping_runtime_mode_env_var_mame):
@@ -1834,6 +2013,98 @@ def tensorleap_custom_latent_space(name: Optional[str] = None, use_ls_for_analys
     return decorating_function
 
 
+def _decorate_model_latent_space(user_function, ls_name, use_ls_for_analysis, reduce, n_components,
+                                channel_axis):
+    arg_names = _model_latent_space_arg_names(user_function)
+
+    def _validate_input_args(*args, **kwargs):
+        # Every bound argument must be an array: a ground truth is never passed as None, so a
+        # model-computed LS cannot fall back from ground truth to predictions on unlabeled rows.
+        # The engine skips the LS for those rows instead (see leaploader._check_model_latent_spaces).
+        assert len(args) + len(kwargs) > 0, (
+            f"tensorleap_custom_latent_space validation failed: '{user_function.__name__}' is "
+            f"model-computed and expects at least one np.ndarray argument, but received none.")
+        for i, arg in enumerate(args):
+            assert isinstance(arg, (np.ndarray, SamplePreprocessResponse)), (
+                f"tensorleap_custom_latent_space validation failed: Argument #{i} of "
+                f"'{user_function.__name__}' should be a numpy array. Got {type(arg)}.")
+        for arg_name, arg in kwargs.items():
+            assert isinstance(arg, (np.ndarray, SamplePreprocessResponse)), (
+                f"tensorleap_custom_latent_space validation failed: Argument {arg_name} of "
+                f"'{user_function.__name__}' should be a numpy array. Got {type(arg)}.")
+
+    def _validate_result(result):
+        assert isinstance(result, np.ndarray), (
+            f"tensorleap_custom_latent_space validation failed: '{user_function.__name__}' is "
+            f"model-computed and should return a numpy array of shape (batch, d). "
+            f"Got {type(result)}.")
+        assert result.ndim >= 2, (
+            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__}' "
+                f"returned leading dim {result.shape[0]} instead of the batch size "
+                f"{leap_binder.batch_size_to_validate}.")
+
+        _check_custom_latent_space_width(result, ls_name, reduce, n_components, channel_axis,
+                                         has_batch_axis=True)
+
+    def inner_without_validate(*args, **kwargs):
+        global _called_from_inside_tl_decorator
+        _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
+
+        return result
+
+    inner_without_validate.__signature__ = inspect.signature(user_function)
+
+    leap_binder.set_custom_latent_space(inner_without_validate, ls_name,
+                                        use_ls_for_analysis=use_ls_for_analysis,
+                                        computed_at=CustomLatentSpaceComputedAt.MODEL, arg_names=arg_names, reduce=reduce,
+                                        n_components=n_components, channel_axis=channel_axis)
+
+    def inner(*args, **kwargs):
+        args, kwargs, _was_downcast = _simulate_engine_tensor_dtype(args, kwargs)
+        _validate_input_args(*args, **kwargs)
+        result = inner_without_validate(*args, **kwargs)
+        _validate_result(result)
+        return result
+
+    def mapping_inner(*args, **kwargs):
+        if _mapping_dataset_is_grouped:
+            raise LeapValidationError(
+                f"tensorleap_custom_latent_space validation failed: '{ls_name}' is model-computed, "
+                f"which is not supported for a grouped preprocess response. Use the "
+                f"(sample_id, preprocess: PreprocessResponse) form instead.")
+
+        ordered_connections = [kwargs[arg_name] for arg_name in arg_names if arg_name in kwargs]
+        ordered_connections = list(args) + ordered_connections
+
+        leap_binder.mapping_connections[:] = [
+            connection for connection in leap_binder.mapping_connections
+            if not (connection.node.type is NodeMappingType.CustomLatentSpace
+                    and connection.node.name == ls_name)]
+        _add_mapping_connection(ls_name, ordered_connections, arg_names, ls_name,
+                                NodeMappingType.CustomLatentSpace)
+        return None
+
+    @functools.wraps(user_function)
+    def final_inner(*args, **kwargs):
+        if os.environ.get(mapping_runtime_mode_env_var_mame):
+            return mapping_inner(*args, **kwargs)
+        return inner(*args, **kwargs)
+
+    return final_inner
+
+
 def tensorleap_instance_custom_latent_space(name: Optional[str] = None, use_ls_for_analysis: bool = False):
     assert isinstance(use_ls_for_analysis, bool), \
         ("tensorleap_instance_custom_latent_space validation failed: use_ls_for_analysis must be a bool. "
@@ -1859,6 +2130,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,9 @@ 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, \
     DatasetPreprocess, DatasetSetup, DatasetInputInstance, DatasetOutputInstance, DatasetMetadataInstance, \
@@ -28,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:
@@ -352,6 +355,9 @@ class LeapLoader(LeapLoaderBase):
                 instance_ls_test_payload = self._check_instance_custom_latent_spaces()
                 if instance_ls_test_payload is not None:
                     test_payloads.append(instance_ls_test_payload)
+                model_ls_test_payload = self._check_model_latent_spaces()
+                if model_ls_test_payload is not None:
+                    test_payloads.append(model_ls_test_payload)
                 handlers_test_payloads = self._check_handlers()
                 test_payloads.extend(handlers_test_payloads)
                 simulation_test_payloads = self._check_simulations()
@@ -386,8 +392,9 @@ class LeapLoader(LeapLoaderBase):
                                        is_valid_for_model=is_valid_for_model, setup=setup_response,
                                        model_setup=model_setup, general_error=general_error,
                                        print_log=print_log,
-                                       engine_file_contract=EngineFileContract(global_leap_binder.mapping_connections,
-                                                                               global_leap_binder.leap_analysis_configuration))
+                                       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')
@@ -425,6 +432,42 @@ class LeapLoader(LeapLoaderBase):
             test_result.is_passed = False
         return test_result
 
+    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 == CustomLatentSpaceComputedAt.MODEL
+        ]
+        if not model_names:
+            return None
+
+        test_result = DatasetTestResultPayload('model_custom_latent_space')
+        grouped_states = [
+            state.name for state, preprocess_response in self._preprocess_result().items()
+            if preprocess_response.is_grouped
+        ]
+        if grouped_states:
+            test_result.is_passed = False
+            test_result.display[TestingSectionEnum.Errors.name] = (
+                f"Model-computed custom latent space(s) {model_names} are not supported with a "
+                f"grouped preprocess response (grouped: {grouped_states}). Use the "
+                f"(sample_id, preprocess: PreprocessResponse) form instead."
+            )
+        if global_leap_binder.setup_container.unlabeled_data_preprocess is not None:
+            gt_bound_names = [
+                connection.node.name for connection in global_leap_binder.mapping_connections
+                if connection.node.type is NodeMappingType.CustomLatentSpace
+                and any(node_input.type == NodeMappingType.GroundTruth
+                        for node_input in (connection.node_inputs or {}).values())
+            ]
+            if gt_bound_names:
+                test_result.display[TestingSectionEnum.Warnings.name] = (
+                    f"Model-computed custom latent space(s) {gt_bound_names} read a ground truth, so "
+                    f"they are skipped for unlabeled samples, which will have no vector in them. A "
+                    f"latent space cannot fall back from ground truth to predictions; to cover "
+                    f"unlabeled samples, add one bound only to model predictions."
+                )
+        return test_result
+
     def _check_instance_custom_latent_spaces(self) -> Optional[DatasetTestResultPayload]:
         instance_aware_names = [
             name for name, handler in global_leap_binder.setup_container.custom_latent_spaces.items()
@@ -773,10 +816,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]]):
@@ -1166,6 +1206,14 @@ class LeapLoader(LeapLoaderBase):
             if any(handler.instance_aware for handler in latent_handlers.values()):
                 raise Exception(
                     "instance-aware custom latent spaces are not supported with grouped preprocess responses")
+            # TODO: support model-computed custom latent spaces on grouped datasets (skip them here,
+            # as the per-sample path does, once the grouped metrics path is verified to compute them).
+            model_ls_names = [name for name, handler in latent_handlers.items()
+                              if handler.computed_at == CustomLatentSpaceComputedAt.MODEL]
+            if model_ls_names:
+                raise Exception(
+                    f"model-computed custom latent spaces {model_ls_names} are not supported with "
+                    f"grouped preprocess responses yet")
             custom_latent_spaces = {
                 name: self._to_grouped_list(handler.function(group_ids, preprocess_state))
                 for name, handler in latent_handlers.items()
@@ -1390,7 +1438,9 @@ class LeapLoader(LeapLoaderBase):
             sample_id: Union[int, str],
             preprocess: "PreprocessResponse",
             instance_id: Optional[int] = None) -> Optional[Dict[str, npt.NDArray[np.float32]]]:
-        handlers = global_leap_binder.setup_container.custom_latent_spaces
+        handlers = {handler_name: handler for handler_name, handler
+                    in global_leap_binder.setup_container.custom_latent_spaces.items()
+                    if handler.computed_at != CustomLatentSpaceComputedAt.MODEL}
         if not handlers:
             return None
         if preprocess.is_grouped:
@@ -1428,6 +1478,47 @@ class LeapLoader(LeapLoaderBase):
         self.exec_script()
         return tuple(global_leap_binder.setup_container.custom_latent_spaces.keys())
 
+    @lru_cache()
+    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 != 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.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,
+                'channel_axis': handler.channel_axis,
+            }
+            for name, handler in global_leap_binder.setup_container.custom_latent_spaces.items()
+        }
+
+    @lru_cache()
+    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.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 = {
+                **input_tensors_by_arg_name,
+                preprocess_response_arg_name: SamplePreprocessResponse(sample_ids, self._preprocess_result()[state])}
+
+        return handler.function(**input_tensors_by_arg_name)
+
     @lru_cache()
     def get_instance_custom_latent_space_names(self) -> Tuple[str, ...]:
         """Names of registered custom latent spaces that are instance-aware.

code_loader/leaploaderbase.py

@@ -226,6 +226,31 @@ class LeapLoaderBase:
     def get_custom_latent_space_for_analysis(self) -> Optional[str]:
         pass
 
+    # These raise rather than `pass` for the same reason as the autoregressive entry points
+    # above: an un-overridden `pass` body would report "no model-computed latent spaces" on a
+    # loader that simply predates them, and the engine would silently skip computing them.
+    @abstractmethod
+    def get_dataset_custom_latent_space_names(self) -> Tuple[str, ...]:
+        raise NotImplementedError(f'{type(self).__name__} does not implement '
+                                  'get_dataset_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_custom_latent_space_specs(self) -> Dict[str, Dict[str, Any]]:
+        raise NotImplementedError(f'{type(self).__name__} does not implement '
+                                  'get_model_custom_latent_space_specs.')
+
+    @abstractmethod
+    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]:
+        raise NotImplementedError(f'{type(self).__name__} does not implement '
+                                  'run_model_latent_space.')
+
     @abstractmethod
     def get_heatmap_visualizer_raw_vis_input_arg_name(self, visualizer_name: str) -> Optional[str]:
         pass

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]:
+    # inspect.signature follows functools.wraps' __wrapped__; getfullargspec does not.
+    for param in inspect.signature(func).parameters.values():
+        if param.annotation == SamplePreprocessResponse:
+            return param.name
+    return None

{code_loader-1.0.207.dev0.dist-info → code_loader-1.0.208.dist-info}/METADATA

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

{code_loader-1.0.207.dev0.dist-info → code_loader-1.0.208.dist-info}/RECORD

@@ -1,10 +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=6Ozy9_C7HCP6YHqM27teBLe503MRvn7jg7h8uXHPuUY,17395
-code_loader/contract/enums.py,sha256=__GkPkwAXi2agmDGtEQgbMucPm4-n80maG6n_MmObPA,1691
+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=sWJhpng-IkOzQnWQdMT5w2ZZ3X1Z_OOzSwCLXIS7oxE,1446
+code_loader/contract/mapping.py,sha256=i-yVyFuGUITL5lchPNfYlu7bhwk-yuoHPacAeFhcYr8,1490
 code_loader/contract/responsedataclasses.py,sha256=2SQCccuIlSeUJT0igyvIJRYtmaWSqqlQwtaAA1iEuSI,5044
 code_loader/contract/sim_config.py,sha256=le8KMALZiP0WU4UcuKnTOSWBW2rNjpnWYfII502NqDM,3493
 code_loader/contract/visualizer_classes.py,sha256=vzX9YcwxKOm3IpYj8OaqsA1odPlRgj2Cfvglwd88Wbw,18213
@@ -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=mWcjx31fnrtRfV5agveW79lcMGJhwhDfLz7brpexBv0,60408
-code_loader/inner_leap_binder/leapbinder_decorators.py,sha256=rvd9wJuWn8_Yf_s0QFoI4q50pA8xNKtrJ4-01FMKiPE,196641
-code_loader/leaploader.py,sha256=dwBQmfL9e2X_l8-O53ga5oADi2SxL5exlC4X2Aat_uk,92568
-code_loader/leaploaderbase.py,sha256=Aa8wCcxojf8EBn_14W5I1gKI4OMBdpdEcNAZ_6E2eV4,10940
+code_loader/inner_leap_binder/leapbinder.py,sha256=fplNN3TfJHg79YpEPHKK3b6CxrR7W0ugDeHhAZfYty0,62784
+code_loader/inner_leap_binder/leapbinder_decorators.py,sha256=WNaV9M02Mh8OkPiOrZlnmj_GquGKTa1IxIsaLNk6R2E,212474
+code_loader/leaploader.py,sha256=GAGkIWJIt9g_a2Aj4ZakBBcKymbQD7BN-EcuCDlwD70,97599
+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=Yuv2hPx4G70RV2x0Fc_UCube9BLpEryyq4cuKIcsq7s,12347
 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.207.dev0.dist-info/LICENSE,sha256=qIwWjdspQeSMTtnFZBC8MuT-95L02FPvzRUdWFxrwJY,1067
-code_loader-1.0.207.dev0.dist-info/METADATA,sha256=3dh9WdOLBNx4tbYLSxohQQarGGzzQEs3IFH49NvmsOE,1095
-code_loader-1.0.207.dev0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-code_loader-1.0.207.dev0.dist-info/RECORD,,
+code_loader-1.0.208.dist-info/LICENSE,sha256=qIwWjdspQeSMTtnFZBC8MuT-95L02FPvzRUdWFxrwJY,1067
+code_loader-1.0.208.dist-info/METADATA,sha256=mDaljR7xkrd2QeONwX9U9msymlqphtsV1OkYbezdIMQ,1090
+code_loader-1.0.208.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+code_loader-1.0.208.dist-info/RECORD,,