fiddler-client 2.0.0.dev8__py3-none-any.whl → 2.0.0.dev10__py3-none-any.whl

fiddler/__init__.py

@@ -10,6 +10,11 @@ TODO: Add Licence.
 from fiddler import utils
 from fiddler._version import __version__
 from fiddler.api import FiddlerApi, FiddlerClient
+from fiddler.api.explainability_mixin import (
+    DatasetDataSource,
+    RowDataSource,
+    SqlSliceQueryDataSource,
+)
 from fiddler.constants import CSV_EXTENSION
 from fiddler.core_objects import (
     ArtifactStatus,
@@ -18,7 +23,6 @@ from fiddler.core_objects import (
     Column,
     DatasetInfo,
     DataType,
-    DeploymentType,
     ExplanationMethod,
     FiddlerPublishSchema,
     FiddlerTimestamp,
@@ -29,8 +33,18 @@ from fiddler.core_objects import (
     WindowSize,
 )
 from fiddler.packtools import gem
-from fiddler.schemas.custom_features import Multivariate, TextEmbedding, ImageEmbedding
-from fiddler.utils import logger, ColorLogger
+from fiddler.schema.alert import (
+    AlertCondition,
+    AlertType,
+    BinSize,
+    ComparePeriod,
+    CompareTo,
+    Metric,
+    Priority,
+)
+from fiddler.schema.model_deployment import DeploymentParams, DeploymentType
+from fiddler.schemas.custom_features import CustomFeature, ImageEmbedding, Multivariate, TextEmbedding, VectorFeature, CustomFeatureType
+from fiddler.utils import ColorLogger, logger
 from fiddler.utils.validator import (
     PackageValidator,
     ValidationChainSettings,
@@ -46,12 +60,17 @@ __all__ = [
     '__version__',
     'BatchPublishType',
     'Column',
+    'CustomFeature',
+    'CustomFeatureType',
     'Multivariate',
+    'VectorFeature',
     'TextEmbedding',
     'ImageEmbedding',
     'ColorLogger',
     'DatasetInfo',
     'DataType',
+    'DeploymentParams',
+    'DeploymentType',
     'FiddlerClient',
     'FiddlerApi',
     'FiddlerTimestamp',

fiddler/_version.py

@@ -1 +1 @@
-__version__ = '2.0.0.dev8'
+__version__ = '2.0.0.dev10'

fiddler/api/alert_mixin.py

@@ -35,7 +35,7 @@ class AlertMixin:
     FILTER_ALERT_RULES_API_VERSION = '>=23.1.0'
     GROUP_OF_COLUMNS_API_VERSION = '>=23.3.0'
     RULE_V3_API_VERSION = '>=23.4.0'
-
+    
     client: RequestClient
     organization_name: str
 
@@ -54,6 +54,7 @@ class AlertMixin:
         alert_type: Optional[AlertType] = None,
         baseline_name: Optional[str] = None,
         compare_period: Optional[ComparePeriod] = None,
+        column: Optional[str] = None,
         columns: Optional[List[str]] = None,
         warning_threshold: Optional[float] = None,
         project_name: str = None,
@@ -120,19 +121,13 @@ class AlertMixin:
         :param condition: Select from:
                 1) AlertCondition.LESSER
                 2) AlertCondition.GREATER
+        :param column: column name on which alert rule is to be created. Supported by server version 23.3.0 or lower.
         :param columns: List of column names on which alert rule is to be created. It can take ['__ANY__'] to check for all columns
         :param notifications_config: notifications config object created using helper method build_notifications_config()
         :param baseline_name: Name of the baselne, whose histogram is compared against the same derived from current data.
                             Used only when alert type is AlertType.DATA_DRIFT.
         :return: created alert rule object
-        """
-        if columns and not match_semver(
-            self.server_info.server_version, self.GROUP_OF_COLUMNS_API_VERSION
-        ):
-            raise ValueError(
-                f'columns parameter works with server version {self.GROUP_OF_COLUMNS_API_VERSION}'
-            )
-
+        """                        
         project_name = project_id_compat(
             project_id=project_id, project_name=project_name
         )
@@ -154,7 +149,7 @@ class AlertMixin:
         if compare_period and compare_period not in ComparePeriod.keys():
             raise ValueError(f'compare_period should be one of{ComparePeriod.keys()}')
 
-        request_body = AlertRulePayload(
+        alert_rule_payload = AlertRulePayload(
             organization_name=self.organization_name,
             project_name=project_name,
             model_name=model_name,
@@ -166,14 +161,41 @@ class AlertMixin:
             compare_period=compare_period,
             priority=priority,
             baseline_name=baseline_name,
-            feature_names=columns,
             warning_threshold=warning_threshold,
             critical_threshold=critical_threshold,
             condition=condition,
             time_bucket=bin_size.value[0],
             bin_size=bin_size.value[1],
             notifications=notifications_config,
-        ).dict()
+        )
+
+        if columns and not match_semver(
+            self.server_info.server_version, self.GROUP_OF_COLUMNS_API_VERSION
+        ):
+            raise ValueError(
+                f'columns parameter works with server version {self.GROUP_OF_COLUMNS_API_VERSION}'
+            )
+
+        if match_semver(self.server_info.server_version, self.GROUP_OF_COLUMNS_API_VERSION):
+            if columns:
+                if match_semver(self.server_info.server_version, self.RULE_V3_API_VERSION):
+                    alert_rule_payload.feature_names=columns
+                else:
+                    # version 23.3 support columns is comma separated string
+                    alert_rule_payload.feature_names=",".join(columns)
+            elif column:
+                if match_semver(self.server_info.server_version, self.RULE_V3_API_VERSION):
+                    alert_rule_payload.feature_names=[column]
+                else:
+                    alert_rule_payload.feature_names=column
+        else:
+            # we do not support columns in server version < 23.3
+            if columns:
+                raise ValueError(f'columns is not supported in the server version {self.server_info.server_version}. Please use column instead.')
+            if column:
+                alert_rule_payload.feature_name=column
+
+        request_body = alert_rule_payload.dict()
         response = self.client.post(
             url='alert-configs',
             data=request_body,

fiddler/api/api.py

@@ -15,6 +15,7 @@ from fiddler.api.job_mixin import JobMixin
 from fiddler.api.model_deployment_mixin import ModelDeploymentMixin
 from fiddler.api.model_mixin import ModelMixin
 from fiddler.api.project_mixin import ProjectMixin
+from fiddler.api.webhooks_mixin import WebhookMixin
 from fiddler.constants import (
     CURRENT_API_VERSION,
     FIDDLER_CLIENT_VERSION_HEADER,
@@ -41,6 +42,7 @@ class FiddlerClient(
     ExplainabilityMixin,
     ModelDeploymentMixin,
     GenerateSchemaMixin,
+    WebhookMixin
 ):
     def __init__(
         self,

fiddler/api/events_mixin.py

@@ -14,11 +14,12 @@ from fiddler.exceptions import HttpException
 from fiddler.libs.http_client import RequestClient
 from fiddler.schema.events import EventIngest, EventsIngest
 from fiddler.utils.compatibility_helpers import (
-    project_id_compat,
     model_id_compat,
+    project_id_compat,
     update_event_compat,
 )
 from fiddler.utils.decorators import handle_api_error_response
+from fiddler.utils.helpers import match_semver
 from fiddler.utils.logger import get_logger
 from fiddler.utils.response_handler import APIResponseHandler
 
@@ -235,7 +236,7 @@ class EventsMixin:
                 timestamp_field=timestamp_field,
                 timestamp_format=timestamp_format,
                 group_by=group_by,
-                file_type=FileType.CSV,
+                file_type=file_type,
                 wait=wait,
             )
         else:
@@ -368,14 +369,23 @@ class EventsMixin:
                 'The batch provided is empty. Please retry with at least one row of data.'
             )
 
-        file_type = FileType.CSV
-        with tempfile.NamedTemporaryFile(suffix=file_type) as temp:
-            events_df.to_csv(temp, index=False)
-            events_path = Path(temp.name)
+        if self.server_info and match_semver(
+            self.server_info.server_version, '>=23.4.0'
+        ):
+            file_type = FileType.PARQUET
+        else:
+            file_type = FileType.CSV
+
+        with tempfile.NamedTemporaryFile(suffix=file_type) as temp_file:
+            if file_type == FileType.PARQUET:
+                events_df.to_parquet(temp_file.name, index=False)
+            else:
+                events_df.to_csv(temp_file.name, index=False)
+
             return self.publish_events_batch(
                 project_name=project_name,
                 model_name=model_name,
-                events_path=events_path,
+                events_path=Path(temp_file.name),
                 batch_id=batch_id,
                 id_field=id_field,
                 is_update=is_update,
@@ -383,6 +393,7 @@ class EventsMixin:
                 timestamp_format=timestamp_format,
                 group_by=group_by,
                 wait=wait,
+                file_type=file_type,
             )
 
     @handle_api_error_response

fiddler/api/model_mixin.py

@@ -436,7 +436,7 @@ class ModelMixin:
                 base_name=str(Path(tmp) / 'files'),
                 format='tar',
                 root_dir=str(artifact_dir),
-                base_dir='',
+                base_dir='.',
             )
 
             logger.info(

fiddler/api/webhooks_mixin.py

@@ -0,0 +1,121 @@
+from http import HTTPStatus
+from typing import List, Optional
+
+from pydantic import parse_obj_as
+
+from fiddler.libs.http_client import RequestClient
+from fiddler.schema.webhook import Webhook
+from fiddler.utils.decorators import handle_api_error_response
+from fiddler.utils.logger import get_logger
+from fiddler.utils.response_handler import (
+    APIResponseHandler,
+    PaginatedResponseHandler,
+)
+
+logger = get_logger(__name__)
+
+
+class WebhookMixin:
+    client: RequestClient
+    organization_name: str
+
+    @handle_api_error_response
+    def add_webhook(self, name:str, url:str, provider:str) -> Webhook:
+        """
+        Add a new `Webhook`.
+
+        :params name: name of webhook
+        :params url: webhook url
+        :params provider: Either 'SLACK' or 'OTHER'
+
+        :returns: Created `Webhook` object.
+        """
+        request_body = {
+            'name': name,
+            'url': url,
+            'provider': provider,
+        }
+        response = self.client.post(
+            url='webhooks',
+            params={'organization_name': self.organization_name},
+            data=request_body,
+        )
+        if response.status_code == HTTPStatus.OK:
+            logger.info(f'Webhook created successfully.')
+        else:
+            logger.info('Webhook creation unsuccessful')
+        return Webhook.deserialize(APIResponseHandler(response))
+
+    @handle_api_error_response
+    def delete_webhook(self, uuid: str = None) -> None:
+        """
+        Delete a webhook
+
+        :params uuid: uuid of the Webhook to delete
+        :returns: None
+        """
+        response = self.client.delete(
+            url=f'webhooks/{uuid}'
+        )
+        if response.status_code == HTTPStatus.OK:
+            logger.info(f'Webhook {uuid} deleted successfully.')
+        else:
+            logger.info('Webhook deletion unsuccessful')
+
+    @handle_api_error_response
+    def get_webhook(self, uuid:str) -> List[Webhook]:
+        """
+        Get a webhook 
+
+        :params uuid: UUID belongs to the Webhook
+        :returns: `Webhook` object
+        """
+        response = self.client.get(
+            url=f'webhooks/{uuid}',
+        )
+        return Webhook.deserialize(APIResponseHandler(response))
+
+    @handle_api_error_response
+    def update_webhook(self, uuid: str, name:str, url:str, provider:str) -> Webhook:
+        """
+        Update a webhook, by changing one or more of name, url or provider.
+        :params name: name of webhook
+        :params url: webhook url
+        :params provider: Either 'SLACK' or 'OTHER'
+
+        :returns: Updated `Webhook` object.
+        """
+        request_body = Webhook(
+            name=name, url=url, provider=provider
+        ).dict()
+        response = self.client.patch(
+            url=f'webhooks/{uuid}',
+            data=request_body,
+        )
+        if response.status_code == HTTPStatus.OK:
+            logger.info(f'Webhook {uuid} updated successfully.')
+        else:
+            logger.info('Webhook updation unsuccessful')
+        return Webhook.deserialize(APIResponseHandler(response))
+
+    @handle_api_error_response
+    def get_webhooks(self, limit: int = 300, offset: int = 0) -> List[Webhook]:
+        """
+        Get a list of all webhooks in the organization
+
+        :params limit: Number of webhooks to fetch in a call
+        :params offset: Number of rows to skip before any rows are retrived
+        :returns: List of `Webhook` object
+        """
+        response = self.client.get(
+            url='webhooks',
+            params={
+                'organization_name': self.organization_name,
+                'limit': limit,
+                'offset': offset,
+            },
+        )
+        items = PaginatedResponseHandler(response).get_pagination_items()
+        return parse_obj_as(List[Webhook], items)
+
+

fiddler/core_objects.py

@@ -24,7 +24,12 @@ import numpy as np
 import pandas as pd
 import pandas.api.types
 
-from fiddler.schemas.custom_features import CustomFeature
+from fiddler.schemas.custom_features import (
+    CustomFeature,
+    ImageEmbedding,
+    TextEmbedding,
+    VectorFeature,
+)
 from fiddler.utils.formatting import prettyprint_number, validate_sanitized_names
 from fiddler.utils.logger import get_logger
 from fiddler.utils.pandas_helper import is_datetime, is_list, is_vector_value
@@ -199,6 +204,7 @@ class ModelTask(enum.Enum):
     MULTICLASS_CLASSIFICATION = 'multiclass_classification'
     REGRESSION = 'regression'
     RANKING = 'ranking'
+    NOT_SET = 'not_set'
 
     def is_classification(self):
         return self.value in (
@@ -1235,6 +1241,9 @@ class ModelInfo:
                 for k, v in numeric_cols.items()
                 if v in (DataType.INTEGER.value, DataType.FLOAT.value)
             ]
+            valid_vector_cols = [
+                input.name for input in self.inputs if input.data_type.is_vector()
+            ]
 
             unique_cf_names = []
             for feature in self.custom_features:
@@ -1256,17 +1265,17 @@ class ModelInfo:
                 else:
                     unique_cf_names.append(feature.name)
 
-                if isinstance(feature.columns, list):
+                if isinstance(feature, (TextEmbedding, ImageEmbedding, VectorFeature)):
+                    if not feature.column in valid_vector_cols:
+                        raise ValueError(
+                            f"Custom features '{feature.name}' defined on column '{feature.column}' is not found"
+                        )
+                else:
                     for col in feature.columns:
                         if col not in valid_col_names:
                             raise ValueError(
                                 f"Custom features '{feature.name}' defined on column '{col}' is not found or not of type int/float."
                             )
-                else:
-                    if feature.columns not in valid_col_names:
-                        raise ValueError(
-                            f"Custom features '{feature.name}' defined on column '{feature.columns}' is not found or not of type int/float."
-                        )
 
     def warn_deprecated_parameter(self, param_name: str, from_version: str) -> None:
         warnings.warn(
@@ -1814,14 +1823,9 @@ class ModelInfo:
         # todo (pradhuman): replace categorical_target_class_details with target_class_order
 
         if not model_task:
-            model_task = cls.infer_model_task(
-                dataset_info=dataset_info,
-                target=target,
-                outputs=outputs,
-            )
-            LOG.warning(
-                f'Fiddler inferred your model as a {model_task.value} model. '
-                f'If this is wrong, please specify your model task.'
+            raise ValueError(
+                'model_task is required to create a model info. Please specify a value '
+                'using the ModelTask enum.'
             )
 
         (
@@ -2290,42 +2294,6 @@ class ModelInfo:
             )
         return is_binary_ranking_model, top_k, bin_class_threshold
 
-    @classmethod
-    def infer_model_task(
-        cls,
-        dataset_info: DatasetInfo,
-        target: Optional[str],
-        outputs: Optional[List[str]],
-    ) -> ModelTask:
-        """
-        Inference assuming user gave all right parameters.
-        After, we run ModelInfoValidator to check all parameters.
-        :param dataset_info: dataset info object
-        :param target: target column name
-        :param outputs: list of output column name(s)
-        :return: Inferred Model task when possible
-        """
-        if not outputs or not target:
-            raise ValueError(
-                f'Fiddler cannot infer your model task because target and/or outputs '
-                f'are not specified. Please specify your model task.'
-            )
-        if len(outputs) > 1:
-            return ModelTask.MULTICLASS_CLASSIFICATION
-
-        target_col = dataset_info[target]
-        output_col = dataset_info[outputs[0]]
-
-        if ModelInfo.check_binary_target(target_column=target_col):
-            if output_col.value_range_min >= 0.0 and output_col.value_range_max <= 1.0:
-                return ModelTask.BINARY_CLASSIFICATION
-            return ModelTask.RANKING
-
-        if not target_col.data_type.is_numeric():
-            return ModelTask.RANKING
-
-        return ModelTask.REGRESSION
-
     @classmethod
     def validate_model_task(
         cls,
@@ -2402,7 +2370,7 @@ class ModelInfo:
         target_column: Column,
     ) -> Optional[List[Union[str, bool, float, int]]]:
 
-        if model_task.value == ModelTask.REGRESSION.value:
+        if model_task.value in [ModelTask.REGRESSION.value, ModelTask.NOT_SET.value]:
             return None
 
         if isinstance(target_class_order, (str, int, float, bool)):

fiddler/schema/alert.py

@@ -1,6 +1,7 @@
 import enum
 from typing import Any, Dict, List, Optional, Union
 
+from ast import literal_eval
 from pydantic import Field, root_validator
 
 from fiddler.schema.base import BaseDataSchema
@@ -140,6 +141,7 @@ class AlertRulePayload(BaseDataSchema):
     alert_type: Optional[AlertType]
     metric: Metric
     metric_id: Union[Metric, str]
+    feature_name: Optional[str]
     feature_names: Optional[List[str]]
     priority: Priority
     compare_to: CompareTo
@@ -161,7 +163,8 @@ class AlertRule(BaseDataSchema):
     name: Optional[str]
     alert_type: Optional[AlertType]
     metric: str
-    columns: Optional[List[str]] = Field(alias='feature_names')
+    column: Optional[str] = Field(alias='feature_name', default=None)
+    columns: Optional[List[str]] = Field(alias='feature_names', default=None)
     baseline_name: Optional[str]
     priority: Priority
     compare_to: CompareTo
@@ -172,7 +175,15 @@ class AlertRule(BaseDataSchema):
     bin_size: Optional[str]
     time_bucket: Optional[int]
 
-
+    @root_validator(pre=True)
+    def set_feature_names(cls, values) -> dict:
+        if 'feature_names' in values and type(values['feature_names']) == str:
+                # in release 23.3 feature_names is stringified list. 23.4 onwards its List[str]
+                try:
+                    values['feature_names'] = literal_eval(values['feature_names'])
+                except SyntaxError:
+                    values['feature_names'] = None
+        return values
 
 class TriggeredAlerts(BaseDataSchema):
     id: int
@@ -180,10 +191,12 @@ class TriggeredAlerts(BaseDataSchema):
     alert_rule_uuid: str = Field(alias='alert_config_uuid')
     alert_run_start_time: int
     alert_time_bucket: int
-    alert_value: Dict[str, float]
+    alert_value: Union[float, Dict[str, float]]
     baseline_time_bucket: Optional[int]
     baseline_value: Optional[float]
     is_alert: bool
     severity: Optional[str]
     failure_reason: str
     message: str
+    multi_col_values: Optional[Dict[str, float]]
+    feature_name: Optional[str]

fiddler/schema/webhook.py

@@ -0,0 +1,10 @@
+from fiddler.schema.base import BaseDataSchema
+
+
+class Webhook(BaseDataSchema):
+    uuid: str
+    name: str
+    organization_name: str
+    url: str
+    # provider is 'SLACK' or 'OTHER' as of Aug 2023.
+    provider: str

fiddler/schemas/custom_features.py

@@ -1,13 +1,16 @@
 from enum import Enum
-from typing import List, Optional, Type, TypeVar
+from typing import Any, Dict, List, Optional, Type, TypeVar
 
 from pydantic import BaseModel
 
-T = TypeVar('T', bound='CustomFeature')
+CustomFeatureTypeVar = TypeVar('CustomFeatureTypeVar', bound='CustomFeature')
+DEFAULT_NUM_CLUSTERS = 5
+DEFAULT_NUM_TAGS = 5
 
 
 class CustomFeatureType(str, Enum):
     FROM_COLUMNS = 'FROM_COLUMNS'
+    FROM_VECTOR = 'FROM_VECTOR'
     FROM_TEXT_EMBEDDING = 'FROM_TEXT_EMBEDDING'
     FROM_IMAGE_EMBEDDING = 'FROM_IMAGE_EMBEDDING'
 
@@ -15,17 +18,31 @@ class CustomFeatureType(str, Enum):
 class CustomFeature(BaseModel):
     name: str
     type: CustomFeatureType
-    n_clusters: Optional[int] = 5
+    n_clusters: Optional[int] = DEFAULT_NUM_CLUSTERS
     centroids: Optional[List] = None
 
     class Config:
         allow_mutation = False
 
     @classmethod
-    def from_dict(cls: Type[T], deserialized_json: dict) -> T:
+    def from_columns(
+        cls, custom_name: str, cols: List[str], n_clusters: int = DEFAULT_NUM_CLUSTERS
+    ) -> 'Multivariate':
+        return Multivariate(
+            name=custom_name,
+            columns=cols,
+            n_clusters=n_clusters,
+        )
+
+    @classmethod
+    def from_dict(
+        cls: Type[CustomFeatureTypeVar], deserialized_json: dict
+    ) -> CustomFeatureTypeVar:
         feature_type = CustomFeatureType(deserialized_json['type'])
         if feature_type == CustomFeatureType.FROM_COLUMNS:
             return Multivariate.parse_obj(deserialized_json)
+        elif feature_type == CustomFeatureType.FROM_VECTOR:
+            return VectorFeature.parse_obj(deserialized_json)
         elif feature_type == CustomFeatureType.FROM_TEXT_EMBEDDING:
             return TextEmbedding.parse_obj(deserialized_json)
         elif feature_type == CustomFeatureType.FROM_IMAGE_EMBEDDING:
@@ -33,19 +50,46 @@ class CustomFeature(BaseModel):
         else:
             raise ValueError(f'Unsupported feature type: {feature_type}')
 
+    def to_dict(self) -> Dict[str, Any]:
+        return_dict = {
+            'name': self.name,
+            'type': self.type,
+            'n_clusters': self.n_clusters,
+        }
+        if self.type == CustomFeatureType.FROM_COLUMNS:
+            return_dict['columns'] = self.columns
+        elif self.type == CustomFeatureType.FROM_VECTOR:
+            return_dict['column'] = self.column
+        elif self.type in (
+            CustomFeatureType.FROM_TEXT_EMBEDDING,
+            CustomFeatureType.FROM_IMAGE_EMBEDDING,
+        ):
+            return_dict['source_column'] = self.source_column
+            return_dict['column'] = self.column
+
+            if self.type == CustomFeatureType.FROM_TEXT_EMBEDDING:
+                return_dict['n_tags'] = self.n_tags
+        else:
+            raise ValueError(f'Unsupported feature type: {self.type}')
+
+        return return_dict
+
 
 class Multivariate(CustomFeature):
+    type: CustomFeatureType = CustomFeatureType.FROM_COLUMNS
     columns: List[str]
     monitor_components: bool = False
 
 
 class VectorFeature(CustomFeature):
+    type: CustomFeatureType = CustomFeatureType.FROM_VECTOR
     source_column: Optional[str] = None
     column: str
 
 
 class TextEmbedding(VectorFeature):
     type: CustomFeatureType = CustomFeatureType.FROM_TEXT_EMBEDDING
+    n_tags: Optional[int] = DEFAULT_NUM_TAGS
 
 
 class ImageEmbedding(VectorFeature):

{fiddler_client-2.0.0.dev8.dist-info → fiddler_client-2.0.0.dev10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fiddler-client
-Version: 2.0.0.dev8
+Version: 2.0.0.dev10
 Summary: Python client for Fiddler Service
 Home-page: https://fiddler.ai
 Author: Fiddler Labs
@@ -63,6 +63,15 @@ Version History
     - Add `monitor_components` as an attribute of `CustomFeature`. Default to `False`
     - Remove `column` as a parameter in `add_alert_rule` and `get_alert_rules` functions
 
+### 1.8.4
+ - #### **New Features**
+  - New DeploymentType enum for MANUAL deployment
+
+### 1.8.3
+ - ### **Modifications**
+  - New `columns` parameter in add_alert_rule and get_alert_rules to support multiple columns to be used for server version >= 23.3.0
+  - get_triggered_alerts supports `alert_value` as a float as well as a dict
+
 ### 1.8.2
   - #### **Modifications**
     - Fixed a bug where `min` and `max` for columns of type `float` in `dataset_info` are cast into `int` after uploaded

{fiddler_client-2.0.0.dev8.dist-info → fiddler_client-2.0.0.dev10.dist-info}/RECORD

@@ -1,23 +1,24 @@
-fiddler/__init__.py,sha256=DST8iG_3fsah2MTdaYEjbXbHKr9FoNPhzh2UMWtu-JA,1476
-fiddler/_version.py,sha256=jQ-BePJScZW7IItmgxugWF6A-V7sXZo_y2_tciWZ-uY,27
+fiddler/__init__.py,sha256=Vv9ypQhEkjFdnhiIuv79m8ZtBVlsegjt2anDH6DVHds,1960
+fiddler/_version.py,sha256=Vkmm08Vum_RV2_Nb1HuOhJ09Soq68UZ8mIOy9lPfsvY,28
 fiddler/constants.py,sha256=sNPexKXMCVC9iQNIArgIQBITGhgHuBUiNklEXTD_eFI,1822
-fiddler/core_objects.py,sha256=LdFJ5XqAGP7oT6yE3GhlnRMVbDXEGZSeFJJjOvHMuDw,112950
+fiddler/core_objects.py,sha256=DZnJRwgfeL7lSVco_veU-Depwe_PJ411uFLvQm8ZHkY,111717
 fiddler/exceptions.py,sha256=tis5S9jdGsVmXkFjulLNEHeiFQ8lFjJYlYr68H83euU,2490
 fiddler/api/__init__.py,sha256=9PidyuY4iRgOeEPFyBYo0jcSbTf7KeE3jsDXwFP4ZHs,109
-fiddler/api/alert_mixin.py,sha256=GVdlNmuUrDjdfDYyXogCdkzMWYaXLAt9CxR3MOW1wpI,16916
-fiddler/api/api.py,sha256=00FZYGOa0TSAn_mLQp_oqdc1LLoPTTMJrHFKCUERr5U,4187
+fiddler/api/alert_mixin.py,sha256=Qgp58GPFY52Dq0JzTmXJ3hjZFn4yieQADWrZKqENrn8,18143
+fiddler/api/api.py,sha256=nNOOJcqUPzYpY1jYL9brzZI5_OxDJYq48K3rQAZJ-1M,4256
 fiddler/api/baseline_mixin.py,sha256=D-IvvUDHN-J4y_g_irp5_Y5g53cTL3AEYuu121YnHGo,9813
 fiddler/api/compatibility_mixin.py,sha256=_1vaScKiJeKbPmFjT30IbhCbUoDDQoxHDwQ6o0qSrm0,1313
 fiddler/api/dataset_mixin.py,sha256=5LuaPU1PbTS3srq3vSUUK-e2-Fc56M7ClNl9oRVX8e0,16963
-fiddler/api/events_mixin.py,sha256=EdSAJNRIRXr1nYrbOVJ-mMIrUI7KAww-Muqq7P0piVo,22076
+fiddler/api/events_mixin.py,sha256=zw_wIjrQVIg9LqaAzz8Ye0u4m26LtYMp-dau2v9UVDk,22447
 fiddler/api/explainability_mixin.py,sha256=WsyDEtGAWfQYN9HdS8b8uUan9vjKWvUSB43F7KkjiCg,15332
 fiddler/api/generate_schema_mixin.py,sha256=QWFnMRi0k5mf0wPpCxAkrffbQz5JNU2OgERy5KgVP5w,9792
 fiddler/api/helpers.py,sha256=-ZLyXnZhWJK9IvdKqZVgDo2c3wpYwI5EizFFu4stQjk,4722
 fiddler/api/job_mixin.py,sha256=wGJ8yrKYvNa3_6-4o28-IJ8Zrep_uZ1L2DO2XMaLUuI,4496
 fiddler/api/model_artifact_deploy.py,sha256=t72HkQ2JsQzCB5bUsFuS71KWDJ-KVcKkdtyef-dwnMY,8265
 fiddler/api/model_deployment_mixin.py,sha256=xZ26FwixQ4FvsGSmQvrUB7joveIGqE07Vph7ADoGDRc,4118
-fiddler/api/model_mixin.py,sha256=GZih7bN3k3t7V3pKnrRzBt0YAcX6O-Wicz2h1X6cBrw,21054
+fiddler/api/model_mixin.py,sha256=7_Y4NSFx8NpxbPQdHpXNVSMN2wBN445YAZOnFPOchuI,21055
 fiddler/api/project_mixin.py,sha256=_RRuPnBzANP2Kyo0J_CqG6wqFawRz1Y29z88BUx66Ag,3198
+fiddler/api/webhooks_mixin.py,sha256=nh7EU-VAabxZr42f7iUbphBOudyt-DEnjRLfypetBdw,3800
 fiddler/assets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fiddler/assets/pg_reserved_words.py,sha256=Ar8Y4vrw5cJxc6xMmul42cNw0NEu-LjEV5jK6QlKisY,8200
 fiddler/libs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -28,7 +29,7 @@ fiddler/packtools/keras_ig_helpers.py,sha256=66KhHhiYYHryieF7DYhmHC-S6D5NUgrm7lM
 fiddler/packtools/project_attributions_helpers.py,sha256=PzMTDPUX0KqE-kLyrkW46W6F4nDRvRIka0HjzLYxI4k,14619
 fiddler/packtools/template_model.py,sha256=-I0hMcuZsHc3jw59o4hyTztU-V1onKJ5z0rKkZzSy1A,9500
 fiddler/schema/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fiddler/schema/alert.py,sha256=PsKvDzDc0Ysuxb1pGl_HGFPm0NOJjehIySmgXECag2A,4493
+fiddler/schema/alert.py,sha256=8OUJPWZbHHOjdgKS4mvP7rrDoiNYmoCSTrIdUXs8GTo,5199
 fiddler/schema/base.py,sha256=3P0h6r1flDQeXfLRANSt6Rng2mTy17hKPYtopFxjKF8,343
 fiddler/schema/baseline.py,sha256=h8SyR32L1AMo2DrcwgEOqWN-U538-XFngjAtQQfMklI,487
 fiddler/schema/dataset.py,sha256=kFr_BlP9-hFRjYxy_ezr3M7bmedfK_ZznAdLfvBxYlQ,3045
@@ -39,8 +40,9 @@ fiddler/schema/model_deployment.py,sha256=CkYAzgJN4WQFNgElaZrhTvpLnRFMWnZ3F4hYkz
 fiddler/schema/project.py,sha256=7kKUMIrGmLWjzuvKsIIIEZj9PIoJ8dXsAnyVOSL35pc,121
 fiddler/schema/server_info.py,sha256=RKpFDUtpzicQ7I6FB9sMNaFEx-esdSjMiNrc0UIUKjg,388
 fiddler/schema/user.py,sha256=8p4r2ZMqPEggggd10l62w_7A5KsRr6Se5QP-xfrEtks,109
+fiddler/schema/webhook.py,sha256=0OknRLjXWocHNxMFWrxV2VvEfFzGn91vLw74FiGQSFU,218
 fiddler/schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fiddler/schemas/custom_features.py,sha256=P1JDI0Nnp-v7xOvSvUSxvqXdwHSe9znl9ZFicrTWDHo,1535
+fiddler/schemas/custom_features.py,sha256=p-kIEd6vx5LH4ZjjqPwAuS33N-4Yp9eu3EMNthKcB7g,3180
 fiddler/schemas/model_schema.py,sha256=ByUVfnPzImNbl3GsiyqCpf8o0bDxOzwk-sIg0zeHpeQ,1124
 fiddler/schemas/model_spec.py,sha256=RiZd-efabsJVfHCI5kXRs_6RrWj4xZB6vqajHSDqxgc,642
 fiddler/schemas/model_task_params.py,sha256=jsBGgHStwBSkW9LZQtddCJJPMY_6EEWdS8lnVolJlbI,679
@@ -67,12 +69,12 @@ tests/fiddler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/fiddler/base.py,sha256=QeDFGtcVP1LscfSvjJeEBPoQN1bp3s726EKaytY1Gis,1418
 tests/fiddler/helper.py,sha256=lE0blhcQysB9BuVKScK-rpaxau04ddWD7NrjD5AZkb4,1785
 tests/fiddler/test_add_model.py,sha256=rWbgfMZa3GExL9Y8ldVvw99BqGH-Zvrww09Z8JPhvTY,3787
-tests/fiddler/test_alert.py,sha256=E2PH7ZGUPBbZzSgyKJ5lsYmwWDkxXGqbSxBNL0diATk,36786
+tests/fiddler/test_alert.py,sha256=LEgk0iU7DC7QEXHcjpip6FzS-8w3uuCExkKlunJItSU,50919
 tests/fiddler/test_baseline.py,sha256=JoAX3KkNYC52_uRVOHZzMNBy5dG57pXtwkT-WtmihHk,10277
 tests/fiddler/test_check_version_decorator.py,sha256=MGcrIX7nscVpIYy1thuLrSvsXBC6KDXfdsHCEST5Xnw,906
 tests/fiddler/test_custom_features.py,sha256=yjz-5Aq_Ey7FoDJiIzugLPcbh_5QdazE6trwpT38rEw,3028
 tests/fiddler/test_dataset_api.py,sha256=donx8nw_BQ6s4-61Wq-Ab4CN5oG5UShnAwY9TX-vskk,6307
-tests/fiddler/test_events_api.py,sha256=Ecwhrjbq_d-8n-BOiYnBV0tv5sWDGZ-AVBuCEjZKKDM,7718
+tests/fiddler/test_events_api.py,sha256=YG0wWBBe0ygpqFvMs7PWAxu0DkYUH76EDY0u4iXCQY8,7748
 tests/fiddler/test_exceptions.py,sha256=3dUe85gqf8MVxEM_9D1wrNRU8jvmu1-ja36jaDKgOQk,2801
 tests/fiddler/test_explainability_apis.py,sha256=B73inIm2tNNRDnTLgiqU0o1Sy3N_QAuzlOms0QvA5oE,15111
 tests/fiddler/test_file_upload.py,sha256=TBy0gLfu2sfbqcvx_rrgNF0I4keqkBTReG2EkVIei_Y,7611
@@ -84,12 +86,13 @@ tests/fiddler/test_project.py,sha256=sADiYMDeMnS7d90FHsHugUw3Tz1XASmlhjlSOOVSqnk
 tests/fiddler/test_response_handler.py,sha256=YWhd8QIJrW3nUag-nZ4jutAs1B9eOqQekgUN1vtsbU0,2958
 tests/fiddler/test_upload_dataset.py,sha256=fQ7fNtB4-kuY7g6XSNftklxgi_-uhkiuXb7CtxmWz9Q,13719
 tests/fiddler/test_validations.py,sha256=1FUlfXzf1L-DrSth12u4MUBHGGgGAXDCn-x2TS79Y10,581
+tests/fiddler/test_webhook.py,sha256=Js0zNdXYLOyh3k0Y1qRSS94ACITdiId4YXTQPTpeoc0,4395
 tests/fiddler/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/fiddler/utils/test_general_checks.py,sha256=pwXqEf1KdXnMugej8fpr8zfiRsN1-yDGwQWuVheIl3c,1473
 tests/fiddler/utils/test_pandas.py,sha256=rsJg_a1Z60FbY1v5WNhhyqXJIjW-qVFZhNjfwptL7is,8084
 tests/fiddler/utils/tests_utils.py,sha256=kPmMoOlaSIWw6Gk7QnAnn8QJvEyqtd2Rz32kS6RGEc8,1800
-fiddler_client-2.0.0.dev8.dist-info/LICENSE.txt,sha256=w8-LUAb_VLBWSsCNmih0pAqLIicJfGu8OJXpDjkIg_o,559
-fiddler_client-2.0.0.dev8.dist-info/METADATA,sha256=dUoCOsPu1Akevj8pUtTes3HhcMfpwaxl8OI_EbeLZKA,17588
-fiddler_client-2.0.0.dev8.dist-info/WHEEL,sha256=g4nMs7d-Xl9-xC9XovUrsDHGXt-FT0E17Yqo92DEfvY,92
-fiddler_client-2.0.0.dev8.dist-info/top_level.txt,sha256=GdJimrE4Q9O20-dA6QljDHm5KBrlz25oQTdbMHu41So,14
-fiddler_client-2.0.0.dev8.dist-info/RECORD,,
+fiddler_client-2.0.0.dev10.dist-info/LICENSE.txt,sha256=w8-LUAb_VLBWSsCNmih0pAqLIicJfGu8OJXpDjkIg_o,559
+fiddler_client-2.0.0.dev10.dist-info/METADATA,sha256=eSsma_0KiXXx4-YmihMJ4Jqwlpb2JtsaTv8BG7ejUFk,17922
+fiddler_client-2.0.0.dev10.dist-info/WHEEL,sha256=g4nMs7d-Xl9-xC9XovUrsDHGXt-FT0E17Yqo92DEfvY,92
+fiddler_client-2.0.0.dev10.dist-info/top_level.txt,sha256=GdJimrE4Q9O20-dA6QljDHm5KBrlz25oQTdbMHu41So,14
+fiddler_client-2.0.0.dev10.dist-info/RECORD,,

tests/fiddler/test_alert.py

@@ -395,6 +395,185 @@ class TestAlert(BaseTestCase):
         self.assertEqual(response_items[0]['alert_type'], 'drift')
         self.assertEqual(response_items[0]['name'], 'alert_name_1')
 
+    def test_get_alert_rules_diff_feature_names_format(self):
+        response = {
+            'data': {
+                'page_size': 100,
+                'total': 84,
+                'item_count': 84,
+                'page_count': 1,
+                'page_index': 1,
+                'offset': 0,
+                'items': [
+                    {
+                        'critical_threshold': 0.5,
+                        'organization_name': self._org,
+                        'id': 1,
+                        'sub_metric': 'jsd',
+                        'metric': 'jsd',
+                        'condition': 'greater',
+                        'time_bucket': 3600000,
+                        'compare_period': 86400000,
+                        'details': 'New Alert',
+                        'model_name': self._model_name,
+                        'name': 'alert_name_1',
+                        'feature_names': "['probability_churned']",
+                        'baseline_name': 'baseline_name',
+                        'created_by': 'admin@fiddler.ai',
+                        'alert_type': 'drift',
+                        'uuid': '932bb123-3fc6-4ee5-a48c-1f96bb29f7ee',
+                        'is_active': True,
+                        'created_at': '2022-09-08T18:47:26.889000+00:00',
+                        'project_name': self._project_name,
+                        'warning_threshold': 0.2,
+                        'compare_to': 'time_period',
+                        'alert_log_time': '2022-09-08T18:47:28.034165+00:00',
+                        'priority': 'LOW',
+                    },
+                    {
+                        'critical_threshold': 0.7,
+                        'organization_name': self._org,
+                        'id': 2,
+                        'sub_metric': 'jsd',
+                        'metric': 'jsd',
+                        'condition': 'lesser',
+                        'time_bucket': 3600000,
+                        'compare_period': 86400000,
+                        'details': 'New Alert',
+                        'model_name': self._model_name,
+                        'name': 'alert_name_2',
+                        'feature_names': ['probability_churned'],
+                        'created_by': 'admin@fiddler.ai',
+                        'alert_type': 'drift',
+                        'uuid': 'e7c7f891-53ba-4246-b691-53b6efda332b',
+                        'is_active': True,
+                        'created_at': '2022-09-08T18:47:27.923000+00:00',
+                        'project_name': self._project_name,
+                        'warning_threshold': 0.1,
+                        'compare_to': 'time_period',
+                        'alert_log_time': '2022-09-08T18:47:29.087871+00:00',
+                        'priority': 'LOW',
+                    },
+                    {
+                        'critical_threshold': 0.8,
+                        'organization_name': self._org,
+                        'id': 3,
+                        'sub_metric': 'jsd',
+                        'metric': 'jsd',
+                        'condition': 'greater',
+                        'time_bucket': 3600000,
+                        'model_name': self._model_name,
+                        'name': 'alert_name_3',
+                        'feature_name': 'probability_churned',
+                        'created_by': 'admin@fiddler.ai',
+                        'alert_type': 'drift',
+                        'uuid': '320060fa-abeb-4cae-9718-17d6f917b414',
+                        'is_active': True,
+                        'created_at': '2022-09-08T18:47:28.975000+00:00',
+                        'project_name': self._project_name,
+                        'warning_threshold': 0.4,
+                        'compare_to': 'raw_value',
+                        'alert_log_time': '2022-09-08T18:47:30.100808+00:00',
+                        'priority': 'LOW',
+                    },
+                ],
+            },
+            'api_version': '2.0',
+            'kind': 'PAGINATED',
+        }
+
+        url = self._get_url()
+        query_params = {
+            'organization_name': self._org,
+            'filter': json.dumps(
+                {
+                    'condition': 'AND',
+                    'rules': [
+                        {
+                            'field': 'project_name',
+                            'operator': 'equal',
+                            'value': 'test_project',
+                        },
+                        {
+                            'field': 'model_name',
+                            'operator': 'equal',
+                            'value': 'test_model',
+                        },
+                        {'field': 'alert_type', 'operator': 'equal', 'value': 'drift'},
+                        {'field': 'metric', 'operator': 'equal', 'value': 'jsd'},
+                        {
+                            'field': 'feature_names',
+                            'operator': 'contains',
+                            'value': ['test_column'],
+                        },
+                        {
+                            'field': 'baseline_name',
+                            'operator': 'equal',
+                            'value': 'test_baseline',
+                        },
+                    ],
+                }
+            ),
+            'ordering': 'alert_type,metric',
+            'limit': 20,
+            'offset': 0,
+        }
+        self.requests_mock.get(
+            url, json=response, match=[matchers.query_param_matcher(query_params)]
+        )
+
+        server_info = ServerInfo(**{'feature_flags': {}, 'server_version': '23.3.0'})
+        with mock.patch.object(
+            self.client, 'server_info', server_info
+        ) as mock_server_info:
+            alert_rules = self.client.get_alert_rules(
+                project_name='test_project',
+                model_name='test_model',
+                alert_type='drift',
+                metrics=['jsd'],
+                columns=['test_column'],
+                baseline_name='test_baseline',
+                ordering=['alert_type', 'metric'],
+            )
+            for alert_rule in alert_rules:
+                self.assertTrue(alert_rule.columns or alert_rule.column)
+                if alert_rule.columns:
+                    self.assertEqual(alert_rule.columns, ['probability_churned'])
+                else:
+                    self.assertEqual(alert_rule.column, 'probability_churned')
+
+        query_params = {
+            'filter': json.dumps(
+                {"condition": "AND", "rules": [{"field": "project_name", "operator": "equal", "value": "test_project"}, {"field": "model_name", "operator": "equal", "value": "test_model"}, {"field": "metric_id", "operator": "contains", "value": ["jsd"]}, {"field": "feature_names", "operator": "contains", "value": ["test_column"]}, {"field": "baseline_name", "operator": "equal", "value": "test_baseline"}]}
+            ),
+            'organization_name': 'test_organization', 
+            'ordering': 'alert_type,metric',
+            'limit': 20,
+            'offset': 0,
+        }
+        self.requests_mock.get(
+            url, json=response, match=[matchers.query_param_matcher(query_params)]
+        )
+        server_info = ServerInfo(**{'feature_flags': {}, 'server_version': '23.4.0'})
+        with mock.patch.object(
+            self.client, 'server_info', server_info
+        ) as mock_server_info:
+            alert_rules = self.client.get_alert_rules(
+                project_name='test_project',
+                model_name='test_model',
+                alert_type='drift',
+                metrics=['jsd'],
+                columns=['test_column'],
+                baseline_name='test_baseline',
+                ordering=['alert_type', 'metric'],
+            )
+            for alert_rule in alert_rules:
+                self.assertTrue(alert_rule.columns or alert_rule.column)
+                if alert_rule.columns:
+                    self.assertEqual(alert_rule.columns, ['probability_churned'])
+                else:
+                    self.assertEqual(alert_rule.column, 'probability_churned')
+
     def test_delete_alert_rule(self):
         url = self._get_url(alert_rule_uuid=self._alert_rule_uuid)
         self.requests_mock.delete(url)
@@ -769,8 +948,8 @@ class TestAlert(BaseTestCase):
                 'offset': 0,
                 'items': [
                     {
-                        'id': 285,
-                        'uuid': 'ea45ff98-96de-4015-817d-00e571b3fac7',
+                        'id': 1,
+                        'uuid': 'uuid_1',
                         'alert_config_uuid': self._alert_rule_uuid,
                         'alert_run_start_time': 1658481873833,
                         'alert_time_bucket': 1657710000000,
@@ -783,12 +962,12 @@ class TestAlert(BaseTestCase):
                         'message': 'In project bank_churn and model  bank_churn, during the time period of one hour  starting |2022-07-13 11:00:00 (UTC time)|, the prediction drift score was 0.789,   greater than 0.1.',
                     },
                     {
-                        'id': 287,
-                        'uuid': '9cc8df42-73f4-4f5d-aea9-d8a5ab5b195e',
+                        'id': 2,
+                        'uuid': 'uuid_2',
                         'alert_config_uuid': self._alert_rule_uuid,
                         'alert_run_start_time': 1658481873991,
                         'alert_time_bucket': 1657720800000,
-                        'alert_value': {'__DEFAULT__': 0.789176795308359},
+                        'alert_value': 0.789176795308359,
                         'baseline_time_bucket': None,
                         'baseline_value': None,
                         'is_alert': True,
@@ -797,18 +976,19 @@ class TestAlert(BaseTestCase):
                         'message': 'In project bank_churn and model  bank_churn, during the time period of one hour  starting |2022-07-13 14:00:00 (UTC time)|, the prediction drift score was 0.789,   greater than 0.1.',
                     },
                     {
-                        'id': 288,
-                        'uuid': '5d2868cf-0321-46cd-af36-b784710b2295',
+                        'id': 3,
+                        'uuid': 'uuid_3',
                         'alert_config_uuid': self._alert_rule_uuid,
                         'alert_run_start_time': 1658481874167,
                         'alert_time_bucket': 1657724400000,
-                        'alert_value': {'__DEFAULT__': 0.789176795308359},
+                        'alert_value': 0.789176795308359,
                         'baseline_time_bucket': None,
                         'baseline_value': None,
                         'is_alert': True,
                         'severity': None,
                         'failure_reason': 'NA',
                         'message': 'In project bank_churn and model  bank_churn, during the time period of one hour  starting |2022-07-13 15:00:00 (UTC time)|, the prediction drift score was 0.789,   greater than 0.1.',
+                        'feature_name':'feature_name'
                     },
                 ],
             }
@@ -830,14 +1010,160 @@ class TestAlert(BaseTestCase):
         )
         self.assertEqual(triggered_alerts[0].failure_reason, 'NA')
         self.assertEqual(triggered_alerts[0].is_alert, True)
+        self.assertEqual(triggered_alerts[1].alert_value, 0.789176795308359)
+        self.assertTrue('feature_names' not in triggered_alerts[2].dict())
+        self.assertEqual(triggered_alerts[2].alert_value, 0.789176795308359)
+        self.assertEqual(triggered_alerts[2].feature_name, 'feature_name')
 
         response_items = self.requests_mock.calls[0].response.json()['data']['items']
 
         self.assertEqual(response_items[0]['is_alert'], True)
-        self.assertEqual(response_items[0]['id'], 285)
+        self.assertEqual(response_items[0]['id'], 1)
         self.assertEqual(response_items[0]['alert_time_bucket'], 1657710000000)
         self.assertEqual(response_items[0]['alert_config_uuid'], self._alert_rule_uuid)
 
+    def test_alert_rule_serializer(self):
+        alert_rule_231 = {
+            'critical_threshold': 0.8,
+            'organization_name': self._org,
+            'id': 3,
+            'sub_metric': 'jsd',
+            'metric': 'jsd',
+            'condition': 'greater',
+            'time_bucket': 3600000,
+            'model_name': self._model_name,
+            'name': 'alert_name_3',
+            'feature_name': 'probability_churned',
+            'created_by': 'admin@fiddler.ai',
+            'alert_type': 'drift',
+            'uuid': '320060fa-abeb-4cae-9718-17d6f917b414',
+            'is_active': True,
+            'created_at': '2022-09-08T18:47:28.975000+00:00',
+            'project_name': self._project_name,
+            'warning_threshold': 0.4,
+            'compare_to': 'raw_value',
+            'alert_log_time': '2022-09-08T18:47:30.100808+00:00',
+            'priority': 'LOW',
+        }
+        alert_rule_parsed_231:AlertRule = AlertRule.parse_obj(alert_rule_231)
+        self.assertEqual(alert_rule_parsed_231.column, 'probability_churned')
+        self.assertEqual(alert_rule_parsed_231.columns, None)
+
+        alert_rule_232 = {
+            'critical_threshold': 0.8,
+            'organization_name': self._org,
+            'id': 3,
+            'sub_metric': 'jsd',
+            'metric': 'jsd',
+            'condition': 'greater',
+            'time_bucket': 3600000,
+            'model_name': self._model_name,
+            'name': 'alert_name_3',
+            'feature_names': "['probability_churned']",
+            'created_by': 'admin@fiddler.ai',
+            'alert_type': 'drift',
+            'uuid': '320060fa-abeb-4cae-9718-17d6f917b414',
+            'is_active': True,
+            'created_at': '2022-09-08T18:47:28.975000+00:00',
+            'project_name': self._project_name,
+            'warning_threshold': 0.4,
+            'compare_to': 'raw_value',
+            'alert_log_time': '2022-09-08T18:47:30.100808+00:00',
+            'priority': 'LOW',
+        }
+        alert_rule_parsed_232:AlertRule = AlertRule.parse_obj(alert_rule_232)
+        self.assertEqual(alert_rule_parsed_232.column, None)
+        self.assertEqual(alert_rule_parsed_232.columns, ['probability_churned'])
+
+        alert_rule_233 = {
+            'critical_threshold': 0.8,
+            'organization_name': self._org,
+            'id': 3,
+            'sub_metric': 'jsd',
+            'metric': 'jsd',
+            'condition': 'greater',
+            'time_bucket': 3600000,
+            'model_name': self._model_name,
+            'name': 'alert_name_3',
+            'feature_names': ['probability_churned'],
+            'created_by': 'admin@fiddler.ai',
+            'alert_type': 'drift',
+            'uuid': '320060fa-abeb-4cae-9718-17d6f917b414',
+            'is_active': True,
+            'created_at': '2022-09-08T18:47:28.975000+00:00',
+            'project_name': self._project_name,
+            'warning_threshold': 0.4,
+            'compare_to': 'raw_value',
+            'alert_log_time': '2022-09-08T18:47:30.100808+00:00',
+            'priority': 'LOW',
+        }
+        alert_rule_parsed_233:AlertRule = AlertRule.parse_obj(alert_rule_233)
+        self.assertEqual(alert_rule_parsed_233.column, None)
+        self.assertEqual(alert_rule_parsed_233.columns, ['probability_churned'])
+
+        alert_rule_empty_features = {
+            'critical_threshold': 0.8,
+            'organization_name': self._org,
+            'id': 3,
+            'sub_metric': 'jsd',
+            'metric': 'jsd',
+            'condition': 'greater',
+            'time_bucket': 3600000,
+            'model_name': self._model_name,
+            'name': 'alert_name_3',
+            'created_by': 'admin@fiddler.ai',
+            'alert_type': 'drift',
+            'uuid': '320060fa-abeb-4cae-9718-17d6f917b414',
+            'is_active': True,
+            'created_at': '2022-09-08T18:47:28.975000+00:00',
+            'project_name': self._project_name,
+            'warning_threshold': 0.4,
+            'compare_to': 'raw_value',
+            'alert_log_time': '2022-09-08T18:47:30.100808+00:00',
+            'priority': 'LOW',
+        }
+        alert_rule_parsed_empty_features:AlertRule = AlertRule.parse_obj(alert_rule_empty_features)
+        self.assertEqual(alert_rule_parsed_empty_features.column, None)
+        self.assertEqual(alert_rule_parsed_empty_features.columns, None)
+
+    def test_triggered_alert_record_serializer(self):
+        tar_with_value_as_float = {
+            'id': 1,
+            'uuid': 'uuid',
+            'alert_config_uuid': 'alert_config_uuid',
+            'alert_run_start_time': 1,
+            'alert_time_bucket': 1,
+            'alert_value': 1.0,
+            'baseline_time_bucket': 1,
+            'baseline_value': 0.0,
+            'is_alert': True,
+            'severity': 'HIGH',
+            'failure_reason': 'NA',
+            'message': 'some message',
+            'multi_col_values': {'a' : 1.0, 'b': 2.0},
+            'feature_name': 'age'
+        }
+        tar:TriggeredAlerts = TriggeredAlerts.parse_obj(tar_with_value_as_float)
+        self.assertEqual(tar.alert_value, 1.0)
+        self.assertEqual(tar.feature_name, 'age')
+
+        tar_with_value_as_dict = {
+            'id': 1,
+            'uuid': 'uuid',
+            'alert_config_uuid': 'alert_config_uuid',
+            'alert_run_start_time': 1,
+            'alert_time_bucket': 1,
+            'alert_value': {'a' : 1.0, 'b': 2.0},
+            'baseline_time_bucket': 1,
+            'baseline_value': 0.0,
+            'is_alert': True,
+            'severity': 'HIGH',
+            'failure_reason': 'NA',
+            'message': 'some message',
+        }
+        tar:TriggeredAlerts = TriggeredAlerts.parse_obj(tar_with_value_as_dict)
+        self.assertEqual(tar.alert_value, {'a' : 1.0, 'b': 2.0})
 
 if __name__ == '__main__':
     unittest.main()
+

tests/fiddler/test_events_api.py

@@ -145,6 +145,7 @@ class TestEventsAPI(BaseTestCase):
             timestamp_format=timestamp_format,
             group_by=group_by,
             wait=wait,
+            file_type='.csv',
         )
 
         _, kwargs = publish_events_patcher.call_args

tests/fiddler/test_webhook.py

@@ -0,0 +1,124 @@
+import json
+import unittest
+from http import HTTPStatus
+from typing import Tuple
+
+from responses import matchers
+
+from fiddler.exceptions import (
+    BadRequest,
+    Conflict,
+    NotFound,
+)
+from fiddler.schema.webhook import Webhook
+from tests.fiddler.base import BaseTestCase
+
+
+class TestWebhook(BaseTestCase):
+    def setUp(self):
+        super(TestWebhook, self).setUp()        
+
+    def _get_url(self, uuid: str = None) -> str:
+        base_url = f'{self._url}/webhooks'
+        if uuid:
+            return f'{base_url}/{uuid}',
+        return base_url
+
+    def test_get_webhooks(self):
+        response = {
+            'data': {
+                'page_size': 100,
+                'total': 3,
+                'item_count': 3,
+                'page_count': 1,
+                'page_index': 1,
+                'offset': 0,
+                'items': [
+                    {
+                        'id': 0,
+                        'uuid': 'uuid_0',
+                        'name': 'webhook_0',
+                        'url': 'url_0',
+                        'provider': 'SLACK',
+                        'organization_name': 'test_organization',
+                        'created_at': '2022-05-19T18:20:25.991688+00:00',
+                        'updated_at': '2022-05-19T18:20:25.991688+00:00',
+                        'created_by': 'test_user',
+                        'updated_by': 'test_user',
+                    },
+                    {
+                        'id': 1,
+                        'uuid': 'uuid_1',
+                        'name': 'webhook_1',
+                        'url': 'url_1',
+                        'provider': 'SLACK',
+                        'organization_name': 'test_organization',
+                        'created_at': '2022-05-19T18:20:25.991688+00:00',
+                        'updated_at': '2022-05-19T18:20:25.991688+00:00',
+                        'created_by': 'test_user',
+                        'updated_by': 'test_user',
+                    },
+                    {
+                        'id': 2,
+                        'uuid': 'uuid_2',
+                        'name': 'webhook_2',
+                        'url': 'url_2',
+                        'provider': 'SLACK',
+                        'organization_name': 'test_organization',
+                        'created_at': '2022-05-19T18:20:25.991688+00:00',
+                        'updated_at': '2022-05-19T18:20:25.991688+00:00',
+                        'created_by': 'test_user',
+                        'updated_by': 'test_user',
+                    },
+                ],
+            },
+            'api_version': '2.0',
+            'kind': 'PAGINATED',
+        }
+        url = self._get_url()
+        query_params = {'limit': 300, 'offset': 0, 'organization_name': 'test_organization'}
+
+        self.requests_mock.get(
+            url, json=response, match=[matchers.query_param_matcher(query_params)]
+        )
+
+        webhooks = self.client.get_webhooks()
+        self.assertIsInstance(webhooks[0], Webhook)
+        self.assertEqual(webhooks[0].name, 'webhook_0')
+        self.assertEqual(webhooks[0].organization_name, self._org)
+        self.assertEqual(len(webhooks), 3)
+
+    def test_add_webhook(self):
+        response_body = {
+            'data': {
+                'id': 0,
+                'uuid': 'uuid_0',
+                'name': 'webhook_0',
+                'url': 'url_0',
+                'provider': 'SLACK',
+                'organization_name': 'test_organization',
+                'created_at': '2022-05-19T18:20:25.991688+00:00',
+                'updated_at': '2022-05-19T18:20:25.991688+00:00',
+                'created_by': 'test_user',
+                'updated_by': 'test_user',
+            },
+            'api_version': '2.0',
+            'kind': 'NORMAL',
+        }
+
+        url = self._get_url()
+        query_params = {'organization_name':'test_organization'}
+
+        self.requests_mock.post(
+            url, json=response_body, match=[matchers.query_param_matcher(query_params)]
+        )
+
+        webhook = self.client.add_webhook(
+            name='webhook_0', url='url_i', provider='SLACK'
+        )
+        request_body = json.loads(self.requests_mock.calls[0].request.body)
+        self.assertEqual(
+            webhook.uuid, 'uuid_0'
+        )
+        self.assertEqual(len(self.requests_mock.calls), 1)
+        self.assertEqual(request_body['name'], 'webhook_0')