fiddler-client 2.4.0.dev1__py3-none-any.whl → 2.5.0.dev1__py3-none-any.whl

fiddler/_version.py

@@ -1 +1 @@
-__version__ = '2.4.0.dev1'
+__version__ = '2.5.0.dev1'

fiddler/api/alert_mixin.py

@@ -6,6 +6,8 @@ from typing import Any, Dict, List, Optional, Union
 
 from pydantic import parse_obj_as
 
+import fiddler3
+from fiddler3.entities.model import Model
 from fiddler.libs.http_client import RequestClient
 from fiddler.schema.alert import (
     AlertCondition,
@@ -38,6 +40,8 @@ class AlertMixin:
     client: RequestClient
     organization_name: str
     server_info: ServerInfo
+    url: str
+    auth_token: str
 
     @handle_api_error_response
     def add_alert_rule(
@@ -50,6 +54,7 @@ class AlertMixin:
         condition: AlertCondition,
         project_id: str,
         model_id: str,
+        segment_id: Optional[str] = None,
         bin_size: BinSize = BinSize.ONE_DAY,
         alert_type: Optional[AlertType] = None,
         baseline_id: Optional[str] = None,
@@ -60,13 +65,14 @@ class AlertMixin:
         warning_threshold: Optional[float] = None,
         notifications_config: Optional[Dict[str, Any]] = None,
     ) -> AlertRule:
-        """
+        f"""
         To add an alert rule
 
         :param project_id: Unique project name for which the alert rule is created
         :param model_id: Unique model name for which the alert rule is created
         :param project_id: Unique project name for which the alert rule is created
         :param model_id: Unique model name for which the alert rule is created
+        :param segment_id: An optional segment id to filter the data for alert rule
         :param name: Name of the Alert rule
         :param alert_type: [DEPRECATED] Used only for older server versions. For {self.RULE_V3_API_VERSION} you can simply use 'metric'.
             Selects one of the four metric types:
@@ -147,6 +153,7 @@ class AlertMixin:
             alert_type=alert_type,
             metric=metric,
             metric_id=metric,
+            segment_id=segment_id,
             category=category,
             compare_to=compare_to,
             compare_period=compare_period,
@@ -485,3 +492,49 @@ class AlertMixin:
             },
             'webhooks': webhooks_dict,
         }
+
+    def update_alert_notification_status(
+        self,
+        notification_status: bool,
+        alert_config_ids: Optional[list[str]] = None,
+        model_id: Optional[str] = None,
+    ) -> list[AlertRuleWithNotifications]:
+        """
+        To enable/disable the notifications for a list of Alert Ids or for a given Model Id.
+        Either the Alert Ids should be given or the Model Id, but not both.
+        :param notification_status: The value of notification status for an alert
+        :param alert_config_ids: List of Alert Ids, on which we need to update notification
+        :param model_id: The Model Id which for whom we want to update all alerts.
+        :return: List of updated Alert Rules.
+        """
+        if not alert_config_ids and not model_id:
+            raise ValueError('Either alert_config_ids or model_id must be specified')
+        elif alert_config_ids and model_id:
+            raise ValueError(
+                'Either alert_config_ids or model_id should be specified, not both.'
+            )
+
+        updated_alert_configs: list[AlertRuleWithNotifications] = []
+        alert_ids: list[str] = []
+
+        if alert_config_ids:
+            # verify that all the alert-configs are valid
+            for alert_id in alert_config_ids:
+                self.client.get(
+                    url=f'alert-configs/{alert_id}',
+                )
+            alert_ids = alert_config_ids
+
+        if model_id:
+            fiddler3.init(url=self.url, token=self.auth_token)
+            model: Model = Model.get(id_=model_id)
+            alerts: list[AlertRule] = self.get_alert_rules(model_id=model.name)
+            alert_ids = [alert.alert_rule_uuid for alert in alerts]
+
+        for alert_id in alert_ids:
+            updated_alert_configs.append(
+                self.update_alert_rule(
+                    alert_config_uuid=alert_id, enable_notification=notification_status
+                )
+            )
+        return updated_alert_configs

fiddler/api/webhooks_mixin.py

@@ -1,5 +1,5 @@
 from http import HTTPStatus
-from typing import List
+from typing import Dict, List
 
 from pydantic import parse_obj_as
 
@@ -80,13 +80,11 @@ class WebhookMixin:
 
         :returns: Updated `Webhook` object.
         """
-        request_body = Webhook(
-            uuid=uuid,
-            organization_name=self.organization_name,
-            name=name,
-            url=url,
-            provider=provider,
-        ).dict()
+        request_body: Dict[str, str] = {
+            'name': name,
+            'url': url,
+            'provider': provider,
+        }
         response = self.client.patch(
             url=f'webhooks/{uuid}',
             data=request_body,

fiddler/core_objects.py

@@ -1232,10 +1232,10 @@ class ModelInfo:
                     'The custom_features argument only accepts a list of CustomFeature objects.'
                 )
 
-            available_cols = (
-                self.get_input_names()
-                + self.get_target_names()
-                + self.get_metadata_names()
+            available_cols: Set[str] = set().union(
+                self.get_input_names(),
+                self.get_target_names(),
+                self.get_metadata_names(),
             )
 
             numeric_cols = self.get_input_pandas_dtypes()
@@ -1244,23 +1244,18 @@ class ModelInfo:
             if self.targets:
                 numeric_cols.update(self.get_target_pandas_dtypes())
 
-            valid_numeric_names = [
+            valid_numeric_names = set(
                 k
                 for k, v in numeric_cols.items()
                 if v in (DataType.INTEGER.value, DataType.FLOAT.value)
-            ]
-
-            valid_enrichment_names = [
-                cf.name for cf in self.custom_features if isinstance(cf, Enrichment)
-            ]
-
-            valid_vector_cols = [
+            )
+            valid_vector_cols = set(
                 vec_col.name
                 for vec_col in (self.inputs or []) + (self.metadata or [])
                 if vec_col.data_type.is_vector()
-            ]
+            )
 
-            unique_cf_names = []
+            valid_cf_names, valid_enrichment_names = set(), set()
             for feature in self.custom_features:
                 if not isinstance(feature, CustomFeature):
                     raise ValueError(
@@ -1272,61 +1267,74 @@ class ModelInfo:
                         f'A column name "{feature.name}" already exists in the dataset. Please use a different name for custom feature {feature}.'
                     )
 
-                if feature.name in unique_cf_names:
+                if feature.name in valid_cf_names:
                     raise ValueError(
                         f'Multiple custom features are defined with the same name {feature.name}.'
                     )
-                else:
-                    unique_cf_names.append(feature.name)
+                if isinstance(feature, Enrichment):
+                    valid_enrichment_names.add(feature.name)
+                valid_cf_names.add(feature.name)
 
+            for feature in self.custom_features:
                 if isinstance(feature, Multivariate):
                     self.validate_multivariate_cf(feature, valid_numeric_names)
                 elif isinstance(feature, TextEmbedding):
-                    self.validate_text_embedding_cf(
+                    self.validate_embedding_cf(
                         feature,
                         available_cols,
                         valid_vector_cols,
                         valid_enrichment_names,
                     )
+                elif isinstance(feature, ImageEmbedding):
+                    self.validate_embedding_cf(
+                        feature,
+                        available_cols,
+                        valid_vector_cols,
+                        [],
+                    )
                 elif isinstance(feature, VectorFeature):
                     self.validate_vector_cf(feature, valid_vector_cols)
                 elif isinstance(feature, Enrichment):
                     self.validate_enrichment_cf(
-                        feature, available_cols, valid_enrichment_names
+                        feature, available_cols, valid_cf_names
                     )
 
     def validate_enrichment_cf(
         self,
         feature: Enrichment,
-        available_cols: List[str],
-        valid_enrichment_names: List[str],
+        available_cols: Iterable[str],
+        valid_cf_names: Iterable[str],
     ) -> None:
         if not feature.columns:
             raise ValueError(
-                f'{feature.name} ({feature.__class__.__name__}) must specify at least one enrichment/column in columns.'
+                f'{feature.name} ({feature.__class__.__name__}) must specify at least one enrichment/column/custom feature in columns.'
             )
         for column in feature.columns:
             if column == feature.name:
                 raise ValueError(
                     f'{feature.name} ({feature.__class__.__name__}) cannot depend on itself.'
                 )
-            if column not in [*valid_enrichment_names, *available_cols]:
+            if column not in valid_cf_names and column not in available_cols:
                 raise ValueError(
-                    f"Column '{column}' defined in {feature.name} ({feature.__class__.__name__}) does not exist in the data or as an enrichment."
+                    f"Column '{column}' defined in {feature.name} ({feature.__class__.__name__}) does not exist in the data, as a custom feature or as an enrichment."
                 )
 
-    def validate_text_embedding_cf(
+    def validate_embedding_cf(
         self,
-        feature: TextEmbedding,
-        available_cols: List[str],
-        valid_vector_cols: List[str],
-        valid_enrichment_names: List[str],
+        feature: Union[TextEmbedding, ImageEmbedding],
+        available_cols: Iterable[str],
+        valid_vector_cols: Iterable[str],
+        valid_enrichment_names: Iterable[str],
     ) -> None:
         if feature.column not in valid_vector_cols:
             # we require either a column or source_column
+            if not feature.source_column:
+                raise ValueError(
+                    f'{feature.name} ({feature.__class__.__name__}) needs to specify source_column.'
+                )
             if feature.source_column not in available_cols:
                 raise ValueError(
-                    f'{feature.name} ({feature.__class__.__name__}) needs to specify at least one of [column, source_col].'
+                    f'source_column {feature.source_column} defined in {feature.name} ({feature.__class__.__name__}) does not exist or cannot be used as a source column.'
                 )
             # column could be the result of an enrichment
             if feature.column not in valid_enrichment_names:
@@ -1334,13 +1342,13 @@ class ModelInfo:
                     f"Column/Enrichment'{feature.column}' defined in {feature.name} ({feature.__class__.__name__}) does not exist or not of type vector."
                 )
 
-    def validate_vector_cf(self, feature: VectorFeature, valid_vector_cols: List[str]) -> None:
+    def validate_vector_cf(self, feature: VectorFeature, valid_vector_cols: Iterable[str]) -> None:
         if feature.column not in valid_vector_cols:
             raise ValueError(
                 f"Column '{feature.column}' defined in {feature.name} ({feature.__class__.__name__}) does not exist or not of type vector."
             )
 
-    def validate_multivariate_cf(self, feature: Multivariate, valid_numeric_names: List[str]) -> None:
+    def validate_multivariate_cf(self, feature: Multivariate, valid_numeric_names: Iterable[str]) -> None:
         if len(feature.columns or []) < 2:
             raise ValueError(
                 f'{feature.name} ({feature.__class__.__name__}) must specify at least two columns.'

fiddler/schema/alert.py

@@ -5,6 +5,7 @@ from typing import Any, Dict, List, Optional, Union
 from pydantic import Field, root_validator
 
 from fiddler.schema.base import BaseDataSchema
+from fiddler.schema.segment import Segment
 
 
 @enum.unique
@@ -33,6 +34,12 @@ class Metric(str, enum.Enum):
     MISSING_VALUE = 'null_violation_count'
     RANGE_VIOLATION = 'range_violation_count'
     TYPE_VIOLATION = 'type_violation_count'
+    ANY_VIOLATION = 'any_violation_count'
+
+    MISSING_VALUE_PCT = 'null_violation_percentage'
+    RANGE_VIOLATION_PCT = 'range_violation_percentage'
+    TYPE_VIOLATION_PCT = 'type_violation_percentage'
+    ANY_VIOLATION_PCT = 'any_violation_percentage'
 
     ## Performance metrics
     # Binary Classification
@@ -46,7 +53,6 @@ class Metric(str, enum.Enum):
     CALIBRATED_THRESHOLD = 'calibrated_threshold'
     GMEAN = 'geometric_mean'
     LOG_LOSS = 'log_loss'
-    
 
     # Regression
     R2 = 'r2'
@@ -146,6 +152,7 @@ class AlertRulePayload(BaseDataSchema):
     alert_type: Optional[AlertType]
     metric: Union[Metric, str]
     metric_id: Union[Metric, str]
+    segment_id: Optional[str]
     feature_name: Optional[str]
     feature_names: Optional[List[str]]
     category: Optional[str]
@@ -183,6 +190,7 @@ class AlertRule(BaseDataSchema):
     compare_to: CompareTo
     compare_period: Optional[ComparePeriod]
     warning_threshold: Optional[float]
+    segment: Optional[Segment]
     critical_threshold: float
     condition: AlertCondition
     bin_size: Optional[str]
@@ -221,3 +229,6 @@ class TriggeredAlerts(BaseDataSchema):
     message: str
     multi_col_values: Optional[Dict[str, float]]
     feature_name: Optional[str]
+    alert_record_main_version: int
+    alert_record_sub_version: int
+    segment: Optional[Segment]

fiddler3/__init__.py

@@ -1,39 +1,4 @@
-from __future__ import annotations
-
-from fiddler3.configs import DEFAULT_CONNECTION_TIMEOUT
-from fiddler3.connection import Connection
+from fiddler3.connection import Connection, ConnectionMixin, init  # noqa
 from fiddler3.entities import *  # noqa
 from fiddler3.exceptions import *  # noqa
 from fiddler3.schemas import *  # noqa
-
-# Global connection object
-connection: Connection | None = None
-
-
-def init(
-    url: str,
-    token: str,
-    proxies: dict | None = None,
-    timeout: int = DEFAULT_CONNECTION_TIMEOUT,
-    verify: bool = True,
-    validate: bool = True,
-) -> None:
-    """
-    Initiate Python Client Connection
-    :param url: URL of Fiddler Platform
-    :param token: Authorization token
-    :param proxies: Dictionary mapping protocol to the URL of the proxy
-    :param timeout: Seconds to wait for the server to send data before giving up
-    :param verify: Controls whether we verify the server’s TLS certificate
-    :param validate: Whether to validate the server/client version compatibility.
-         Some functionalities might not work if this is turned off.
-    """
-    global connection
-    connection = Connection(
-        url=url,
-        token=token,
-        proxies=proxies,
-        timeout=timeout,
-        verify=verify,
-        validate=validate,
-    )

fiddler3/connection.py

@@ -15,9 +15,12 @@ from fiddler3.version import __version__
 
 logger = get_logger(__name__)
 
+# Global connection object
+connection: Connection | None = None
+
 
 class Connection:
-    def __init__(
+    def __init__(  # pylint: disable=too-many-arguments
         self,
         url: str,
         token: str,
@@ -28,6 +31,7 @@ class Connection:
     ) -> None:
         """
         Initiate connection to Fiddler Platform
+
         :param url: URL of Fiddler Platform
         :param token: Authorization token
         :param proxies: Dictionary mapping protocol to the URL of the proxy
@@ -115,3 +119,66 @@ class Connection:
             return
 
         raise IncompatibleClient(server_version=str(self.server_version))
+
+
+class ConnectionMixin:
+    @classmethod
+    def _connection(cls) -> Connection:
+        """Fiddler connection instance"""
+        assert connection is not None
+        return connection
+
+    @classmethod
+    def _client(cls) -> RequestClient:
+        """Request client instance"""
+        return cls._connection().client
+
+    @property
+    def organization_name(self) -> str:
+        """Organization name property"""
+        return self._connection().server_info.organization.name
+
+    @property
+    def organization_id(self) -> UUID:
+        """Organization id property"""
+        return self._connection().server_info.organization.id
+
+    @classmethod
+    def get_organization_name(cls) -> str:
+        """Organization name"""
+        return cls._connection().server_info.organization.name
+
+    @classmethod
+    def get_organization_id(cls) -> UUID:
+        """Organization id"""
+        return cls._connection().server_info.organization.id
+
+
+def init(  # pylint: disable=too-many-arguments
+    url: str,
+    token: str,
+    proxies: dict | None = None,
+    timeout: int = DEFAULT_CONNECTION_TIMEOUT,
+    verify: bool = True,
+    validate: bool = True,
+) -> None:
+    """
+    Initiate Python Client Connection
+
+    :param url: URL of Fiddler Platform
+    :param token: Authorization token
+    :param proxies: Dictionary mapping protocol to the URL of the proxy
+    :param timeout: Seconds to wait for the server to send data before giving up
+    :param verify: Controls whether we verify the server’s TLS certificate
+    :param validate: Whether to validate the server/client version compatibility.
+         Some functionalities might not work if this is turned off.
+    """
+    global connection  # pylint: disable=global-statement
+    connection = Connection(
+        url=url,
+        token=token,
+        proxies=proxies,
+        timeout=timeout,
+        verify=verify,
+        validate=validate,
+    )

fiddler3/constants/alert_rule.py

@@ -0,0 +1,30 @@
+import enum
+
+
+@enum.unique
+class BinSize(str, enum.Enum):
+    HOUR = 'Hour'
+    DAY = 'Day'
+    WEEK = 'Week'
+    MONTH = 'Month'
+
+
+@enum.unique
+class CompareTo(str, enum.Enum):
+    """Comparison with Absolute(raw_value) or Relative(time_period)"""
+
+    TIME_PERIOD = 'time_period'
+    RAW_VALUE = 'raw_value'
+
+
+@enum.unique
+class AlertCondition(str, enum.Enum):
+    GREATER = 'greater'
+    LESSER = 'lesser'
+
+
+@enum.unique
+class Priority(str, enum.Enum):
+    HIGH = 'HIGH'
+    MEDIUM = 'MEDIUM'
+    LOW = 'LOW'

fiddler3/constants/events.py

@@ -0,0 +1,7 @@
+import enum
+
+
+@enum.unique
+class PublishEventsSourceType(str, enum.Enum):
+    EVENTS = 'EVENTS'
+    FILE = 'FILE'

fiddler3/entities/__init__.py

@@ -1,6 +1,9 @@
 """Initialize all new entities."""
+from fiddler3.entities.alert_record import AlertRecord  # noqa
+from fiddler3.entities.alert_rule import AlertRule  # noqa
 from fiddler3.entities.baseline import Baseline  # noqa
 from fiddler3.entities.dataset import Dataset  # noqa
+from fiddler3.entities.files import File  # noqa
 from fiddler3.entities.job import Job  # noqa
 from fiddler3.entities.model import Model  # noqa
 from fiddler3.entities.model_deployment import ModelDeployment  # noqa

fiddler3/entities/alert_record.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta
+from typing import Any, Iterator
+from uuid import UUID
+
+from fiddler3.decorators import handle_api_error
+from fiddler3.entities.base import BaseEntity
+from fiddler3.schemas.alert_record import AlertRecordResp
+
+
+class AlertRecord(BaseEntity):
+    def __init__(self) -> None:
+        """Construct a alert record instance"""
+
+        self.alert_run_start_time: int | None = None
+        self.alert_time_bucket: int | None = None
+        self.alert_value: float | None = None
+        self.baseline_time_bucket: int | None = None
+        self.baseline_value: float | None = None
+        self.is_alert: bool | None = None
+        self.severity: str | None = None
+        self.failure_reason: str | None = None
+        self.message: str | None = None
+        self.feature_name: str | None = None
+        self.alert_record_main_version: int | None = None
+        self.alert_record_sub_version: int | None = None
+
+        self.id: UUID | None = None
+        self.alert_rule_id: UUID | None = None
+        self.created_at: datetime | None = None
+        self.updated_at: datetime | None = None
+
+        # Deserialized response object
+        self._resp: AlertRecordResp | None = None
+
+    @classmethod
+    def _from_dict(cls, data: dict) -> AlertRecord:
+        """Build alert record object from the given dictionary"""
+
+        # Deserialize the response
+        resp_obj = AlertRecordResp(**data)
+
+        # Initialize
+        instance = cls()
+
+        # Add remaining fields
+        fields = [
+            'id',
+            'alert_rule_id',
+            'alert_run_start_time',
+            'alert_time_bucket',
+            'alert_value',
+            'baseline_time_bucket',
+            'baseline_value',
+            'is_alert',
+            'severity',
+            'failure_reason',
+            'message',
+            'feature_name',
+            'alert_record_main_version',
+            'alert_record_sub_version',
+            'created_at',
+            'updated_at',
+        ]
+        for field in fields:
+            setattr(instance, field, getattr(resp_obj, field, None))
+
+        instance._resp = resp_obj
+
+        return instance
+
+    @staticmethod
+    def _get_url(alert_rule_id: UUID | str, id_: UUID | str | None = None) -> str:
+        """Get alert record resource/item url"""
+        url = f'/v2/alert-configs/{alert_rule_id}/records'
+
+        return url if not id_ else f'{url}/{id_}'
+
+    @classmethod
+    @handle_api_error
+    def list(
+        cls,
+        alert_rule_id: UUID | str,
+        start_time: datetime | None = None,
+        end_time: datetime | None = None,
+        ordering: list[str] | None = None,
+    ) -> Iterator[AlertRecord]:
+        """
+        List alert records triggered for an alert rule
+
+        :param alert_rule_id: unique identifier for alert rule
+        :param start_time: Start time to filter trigger alerts :default: 7 days ago
+        :param end_time: End time to filter trigger alerts :default: time now
+
+        :return: paginated list of alert records for the given alert rule
+        """
+        params: dict[str, Any] = {
+            'start_time': start_time or datetime.now() - timedelta(days=7),
+            'end_time': end_time or datetime.now(),
+        }
+        if ordering:
+            params['ordering'] = ordering
+
+        for record in cls._paginate(url=cls._get_url(alert_rule_id), params=params):
+            yield cls._from_dict(data=record)