fiddler-client 3.1.0.dev1__py3-none-any.whl → 3.1.0.dev3__py3-none-any.whl

fiddler/VERSION

@@ -1 +1 @@
-3.1.0.dev1
+3.1.0.dev3

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/entities/alert_rule.py

@@ -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
@@ -84,7 +86,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,
         )
 
@@ -210,6 +213,7 @@ class AlertRule(
             '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,

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

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import builtins
-import copy
 import typing
 from dataclasses import dataclass
 from datetime import datetime
@@ -33,6 +32,7 @@ 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:
@@ -40,6 +40,9 @@ if typing.TYPE_CHECKING:
     from fiddler.entities.dataset import Dataset
 
 
+logger = get_logger(__name__)
+
+
 class Model(
     BaseEntity,
     CreatedByMixin,
@@ -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=self.schema,
+            spec=self.spec,
+            version=version if version else self.version,
+            input_type=self.input_type,
+            task=self.task,
+            task_params=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=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,
@@ -548,6 +561,7 @@ class Model(
 class ModelCompact:
     id: UUID
     name: str
+    version: str | None = None
 
     def fetch(self) -> Model:
         """Fetch model instance"""
@@ -565,4 +579,8 @@ class ModelCompactMixin:
                 'response.'
             )
 
-        return ModelCompact(id=response.model.id, name=response.model.name)
+        return ModelCompact(
+            id=response.model.id,
+            name=response.model.name,
+            version=response.model.version,
+        )

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/schemas/alert_rule.py

@@ -7,6 +7,7 @@ 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
 
@@ -17,14 +18,14 @@ class AlertRuleResp(BaseModel):
     model: ModelCompactResp
     project: ProjectCompactResp
     baseline: Optional[BaselineCompactResp]
+    segment: Optional[SegmentCompactResp]
     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]
+    columns: Optional[List[str]] = Field(alias='feature_names')
     compare_bin_delta: Optional[int]
     warning_threshold: Optional[float]
 

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

fiddler/schemas/custom_features.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Optional, Type, TypeVar
+from typing import Any, Dict, List, Optional, Type, TypeVar, Literal
 
 from pydantic import BaseModel, validator
 
@@ -10,18 +10,12 @@ CustomFeatureTypeVar = TypeVar('CustomFeatureTypeVar', bound='CustomFeature')
 
 class CustomFeature(BaseModel):
     name: str
-    type: CustomFeatureType
-    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
+    type: Any
 
     class Config:
         allow_mutation = False
+        use_enum_values = True
+        discriminator = 'type'
 
     @classmethod
     def from_columns(
@@ -53,12 +47,13 @@ class CustomFeature(BaseModel):
         return_dict: Dict[str, Any] = {
             'name': self.name,
             'type': self.type.value,
-            'n_clusters': self.n_clusters,
         }
         if isinstance(self, Multivariate):
             return_dict['columns'] = self.columns
+            return_dict['n_clusters'] = self.n_clusters
         elif isinstance(self, VectorFeature):
             return_dict['column'] = self.column
+            return_dict['n_clusters'] = self.n_clusters
             if isinstance(self, (ImageEmbedding, TextEmbedding)):
                 return_dict['source_column'] = self.source_column
                 if isinstance(self, TextEmbedding):
@@ -74,7 +69,9 @@ class CustomFeature(BaseModel):
 
 
 class Multivariate(CustomFeature):
-    type: CustomFeatureType = CustomFeatureType.FROM_COLUMNS
+    type: Literal['FROM_COLUMNS'] = CustomFeatureType.FROM_COLUMNS.value
+    n_clusters: Optional[int] = DEFAULT_NUM_CLUSTERS
+    centroids: Optional[List] = None
     columns: List[str]
     monitor_components: bool = False
 
@@ -84,22 +81,31 @@ class Multivariate(CustomFeature):
             raise ValueError('Multivariate columns must be greater than 1')
         return value
 
+    @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 VectorFeature(CustomFeature):
-    type: CustomFeatureType = CustomFeatureType.FROM_VECTOR
-    source_column: Optional[str] = None
+    type: Literal['FROM_VECTOR'] = CustomFeatureType.FROM_VECTOR.value
+    n_clusters: Optional[int] = DEFAULT_NUM_CLUSTERS
+    centroids: Optional[List] = None
     column: str
 
+    @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 TextEmbedding(VectorFeature):
-    type: CustomFeatureType = CustomFeatureType.FROM_TEXT_EMBEDDING
+    type: Literal['FROM_TEXT_EMBEDDING'] = CustomFeatureType.FROM_TEXT_EMBEDDING.value  # type: ignore
+    source_column: str
     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
+    tf_idf: Optional[Dict[str, List]] = None
 
     @validator('n_tags')
     def validate_n_tags(cls, value: int) -> int:  # noqa: N805
@@ -109,13 +115,8 @@ class TextEmbedding(VectorFeature):
 
 
 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
+    type: Literal['FROM_IMAGE_EMBEDDING'] = CustomFeatureType.FROM_IMAGE_EMBEDDING.value  # type: ignore
+    source_column: str
 
 
 class Enrichment(CustomFeature):
@@ -134,7 +135,7 @@ class Enrichment(CustomFeature):
     """
 
     # Setting the feature type to ENRICHMENT
-    type: CustomFeatureType = CustomFeatureType.ENRICHMENT
+    type: Literal['ENRICHMENT'] = CustomFeatureType.ENRICHMENT.value
 
     # List of input column names used to generate the enrichment
     columns: List[str]

fiddler/schemas/model.py

@@ -17,6 +17,7 @@ from fiddler.schemas.xai_params import XaiParams
 class ModelCompactResp(BaseModel):
     id: UUID
     name: str
+    version: Optional[str]
 
 
 class ModelResp(BaseModel):

fiddler/schemas/model_spec.py

@@ -1,8 +1,8 @@
-from typing import List
+from typing import List, Union
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
-from fiddler.schemas.custom_features import CustomFeature
+from fiddler.schemas.custom_features import Multivariate, VectorFeature, TextEmbedding, ImageEmbedding, Enrichment
 
 
 class ModelSpec(BaseModel):
@@ -11,20 +11,22 @@ class ModelSpec(BaseModel):
     schema_version: int = 1
     """Schema version"""
 
-    inputs: List[str] = []
+    inputs: List[str] = Field(default_factory=list)
     """Feature columns"""
 
-    outputs: List[str] = []
+    outputs: List[str] = Field(default_factory=list)
     """Prediction columns"""
 
-    targets: List[str] = []
+    targets: List[str] = Field(default_factory=list)
     """Label columns"""
 
-    decisions: List[str] = []
+    decisions: List[str] = Field(default_factory=list)
     """Decisions columns"""
 
-    metadata: List[str] = []
+    metadata: List[str] = Field(default_factory=list)
     """Metadata columns"""
 
-    custom_features: List[CustomFeature] = []
+    custom_features: List[Union[Multivariate, VectorFeature, TextEmbedding, ImageEmbedding, Enrichment]] = Field(
+        default_factory=list
+    )
     """Custom feature definitions"""

fiddler/tests/apis/test_alert_rule.py

@@ -28,54 +28,61 @@ from fiddler.utils.logger import set_logging
 
 API_RESPONSE_200 = {
     'data': {
-        'feature_names': ['age'],
-        'id': 620,
-        'created_at': '2023-11-28T08:04:12.651937+00:00',
+        'id': 794,
         'organization_name': 'mainbuild',
-        'compare_period': None,
-        'time_bucket': 3600000,
-        'alert_type': 'data_integrity',
-        'metric_display_name': 'Missing Value Violation',
-        'enable_notification': True,
-        'last_updated': '2023-11-28T08:04:12.653346+00:00',
-        'alert_type_display_name': 'Data Integrity',
-        'critical_threshold': 0.0,
+        'project_name': PROJECT_NAME,
+        'model_id': 285,
+        'name': 'test_rule',
+        'metric': 'jsd',
+        'metric_id': 'jsd',
+        'metric_display_name': 'Jensen-Shannon Distance',
+        'alert_type': 'drift',
+        'alert_type_display_name': 'Data Drift',
+        'priority': 'MEDIUM',
         'baseline_name': BASELINE_NAME,
-        'baseline': {
-            'id': BASELINE_ID,
-            'name': BASELINE_NAME,
-        },
+        'feature_names': ['creditscore'],
+        'time_bucket': 3600000,
+        'category': None,
+        'bin_size': 'Hour',
+        'compare_to': 'raw_value',
         'condition': 'greater',
-        'uuid': ALERT_RULE_ID,
-        'segment': None,
-        'warning_threshold': None,
-        'name': 'Age Missing 1 Hr',
-        'model_name': MODEL_NAME,
-        'model': {
-            'id': MODEL_ID,
-            'name': MODEL_NAME,
-        },
+        'compare_period': None,
+        'warning_threshold': 1.0,
+        'critical_threshold': 2.3,
         'is_active': True,
         'created_by': 'admin@fiddler.ai',
-        'bin_size': 'Hour',
-        'category': None,
-        'project_name': PROJECT_NAME,
-        'project': {
-            'id': PROJECT_ID,
-            'name': PROJECT_NAME,
+        'created_at': '2024-04-23T10:34:14.321895+00:00',
+        'last_updated': '2024-04-23T10:34:14.323554+00:00',
+        'model_name': 'bank_churn',
+        'enable_notification': True,
+        'segment': {
+            'id': '1c9b551a-808b-4ef0-b67b-e788eaf1e6de',
+            'organization_name': 'mainbuild',
+            'project_name': 'nick_test_project_11',
+            'model_name': 'bank_churn',
+            'name': 'xyzab',
+            'definition': 'Age > 10',
+            'description': 'meh',
+            'created_at': '2024-04-23T10:31:52.181550+00:00',
+            'created_by': {
+                'id': 1,
+                'full_name': 'Fiddler Administrator',
+                'email': 'admin@fiddler.ai',
+            },
         },
-        'metric': 'null_violation_count',
-        'metric_id': 'null_violation_count',
-        'compare_to': 'raw_value',
-        'priority': 'HIGH',
+        'project': {'id': PROJECT_ID, 'name': PROJECT_NAME},
+        'model': {'id': MODEL_ID, 'name': MODEL_NAME, 'version': 'v1'},
+        'baseline': {'id': BASELINE_ID, 'name': BASELINE_NAME},
+        'compare_bin_delta': None,
+        'uuid': ALERT_RULE_ID,
         'notifications': {
-            'emails': {'alert_config_uuid': ALERT_RULE_ID, 'email': 'admin@fiddler.ai'},
             'pagerduty': {
-                'severity': '',
                 'alert_config_uuid': ALERT_RULE_ID,
                 'service': '',
+                'severity': '',
             },
-            'webhooks': [{'uuid': 'e20bf4cc-d2cf-4540-baef-d96913b14f1b'}],
+            'emails': {'email': ''},
+            'webhooks': [],
         },
     },
     'api_version': '2.0',

fiddler/tests/apis/test_mixin.py

@@ -20,6 +20,7 @@ from fiddler.tests.constants import (
     DATASET_NAME,
     MODEL_ID,
     MODEL_NAME,
+    MODEL_VERSION,
     PROJECT_ID,
     PROJECT_NAME,
     USER_EMAIL,
@@ -39,7 +40,9 @@ class DummyEntity(
     def __init__(self) -> None:
         self._resp = mock.MagicMock()
         self._resp.project = ProjectCompactResp(id=PROJECT_ID, name=PROJECT_NAME)
-        self._resp.model = ModelCompactResp(id=MODEL_ID, name=MODEL_NAME)
+        self._resp.model = ModelCompactResp(
+            id=MODEL_ID, name=MODEL_NAME, version=MODEL_VERSION
+        )
         self._resp.dataset = DatasetCompactResp(
             id=DATASET_ID, name=DATASET_NAME, type=EnvType.PRE_PRODUCTION
         )

fiddler/tests/apis/test_model.py

@@ -471,6 +471,7 @@ def test_model_list_success() -> None:
     models = Model.list(project_id=PROJECT_ID)
     for model in models:
         assert isinstance(model, ModelCompact)
+        assert model.version is not None
 
 
 @responses.activate
@@ -654,12 +655,18 @@ def test_model_duplicate() -> None:
     model = Model.get(id_=MODEL_ID)
 
     assert model.id == UUID(MODEL_ID)
+    assert model._event_publisher.model_id == model.id
 
     # Without version parameter
     model_copy = model.duplicate()
+
     assert model_copy.id is None
     assert model_copy.version == model.version
 
+    with pytest.raises(AssertionError):
+        # since id is None
+        _ = model_copy._event_publisher
+
     # With version parameter
     new_version = 'v2'
     model_copy = model.duplicate(version=new_version)