fiddler-client 2.0.0.dev9__tar.gz → 2.0.0.dev10__tar.gz

{fiddler-client-2.0.0.dev9 → fiddler-client-2.0.0.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fiddler-client
-Version: 2.0.0.dev9
+Version: 2.0.0.dev10
 Summary: Python client for Fiddler Service
 Home-page: https://fiddler.ai
 Author: Fiddler Labs
@@ -47,6 +47,15 @@ Description: Fiddler Client
             - 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.dev9 → fiddler-client-2.0.0.dev10}/PUBLIC.md

@@ -40,6 +40,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.dev9 → fiddler-client-2.0.0.dev10}/fiddler/__init__.py

@@ -23,7 +23,6 @@ from fiddler.core_objects import (
     Column,
     DatasetInfo,
     DataType,
-    DeploymentType,
     ExplanationMethod,
     FiddlerPublishSchema,
     FiddlerTimestamp,
@@ -43,9 +42,9 @@ from fiddler.schema.alert import (
     Metric,
     Priority,
 )
-from fiddler.schema.model_deployment import DeploymentParams
-from fiddler.schemas.custom_features import Multivariate, TextEmbedding, ImageEmbedding
-from fiddler.utils import logger, ColorLogger
+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,
@@ -61,13 +60,17 @@ __all__ = [
     '__version__',
     'BatchPublishType',
     'Column',
+    'CustomFeature',
+    'CustomFeatureType',
     'Multivariate',
+    'VectorFeature',
     'TextEmbedding',
     'ImageEmbedding',
     'ColorLogger',
     'DatasetInfo',
     'DataType',
     'DeploymentParams',
+    'DeploymentType',
     'FiddlerClient',
     'FiddlerApi',
     'FiddlerTimestamp',

fiddler-client-2.0.0.dev10/fiddler/_version.py

@@ -0,0 +1 @@
+__version__ = '2.0.0.dev10'

{fiddler-client-2.0.0.dev9 → fiddler-client-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-client-2.0.0.dev9 → fiddler-client-2.0.0.dev10}/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-client-2.0.0.dev9 → fiddler-client-2.0.0.dev10}/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-client-2.0.0.dev10/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-client-2.0.0.dev9 → fiddler-client-2.0.0.dev10}/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-client-2.0.0.dev9 → fiddler-client-2.0.0.dev10}/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-client-2.0.0.dev10/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-client-2.0.0.dev10/fiddler/schemas/custom_features.py

@@ -0,0 +1,96 @@
+from enum import Enum
+from typing import Any, Dict, List, Optional, Type, TypeVar
+
+from pydantic import BaseModel
+
+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'
+
+
+class CustomFeature(BaseModel):
+    name: str
+    type: CustomFeatureType
+    n_clusters: Optional[int] = DEFAULT_NUM_CLUSTERS
+    centroids: Optional[List] = None
+
+    class Config:
+        allow_mutation = False
+
+    @classmethod
+    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:
+            return ImageEmbedding.parse_obj(deserialized_json)
+        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):
+    type: CustomFeatureType = CustomFeatureType.FROM_IMAGE_EMBEDDING

{fiddler-client-2.0.0.dev9 → fiddler-client-2.0.0.dev10}/fiddler_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fiddler-client
-Version: 2.0.0.dev9
+Version: 2.0.0.dev10
 Summary: Python client for Fiddler Service
 Home-page: https://fiddler.ai
 Author: Fiddler Labs
@@ -47,6 +47,15 @@ Description: Fiddler Client
             - 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