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

fiddler/_version.py

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

fiddler/core_objects.py

@@ -1295,9 +1295,7 @@ class ModelInfo:
                 elif isinstance(feature, VectorFeature):
                     self.validate_vector_cf(feature, valid_vector_cols)
                 elif isinstance(feature, Enrichment):
-                    self.validate_enrichment_cf(
-                        feature, available_cols, valid_cf_names
-                    )
+                    self.validate_enrichment_cf(feature, available_cols, valid_cf_names)
 
     def validate_enrichment_cf(
         self,
@@ -1326,6 +1324,17 @@ class ModelInfo:
         valid_vector_cols: Iterable[str],
         valid_enrichment_names: Iterable[str],
     ) -> None:
+        if isinstance(feature, TextEmbedding):
+            if not feature.n_tags:
+                raise ValueError(
+                    f'{feature.name} ({feature.__class__.__name__}) must specify a number of tags.'
+                )
+
+            if feature.n_tags < 0:
+                raise ValueError(
+                    f'{feature.name} ({feature.__class__.__name__}) must specify a non-negative number of tags.'
+                )
+
         if feature.column not in valid_vector_cols:
             # we require either a column or source_column
             if not feature.source_column:
@@ -1342,13 +1351,17 @@ 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: Iterable[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: Iterable[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

@@ -197,7 +197,7 @@ class AlertRule(BaseDataSchema):
     time_bucket: Optional[int]
     alert_type_display_name: str
     metric_display_name: str
-    enable_notification: bool
+    enable_notification: Optional[bool]
 
     @root_validator(pre=True)
     def set_feature_names(cls, values: dict) -> dict:
@@ -229,6 +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
+    alert_record_main_version: Optional[int]
+    alert_record_sub_version: Optional[int]
     segment: Optional[Segment]

fiddler/schemas/custom_features.py

@@ -1,7 +1,7 @@
 from enum import Enum
 from typing import Any, Dict, List, Optional, Type, TypeVar
 
-from pydantic import BaseModel, Extra
+from pydantic import BaseModel, Extra, validator
 
 CustomFeatureTypeVar = TypeVar('CustomFeatureTypeVar', bound='CustomFeature')
 DEFAULT_NUM_CLUSTERS = 5
@@ -22,6 +22,12 @@ class CustomFeature(BaseModel):
     n_clusters: Optional[int] = DEFAULT_NUM_CLUSTERS
     centroids: Optional[List] = None
 
+    @validator('n_clusters')
+    def validate_n_clusters(cls, value: int) -> int:  # noqa: N805
+        if value < 0:
+            raise ValueError('n_clusters must be greater than 0')
+        return value
+
     class Config:
         allow_mutation = False
         extra = Extra.forbid
@@ -81,6 +87,12 @@ class Multivariate(CustomFeature):
     columns: List[str]
     monitor_components: bool = False
 
+    @validator('columns')
+    def validate_columns(cls, value: List[str]) -> List[str]:  # noqa: N805
+        if len(value) < 2:
+            raise ValueError('Multivariate features must have at least 2 columns')
+        return value
+
 
 class VectorFeature(CustomFeature):
     type: CustomFeatureType = CustomFeatureType.FROM_VECTOR
@@ -92,10 +104,28 @@ class TextEmbedding(VectorFeature):
     type: CustomFeatureType = CustomFeatureType.FROM_TEXT_EMBEDDING
     n_tags: Optional[int] = DEFAULT_NUM_TAGS
 
+    @validator('source_column')
+    def validate_source_column(cls, value: str) -> str:  # noqa: N805
+        if value is None:
+            raise ValueError('source_column must be specified')
+        return value
+
+    @validator('n_tags')
+    def validate_n_tags(cls, value: int) -> int:  # noqa: N805
+        if value < 1:
+            raise ValueError('n_tags must be greater than 0')
+        return value
+
 
 class ImageEmbedding(VectorFeature):
     type: CustomFeatureType = CustomFeatureType.FROM_IMAGE_EMBEDDING
 
+    @validator('source_column')
+    def validate_source_column(cls, value: str) -> str:  # noqa: N805
+        if value is None:
+            raise ValueError('source_column must be specified')
+        return value
+
 
 class Enrichment(CustomFeature):
     type: CustomFeatureType = CustomFeatureType.ENRICHMENT

fiddler3/__init__.py

@@ -1,4 +1,122 @@
 from fiddler3.connection import Connection, ConnectionMixin, init  # noqa
-from fiddler3.entities import *  # noqa
-from fiddler3.exceptions import *  # noqa
-from fiddler3.schemas import *  # noqa
+from fiddler3.constants.alert_rule import (  # noqa
+    AlertCondition,
+    BinSize,
+    CompareTo,
+    Priority,
+)
+from fiddler3.constants.baseline import BaselineType, WindowSize  # noqa
+from fiddler3.constants.dataset import EnvType  # noqa
+from fiddler3.constants.job import JobStatus  # noqa
+from fiddler3.constants.model import (  # noqa
+    ArtifactStatus,
+    CustomFeatureType,
+    DataType,
+    ModelInputType,
+    ModelTask,
+)
+from fiddler3.constants.model_deployment import ArtifactType, DeploymentType  # noqa
+from fiddler3.constants.xai import ExplainMethod  # noqa
+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.file 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
+from fiddler3.entities.project import Project  # noqa
+from fiddler3.entities.webhook import Webhook  # noqa
+from fiddler3.exceptions import (  # noqa
+    ApiError,
+    AsyncJobFailed,
+    Conflict,
+    ConnectionError,
+    ConnectionTimeout,
+    HttpError,
+    IncompatibleClient,
+    NotFound,
+    Unsupported,
+)
+from fiddler3.schemas.custom_features import (  # noqa
+    CustomFeature,
+    Enrichment,
+    ImageEmbedding,
+    Multivariate,
+    TextEmbedding,
+    VectorFeature,
+)
+from fiddler3.schemas.dataset import EnvType  # noqa
+from fiddler3.schemas.deployment_params import DeploymentParams  # noqa
+from fiddler3.schemas.model_schema import ModelSchema  # noqa
+from fiddler3.schemas.model_spec import ModelSpec  # noqa
+from fiddler3.schemas.model_task_params import ModelTaskParams  # noqa
+from fiddler3.schemas.xai import (  # noqa
+    DatasetDataSource,
+    EventIdDataSource,
+    RowDataSource,
+    SqlSliceQueryDataSource,
+)
+from fiddler3.schemas.xai_params import XaiParams  # noqa
+from fiddler3.utils.logger import set_logging  # noqa
+
+__all__ = [
+    'Connection',
+    'ConnectionMixin',
+    'init',
+    # Constants
+    'AlertCondition',
+    'ArtifactStatus',
+    'ArtifactType',
+    'BaselineType',
+    'BinSize',
+    'CompareTo',
+    'DataType',
+    'DeploymentType',
+    'EnvType',
+    'ExplainMethod',
+    'JobStatus',
+    'ModelInputType',
+    'ModelTask',
+    'Priority',
+    'WindowSize',
+    # Schemas
+    'CustomFeature',
+    'DatasetDataSource',
+    'DeploymentParams',
+    'Enrichment',
+    'EventIdDataSource',
+    'ImageEmbedding',
+    'ModelSchema',
+    'ModelSpec',
+    'ModelTaskParams',
+    'Multivariate',
+    'RowDataSource',
+    'SqlSliceQueryDataSource',
+    'TextEmbedding',
+    'VectorFeature',
+    'XaiParams',
+    # Entities
+    'AlertRecord',
+    'AlertRule',
+    'Baseline',
+    'Dataset',
+    'File',
+    'Job',
+    'Model',
+    'ModelDeployment',
+    'Project',
+    'Webhook',
+    # Exceptions
+    'NotFound',
+    'Conflict',
+    'IncompatibleClient',
+    'AsyncJobFailed',
+    'Unsupported',
+    'HttpError',
+    'ConnectionTimeout',
+    'ConnectionError',
+    'ApiError',
+    # Utilities
+    'set_logging',
+]

fiddler3/configs.py

@@ -3,3 +3,6 @@ MIN_SERVER_VERSION = '23.7.0'  # @TODO: Change this before 3.0 release
 DEFAULT_PAGE_SIZE = 50
 JOB_POLL_INTERVAL = 3
 JOB_WAIT_TIMEOUT = 1800
+STREAM_EVENT_LIMIT = 1000
+DEFAULT_NUM_CLUSTERS = 5
+DEFAULT_NUM_TAGS = 5

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,10 +0,0 @@
-"""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
-from fiddler3.entities.project import Project  # noqa

fiddler3/entities/alert_rule.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import builtins
 from datetime import datetime
 from typing import Any, Iterator
 from uuid import UUID
@@ -10,7 +11,7 @@ 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
+from fiddler3.schemas.alert_rule import AlertRuleResp, NotificationConfig
 from fiddler3.schemas.filter_query import OperatorType, QueryCondition, QueryRule
 from fiddler3.utils.logger import get_logger
 
@@ -237,10 +238,86 @@ class AlertRule(
 
     @handle_api_error
     def disable_notifications(self) -> None:
-        """Diable notifications for an alert rule"""
+        """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/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):

fiddler3/entities/events.py

@@ -1,70 +1,94 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Any, Callable
+from typing import Any, Iterator
 from uuid import UUID
 
 import pandas as pd
 from requests import Response
 
+from fiddler3.configs import STREAM_EVENT_LIMIT
+from fiddler3.connection import ConnectionMixin
 from fiddler3.decorators import handle_api_error
-from fiddler3.entities.files import File
+from fiddler3.entities.file import File
 from fiddler3.entities.job import Job
 from fiddler3.schemas.dataset import EnvType
 from fiddler3.schemas.events import EventsSource, FileSource
 from fiddler3.schemas.job import JobCompactResp
 
-STREAM_EVENTS_MAX = 1000
 
+class EventPublisher(ConnectionMixin):
+    STREAM_LIMIT = STREAM_EVENT_LIMIT
 
-class EventMixin:
-    id: UUID | None
-    _client: Callable
+    def __init__(self, model_id: UUID) -> None:
+        """
+        Event publishing methods
+
+        :param model_id: Model identifier
+        """
+        self.model_id = model_id
+
+    def _get_stream_chunks(
+        self, source: pd.DataFrame | list[dict[str, Any]]
+    ) -> Iterator[list[dict[str, Any]]]:
+        """Chunk the source based on stream limit"""
+
+        for i in range(0, len(source), self.STREAM_LIMIT):
+            chunk = source[i : i + self.STREAM_LIMIT]
+
+            if isinstance(chunk, pd.DataFrame):
+                events = chunk.to_dict('records')
+            else:
+                events = chunk
+
+            yield events
 
     @handle_api_error
     def publish(
         self,
-        source: list[dict[Any, Any]] | str | Path | pd.DataFrame,
-        environment: EnvType,
+        source: list[dict[str, Any]] | str | Path | pd.DataFrame,
+        environment: EnvType = EnvType.PRODUCTION,
         dataset_name: str | None = None,
+        update: bool = False,
     ) -> list[UUID] | Job:
         """
         Publish Pre-production or Production data
 
-        :param source: source can be:
+        :param source: one of:
             Path or str path: path for data file.
-            list[dict]: list of event dicts. max_len=1000. EnvType.PRE_PRODUCTION not supported
+            list[dict]: list of event dicts (max 1000) EnvType.PRE_PRODUCTION is not supported
             dataframe: events dataframe. EnvType.PRE_PRODUCTION not supported.
-        :param environment: either EnvType.PRE_PRODUCTION or EnvType.PRODUCTION
-        :param dataset_name: name of the dataset. Not supported for EnvType.PRODUCTION
+        :param environment: Either EnvType.PRE_PRODUCTION or EnvType.PRODUCTION
+        :param dataset_name: Name of the dataset. Not supported for EnvType.PRODUCTION
+        :param update: flag indicating if the events are updates to previously published rows
 
         :return: list[UUID] for list of dicts or dataframe source and Job object for file path source.
         """
-        _sources = self._get_sources(source)
-        if isinstance(_sources, FileSource):
+        if isinstance(source, (str, Path)):
             return self._publish_file(
-                source=_sources,
+                source=source,
                 environment=environment,
                 dataset_name=dataset_name,
+                update=update,
             )
-        return self._publish_stream(
-            sources=_sources,
-            environment=environment,
-            dataset_name=dataset_name,
-        )
+
+        if isinstance(source, (list, pd.DataFrame)):
+            return self._publish_stream(source=source, update=update)
+
+        raise ValueError(f'Unsupported source - {type(source)}')
 
     def _publish_stream(
         self,
-        sources: list[EventsSource],
-        environment: EnvType,
-        dataset_name: str | None = None,
+        source: list[dict[str, Any]] | pd.DataFrame,
+        update: bool = False,
     ) -> list[UUID]:
         fiddler_ids = []
-        for _source in sources:
+        for events in self._get_stream_chunks(source=source):
             response = self._publish_call(
-                source=_source,
-                environment=environment,
-                dataset_name=dataset_name,
+                source=EventsSource(events=events),
+                environment=EnvType.PRODUCTION,
+                dataset_name=None,
+                update=update,
             )
             fiddler_ids.extend(response.json()['data']['fiddler_ids'])
 
@@ -72,48 +96,40 @@ class EventMixin:
 
     def _publish_file(
         self,
-        source: FileSource,
+        source: Path | str,
         environment: EnvType,
         dataset_name: str | None = None,
+        update: bool = False,
     ) -> Job:
+        file = File(path=Path(source)).upload()
+
+        assert file.id is not None
+
         response = self._publish_call(
-            source=source, environment=environment, dataset_name=dataset_name
+            source=FileSource(file_id=file.id),
+            environment=environment,
+            dataset_name=dataset_name,
+            update=update,
         )
         job_compact = JobCompactResp(**response.json()['data']['job'])
         return Job.get(id_=job_compact.id)
 
-    def _get_sources(
-        self, source: list[dict[str, Any]] | str | Path | pd.DataFrame
-    ) -> list[EventsSource] | FileSource:
-        _source = []
-        if isinstance(source, (str, Path)):
-            file = File(path=Path(source)).upload()
-            assert file.id is not None
-            return FileSource(file_id=file.id)
-
-        if isinstance(source, list):
-            _source.append(EventsSource(events=source))
-
-        elif isinstance(source, pd.DataFrame):
-            for event_dict in [
-                source[i : i + STREAM_EVENTS_MAX]
-                for i in range(0, source.shape[0], STREAM_EVENTS_MAX)
-            ]:
-                _source.append(EventsSource(events=event_dict.to_dict('records')))
-
-        return _source
-
     def _publish_call(
         self,
         source: FileSource | EventsSource,
         environment: EnvType,
         dataset_name: str | None = None,
+        update: bool = False,
     ) -> Response:
-        return self._client().post(
+        if update:
+            method = self._client().patch
+        else:
+            method = self._client().post
+        return method(
             url='/v3/events',
             data={
                 'source': source.dict(),
-                'model_id': self.id,
+                'model_id': self.model_id,
                 'env_type': environment,
                 'env_name': dataset_name,
             },