fiddler-client 3.1.0.dev2__tar.gz → 3.1.0.dev4__tar.gz

{fiddler-client-3.1.0.dev2/fiddler_client.egg-info → fiddler_client-3.1.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fiddler-client
-Version: 3.1.0.dev2
+Version: 3.1.0.dev4
 Summary: Python client for Fiddler Platform
 Home-page: https://fiddler.ai
 Author: Fiddler Labs
@@ -20,6 +20,7 @@ Requires-Dist: tqdm
 Requires-Dist: simplejson>=3.17.0
 Requires-Dist: pyarrow>=7.0.0
 Requires-Dist: pyyaml
+Requires-Dist: typing-extensions<=4.5.0
 
 Fiddler Client
 =============

fiddler_client-3.1.0.dev4/fiddler/VERSION

@@ -0,0 +1 @@
+3.1.0.dev4

{fiddler-client-3.1.0.dev2 → fiddler_client-3.1.0.dev4}/fiddler/__init__.py

@@ -61,6 +61,7 @@ from fiddler.schemas.xai import (  # noqa
     SqlSliceQueryDataSource,
 )
 from fiddler.schemas.xai_params import XaiParams  # noqa
+from fiddler.utils.helpers import group_by  # noqa
 from fiddler.utils.logger import set_logging  # noqa
 from fiddler.version import __version__  # noqa
 
@@ -141,4 +142,5 @@ __all__ = [
     'ApiError',
     # Utilities
     'set_logging',
+    'group_by',
 ]

{fiddler-client-3.1.0.dev2 → fiddler_client-3.1.0.dev4}/fiddler/entities/alert_rule.py

@@ -8,8 +8,8 @@ from uuid import UUID
 from fiddler.constants.alert_rule import AlertCondition, BinSize, CompareTo, Priority
 from fiddler.decorators import handle_api_error
 from fiddler.entities.base import BaseEntity
-from fiddler.entities.baseline import Baseline, BaselineCompactMixin
-from fiddler.entities.model import Model, ModelCompactMixin
+from fiddler.entities.baseline import BaselineCompactMixin
+from fiddler.entities.model import ModelCompactMixin
 from fiddler.entities.project import ProjectCompactMixin
 from fiddler.schemas.alert_rule import AlertRuleResp, NotificationConfig
 from fiddler.schemas.filter_query import OperatorType, QueryCondition, QueryRule
@@ -34,6 +34,7 @@ class AlertRule(
         warning_threshold: float | None = None,
         columns: list[str] | None = None,
         baseline_id: UUID | str | None = None,
+        segment_id: UUID | str | None = None,
         compare_bin_delta: int | None = None,
     ) -> None:
         """Construct a alert rule instance."""
@@ -49,6 +50,7 @@ class AlertRule(
         self.critical_threshold = critical_threshold
         self.condition = condition
         self.bin_size = bin_size
+        self.segment_id = segment_id
 
         self.id: UUID | None = None
         self.project_id: UUID | None = None
@@ -61,6 +63,12 @@ class AlertRule(
 
     @staticmethod
     def _get_url(id_: UUID | str | None = None) -> str:
+        """Get model resource/item url."""
+        url = '/v3/alert-rules'
+        return url if not id_ else f'{url}/{id_}'
+
+    @staticmethod
+    def _get_url_v2(id_: UUID | str | None = None) -> str:
         """Get model resource/item url."""
         url = '/v2/alert-configs'
         return url if not id_ else f'{url}/{id_}'
@@ -76,7 +84,7 @@ class AlertRule(
         instance = cls(
             name=resp_obj.name,
             model_id=resp_obj.model.id,
-            metric_id=resp_obj.metric_id,
+            metric_id=resp_obj.metric.id,
             priority=resp_obj.priority,
             compare_to=resp_obj.compare_to,
             condition=resp_obj.condition,
@@ -84,7 +92,8 @@ class AlertRule(
             critical_threshold=resp_obj.critical_threshold,
             warning_threshold=resp_obj.warning_threshold,
             columns=resp_obj.columns,
-            baseline_id=resp_obj.baseline_id,
+            baseline_id=resp_obj.baseline.id if resp_obj.baseline else None,
+            segment_id=resp_obj.segment.id if resp_obj.segment else None,
             compare_bin_delta=resp_obj.compare_bin_delta,
         )
 
@@ -110,11 +119,11 @@ class AlertRule(
         # Reset properties
         self.model_id = resp_obj.model.id
         self.project_id = resp_obj.project.id
+        self.metric_id = resp_obj.metric.id
 
         # Add remaining fields
         fields = [
             'id',
-            'metric_id',
             'created_at',
             'updated_at',
         ]
@@ -176,7 +185,9 @@ class AlertRule(
         if columns:
             for column in columns:
                 rules.append(
-                    QueryRule(field='columns', operator=OperatorType.ANY, value=column)
+                    QueryRule(
+                        field='feature_names', operator=OperatorType.ANY, value=column
+                    )
                 )
 
         _filter = QueryCondition(rules=rules)
@@ -185,7 +196,6 @@ class AlertRule(
         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)
 
@@ -199,26 +209,22 @@ class AlertRule(
     @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,
+            'model_id': self.model_id,
             'metric_id': self.metric_id,
             'priority': self.priority,
             'compare_to': self.compare_to,
             'condition': self.condition,
             'bin_size': self.bin_size,
+            'segment_id': self.segment_id,
             'critical_threshold': self.critical_threshold,
             'warning_threshold': self.warning_threshold,
             'feature_names': self.columns,
             'compare_bin_delta': self.compare_bin_delta,
-            'notifications': self._get_notifications_dict(),
         }
         if self.baseline_id:
-            baseline = Baseline.get(self.baseline_id)
-            payload['baseline_name'] = baseline.name
+            payload['baseline_id'] = self.baseline_id
 
         response = self._client().post(
             url=self._get_url(),
@@ -232,7 +238,7 @@ class AlertRule(
     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}
+            url=self._get_url_v2(id_=self.id), data={'enable_notification': True}
         )
         logger.info(
             'Notifications have been enabled for alert rule with id: %s', self.id
@@ -242,7 +248,7 @@ class AlertRule(
     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}
+            url=self._get_url_v2(id_=self.id), data={'enable_notification': False}
         )
         logger.info(
             'Notifications have been disabled for alert rule with id: %s', self.id
@@ -273,7 +279,7 @@ class AlertRule(
             webhooks=webhooks,
         )
         response = self._client().patch(
-            url=self._get_url(id_=self.id),
+            url=self._get_url_v2(id_=self.id),
             data={'notifications': notifications},
         )
 
@@ -289,7 +295,7 @@ class AlertRule(
         :return: NotificationConfig object
         """
 
-        response = self._client().get(url=self._get_url(id_=self.id))
+        response = self._client().get(url=self._get_url_v2(id_=self.id))
 
         return self._get_notifications_from_dict(
             response.json()['data']['notifications']

{fiddler-client-3.1.0.dev2 → fiddler_client-3.1.0.dev4}/fiddler/entities/events.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import tempfile
 from pathlib import Path
-from typing import Any
+from typing import Any, Callable
 from uuid import UUID
 
 import pandas as pd
@@ -17,6 +17,9 @@ from fiddler.entities.job import Job
 from fiddler.schemas.dataset import EnvType
 from fiddler.schemas.events import EventsSource, FileSource
 from fiddler.schemas.job import JobCompactResp
+from fiddler.utils.logger import get_logger
+
+logger = get_logger(__name__)
 
 
 class EventPublisher(ConnectionMixin):
@@ -51,40 +54,72 @@ class EventPublisher(ConnectionMixin):
 
         :return: list[UUID] for list of dicts source and Job object for file path or dataframe source.
         """
+
+        publish_method = self._get_publish_method(source=source)
+
+        return publish_method(
+            source=source,
+            environment=environment,
+            dataset_name=dataset_name,
+            update=update,
+        )
+
+    def _get_publish_method(
+        self, source: list[dict[str, Any]] | str | Path | pd.DataFrame
+    ) -> Callable:
         if isinstance(source, (str, Path)):
-            return self._publish_file(
-                source=source,
-                environment=environment,
-                dataset_name=dataset_name,
-                update=update,
-            )
+            return self._publish_file
 
         if isinstance(source, pd.DataFrame):
-            with tempfile.NamedTemporaryFile(suffix='.csv') as temp_file:
-                source.to_csv(temp_file.name, index=False)
+            return self._publish_df
+
+        if isinstance(source, list):
+            return self._publish_stream
+
+        raise ValueError(f'Unsupported source - {type(source)}')
+
+    def _publish_df(
+        self,
+        source: pd.DataFrame,
+        environment: EnvType,
+        dataset_name: str | None = None,
+        update: bool = False,
+    ) -> Job:
+        with tempfile.NamedTemporaryFile(suffix='.parquet') as temp_file:
+            try:
+                source.to_parquet(temp_file.name, index=False)
                 return self._publish_file(
                     source=temp_file.name,
                     environment=environment,
                     dataset_name=dataset_name,
                     update=update,
                 )
-
-        elif isinstance(source, list):
-            return self._publish_stream(source=source, update=update)
-
-        raise ValueError(f'Unsupported source - {type(source)}')
+            except Exception:
+                logger.warning(
+                    'Failed to convert input dataframe to parquet format. Retrying as a CSV file.'
+                )
+        with tempfile.NamedTemporaryFile(suffix='.csv') as temp_file:
+            source.to_csv(temp_file.name, index=False)
+            return self._publish_file(
+                source=temp_file.name,
+                environment=environment,
+                dataset_name=dataset_name,
+                update=update,
+            )
 
     def _publish_stream(
         self,
         source: list[dict[str, Any]],
+        environment: EnvType = EnvType.PRODUCTION,
+        dataset_name: str | None = None,
         update: bool = False,
     ) -> list[UUID]:
         event_ids = []
         for i in tqdm(range(0, len(source), self.STREAM_LIMIT)):
             response = self._publish_call(
                 source=EventsSource(events=source[i : i + self.STREAM_LIMIT]),
-                environment=EnvType.PRODUCTION,
-                dataset_name=None,
+                environment=environment,
+                dataset_name=dataset_name,
                 update=update,
             )
             event_ids.extend(response.json()['data']['event_ids'])

{fiddler-client-3.1.0.dev2 → fiddler_client-3.1.0.dev4}/fiddler/entities/model.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
 import builtins
-import copy
 import typing
+from copy import deepcopy
 from dataclasses import dataclass
 from datetime import datetime
 from functools import cached_property
@@ -33,12 +33,15 @@ from fiddler.schemas.model_spec import ModelSpec
 from fiddler.schemas.model_task_params import ModelTaskParams
 from fiddler.schemas.xai_params import XaiParams
 from fiddler.utils.helpers import raise_not_found
+from fiddler.utils.logger import get_logger
 from fiddler.utils.model_generator import ModelGenerator
 
 if typing.TYPE_CHECKING:
     from fiddler.entities.baseline import Baseline
     from fiddler.entities.dataset import Dataset
 
+logger = get_logger(__name__)
+
 
 class Model(
     BaseEntity,
@@ -307,7 +310,9 @@ class Model(
         params = {'filter': _filter.json()}
 
         for model in cls._paginate(url=cls._get_url(), params=params):
-            yield ModelCompact(id=model['id'], name=model['name'])
+            yield ModelCompact(
+                id=model['id'], name=model['name'], version=model['version']
+            )
 
     def duplicate(self, version: str | None = None) -> Model:
         """
@@ -319,13 +324,21 @@ class Model(
         :param version: Version name for the new instance
         :return: Model instance
         """
-        self_copy = copy.deepcopy(self)
-        self_copy.id = None
-
-        if version:
-            self_copy.version = version
-
-        return self_copy
+        return Model(
+            name=self.name,
+            project_id=self.project_id,
+            schema=deepcopy(self.schema),
+            spec=deepcopy(self.spec),
+            version=version if version else self.version,
+            input_type=self.input_type,
+            task=self.task,
+            task_params=deepcopy(self.task_params),
+            description=self.description,
+            event_id_col=self.event_id_col,
+            event_ts_col=self.event_ts_col,
+            event_ts_format=self.event_ts_format,
+            xai_params=deepcopy(self.xai_params),
+        )
 
     @property
     def datasets(self) -> Iterator[Dataset]:
@@ -456,7 +469,7 @@ class Model(
         :return: list[UUID] for list of dicts or dataframe source and Job object for
             file path source.
         """
-
+        logger.info('Model[%s/%s] - Publishing events', self.name, self.version)
         return self._event_publisher.publish(
             source=source,
             environment=environment,

{fiddler-client-3.1.0.dev2 → fiddler_client-3.1.0.dev4}/fiddler/entities/model_deployment.py

@@ -6,7 +6,9 @@ from uuid import UUID
 
 from fiddler.decorators import handle_api_error
 from fiddler.entities.base import BaseEntity
+from fiddler.entities.job import Job
 from fiddler.entities.project import ProjectCompactMixin
+from fiddler.schemas.job import JobCompactResp
 from fiddler.schemas.model_deployment import ModelDeploymentResponse
 from fiddler.utils.logger import get_logger
 
@@ -94,7 +96,7 @@ class ModelDeployment(
         self._resp = resp_obj
 
     @handle_api_error
-    def update(self) -> None:
+    def update(self) -> Job:
         """Update an existing model deployment."""
         payload: dict[str, Any] = {'active': self.active}
         if self.replicas is not None:
@@ -108,6 +110,8 @@ class ModelDeployment(
             url=self._get_url(model_id=self.model_id), data=payload
         )
         self._refresh_from_response(response=response)
+        job_compact = JobCompactResp(**response.json()['data']['job'])
+        return Job.get(id_=job_compact.id)
 
     @classmethod
     def of(cls, model_id: UUID | str) -> ModelDeployment:

{fiddler-client-3.1.0.dev2 → fiddler_client-3.1.0.dev4}/fiddler/entities/webhook.py

@@ -6,7 +6,9 @@ from uuid import UUID
 
 from fiddler.decorators import handle_api_error
 from fiddler.entities.base import BaseEntity
+from fiddler.schemas.filter_query import OperatorType, QueryCondition, QueryRule
 from fiddler.schemas.webhook import WebhookProvider, WebhookResp
+from fiddler.utils.helpers import raise_not_found
 
 
 class Webhook(BaseEntity):
@@ -81,6 +83,22 @@ class Webhook(BaseEntity):
         response = cls._client().get(url=cls._get_url(id_))
         return cls._from_response(response=response)
 
+    @classmethod
+    @handle_api_error
+    def from_name(cls, name: str) -> Webhook:
+        """Get the webhook instance using webhook name"""
+        _filter = QueryCondition(
+            rules=[QueryRule(field='name', operator=OperatorType.EQUAL, value=name)]
+        )
+
+        response = cls._client().get(
+            url=cls._get_url(), params={'filter': _filter.json()}
+        )
+        if response.json()['data']['total'] == 0:
+            raise_not_found('Webhook not found for the given identifier')
+
+        return cls._from_dict(data=response.json()['data']['items'][0])
+
     @classmethod
     @handle_api_error
     def list(cls) -> Iterator[Webhook]:

{fiddler-client-3.1.0.dev2 → fiddler_client-3.1.0.dev4}/fiddler/packtools/template_model.py

@@ -36,7 +36,8 @@ class TemplateKerasTF2Model:
         :param hybrid: Boolean value for hybrid data type (for example matrices). Default to False.
         """
         import tensorflow as tf
-        from packtools.keras_ig_helpers import ComputeGradientsKerasTF2
+
+        from fiddler.packtools.keras_ig_helpers import ComputeGradientsKerasTF2
 
         embedding_names = embedding_names or []
         batch_input_shape_list = batch_input_shape_list or []
@@ -197,7 +198,7 @@ class TemplateTreeShap:
         :return: explanations_by_output and extras_by_output: two dictionaries with keys the output columns and values
                  the corresponding explanations and extra information necessary
         """
-        from packtools.project_attributions_helpers import TreeShapAttributions
+        from fiddler.packtools.project_attributions_helpers import TreeShapAttributions
 
         if explanation_name != self.tree_shap_explanations:
             raise NotImplementedError(

{fiddler-client-3.1.0.dev2 → fiddler_client-3.1.0.dev4}/fiddler/schemas/alert_rule.py

@@ -7,29 +7,38 @@ from pydantic import Field
 from fiddler.constants.alert_rule import AlertCondition, BinSize, CompareTo, Priority
 from fiddler.schemas.base import BaseModel
 from fiddler.schemas.baseline import BaselineCompactResp
+from fiddler.schemas.custom_expression import SegmentCompactResp
 from fiddler.schemas.model import ModelCompactResp
 from fiddler.schemas.project import ProjectCompactResp
 
 
+class MetricResp(BaseModel):
+    id: Union[str, UUID]
+    display_name: str
+    type: str
+    type_display_name: str
+
+
 class AlertRuleResp(BaseModel):
-    id: UUID = Field(alias='uuid')
+    id: UUID
     name: str
-    model: ModelCompactResp
-    project: ProjectCompactResp
-    baseline: Optional[BaselineCompactResp]
     priority: Union[str, Priority]
     compare_to: Union[str, CompareTo]
-    metric_id: Union[str, UUID]
-    critical_threshold: float
     condition: Union[str, AlertCondition]
-    bin_size: Union[str, BinSize]
-    columns: Optional[List[str]]
-    baseline_id: Optional[UUID]
     compare_bin_delta: Optional[int]
+    bin_size: Union[str, BinSize]
+    columns: Optional[List[str]] = Field(alias='feature_names')
+    critical_threshold: float
     warning_threshold: Optional[float]
 
     created_at: datetime
-    updated_at: datetime = Field(alias='last_updated')
+    updated_at: datetime
+
+    metric: MetricResp
+    model: ModelCompactResp
+    project: ProjectCompactResp
+    baseline: Optional[BaselineCompactResp]
+    segment: Optional[SegmentCompactResp]
 
 
 class NotificationConfig(BaseModel):

{fiddler-client-3.1.0.dev2 → fiddler_client-3.1.0.dev4}/fiddler/schemas/custom_expression.py

@@ -29,3 +29,10 @@ class CustomMetricResp(CustomExpressionResp):
 
 class SegmentResp(CustomExpressionResp):
     """Segment response object"""
+
+
+class SegmentCompactResp(BaseModel):
+    """Segment compact response object"""
+
+    id: UUID
+    name: str