code-loader 1.0.165.dev2__tar.gz → 1.0.165.dev3__tar.gz

{code_loader-1.0.165.dev2 → code_loader-1.0.165.dev3}/PKG-INFO

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

{code_loader-1.0.165.dev2 → code_loader-1.0.165.dev3}/code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -45,6 +45,7 @@ _PARAM_DEFAULT_FUNCS: DefaultDict[str, Set[str]] = defaultdict(set)
 # param_name -> default_value used (repr-able)
 _PARAM_DEFAULT_VALUE: Dict[str, Any] = {}
 _PARAM_DEFAULT_DOCS: Dict[str, str] = {}
+_PARAM_DEFAULT_MESSAGES: DefaultDict[str, Set[str]] = defaultdict(set)
 
 
 def get_entry_script_path() -> str:
@@ -67,6 +68,7 @@ def store_warning_by_param(
         user_func_name: str,
         default_value: Any,
         link_to_docs: str = None,
+        custom_message: Optional[str] = None,
 ) -> None:
     _PARAM_DEFAULT_FUNCS[param_name].add(user_func_name)
 
@@ -76,6 +78,9 @@ def store_warning_by_param(
     if link_to_docs and param_name not in _PARAM_DEFAULT_DOCS:
         _PARAM_DEFAULT_DOCS[param_name] = link_to_docs
 
+    if custom_message:
+        _PARAM_DEFAULT_MESSAGES[param_name].add(custom_message)
+
 
 def _get_param_default_warnings() -> Dict[str, Dict[str, Any]]:
     out: Dict[str, Dict[str, Any]] = {}
@@ -84,6 +89,7 @@ def _get_param_default_warnings() -> Dict[str, Dict[str, Any]]:
             "default_value": _PARAM_DEFAULT_VALUE.get(p, None),
             "funcs": set(funcs),
             "link_to_docs": _PARAM_DEFAULT_DOCS.get(p),
+            "messages": sorted(_PARAM_DEFAULT_MESSAGES.get(p, set())),
         }
     return out
 
@@ -530,8 +536,6 @@ def tensorleap_custom_metric(name: str,
             ConfusionMatrixCallableInterfaceMultiArgs]):
         nonlocal direction
 
-        direction_was_provided = direction is not _UNSET
-
         def _validate_decorators_signature():
             err_message = f"{user_function.__name__} validation failed.\n"
             if not isinstance(name, str):
@@ -678,28 +682,38 @@ def tensorleap_custom_metric(name: str,
                         (f'{user_function.__name__}() validation failed: '
                          f'Keys in the return dict should be of type str. Got {type(key)}.')
 
-                assert direction is _UNSET or isinstance(direction, dict), \
-                    (f'{user_function.__name__}() validation failed: '
-                     f'direction should be a dict when using dict results. Got {type(direction)}.') #TODO - remove this assertion so a single value would controll all directions
-
                 if isinstance(direction, dict):
                     for direction_key in direction:
                         assert direction_key in result, \
                             (f'{user_function.__name__}() validation failed: '
                              f'Keys in the direction mapping should be part of result keys. Got key {direction_key}.')
 
-                if compute_insights is not None:
-                    assert isinstance(compute_insights, dict), \
-                        (f'{user_function.__name__}() validation failed: '
-                         f'compute_insights should be dict if using the dict results. Got {type(compute_insights)}.') #TODO - remove this assertion so a single value would controll all compute_insights
+                if isinstance(compute_insights, dict):
+                    for ci_key in compute_insights:
+                        assert ci_key in result, \
+                            (f'{user_function.__name__}() validation failed: '
+                             f'Keys in the compute_insights mapping should be part of result keys. Got key {ci_key}.')
 
-                    if isinstance(compute_insights, dict):
-                        for ci_key in compute_insights:
-                            assert ci_key in result, \
-                                (f'{user_function.__name__}() validation failed: '
-                                 f'Keys in the compute_insights mapping should be part of result keys. Got key {ci_key}.')
+                if direction is _UNSET:
+                    effective_direction = {}
+                elif isinstance(direction, dict):
+                    effective_direction = direction
+                else:
+                    effective_direction = {}
+                    if not _call_from_tl_platform:
+                        # TODO- remove this warning when engine supports high level direction setting for all submetrics
+                        store_warning_by_param(
+                            param_name="direction",
+                            user_func_name=user_function.__name__,
+                            default_value=MetricDirection.Downward,
+                            link_to_docs="https://docs.tensorleap.ai/tensorleap-integration/writing-integration-code/custom-metrics",
+                            custom_message=(
+                                f"'direction': expected Dict[str, MetricDirection] for dict output, "
+                                f"got {type(direction).__name__}; reverted to default per sub-metric "
+                                f"({MetricDirection.Downward.name})."
+                            )
+                        )
 
-                effective_direction = {} if direction is _UNSET else direction
                 defaulted_direction_keys = result_keys.difference(effective_direction.keys())
 
                 if defaulted_direction_keys:
@@ -708,38 +722,88 @@ def tensorleap_custom_metric(name: str,
                 leap_binder.setup_container.metrics[-1].metric_handler_data.direction = effective_direction
 
                 if defaulted_direction_keys and not _call_from_tl_platform:
-                    effective_compute_insights = compute_insights or {}
+                    if compute_insights is None:
+                        effective_compute_insights = {}
+                    elif isinstance(compute_insights, dict):
+                        effective_compute_insights = compute_insights
+                    else:
+                        effective_compute_insights = {}
                     warning_keys = {key for key in defaulted_direction_keys if effective_compute_insights.get(key, True)}
                     if warning_keys:
                         store_warning_by_param(
-                            param_name=f"direction[{warning_keys}]",
+                            param_name=f"direction[{sorted(warning_keys)}]",
                             user_func_name=user_function.__name__,
                             default_value=MetricDirection.Downward,
                             link_to_docs="https://docs.tensorleap.ai/tensorleap-integration/writing-integration-code/custom-metrics"
                         )
 
+                if compute_insights is not None and not isinstance(compute_insights, dict) and not _call_from_tl_platform:
+                    # TODO- remove this warning when engine supports high level compute_insights setting for all submetrics
+                    store_warning_by_param(
+                        param_name="compute_insights",
+                        user_func_name=user_function.__name__,
+                        default_value=None,
+                        link_to_docs="https://docs.tensorleap.ai/tensorleap-integration/writing-integration-code/custom-metrics",
+                        custom_message=(
+                            f"'compute_insights': expected Dict[str, bool] for dict output, "
+                            f"got {type(compute_insights).__name__}; reverted to default (None)."
+                        )
+                    )
+
+                if compute_insights is None:
+                    effective_compute_insights_for_handler = None
+                elif isinstance(compute_insights, dict):
+                    effective_compute_insights_for_handler = compute_insights
+                else:
+                    effective_compute_insights_for_handler = None
+                leap_binder.setup_container.metrics[-1].metric_handler_data.compute_insights = effective_compute_insights_for_handler
+
             else:
                 _validate_single_metric(result)
 
-                if compute_insights is not None:
-                    assert isinstance(compute_insights, bool), \
-                        (f'{user_function.__name__}() validation failed: '
-                         f'compute_insights should be boolean. Got {type(compute_insights)}.')
-                if direction is not _UNSET:
-                    assert isinstance(direction, MetricDirection), \
-                        (f'{user_function.__name__}() validation failed: '
-                         f'direction should be a MetricDirection when using a single result. Got {type(direction)}.')
-
+                if compute_insights is None or isinstance(compute_insights, bool):
+                    effective_single_compute_insights = compute_insights
                 else:
-                    direction = MetricDirection.Downward
-                    leap_binder.setup_container.metrics[-1].metric_handler_data.direction = direction
-                    if not _call_from_tl_platform and compute_insights is not False:
+                    effective_single_compute_insights = None
+                    if not _call_from_tl_platform:
+                        store_warning_by_param(
+                            param_name="compute_insights",
+                            user_func_name=user_function.__name__,
+                            default_value=None,
+                            link_to_docs="https://docs.tensorleap.ai/tensorleap-integration/writing-integration-code/custom-metrics",
+                            custom_message=(
+                                f"'compute_insights': expected bool for single-valued output, "
+                                f"got {type(compute_insights).__name__}; reverted to default (None)."
+                            )
+                        )
+
+                if direction is _UNSET:
+                    effective_single_direction = MetricDirection.Downward
+                    if not _call_from_tl_platform and effective_single_compute_insights is not False:
                         store_warning_by_param(
                             param_name="direction",
                             user_func_name=user_function.__name__,
-                            default_value=direction,
+                            default_value=effective_single_direction,
                             link_to_docs="https://docs.tensorleap.ai/tensorleap-integration/writing-integration-code/custom-metrics"
                         )
+                elif isinstance(direction, MetricDirection):
+                    effective_single_direction = direction
+                else:
+                    effective_single_direction = MetricDirection.Downward
+                    if not _call_from_tl_platform and effective_single_compute_insights is not False:
+                        store_warning_by_param(
+                            param_name="direction",
+                            user_func_name=user_function.__name__,
+                            default_value=effective_single_direction,
+                            link_to_docs="https://docs.tensorleap.ai/tensorleap-integration/writing-integration-code/custom-metrics",
+                            custom_message=(
+                                f"'direction': expected MetricDirection for single-valued output, "
+                                f"got {type(direction).__name__}; reverted to default ({MetricDirection.Downward.name})."
+                            )
+                        )
+
+                leap_binder.setup_container.metrics[-1].metric_handler_data.direction = effective_single_direction
+                leap_binder.setup_container.metrics[-1].metric_handler_data.compute_insights = effective_single_compute_insights
 
         @functools.wraps(user_function)
         def inner_without_validate(*args, **kwargs):
@@ -1700,12 +1764,17 @@ def tensorleap_status_table():
             default_value = data[param_name]["default_value"]
             funcs = ", ".join(sorted(data[param_name]["funcs"]))
             dv = _format_default_value(default_value)
+            messages = data[param_name].get("messages", [])
 
             docs_link = data[param_name].get("link_to_docs")
             docs_part = f" {_link(docs_link)}" if docs_link else ""
-            print(
-                f" ⚠️ Parameter '{param_name}' defaults to {dv} in the following functions: [{funcs}]. "
-                f"For more information, check {docs_part}")
+            if messages:
+                for msg in messages:
+                    print(f" ⚠️ {msg} (functions: [{funcs}]).")
+            else:
+                print(
+                    f" ⚠️ Parameter '{param_name}' defaults to {dv} in the following functions: [{funcs}]. "
+                    f"For more information, check {docs_part}")
         print("\nIf this isn’t the intended behaviour, set them explicitly.")
 
     def _print_table():
@@ -1795,8 +1864,3 @@ def tensorleap_status_table():
 
 if not _call_from_tl_platform:
     set_current, update_env_params_func = tensorleap_status_table()
-
-
-
-
-

{code_loader-1.0.165.dev2 → code_loader-1.0.165.dev3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "code-loader"
-version = "1.0.165.dev2"
+version = "1.0.165.dev3"
 description = ""
 authors = ["dorhar <doron.harnoy@tensorleap.ai>"]
 license = "MIT"