code-loader 1.0.169__tar.gz → 1.0.169.dev1__tar.gz

{code_loader-1.0.169 → code_loader-1.0.169.dev1}/PKG-INFO

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

code_loader-1.0.169.dev1/code_loader/contract/metric_metadata_utils.py

@@ -0,0 +1,36 @@
+from typing import Dict, Iterable, Optional, Tuple, Union
+
+from code_loader.contract.enums import MetricDirection
+
+
+def resolve_metric_output_metadata(
+        direction: Union[None, MetricDirection, Dict[str, MetricDirection]],
+        compute_insights: Optional[Union[bool, Dict[str, bool]]],
+        result_keys: Iterable[str],
+) -> Tuple[Dict[str, MetricDirection], Dict[str, bool]]:
+    result_keys = list(result_keys)
+
+    if isinstance(direction, dict):
+        resolved_direction = {
+            key: direction.get(key, MetricDirection.Downward)
+            for key in result_keys
+        }
+    elif isinstance(direction, MetricDirection):
+        resolved_direction = {key: direction for key in result_keys}
+    else:
+        resolved_direction = {
+            key: MetricDirection.Downward
+            for key in result_keys
+        }
+
+    if isinstance(compute_insights, dict):
+        resolved_compute_insights = {
+            key: compute_insights.get(key, True)
+            for key in result_keys
+        }
+    elif isinstance(compute_insights, bool):
+        resolved_compute_insights = {key: compute_insights for key in result_keys}
+    else:
+        resolved_compute_insights = {key: True for key in result_keys}
+
+    return resolved_direction, resolved_compute_insights

{code_loader-1.0.169 → code_loader-1.0.169.dev1}/code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -21,6 +21,7 @@ from code_loader.contract.datasetclasses import CustomCallableInterfaceMultiArgs
     ConfusionMatrixElement, SamplePreprocessResponse, PredictionTypeHandler, InstanceCallableInterface, ElementInstance, \
     InstanceLengthCallableInterface
 from code_loader.contract.enums import MetricDirection, LeapDataType, DatasetMetadataType, DataStateType
+from code_loader.contract.metric_metadata_utils import resolve_metric_output_metadata
 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, \
@@ -699,21 +700,21 @@ def tensorleap_custom_metric(name: str,
                             (f'{user_function.__name__}() validation failed: '
                              f'Keys in the compute_insights mapping should be part of result keys. Got key {ci_key}.')
 
-                effective_direction = {} if direction is _UNSET else direction if isinstance(direction, dict) else {k:direction for k in result_keys}
-                defaulted_direction_keys = result_keys.difference(effective_direction.keys())
-
-                if defaulted_direction_keys:
-                    effective_direction = {key: effective_direction.get(key, MetricDirection.Downward) for key in result}
+                raw_direction = None if direction is _UNSET else direction
+                effective_direction, effective_compute_insights = resolve_metric_output_metadata(
+                    raw_direction,
+                    compute_insights,
+                    result.keys(),
+                )
+                defaulted_direction_keys = {
+                    key for key in result_keys
+                    if raw_direction is None or (isinstance(raw_direction, dict) and key not in raw_direction)
+                }
 
                 leap_binder.setup_container.metrics[-1].metric_handler_data.direction = effective_direction
+                leap_binder.setup_container.metrics[-1].metric_handler_data.compute_insights = effective_compute_insights
 
                 if defaulted_direction_keys and not _call_from_tl_platform:
-                    if compute_insights is None:
-                        effective_compute_insights = {}
-                    elif isinstance(compute_insights, dict):
-                        effective_compute_insights = compute_insights
-                    else:
-                        effective_compute_insights = {k: compute_insights for k in result_keys}
                     warning_keys = {key for key in defaulted_direction_keys if effective_compute_insights.get(key, True)}
                     if warning_keys:
                         store_warning_by_param(
@@ -961,6 +962,8 @@ 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)
             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)}')
@@ -1812,4 +1815,3 @@ if not _call_from_tl_platform:
 
 
 
-

{code_loader-1.0.169 → code_loader-1.0.169.dev1}/pyproject.toml

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