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

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/constants/model.py

@@ -62,3 +62,12 @@ class ArtifactStatus(str, enum.Enum):
     NO_MODEL = 'no_model'
     SURROGATE = 'surrogate'
     USER_UPLOADED = 'user_uploaded'
+
+
+@enum.unique
+class CustomFeatureType(str, enum.Enum):
+    FROM_COLUMNS = 'FROM_COLUMNS'
+    FROM_VECTOR = 'FROM_VECTOR'
+    FROM_TEXT_EMBEDDING = 'FROM_TEXT_EMBEDDING'
+    FROM_IMAGE_EMBEDDING = 'FROM_IMAGE_EMBEDDING'
+    ENRICHMENT = 'ENRICHMENT'

fiddler3/entities/__init__.py

@@ -1,7 +0,0 @@
-"""Initialize all new entities."""
-from fiddler3.entities.baseline import Baseline  # noqa
-from fiddler3.entities.dataset import Dataset  # noqa
-from fiddler3.entities.job import Job  # noqa
-from fiddler3.entities.model import Model  # noqa
-from fiddler3.entities.model_deployment import ModelDeployment  # noqa
-from fiddler3.entities.project import Project  # 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)

fiddler3/entities/alert_rule.py

@@ -0,0 +1,323 @@
+from __future__ import annotations
+
+import builtins
+from datetime import datetime
+from typing import Any, Iterator
+from uuid import UUID
+
+from fiddler3.constants.alert_rule import AlertCondition, BinSize, CompareTo, Priority
+from fiddler3.decorators import handle_api_error
+from fiddler3.entities.base import BaseEntity
+from fiddler3.entities.baseline import Baseline, BaselineCompactMixin
+from fiddler3.entities.model import Model, ModelCompactMixin
+from fiddler3.entities.project import ProjectCompactMixin
+from fiddler3.schemas.alert_rule import AlertRuleResp, NotificationConfig
+from fiddler3.schemas.filter_query import OperatorType, QueryCondition, QueryRule
+from fiddler3.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class AlertRule(
+    BaseEntity, ModelCompactMixin, ProjectCompactMixin, BaselineCompactMixin
+):
+    def __init__(  # pylint: disable=too-many-arguments
+        self,
+        name: str,
+        model_id: UUID,
+        metric_id: str | UUID,
+        priority: Priority | str,
+        compare_to: CompareTo | str,
+        condition: AlertCondition | str,
+        bin_size: BinSize | str,
+        critical_threshold: float,
+        warning_threshold: float | None = None,
+        columns: list[str] | None = None,
+        baseline_id: UUID | None = None,
+        compare_bin_delta: int | None = None,
+    ) -> None:
+        """Construct a alert rule instance."""
+        self.name = name
+        self.model_id = model_id
+        self.metric_id = metric_id
+        self.columns = columns
+        self.baseline_id = baseline_id
+        self.priority = priority
+        self.compare_to = compare_to
+        self.compare_bin_delta = compare_bin_delta
+        self.warning_threshold = warning_threshold
+        self.critical_threshold = critical_threshold
+        self.condition = condition
+        self.bin_size = bin_size
+
+        self.id: UUID | None = None
+        self.project_id: UUID | None = None
+
+        self.created_at: datetime | None = None
+        self.updated_at: datetime | None = None
+
+        # Deserialized response object
+        self._resp: AlertRuleResp | None = None
+
+    @staticmethod
+    def _get_url(id_: UUID | str | None = None) -> str:
+        """Get model resource/item url."""
+        url = '/v2/alert-configs'
+        return url if not id_ else f'{url}/{id_}'
+
+    @classmethod
+    def _from_dict(cls, data: dict) -> AlertRule:
+        """Build entity object from the given dictionary."""
+
+        # Deserialize the response
+        resp_obj = AlertRuleResp(**data)
+
+        # Initialize
+        instance = cls(
+            name=resp_obj.name,
+            model_id=resp_obj.model.id,
+            metric_id=resp_obj.metric_id,
+            priority=resp_obj.priority,
+            compare_to=resp_obj.compare_to,
+            condition=resp_obj.condition,
+            bin_size=resp_obj.bin_size,
+            critical_threshold=resp_obj.critical_threshold,
+            warning_threshold=resp_obj.warning_threshold,
+            columns=resp_obj.columns,
+            baseline_id=resp_obj.baseline_id,
+            compare_bin_delta=resp_obj.compare_bin_delta,
+        )
+
+        # Add remaining fields
+        fields = [
+            'id',
+            # 'notifications_config',
+            'created_at',
+            'updated_at',
+        ]
+        for field in fields:
+            setattr(instance, field, getattr(resp_obj, field, None))
+
+        instance.project_id = resp_obj.project.id
+        instance._resp = resp_obj
+
+        return instance
+
+    def _refresh(self, data: dict) -> None:
+        """Refresh the fields of this instance from the given response dictionary"""
+        # Deserialize the response
+        resp_obj = AlertRuleResp(**data)
+
+        # Reset properties
+        self.model_id = resp_obj.model.id
+        self.project_id = resp_obj.project.id
+
+        # Add remaining fields
+        fields = [
+            'id',
+            'created_at',
+            'updated_at',
+        ]
+        for field in fields:
+            setattr(self, field, getattr(resp_obj, field, None))
+
+        self._resp = resp_obj
+
+    @classmethod
+    @handle_api_error
+    def get(cls, id_: UUID | str) -> AlertRule:
+        """
+        Get the alert rule instance using alert rule id.
+
+        :param id_: unique uuid format identifier for alert rule
+        :return: alert rule instance
+        """
+
+        response = cls._client().get(url=cls._get_url(id_=id_))
+        return cls._from_response(response=response)
+
+    @classmethod
+    @handle_api_error
+    def list(  # pylint: disable=too-many-arguments
+        cls,
+        model_id: UUID | None = None,
+        project_id: UUID | None = None,
+        metric_id: UUID | str | None = None,
+        columns: list[str] | None = None,
+        baseline_id: UUID | None = None,
+        ordering: list[str] | None = None,
+    ) -> Iterator[AlertRule]:
+        """Get a list of all alert rules in the organization."""
+        rules: list[QueryRule | QueryCondition] = []
+
+        if model_id:
+            rules.append(
+                QueryRule(field='model_id', operator=OperatorType.EQUAL, value=model_id)
+            )
+        if project_id:
+            rules.append(
+                QueryRule(
+                    field='project_id', operator=OperatorType.EQUAL, value=project_id
+                )
+            )
+        if baseline_id:
+            rules.append(
+                QueryRule(
+                    field='baseline_id', operator=OperatorType.EQUAL, value=baseline_id
+                )
+            )
+        if metric_id:
+            rules.append(
+                QueryRule(
+                    field='metric_id', operator=OperatorType.EQUAL, value=metric_id
+                )
+            )
+        if columns:
+            for column in columns:
+                rules.append(
+                    QueryRule(field='columns', operator=OperatorType.ANY, value=column)
+                )
+
+        _filter = QueryCondition(rules=rules)
+        params: dict[str, Any] = {'filter': _filter.json()}
+
+        if ordering:
+            params['ordering'] = ','.join(ordering)
+
+        params['organization_name'] = cls.get_organization_name()
+        for rule in cls._paginate(url=cls._get_url(), params=params):
+            yield cls._from_dict(data=rule)
+
+    @handle_api_error
+    def delete(self) -> None:
+        """Delete an alert rule."""
+        assert self.id is not None
+
+        self._client().delete(url=self._get_url(id_=self.id))
+
+    @handle_api_error
+    def create(self) -> AlertRule:
+        """Create a new alert rule."""
+        model = Model.get(self.model_id)
+        payload: dict[str, Any] = {
+            'name': self.name,
+            'organization_name': self.organization_name,
+            'model_name': model.name,
+            'project_name': model.project.name,
+            'metric_id': self.metric_id,
+            'priority': self.priority,
+            'compare_to': self.compare_to,
+            'condition': self.condition,
+            'bin_size': self.bin_size,
+            'critical_threshold': self.critical_threshold,
+            'warning_threshold': self.warning_threshold,
+            'feature_names': self.columns,
+            'compare_bin_delta': self.compare_bin_delta,
+        }
+        if self.baseline_id:
+            baseline = Baseline.get(self.baseline_id)
+            payload['baseline_name'] = baseline.name
+
+        response = self._client().post(
+            url=self._get_url(),
+            data=payload,
+        )
+
+        self._refresh_from_response(response=response)
+        return self
+
+    @handle_api_error
+    def enable_notifications(self) -> None:
+        """Enable notifications for an alert rule"""
+        self._client().patch(
+            url=self._get_url(id_=self.id), data={'enable_notification': True}
+        )
+        logger.info(
+            'Notifications have been enabled for alert rule with id: %s', self.id
+        )
+
+    @handle_api_error
+    def disable_notifications(self) -> None:
+        """Disable notifications for an alert rule"""
+        self._client().patch(
+            url=self._get_url(id_=self.id), data={'enable_notification': False}
+        )
+        logger.info(
+            'Notifications have been disabled for alert rule with id: %s', self.id
+        )
+
+    @handle_api_error
+    def set_notification_config(
+        self,
+        emails: builtins.list[str] | None = None,
+        pagerduty_services: builtins.list[str] | None = None,
+        pagerduty_severity: str | None = None,
+        webhooks: builtins.list[UUID] | None = None,
+    ) -> NotificationConfig:
+        """
+        Set notifications for an alert rule
+
+        :param emails: list of emails
+        :param pagerduty_services: list of pagerduty services
+        :param pagerduty_severity: severity of pagerduty
+        :param webhooks: list of webhooks UUIDs
+
+        :return: AlertNotifications object
+        """
+        notifications = {
+            'emails': {
+                'email': ','.join(emails) if emails else '',
+            },
+            'pagerduty': {
+                'service': ','.join(pagerduty_services) if pagerduty_services else '',
+                'severity': pagerduty_severity,
+            },
+            'webhooks': [{'uuid': webhook_uuid} for webhook_uuid in webhooks]
+            if webhooks
+            else None,
+        }
+        response = self._client().patch(
+            url=self._get_url(id_=self.id),
+            data={'notifications': notifications},
+        )
+
+        return self._get_notifications_from_dict(
+            response.json()['data']['notifications']
+        )
+
+    @handle_api_error
+    def get_notification_config(self) -> NotificationConfig:
+        """
+        Get notifications setting for an alert rule
+
+        :return: AlertNotifications object
+        """
+
+        response = self._client().get(url=self._get_url(id_=self.id))
+
+        return self._get_notifications_from_dict(
+            response.json()['data']['notifications']
+        )
+
+    @staticmethod
+    def _get_notifications_from_dict(notif_dict: dict) -> NotificationConfig:
+        emails = notif_dict.get('emails', {}).get('email')
+        notifications: dict = {}
+        if emails:
+            notifications['emails'] = [email.strip() for email in emails.split(',')]
+
+        pd_services = notif_dict.get('pagerduty', {}).get('service')
+        if pd_services:
+            notifications['pagerduty_services'] = [
+                pd_service.strip() for pd_service in pd_services.split(',')
+            ]
+            notifications['pagerduty_severity'] = notif_dict.get('pagerduty', {}).get(
+                'severity'
+            )
+
+        if notif_dict.get('webhooks'):
+            notifications['webhooks'] = [
+                webhook['uuid'] for webhook in notif_dict.get('webhooks', [])
+            ]
+
+        return NotificationConfig(**notifications)

fiddler3/entities/base.py

@@ -6,8 +6,7 @@ from typing import Iterator, TypeVar
 from requests import Response
 
 from fiddler3.configs import DEFAULT_PAGE_SIZE
-from fiddler3.connection import Connection
-from fiddler3.libs.http_client import RequestClient
+from fiddler3.connection import ConnectionMixin
 from fiddler3.schemas.response import PaginatedApiResponse
 
 BaseEntityType = TypeVar(  # pylint: disable=invalid-name
@@ -15,20 +14,7 @@ BaseEntityType = TypeVar(  # pylint: disable=invalid-name
 )
 
 
-class BaseEntity(ABC):
-    @classmethod
-    def _connection(cls) -> Connection:
-        """Fiddler connection instance"""
-        from fiddler3 import connection  # pylint: disable=import-outside-toplevel
-
-        assert connection is not None
-        return connection
-
-    @classmethod
-    def _client(cls) -> RequestClient:
-        """Request client instance"""
-        return cls._connection().client
-
+class BaseEntity(ABC, ConnectionMixin):
     @classmethod
     def _from_response(cls: type[BaseEntityType], response: Response) -> BaseEntityType:
         """Build entity object from the given response"""

fiddler3/entities/baseline.py

@@ -9,11 +9,11 @@ from fiddler3.constants.dataset import EnvType
 from fiddler3.decorators import handle_api_error
 from fiddler3.entities.base import BaseEntity
 from fiddler3.entities.dataset import DatasetCompactMixin
-from fiddler3.entities.helpers import raise_not_found
 from fiddler3.entities.model import ModelCompactMixin
 from fiddler3.entities.project import ProjectCompactMixin
 from fiddler3.schemas.baseline import BaselineResp
 from fiddler3.schemas.filter_query import OperatorType, QueryCondition, QueryRule
+from fiddler3.utils.helpers import raise_not_found
 
 
 class Baseline(
@@ -138,9 +138,9 @@ class Baseline(
         """
         Get the baseline instance using baseline name, model name and project name.
 
-        :param name: baseline name
-        :param model_name: name of the model associated with the baseline
-        :param project_name: name of the project associated with the baseline
+        :param name: Baseline name
+        :param model_name: Name of the model associated with the baseline
+        :param project_name: Name of the project associated with the baseline
         :return: Baseline instance for the provided params
         """
 
@@ -179,19 +179,25 @@ class Baseline(
     @handle_api_error
     def create(self) -> Baseline:
         """Create a new baseline."""
+        payload = {
+            'name': self.name,
+            'model_id': self.model_id,
+            'type': self.type,
+            'env_type': self.environment,
+            'env_id': self.dataset_id,
+        }
+        if self.start_time:
+            payload['start_time'] = self.start_time
+        if self.end_time:
+            payload['end_time'] = self.end_time
+        if self.offset:
+            payload['offset'] = self.offset
+        if self.window_size:
+            payload['window_size'] = self.window_size
+
         response = self._client().post(
             url=self._get_url(),
-            data={
-                'name': self.name,
-                'model_id': self.model_id,
-                'type': self.type,
-                'env_type': self.environment,
-                'start_time': self.start_time,
-                'end_time': self.end_time,
-                'offset': self.offset,
-                'window_size': self.window_size,
-                'env_id': self.dataset_id,
-            },
+            data=payload,
         )
         self._refresh_from_response(response=response)
         return self

fiddler3/entities/dataset.py

@@ -7,10 +7,10 @@ from uuid import UUID
 from fiddler3.constants.dataset import EnvType
 from fiddler3.decorators import handle_api_error
 from fiddler3.entities.base import BaseEntity
-from fiddler3.entities.helpers import raise_not_found
 from fiddler3.entities.project import ProjectCompactMixin
 from fiddler3.schemas.dataset import DatasetResp
 from fiddler3.schemas.filter_query import OperatorType, QueryCondition, QueryRule
+from fiddler3.utils.helpers import raise_not_found
 
 
 class Dataset(BaseEntity, ProjectCompactMixin):