code-loader 1.0.169.dev2__tar.gz → 1.0.171__tar.gz

{code_loader-1.0.169.dev2 → code_loader-1.0.171}/PKG-INFO

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

{code_loader-1.0.169.dev2 → code_loader-1.0.171}/code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -21,7 +21,6 @@ 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, \
@@ -700,21 +699,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}.')
 
-                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)
-                }
+                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}
 
                 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(
@@ -1815,3 +1814,4 @@ if not _call_from_tl_platform:
 
 
 
+

{code_loader-1.0.169.dev2 → code_loader-1.0.171}/code_loader/mixpanel_tracker.py

@@ -13,6 +13,7 @@ import mixpanel  # type: ignore[import]
 logger = logging.getLogger(__name__)
 
 TRACKING_VERSION = '1'
+TL_DISABLE_ANALYTICS_ENV_VAR = 'TL_DISABLE_ANALYTICS'
 
 
 class AnalyticsEvent(str, Enum):
@@ -143,6 +144,10 @@ class MixpanelTracker:
         # Skip tracking if IS_TENSORLEAP_PLATFORM environment variable is set to 'true'
         if os.environ.get('IS_TENSORLEAP_PLATFORM') == 'true':
             return
+
+        # Skip tracking if TL_DISABLE_ANALYTICS environment variable is set
+        if os.environ.get(TL_DISABLE_ANALYTICS_ENV_VAR):
+            return
             
         try:
             distinct_id = self._get_distinct_id()
@@ -199,11 +204,24 @@ def get_tracker() -> MixpanelTracker:
     return _tracker
 
 
+def _is_analytics_disabled() -> bool:
+    return bool(os.environ.get(TL_DISABLE_ANALYTICS_ENV_VAR))
+
+
+def disable_analytics() -> None:
+    """Programmatically disable all analytics/Mixpanel tracking."""
+    os.environ[TL_DISABLE_ANALYTICS_ENV_VAR] = 'true'
+
+
 def track_code_loader_loaded(event_properties: Optional[Dict[str, Any]] = None) -> None:
+    if _is_analytics_disabled():
+        return
     get_tracker().track_code_loader_loaded(event_properties)
 
 
 def track_integration_test_event(event_name: Union[str, AnalyticsEvent], event_properties: Optional[Dict[str, Any]] = None) -> None:
+    if _is_analytics_disabled():
+        return
     get_tracker().track_integration_test_event(event_name, event_properties)
 
 
@@ -213,6 +231,8 @@ _integration_events_emitted: Set[str] = set()
 
 def emit_integration_event_once(event_name: Union[str, AnalyticsEvent], props: Dict[str, Any]) -> None:
     """Emit an integration test event only once per test run."""
+    if _is_analytics_disabled():
+        return
     event_name_str = str(event_name)
     if event_name_str in _integration_events_emitted:
         return

{code_loader-1.0.169.dev2 → code_loader-1.0.171}/pyproject.toml

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

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

@@ -1,36 +0,0 @@
-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