code-loader 1.0.179.dev2__py3-none-any.whl → 1.0.180.dev0__py3-none-any.whl

code_loader/contract/datasetclasses.py

@@ -9,6 +9,7 @@ from code_loader.contract.enums import DataStateType, DataStateEnum, LeapDataTyp
     MetricDirection, DatasetMetadataType
 from code_loader.contract.visualizer_classes import LeapImage, LeapText, LeapGraph, LeapHorizontalBar, \
     LeapTextMask, LeapImageMask, LeapImageWithBBox, LeapImageWithHeatmap, LeapVideo
+from code_loader.contract.sim_config import SimConfig
 
 custom_latent_space_attribute = "custom_latent_space"
 
@@ -252,6 +253,13 @@ class CustomLayerHandler:
     use_custom_latent_space: bool = False
 
 
+@dataclass
+class SimulationInstance:
+    name: str
+    function: Callable[..., Any]
+    sim_config: SimConfig
+
+
 @dataclass
 class DatasetIntegrationSetup:
     preprocess: Optional[PreprocessHandler] = None
@@ -267,6 +275,7 @@ class DatasetIntegrationSetup:
     instance_metrics: List[InstanceMetricHandler] = field(default_factory=list)
     custom_layers: Dict[str, CustomLayerHandler] = field(default_factory=dict)
     custom_latent_space: Optional[CustomLatentSpaceHandler] = None
+    simulations: List[SimulationInstance] = field(default_factory=list)
 
 
 @dataclass

code_loader/contract/responsedataclasses.py

@@ -69,6 +69,12 @@ class PredictionTypeInstance:
     channel_dim: int
 
 
+@dataclass
+class SimulationSetupInstance:
+    name: str
+    sim_config: Dict[str, Any]
+
+
 @dataclass
 class DatasetSetup:
     preprocess: DatasetPreprocess
@@ -79,6 +85,7 @@ class DatasetSetup:
     prediction_types: List[PredictionTypeInstance]
     custom_losses: List[CustomLossInstance]
     metrics: List[MetricInstance] = field(default_factory=list)
+    simulations: List[SimulationSetupInstance] = field(default_factory=list)
 
 
 @dataclass

code_loader/contract/sim_config.py

@@ -0,0 +1,92 @@
+from dataclasses import dataclass
+from typing import Any, Dict, List, Union
+
+from code_loader.contract.enums import DatasetMetadataType
+
+
+@dataclass
+class FloatBounds:
+    min: float
+    max: float
+
+
+@dataclass
+class IntBounds:
+    min: int
+    max: int
+
+
+@dataclass
+class CategoricalBounds:
+    values: List[str]
+
+
+@dataclass
+class SimParamConfig:
+    type: DatasetMetadataType
+    bounds: Union[FloatBounds, IntBounds, CategoricalBounds]
+
+
+SimConfig = Dict[str, SimParamConfig]
+
+PARAM_TYPE_MAP = {
+    float:    DatasetMetadataType.float,
+    int:      DatasetMetadataType.int,
+    str:      DatasetMetadataType.string,
+    "float":  DatasetMetadataType.float,
+    "int":    DatasetMetadataType.int,
+    "str":    DatasetMetadataType.string,
+    "string": DatasetMetadataType.string,
+}
+
+
+def _parse_bounds(name: str, metadata_type: DatasetMetadataType, bounds_raw: Dict[str, Any]) -> Union[FloatBounds, IntBounds, CategoricalBounds]:
+    if metadata_type in (DatasetMetadataType.float, DatasetMetadataType.int):
+        if "min" not in bounds_raw or "max" not in bounds_raw:
+            raise ValueError(
+                f"Parameter '{name}' bounds must have 'min' and 'max' for numeric type."
+            )
+        if bounds_raw["min"] >= bounds_raw["max"]:
+            raise ValueError(
+                f"Parameter '{name}': min ({bounds_raw['min']}) must be < max ({bounds_raw['max']})."
+            )
+        if metadata_type == DatasetMetadataType.float:
+            return FloatBounds(min=float(bounds_raw["min"]), max=float(bounds_raw["max"]))
+        return IntBounds(min=int(bounds_raw["min"]), max=int(bounds_raw["max"]))
+
+    if metadata_type == DatasetMetadataType.string:
+        if "values" not in bounds_raw:
+            raise ValueError(
+                f"Parameter '{name}' bounds must have 'values' for string type."
+            )
+        if not bounds_raw["values"]:
+            raise ValueError(f"Parameter '{name}' 'values' must not be empty.")
+        return CategoricalBounds(values=list(bounds_raw["values"]))
+
+    raise ValueError(f"Parameter '{name}' has unsupported metadata type: {metadata_type}.")
+
+
+def parse_sim_config(raw: Dict[str, Any]) -> SimConfig:
+    if not raw:
+        raise ValueError("sim_config must have at least one parameter.")
+
+    result: SimConfig = {}
+    for name, param in raw.items():
+        if "type" not in param:
+            raise ValueError(f"Parameter '{name}' missing 'type'.")
+        if param["type"] not in PARAM_TYPE_MAP:
+            raise ValueError(
+                f"Parameter '{name}' has unsupported type '{param['type']}'. "
+                f"Supported: float, int, str (or string)."
+            )
+        metadata_type = PARAM_TYPE_MAP[param["type"]]
+
+        if "bounds" not in param:
+            raise ValueError(f"Parameter '{name}' missing 'bounds'.")
+
+        result[name] = SimParamConfig(
+            type=metadata_type,
+            bounds=_parse_bounds(name, metadata_type, param["bounds"]),
+        )
+
+    return result

code_loader/inner_leap_binder/leapbinder.py

@@ -12,7 +12,8 @@ from code_loader.contract.datasetclasses import SectionCallableInterface, InputH
     CustomCallableInterfaceMultiArgs, ConfusionMatrixCallableInterfaceMultiArgs, LeapData, \
     CustomMultipleReturnCallableInterfaceMultiArgs, DatasetBaseHandler, custom_latent_space_attribute, \
     RawInputsForHeatmap, VisualizerHandlerData, MetricHandlerData, CustomLossHandlerData, SamplePreprocessResponse, \
-    ElementInstanceMasksHandler, InstanceCallableInterface, CustomLatentSpaceHandler, InstanceMetricHandler
+    ElementInstanceMasksHandler, InstanceCallableInterface, CustomLatentSpaceHandler, InstanceMetricHandler, \
+    SimulationInstance
 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, LeapAnalysisConfiguration
@@ -20,6 +21,7 @@ from code_loader.contract.visualizer_classes import map_leap_data_type_to_visual
 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, to_numpy_return_masks_wrapper
+from code_loader.contract.sim_config import parse_sim_config
 from code_loader.visualizers.default_visualizers import DefaultVisualizer, \
     default_graph_visualizer, \
     default_image_visualizer, default_horizontal_bar_visualizer, default_word_visualizer, \
@@ -219,6 +221,17 @@ class LeapBinder:
         """
         self.setup_container.unlabeled_data_preprocess = UnlabeledDataPreprocessHandler(function)
 
+    def set_simulation(self, function: Callable[..., Any], name: str, sim_config_raw: Dict[str, Any]) -> None:
+        for sim in self.setup_container.simulations:
+            if sim.name == name:
+                raise Exception(
+                    f"Simulation with name '{name}' already exists. Please choose another."
+                )
+        sim_config = parse_sim_config(sim_config_raw)
+        self.setup_container.simulations.append(
+            SimulationInstance(name=name, function=function, sim_config=sim_config)
+        )
+
     def set_input(self, function: SectionCallableInterface, name: str, channel_dim: int = -1) -> None:
         """
         Set the input handler function.

code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -1,4 +1,5 @@
 # mypy: ignore-errors
+import inspect
 import os
 import warnings
 import logging
@@ -28,10 +29,6 @@ from code_loader.contract.visualizer_classes import LeapImage, LeapImageMask, Le
 from code_loader.inner_leap_binder.leapbinder import mapping_runtime_mode_env_var_mame
 from code_loader.mixpanel_tracker import clear_integration_events, AnalyticsEvent, emit_integration_event_once
 
-import inspect
-import functools
-from pathlib import Path
-
 _called_from_inside_tl_decorator = 0
 _called_from_inside_tl_integration_test_decorator = False
 _call_from_tl_platform = os.environ.get('IS_TENSORLEAP_PLATFORM') == 'true'
@@ -1233,8 +1230,9 @@ def tensorleap_metadata(
         def _validate_result(result):
             supported_result_types = (type(None), int, str, bool, float, dict, np.floating,
                                       np.bool_, np.unsignedinteger, np.signedinteger, np.integer)
-            validate_output_structure(result, func_name=user_function.__name__,
-                                      expected_type_name=supported_result_types)
+            if isinstance(result, tuple):
+                validate_output_structure(result, func_name=user_function.__name__,
+                                          expected_type_name=supported_result_types)
             assert isinstance(result, supported_result_types), \
                 (f'{user_function.__name__}() validation failed: '
                  f'Unsupported return type. Got {type(result)}. should be any of {str(supported_result_types)}')
@@ -1400,6 +1398,43 @@ def tensorleap_preprocess():
     return decorating_function
 
 
+def tensorleap_simulation(name: str, sim_params: dict):
+    def decorating_function(user_function: Callable):
+        sig = inspect.signature(user_function)
+        func_params = set(sig.parameters.keys())
+        expected_params = set(sim_params.keys()) | {"N"}
+
+        missing = expected_params - func_params
+        if missing:
+            raise Exception(
+                f"{user_function.__name__}() registration failed: "
+                f"Missing required parameters: {missing}. "
+                f"Function must accept all sim_params params plus 'N'."
+            )
+
+        extra = func_params - expected_params - {"seed"}
+        if extra:
+            raise Exception(
+                f"{user_function.__name__}() registration failed: "
+                f"Unexpected parameters: {extra}. "
+                f"Function must only accept sim_params params plus 'N' and optionally 'seed'."
+            )
+
+        leap_binder.set_simulation(user_function, name, sim_params)
+
+        def inner(*args, **kwargs):
+            result = user_function(*args, **kwargs)
+            assert isinstance(result, PreprocessResponse), (
+                f"{user_function.__name__}() validation failed: "
+                f"Expected return type PreprocessResponse. Got {type(result).__name__}."
+            )
+            return result
+
+        return inner
+
+    return decorating_function
+
+
 def tensorleap_element_instance_preprocess(
         instance_length_encoder: InstanceLengthCallableInterface, instance_mask_encoder: InstanceCallableInterface):
     def decorating_function(user_function: Callable[[], List[PreprocessResponse]]):

code_loader/leaploader.py

@@ -22,13 +22,22 @@ from code_loader.contract.exceptions import DatasetScriptException
 from code_loader.contract.responsedataclasses import DatasetIntegParseResult, DatasetTestResultPayload, \
     DatasetPreprocess, DatasetSetup, DatasetInputInstance, DatasetOutputInstance, DatasetMetadataInstance, \
     VisualizerInstance, PredictionTypeInstance, ModelSetup, CustomLayerInstance, MetricInstance, CustomLossInstance, \
-    EngineFileContract
+    EngineFileContract, SimulationSetupInstance
+from code_loader.contract.sim_config import FloatBounds, IntBounds, CategoricalBounds
 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
 
 
+def _serialize_sim_bounds(bounds) -> dict:
+    if isinstance(bounds, (FloatBounds, IntBounds)):
+        return {"min": bounds.min, "max": bounds.max}
+    if isinstance(bounds, CategoricalBounds):
+        return {"values": bounds.values}
+    raise ValueError(f"Unknown bounds type: {type(bounds)}")
+
+
 class LeapLoader(LeapLoaderBase):
     def __init__(self, code_path: str, code_entry_name: str):
         super().__init__(code_path, code_entry_name)
@@ -454,9 +463,20 @@ class LeapLoader(LeapLoaderBase):
             metric_inst = MetricInstance(metric.metric_handler_data.name, metric.metric_handler_data.arg_names)
             metrics.append(metric_inst)
 
+        simulations = []
+        for sim in setup.simulations:
+            sim_config_serialized = {
+                name: {
+                    "type": param.type.value,
+                    "bounds": _serialize_sim_bounds(param.bounds),
+                }
+                for name, param in sim.sim_config.items()
+            }
+            simulations.append(SimulationSetupInstance(name=sim.name, sim_config=sim_config_serialized))
+
         return DatasetSetup(preprocess=dataset_preprocess, inputs=inputs, outputs=ground_truths,
                             metadata=metadata_instances, visualizers=visualizers, prediction_types=prediction_types,
-                            custom_losses=custom_losses, metrics=metrics)
+                            custom_losses=custom_losses, metrics=metrics, simulations=simulations)
 
     def get_model_setup_response(self) -> ModelSetup:
         setup = global_leap_binder.setup_container

{code_loader-1.0.179.dev2.dist-info → code_loader-1.0.180.dev0.dist-info}/METADATA

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

{code_loader-1.0.179.dev2.dist-info → code_loader-1.0.180.dev0.dist-info}/RECORD

@@ -1,11 +1,12 @@
 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=nQYwxfGpeb60AGYlHwJVV4qPbAE2vEnYO0d_dzvnp5Q,10039
+code_loader/contract/datasetclasses.py,sha256=hMovDpEEl-07lPKV8fp52HYd0yK6trkta7oTZ8cKU6I,10277
 code_loader/contract/enums.py,sha256=2q-IV_5g9lLE306DIbWA1c0tn5IhDtxsKxyV1x_Lreg,1671
 code_loader/contract/exceptions.py,sha256=jWqu5i7t-0IG0jGRsKF4DjJdrsdpJjIYpUkN1F4RiyQ,51
 code_loader/contract/mapping.py,sha256=sWJhpng-IkOzQnWQdMT5w2ZZ3X1Z_OOzSwCLXIS7oxE,1446
-code_loader/contract/responsedataclasses.py,sha256=FE04qgm4gz30RWbB_6UKeyN6BHyg9F1Xjn5VRNTUSp8,4769
+code_loader/contract/responsedataclasses.py,sha256=G37OBHmb-b9-0gc5Hs69t8jjjRtEzmWP389Y9IWWlGQ,4935
+code_loader/contract/sim_config.py,sha256=tWgM3n2_UTP8HnWBUFYLY928ya1ezFWhMOOU9c3WsHU,3002
 code_loader/contract/visualizer_classes.py,sha256=Wz9eItmoRaKEHa3p0aW0Ypxx4_xUmaZyLBznnTuxwi0,15425
 code_loader/default_losses.py,sha256=NoOQym1106bDN5dcIk56Elr7ZG5quUHArqfP5-Nyxyo,1139
 code_loader/default_metrics.py,sha256=2XSlyNw_XLDGSJDoz5W_Evi5wbL0dhwq24pPr15vSPc,5025
@@ -20,9 +21,9 @@ 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=Xrwx0Kptcz2dmoHoZQ7kyyNmitsvAKoTBngIMBvh--I,37859
-code_loader/inner_leap_binder/leapbinder_decorators.py,sha256=M4DQKAI3PnxzxdjYkssOtbfqMvIT08CJS7LpKbzl4Uw,100896
-code_loader/leaploader.py,sha256=VSSxsU2KxHPo5SzN1bJtRXaz29IE0XNFxgrnAJyG3io,32162
+code_loader/inner_leap_binder/leapbinder.py,sha256=07_ZIjRLKuERF12fo3IohMPNjfDUeZQxjk1vJMGtd1A,38484
+code_loader/inner_leap_binder/leapbinder_decorators.py,sha256=YM-gyBi2wHaoyUzhpPtd5-96wAdeKohCrEiSB2honMQ,102282
+code_loader/leaploader.py,sha256=-AnZ_-_FexkW8VRyC2njK-aoE_x0Ud2RRxeZL4OHt5A,33032
 code_loader/leaploaderbase.py,sha256=NJGaas8S6JeHYSsKkMSutyfcSKdK9jXTic7BcjC5uNc,6303
 code_loader/mixpanel_tracker.py,sha256=U7eUGrPjc-2rgFG7isqosf65tKZkotQ0XKuAML_lIjA,9067
 code_loader/plot_functions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -31,7 +32,7 @@ code_loader/plot_functions/visualize.py,sha256=gsBAYYkwMh7jIpJeDMPS8G4CW-pxwx6Lz
 code_loader/utils.py,sha256=YecipkdTA-VcE9F0RQcY9cFnY8P3AksPnHM2Db7xUSk,3972
 code_loader/visualizers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 code_loader/visualizers/default_visualizers.py,sha256=onRnLE_TXfgLN4o52hQIOOhUcFexGlqJ3xSpQDVLuZM,2604
-code_loader-1.0.179.dev2.dist-info/LICENSE,sha256=qIwWjdspQeSMTtnFZBC8MuT-95L02FPvzRUdWFxrwJY,1067
-code_loader-1.0.179.dev2.dist-info/METADATA,sha256=SwqY8uUIwvKGedEGMdZZMUkMrZiVnrTn09nPGHy4D0c,1095
-code_loader-1.0.179.dev2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-code_loader-1.0.179.dev2.dist-info/RECORD,,
+code_loader-1.0.180.dev0.dist-info/LICENSE,sha256=qIwWjdspQeSMTtnFZBC8MuT-95L02FPvzRUdWFxrwJY,1067
+code_loader-1.0.180.dev0.dist-info/METADATA,sha256=RM5e7ncL3g_HCtahcJcAVdJPoztrnhuS98Jszze_Jpw,1095
+code_loader-1.0.180.dev0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+code_loader-1.0.180.dev0.dist-info/RECORD,,

{code_loader-1.0.179.dev2.dist-info → code_loader-1.0.180.dev0.dist-info}/WHEEL

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