fiddler-client 2.3.0.dev1__py3-none-any.whl → 2.4.0.dev1__py3-none-any.whl

fiddler/__init__.py

@@ -50,6 +50,7 @@ from fiddler.schemas.custom_features import (
     Multivariate,
     TextEmbedding,
     VectorFeature,
+    Enrichment,
 )
 from fiddler.utils import ColorLogger
 from fiddler.utils.logger import get_logger
@@ -71,6 +72,7 @@ __all__ = [
     'VectorFeature',
     'TextEmbedding',
     'ImageEmbedding',
+    'Enrichment',
     'ColorLogger',
     'DatasetInfo',
     'DataType',

fiddler/_version.py

@@ -1 +1 @@
-__version__ = '2.3.0.dev1'
+__version__ = '2.4.0.dev1'

fiddler/api/alert_mixin.py

@@ -60,7 +60,7 @@ class AlertMixin:
         warning_threshold: Optional[float] = None,
         notifications_config: Optional[Dict[str, Any]] = None,
     ) -> AlertRule:
-        f"""
+        """
         To add an alert rule
 
         :param project_id: Unique project name for which the alert rule is created
@@ -158,6 +158,8 @@ class AlertMixin:
             time_bucket=bin_size.value[0],
             bin_size=bin_size.value[1],
             notifications=notifications_config,
+            feature_name=None,
+            feature_names=None,
         )
 
         if columns and not match_semver(

fiddler/api/events_mixin.py

@@ -34,7 +34,7 @@ class EventsMixin:
         model_name: str,
         events_path: Path,
         batch_id: Optional[str] = None,
-        events_schema: Optional[str] = None,
+        events_schema: Optional[dict] = None,
         id_field: Optional[str] = None,
         is_update: Optional[bool] = None,
         timestamp_field: Optional[str] = None,
@@ -181,12 +181,12 @@ class EventsMixin:
 
         # Either batch_source or events_path can be given for _publish_events_batch_from_file
         if batch_source is None and events_path is None:
-            raise ValueError(f'`batch_source` parameter is required.')
+            raise ValueError('`batch_source` parameter is required.')
 
         if timestamp_format:
             if type(timestamp_format) is not FiddlerTimestamp:
                 raise ValueError(
-                    f'timestamp_format format is not of type FiddlerTimestamp'
+                    'timestamp_format format is not of type FiddlerTimestamp'
                 )
             timestamp_format = FiddlerTimestamp(timestamp_format.value)
         if type(batch_source) == pd.DataFrame and (
@@ -235,7 +235,7 @@ class EventsMixin:
         event: dict,
         event_id: Optional[str] = None,
         update_event: Optional[bool] = None,
-        event_timestamp: Optional[int] = None,
+        event_timestamp: Optional[str] = None,
         timestamp_format: FiddlerTimestamp = FiddlerTimestamp.INFER,
         casting_type: Optional[bool] = False,
         dry_run: Optional[bool] = False,
@@ -263,7 +263,7 @@ class EventsMixin:
         if timestamp_format:
             if type(timestamp_format) is not FiddlerTimestamp:
                 raise ValueError(
-                    f'timestamp_format format is not of type FiddlerTimestamp'
+                    'timestamp_format format is not of type FiddlerTimestamp'
                 )
             timestamp_format = FiddlerTimestamp(timestamp_format.value)
 

fiddler/api/webhooks_mixin.py

@@ -7,10 +7,7 @@ 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,
-)
+from fiddler.utils.response_handler import APIResponseHandler, PaginatedResponseHandler
 
 logger = get_logger(__name__)
 
@@ -83,7 +80,13 @@ class WebhookMixin:
 
         :returns: Updated `Webhook` object.
         """
-        request_body = Webhook(name=name, url=url, provider=provider).dict()
+        request_body = Webhook(
+            uuid=uuid,
+            organization_name=self.organization_name,
+            name=name,
+            url=url,
+            provider=provider,
+        ).dict()
         response = self.client.patch(
             url=f'webhooks/{uuid}',
             data=request_body,

fiddler/core_objects.py

@@ -28,7 +28,9 @@ from pandas.api.types import CategoricalDtype
 
 from fiddler.schemas.custom_features import (
     CustomFeature,
+    Enrichment,
     ImageEmbedding,
+    Multivariate,
     TextEmbedding,
     VectorFeature,
 )
@@ -1235,18 +1237,27 @@ class ModelInfo:
                 + self.get_target_names()
                 + self.get_metadata_names()
             )
+
             numeric_cols = self.get_input_pandas_dtypes()
             if self.metadata:
                 numeric_cols.update(self.get_metadata_pandas_dtypes())
             if self.targets:
                 numeric_cols.update(self.get_target_pandas_dtypes())
-            valid_col_names = [
+
+            valid_numeric_names = [
                 k
                 for k, v in numeric_cols.items()
                 if v in (DataType.INTEGER.value, DataType.FLOAT.value)
             ]
+
+            valid_enrichment_names = [
+                cf.name for cf in self.custom_features if isinstance(cf, Enrichment)
+            ]
+
             valid_vector_cols = [
-                input.name for input in self.inputs if input.data_type.is_vector()  # type: ignore
+                vec_col.name
+                for vec_col in (self.inputs or []) + (self.metadata or [])
+                if vec_col.data_type.is_vector()
             ]
 
             unique_cf_names = []
@@ -1268,17 +1279,77 @@ class ModelInfo:
                 else:
                     unique_cf_names.append(feature.name)
 
-                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:  # type: ignore
-                        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."
-                            )
+                if isinstance(feature, Multivariate):
+                    self.validate_multivariate_cf(feature, valid_numeric_names)
+                elif isinstance(feature, TextEmbedding):
+                    self.validate_text_embedding_cf(
+                        feature,
+                        available_cols,
+                        valid_vector_cols,
+                        valid_enrichment_names,
+                    )
+                elif isinstance(feature, VectorFeature):
+                    self.validate_vector_cf(feature, valid_vector_cols)
+                elif isinstance(feature, Enrichment):
+                    self.validate_enrichment_cf(
+                        feature, available_cols, valid_enrichment_names
+                    )
+
+    def validate_enrichment_cf(
+        self,
+        feature: Enrichment,
+        available_cols: List[str],
+        valid_enrichment_names: List[str],
+    ) -> None:
+        if not feature.columns:
+            raise ValueError(
+                f'{feature.name} ({feature.__class__.__name__}) must specify at least one enrichment/column in columns.'
+            )
+        for column in feature.columns:
+            if column == feature.name:
+                raise ValueError(
+                    f'{feature.name} ({feature.__class__.__name__}) cannot depend on itself.'
+                )
+            if column not in [*valid_enrichment_names, *available_cols]:
+                raise ValueError(
+                    f"Column '{column}' defined in {feature.name} ({feature.__class__.__name__}) does not exist in the data or as an enrichment."
+                )
+
+    def validate_text_embedding_cf(
+        self,
+        feature: TextEmbedding,
+        available_cols: List[str],
+        valid_vector_cols: List[str],
+        valid_enrichment_names: List[str],
+    ) -> None:
+        if feature.column not in valid_vector_cols:
+            # we require either a column or source_column
+            if feature.source_column not in available_cols:
+                raise ValueError(
+                    f'{feature.name} ({feature.__class__.__name__}) needs to specify at least one of [column, source_col].'
+                )
+            # column could be the result of an enrichment
+            if feature.column not in valid_enrichment_names:
+                raise ValueError(
+                    f"Column/Enrichment'{feature.column}' defined in {feature.name} ({feature.__class__.__name__}) does not exist or not of type vector."
+                )
+
+    def validate_vector_cf(self, feature: VectorFeature, valid_vector_cols: List[str]) -> None:
+        if feature.column not in valid_vector_cols:
+            raise ValueError(
+                f"Column '{feature.column}' defined in {feature.name} ({feature.__class__.__name__}) does not exist or not of type vector."
+            )
+
+    def validate_multivariate_cf(self, feature: Multivariate, valid_numeric_names: List[str]) -> None:
+        if len(feature.columns or []) < 2:
+            raise ValueError(
+                f'{feature.name} ({feature.__class__.__name__}) must specify at least two columns.'
+            )
+        for col in feature.columns:
+            if col not in valid_numeric_names:
+                raise ValueError(
+                    f"Column '{col}' defined on {feature.name} ({feature.__class__.__name__}) does not exist or not of type int/float."
+                )
 
     def warn_deprecated_parameter(self, param_name: str, from_version: str) -> None:
         warnings.warn(
@@ -2659,7 +2730,7 @@ class ModelInfo:
         validate_sanitized_names(self.decisions or [], sanitized_name_dict)
 
     def get_all_cols(self) -> List[Column]:
-        result: List = copy.deepcopy(self.inputs) # type: ignore
+        result: List = copy.deepcopy(self.inputs)  # type: ignore
         if self.outputs is not None:
             result += self.outputs
         if self.metadata is not None:
@@ -2756,41 +2827,21 @@ def _summary_dataframe_for_custom_features(
 ) -> pd.DataFrame:
     """
         Example:
-        name    column                      type                transformation  n_clusters  monitor  monitor_components
-    0   F1      'col_name1'                 FROM_TEXT           'Word2vec'      3           True        False
-    1   F2      ['col_name2','col_name3']   FROM_COLUMNS        None            4           True        False
-    2   F3      'col_name4'                 FROM_VECTOR         None            auto        True        False
-    3   F4      'col_name5'                 FROM_DICTIONARY     None            auto        True        False
+        name    column                      type                n_clusters  monitor_components
+    0   F1      'col_name1'                 FROM_TEXT           3           False
+    1   F2      ['col_name2','col_name3']   FROM_COLUMNS        4           False
+    2   F3      'col_name4'                 FROM_VECTOR         auto        False
     """  # noqa E501
-    names = []
-    columns = []
-    types = []
-    clusters: List[Any] = []
-    source_columns = []
-    embeddings = []
-
-    for feature in custom_features:
-        names.append(feature.name)
-        types.append(feature.type.name)
-        columns.append(feature.column)
-        source_columns.append(feature.source_column)
-        embeddings.append(feature.column)
-
-        if feature.n_clusters is not None:
-            clusters.append(feature.n_clusters)
-        else:
-            clusters.append('auto')
+    data = []
 
-    return pd.DataFrame(
-        {
-            'name': names,
-            'type': types,
-            'column': columns,
-            'source': source_columns,
-            'embeddings': embeddings,
-            'n_clusters': clusters,
-        }
-    )
+    for custom_feature in custom_features:
+        # Convert each model instance to a dictionary
+        model_dict = custom_feature.dict()
+        data.append(model_dict)
+
+    # Create DataFrame from the combined data
+    df = pd.DataFrame(data)
+    return df
 
 
 @enum.unique

fiddler/schemas/custom_features.py

@@ -1,7 +1,7 @@
 from enum import Enum
 from typing import Any, Dict, List, Optional, Type, TypeVar
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Extra
 
 CustomFeatureTypeVar = TypeVar('CustomFeatureTypeVar', bound='CustomFeature')
 DEFAULT_NUM_CLUSTERS = 5
@@ -13,6 +13,7 @@ class CustomFeatureType(str, Enum):
     FROM_VECTOR = 'FROM_VECTOR'
     FROM_TEXT_EMBEDDING = 'FROM_TEXT_EMBEDDING'
     FROM_IMAGE_EMBEDDING = 'FROM_IMAGE_EMBEDDING'
+    ENRICHMENT = 'ENRICHMENT'
 
 
 class CustomFeature(BaseModel):
@@ -20,13 +21,10 @@ class CustomFeature(BaseModel):
     type: CustomFeatureType
     n_clusters: Optional[int] = DEFAULT_NUM_CLUSTERS
     centroids: Optional[List] = None
-    columns: Optional[List[str]] = None
-    column: Optional[str] = None
-    source_column: Optional[str] = None
-    n_tags: Optional[int] = DEFAULT_NUM_TAGS
 
     class Config:
         allow_mutation = False
+        extra = Extra.forbid
 
     @classmethod
     def from_columns(
@@ -49,30 +47,31 @@ class CustomFeature(BaseModel):
             return TextEmbedding.parse_obj(deserialized_json)
         elif feature_type == CustomFeatureType.FROM_IMAGE_EMBEDDING:
             return ImageEmbedding.parse_obj(deserialized_json)
+        elif feature_type == CustomFeatureType.ENRICHMENT:
+            return Enrichment.parse_obj(deserialized_json)
         else:
             raise ValueError(f'Unsupported feature type: {feature_type}')
 
     def to_dict(self) -> Dict[str, Any]:
-        return_dict = {
+        return_dict: Dict[str, Any] = {
             'name': self.name,
             'type': self.type.value,
             'n_clusters': self.n_clusters,
         }
-        if self.type == CustomFeatureType.FROM_COLUMNS:
-            return_dict['columns'] = self.columns  # type: ignore
-        elif self.type == CustomFeatureType.FROM_VECTOR:
+        if isinstance(self, Multivariate):
+            return_dict['columns'] = self.columns
+        elif isinstance(self, VectorFeature):
             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
+            if isinstance(self, (ImageEmbedding, TextEmbedding)):
+                return_dict['source_column'] = self.source_column
+                if isinstance(self, TextEmbedding):
+                    return_dict['n_tags'] = self.n_tags
+        elif isinstance(self, Enrichment):
+            return_dict['columns'] = self.columns
+            return_dict['enrichment'] = self.enrichment
+            return_dict['config'] = self.config
         else:
-            raise ValueError(f'Unsupported feature type: {self.type}')
+            raise ValueError(f'Unsupported feature type: {self.type} {type(self)}')
 
         return return_dict
 
@@ -96,3 +95,10 @@ class TextEmbedding(VectorFeature):
 
 class ImageEmbedding(VectorFeature):
     type: CustomFeatureType = CustomFeatureType.FROM_IMAGE_EMBEDDING
+
+
+class Enrichment(CustomFeature):
+    type: CustomFeatureType = CustomFeatureType.ENRICHMENT
+    columns: List[str]
+    enrichment: str
+    config: Dict[str, Any] = {}

fiddler3/constants/baseline.py

@@ -0,0 +1,19 @@
+import enum
+
+
+@enum.unique
+class BaselineType(str, enum.Enum):
+    STATIC = 'STATIC'
+    ROLLING = 'ROLLING'
+
+
+@enum.unique
+class WindowSize(enum.IntEnum):
+    FIVE_MINUTES = 300
+    ONE_HOUR = 3600
+    ONE_DAY = 86400
+    ONE_WEEK = 604800
+    ONE_MONTH = 2592000
+
+    def __str__(self) -> str:
+        return self.name

fiddler3/constants/common.py

@@ -1,3 +1,15 @@
 JSON_CONTENT_TYPE = 'application/json'
 FIDDLER_CLIENT_VERSION_HEADER = 'X-Fiddler-Client-Version'
 CLIENT_NAME = 'python-sdk'
+LOGGER_NAME = 'fiddler3'
+LOG_FORMAT = '%(asctime)s [%(name)s:%(lineno)d] %(levelname)s: %(message)s'
+TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S.%f'
+
+# Headers
+CONTENT_TYPE_HEADER_KEY = 'Content-Type'
+CONTENT_TYPE_OCTET_STREAM = 'application/octet-stream'
+CONTENT_TYPE_OCTET_STREAM_HEADER = {CONTENT_TYPE_HEADER_KEY: CONTENT_TYPE_OCTET_STREAM}
+
+# Multi-part upload
+MULTI_PART_UPLOAD_SIZE_THRESHOLD = 5 * 1024 * 1024  # 5MB in bytes
+MULTI_PART_CHUNK_SIZE = 100 * 1024 * 1024  # 100MB in bytes

fiddler3/constants/dataset.py

@@ -0,0 +1,7 @@
+import enum
+
+
+@enum.unique
+class EnvType(str, enum.Enum):
+    PRODUCTION = 'PRODUCTION'
+    PRE_PRODUCTION = 'PRE_PRODUCTION'

fiddler3/constants/model_deployment.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+import enum
+
+
+@enum.unique
+class DeploymentType(str, enum.Enum):
+    BASE_CONTAINER = 'BASE_CONTAINER'
+    MANUAL = 'MANUAL'
+
+
+@enum.unique
+class ArtifactType(str, enum.Enum):
+    SURROGATE = 'SURROGATE'
+    PYTHON_PACKAGE = 'PYTHON_PACKAGE'

fiddler3/constants/xai.py

@@ -0,0 +1,11 @@
+import enum
+
+
+@enum.unique
+class ExplainMethod(str, enum.Enum):
+    SHAP = 'SHAP'
+    FIDDLER_SHAP = 'FIDDLER_SHAP'
+    IG = 'IG'
+    PERMUTE = 'PERMUTE'
+    ZERO_RESET = 'ZERO_RESET'
+    MEAN_RESET = 'MEAN_RESET'

fiddler3/entities/__init__.py

@@ -1,3 +1,7 @@
+"""Initialize all new entities."""
+from fiddler3.entities.baseline import Baseline  # noqa
+from fiddler3.entities.dataset import Dataset  # noqa
+from fiddler3.entities.job import Job  # noqa
 from fiddler3.entities.model import Model  # noqa
+from fiddler3.entities.model_deployment import ModelDeployment  # noqa
 from fiddler3.entities.project import Project  # noqa
-from fiddler3.entities.job import Job  # noqa

fiddler3/entities/base.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 
+from abc import ABC, abstractmethod
 from typing import Iterator, TypeVar
 
 from requests import Response
 
-from fiddler3 import Connection
 from fiddler3.configs import DEFAULT_PAGE_SIZE
+from fiddler3.connection import Connection
 from fiddler3.libs.http_client import RequestClient
 from fiddler3.schemas.response import PaginatedApiResponse
 
@@ -14,11 +15,11 @@ BaseEntityType = TypeVar(  # pylint: disable=invalid-name
 )
 
 
-class BaseEntity:
+class BaseEntity(ABC):
     @classmethod
     def _connection(cls) -> Connection:
         """Fiddler connection instance"""
-        from fiddler3 import connection
+        from fiddler3 import connection  # pylint: disable=import-outside-toplevel
 
         assert connection is not None
         return connection
@@ -34,43 +35,46 @@ class BaseEntity:
         return cls._from_dict(data=response.json()['data'])
 
     @classmethod
+    @abstractmethod
     def _from_dict(cls: type[BaseEntityType], data: dict) -> BaseEntityType:
         """Build entity object from the given dictionary"""
-        raise NotImplementedError()
+
+    def _refresh(self, data: dict) -> None:  # pylint: disable=unused-argument
+        """Refresh the fields of this instance from the given response dictionary"""
+        return
+
+    def _refresh_from_response(self, response: Response) -> None:
+        """Refresh the instance from the given response"""
+        self._refresh(data=response.json()['data'])
 
     @classmethod
     def _paginate(
         cls, url: str, params: dict | None = None, page_size: int = DEFAULT_PAGE_SIZE
     ) -> Iterator[dict]:
         """
-        Iterator over pagination API
+        Iterate over given pagination endpoint
+
         :param url: Pagination endpoint
         :param page_size: Number of items per page
         :return: Iterator of items
         """
         offset = 0
         params = params or {}
-        params.update(
-            {
-                'limit': page_size,
-                'offset': offset,
-            }
-        )
+        params.update({'limit': page_size})
 
         while True:
+            params.update({'offset': offset})
             response = cls._client().get(
                 url=url,
-                params={
-                    'limit': page_size,
-                    'offset': offset,
-                },
+                params=params,
             )
             resp_obj = PaginatedApiResponse(**response.json()).data
 
-            if resp_obj.page_count == resp_obj.page_index:
-                break
-
             yield from resp_obj.items
 
+            if resp_obj.page_index >= resp_obj.page_count:
+                # Last page
+                break
+
             # Update offset
             offset = resp_obj.offset + page_size