code-loader 1.0.188.dev1__tar.gz → 1.0.189__tar.gz

{code_loader-1.0.188.dev1 → code_loader-1.0.189}/PKG-INFO

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

{code_loader-1.0.188.dev1 → code_loader-1.0.189}/code_loader/inner_leap_binder/leapbinder.py

@@ -1,6 +1,6 @@
 
 import inspect
-from typing import Callable, List, Optional, Dict, Any, Type, Union
+from typing import Callable, List, Optional, Dict, Any, Type, Union, get_args
 
 import numpy as np
 import numpy.typing as npt
@@ -31,6 +31,27 @@ from code_loader.visualizers.default_visualizers import DefaultVisualizer, \
 mapping_runtime_mode_env_var_mame = '__MAPPING_RUNTIME_MODE__'
 
 
+def _stringized_annotation_type_name(annotation: Any) -> Optional[str]:
+    """Bare type name if ``annotation`` is a stringized annotation (from ``from __future__
+    import annotations`` or a quoted hint), else ``None``. code_loader inspects raw
+    annotations expecting real classes, so stringization silently breaks type detection."""
+    if isinstance(annotation, str):
+        return annotation.split("[")[0].strip().rsplit(".", 1)[-1]
+    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__:
+        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"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.")
+
+
 
 
 class LeapBinder:
@@ -123,6 +144,7 @@ class LeapBinder:
         regular_arg_names = inspect.getfullargspec(function)[0]
         preprocess_response_arg_name = None
         for arg_name, arg_type in inspect.getfullargspec(function).annotations.items():
+            _reject_stringized_sample_preprocess_response(function, arg_name, arg_type)
             if arg_type == SamplePreprocessResponse:
                 if preprocess_response_arg_name is not None:
                     raise Exception("only one argument can be of type SamplePreprocessResponse")
@@ -144,8 +166,8 @@ class LeapBinder:
 
         if visualizer_type.value not in map_leap_data_type_to_visualizer_class:
             raise Exception(
-                f'The visualizer_type is invalid. current visualizer_type: {visualizer_type}, '  # type: ignore[attr-defined]
-                f'should be one of : {", ".join([arg.__name__ for arg in LeapData.__args__])}')
+                f'The visualizer_type is invalid. current visualizer_type: {visualizer_type}, '
+                f'should be one of : {", ".join([arg.__name__ for arg in get_args(LeapData)])}')
 
         func_annotations = function.__annotations__
         if "return" not in func_annotations:
@@ -155,10 +177,17 @@ class LeapBinder:
                   f"https://docs.python.org/3/library/typing.html")
         else:
             return_type = func_annotations["return"]
-            if return_type not in LeapData.__args__:  # type: ignore[attr-defined]
+            if isinstance(return_type, str):
+                raise Exception(
+                    f"The return type hint of function '{function.__name__}' is a string "
+                    f"('{return_type}') instead of a type. This usually means the file uses "
+                    f"'from __future__ import annotations' (or a quoted return hint), which stringizes "
+                    f"annotations and prevents Tensorleap from detecting the visualizer type. Remove "
+                    f"that import (or the quotes) so the return type is a real class.")
+            if return_type not in get_args(LeapData):
                 raise Exception(
-                    f'The return type of function {function.__name__} is invalid. current return type: {return_type}, '  # type: ignore[attr-defined]
-                    f'should be one of : {", ".join([arg.__name__ for arg in LeapData.__args__])}')
+                    f'The return type of function {function.__name__} is invalid. current return type: {return_type}, '
+                    f'should be one of : {", ".join([arg.__name__ for arg in get_args(LeapData)])}')
 
             expected_return_type = map_leap_data_type_to_visualizer_class[visualizer_type.value]
             if not issubclass(return_type, expected_return_type):
@@ -296,6 +325,7 @@ class LeapBinder:
         regular_arg_names = inspect.getfullargspec(function)[0]
         preprocess_response_arg_name = None
         for arg_name, arg_type in inspect.getfullargspec(function).annotations.items():
+            _reject_stringized_sample_preprocess_response(function, arg_name, arg_type)
             if arg_type == SamplePreprocessResponse:
                 if preprocess_response_arg_name is not None:
                     raise Exception("only one argument can be of type SamplePreprocessResponse")
@@ -339,6 +369,7 @@ class LeapBinder:
         regular_arg_names = inspect.getfullargspec(function)[0]
         preprocess_response_arg_name = None
         for arg_name, arg_type in inspect.getfullargspec(function).annotations.items():
+            _reject_stringized_sample_preprocess_response(function, arg_name, arg_type)
             if arg_type == SamplePreprocessResponse:
                 if preprocess_response_arg_name is not None:
                     raise Exception("only one argument can be of type SamplePreprocessResponse")
@@ -380,6 +411,7 @@ class LeapBinder:
         regular_arg_names = inspect.getfullargspec(function)[0]
         preprocess_response_arg_name = None
         for arg_name, arg_type in inspect.getfullargspec(function).annotations.items():
+            _reject_stringized_sample_preprocess_response(function, arg_name, arg_type)
             if arg_type == SamplePreprocessResponse:
                 if preprocess_response_arg_name is not None:
                     raise Exception("only one argument can be of type SamplePreprocessResponse")

{code_loader-1.0.188.dev1 → code_loader-1.0.189}/code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -223,6 +223,59 @@ def _add_mapping_connections(connects_to, arg_names, node_mapping_type, name):
         _add_mapping_connection(user_unique_name, connection_destinations, arg_names, name, node_mapping_type)
 
 
+def _require_sample_preprocess_response_supplied(user_function: Callable, args: tuple, kwargs: dict) -> None:
+    """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
+    if spr_arg_name is None:
+        return
+    signature = inspect.signature(user_function)
+    param = signature.parameters.get(spr_arg_name)
+    # Only enforce a REQUIRED SamplePreprocessResponse arg. If it has a default it is
+    # optional and the function may legitimately be called with or without it.
+    if param is None or param.default is not inspect.Parameter.empty:
+        return
+    try:
+        supplied = signature.bind_partial(*args, **kwargs).arguments
+    except TypeError:
+        return
+    if spr_arg_name not in supplied:
+        raise Exception(
+            f"'{user_function.__name__}' takes a SamplePreprocessResponse argument "
+            f"'{spr_arg_name}', but it was not provided. Inside integration_test pass it "
+            f"explicitly, e.g. {user_function.__name__}(..., "
+            f"SamplePreprocessResponse(sample_id, preprocess)).")
+
+
+def _warn_loss_inputs_not_wired_to_model() -> None:
+    """Warn when a custom loss consumes an input encoder the model is not given.
+
+    Such an input stays a plain NodeMappingType.Input (model-fed inputs get re-tagged to
+    Input0/Input1/...) and crashes the platform model build. Losses only — the same pattern
+    in a metric or visualizer builds fine."""
+    loss_types = {NodeMappingType.Loss, NodeMappingType.CustomLoss}
+    for connection in leap_binder.mapping_connections:
+        if connection.node is None or connection.node.type not in loss_types:
+            continue
+        for arg_name, source in (connection.node_inputs or {}).items():
+            if source is not None and source.type == NodeMappingType.Input:
+                input_name = source.name or arg_name
+                store_general_warning(
+                    key=("loss_input_not_wired_to_model", connection.node.name, input_name),
+                    message=(
+                        f"Custom loss '{connection.node.name}' consumes input '{input_name}', "
+                        f"which is not fed to the model. This is not supported: the platform builds "
+                        f"losses into the model graph, so an input the model does not take has no "
+                        f"source there and the model build fails. Instead, carry this data in the "
+                        f"ground truth and derive it inside the loss (not as a separate input "
+                        f"encoder)."))
+
+
 def tensorleap_integration_test():
     def decorating_function(integration_test_function: Callable):
         leap_binder.integration_test_func = integration_test_function
@@ -279,6 +332,8 @@ def tensorleap_integration_test():
             finally:
                 _called_from_inside_tl_integration_test_decorator = False
 
+            _warn_loss_inputs_not_wired_to_model()
+
             leap_binder.check()
 
         return inner
@@ -822,6 +877,7 @@ def tensorleap_custom_metric(name: str,
             _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
@@ -1031,6 +1087,7 @@ def tensorleap_custom_instances_metric(name: str,
             _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
@@ -1383,6 +1440,7 @@ def tensorleap_custom_visualizer(name: str, visualizer_type: LeapDataType,
             _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
@@ -1929,8 +1987,13 @@ def tensorleap_input_encoder(name: str, channel_dim=_UNSET, model_input_index=No
 
                 )
 
+        # channel_dim is the channel axis in the BATCHED tensor (batch = axis 0):
+        # 1 for channel-first (NCHW), -1 for channel-last (NHWC); 0 is invalid.
         if channel_dim <= 0 and channel_dim != -1:
-            raise Exception(f"Channel dim for input {name} is expected to be either -1 or positive")
+            raise Exception(
+                f"Invalid channel_dim ({channel_dim}) for input '{name}'. channel_dim is the "
+                f"channel axis in the batched tensor (batch = axis 0), so 0 is invalid. Use 1 "
+                f"for channel-first (NCHW) and -1 for channel-last (NHWC).")
 
         def _validate_input_args(sample_id: Union[int, str], preprocess_response: PreprocessResponse):
             assert type(sample_id) == preprocess_response.sample_id_type, \
@@ -2149,6 +2212,7 @@ def tensorleap_custom_loss(name: str, connects_to=None):
             _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

{code_loader-1.0.188.dev1 → code_loader-1.0.189}/code_loader/leaploader.py

@@ -64,9 +64,6 @@ class LeapLoader(LeapLoaderBase):
             self.evaluate_module()
             if global_leap_binder.integration_test_func is not None:
                 global_leap_binder.integration_test_func(None, PreprocessResponse(state=DataStateType.training, length=0))
-        except DatasetScriptException:
-            global_leap_binder.setup_container = DatasetIntegrationSetup()
-            raise
         except TypeError as e:
             import traceback
             global_leap_binder.setup_container = DatasetIntegrationSetup()
@@ -88,17 +85,10 @@ class LeapLoader(LeapLoaderBase):
                 return
 
             parent_path = str(Path(full_path).parent)
-            if parent_path == full_path:
-                return
             append_path_recursively(parent_path)
             sys.path.append(parent_path)
 
         file_path = Path(self.code_path, self.code_entry_name)
-        if not file_path.is_file():
-            raise DatasetScriptException(
-                f"Entry file not found: '{self.code_entry_name}' does not exist under '{self.code_path}'. "
-                f"Check the 'entryFile' setting in your leap.yaml."
-            )
         append_path_recursively(str(file_path))
 
         importlib.invalidate_caches()
@@ -113,13 +103,6 @@ class LeapLoader(LeapLoaderBase):
 
         spec.loader.exec_module(file)
 
-        if global_leap_binder.setup_container.preprocess is None:
-            raise DatasetScriptException(
-                f"No Tensorleap integration found in '{self.code_entry_name}': the script never called "
-                f"leap_binder.set_preprocess(...). Check the 'entryFile' setting in your leap.yaml — "
-                f"it may be pointing to the wrong file."
-            )
-
     @lru_cache()
     def metric_by_name(self) -> Dict[str, MetricHandlerData]:
         self.exec_script()
@@ -337,6 +320,9 @@ class LeapLoader(LeapLoaderBase):
             try:
                 self.exec_script()
 
+                integration_test_test_payload = self._check_integration_test_exists()
+                test_payloads.append(integration_test_test_payload)
+
                 preprocess_test_payload = self._check_preprocess()
                 test_payloads.append(preprocess_test_payload)
                 handlers_test_payloads = self._check_handlers()
@@ -373,6 +359,23 @@ class LeapLoader(LeapLoaderBase):
                                        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')
+        # Only enforced on the Tensorleap platform (i.e. during a push / inspection,
+        # where IS_TENSORLEAP_PLATFORM=true). Running code-loader locally or in unit
+        # tests must not require the decorator, so pre-decorator integrations and
+        # local check runs keep working unchanged.
+        is_on_platform = os.environ.get('IS_TENSORLEAP_PLATFORM') == 'true'
+        if is_on_platform and global_leap_binder.integration_test_func is None:
+            test_result.is_passed = False
+            test_result.display[TestingSectionEnum.Errors.name] = (
+                "No integration test was found in your integration file. A valid Tensorleap "
+                "integration file must define an integration test function decorated with "
+                "@tensorleap_integration_test. Without it the integration cannot be validated "
+                "and the push is aborted. See the mnist leap_integration.py for a valid example."
+            )
+        return test_result
+
     def _check_preprocess(self) -> DatasetTestResultPayload:
         test_result = DatasetTestResultPayload('preprocess')
         try:

{code_loader-1.0.188.dev1 → code_loader-1.0.189}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "code-loader"
 
-version = "1.0.188.dev1"
+version = "1.0.189"
 description = ""
 authors = ["dorhar <doron.harnoy@tensorleap.ai>"]
 license = "MIT"