fiddler-client 2.5.0.dev1__py3-none-any.whl → 2.5.0.dev2__py3-none-any.whl

fiddler3/entities/{files.py → file.py}

@@ -4,7 +4,7 @@ import io
 import os
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Callable
+from typing import Any
 from uuid import UUID
 
 from requests import Response
@@ -14,7 +14,7 @@ from fiddler3.constants.common import MULTI_PART_CHUNK_SIZE
 from fiddler3.decorators import handle_api_error
 from fiddler3.entities.base import BaseEntity
 from fiddler3.entities.user import CreatedByMixin, UpdatedByMixin
-from fiddler3.schemas.files import FileResp
+from fiddler3.schemas.file import FileResp
 from fiddler3.utils.logger import get_logger
 
 logger = get_logger(__name__)
@@ -66,16 +66,13 @@ class File(BaseEntity, CreatedByMixin, UpdatedByMixin):
         chunk_size: int = MULTI_PART_CHUNK_SIZE,
     ) -> File:
         """Upload file. Single or multipart upload depends on file size"""
-        upload_method = self._get_upload_method(chunk_size=chunk_size)
-        return upload_method(
-            chunk_size=chunk_size,
-        )
+        if os.path.getsize(self.path) < chunk_size:
+            return self.single_upload()
+
+        return self.multipart_upload(chunk_size=chunk_size)
 
     @handle_api_error
-    def single_upload(
-        self,
-        chunk_size: int = MULTI_PART_CHUNK_SIZE,  # pylint: disable=unused-argument
-    ) -> File:
+    def single_upload(self) -> File:
         """Single part file upload"""
         with open(self.path, 'rb') as f:
             multipart_data = MultipartEncoder(fields={'file': (self.name, f)})
@@ -163,8 +160,3 @@ class File(BaseEntity, CreatedByMixin, UpdatedByMixin):
 
         logger.info('Multi-part upload complete')
         return response
-
-    def _get_upload_method(self, chunk_size: int) -> Callable:
-        if os.path.getsize(self.path) < chunk_size:
-            return self.single_upload
-        return self.multipart_upload

fiddler3/entities/model.py

@@ -11,16 +11,16 @@ from uuid import UUID
 
 import pandas as pd
 
+from fiddler3.constants.dataset import EnvType
 from fiddler3.constants.model import ModelInputType, ModelTask
 from fiddler3.decorators import handle_api_error
 from fiddler3.entities.base import BaseEntity
-from fiddler3.entities.events import EventMixin
-from fiddler3.entities.helpers import raise_not_found
+from fiddler3.entities.events import EventPublisher
 from fiddler3.entities.job import Job
 from fiddler3.entities.model_artifact import ModelArtifact
 from fiddler3.entities.model_deployment import ModelDeployment
-from fiddler3.entities.model_surrogate import SurrogateMixin
 from fiddler3.entities.project import ProjectCompactMixin
+from fiddler3.entities.surrogate import Surrogate
 from fiddler3.entities.user import CreatedByMixin, UpdatedByMixin
 from fiddler3.entities.xai import XaiMixin
 from fiddler3.schemas.deployment_params import DeploymentParams
@@ -31,6 +31,7 @@ from fiddler3.schemas.model_schema import ModelSchema
 from fiddler3.schemas.model_spec import ModelSpec
 from fiddler3.schemas.model_task_params import ModelTaskParams
 from fiddler3.schemas.xai_params import XaiParams
+from fiddler3.utils.helpers import raise_not_found
 from fiddler3.utils.model_schema_generator import SchemaGeneratorFactory
 
 if typing.TYPE_CHECKING:
@@ -42,16 +43,14 @@ class Model(
     CreatedByMixin,
     ProjectCompactMixin,
     UpdatedByMixin,
-    SurrogateMixin,
     XaiMixin,
-    EventMixin,
 ):  # pylint: disable=too-many-ancestors
     def __init__(  # pylint: disable=too-many-arguments
         self,
         name: str,
         project_id: UUID,
         schema: ModelSchema,
-        spec: ModelSpec | None = None,
+        spec: ModelSpec,
         input_type: str = ModelInputType.TABULAR,
         task: str = ModelTask.NOT_SET,
         task_params: ModelTaskParams | None = None,
@@ -71,7 +70,7 @@ class Model(
         self.event_id_col = event_id_col
         self.event_ts_col = event_ts_col
         self.event_ts_format = event_ts_format
-        self.spec = spec or ModelSpec()
+        self.spec = spec
         self.task_params = task_params or ModelTaskParams()
         self.xai_params = xai_params or XaiParams()
 
@@ -167,6 +166,18 @@ class Model(
         assert self.id is not None
         return ModelArtifact(model_id=self.id)
 
+    @cached_property
+    def _surrogate(self) -> Surrogate:
+        """Model artifact instance"""
+        assert self.id is not None
+        return Surrogate(model_id=self.id)
+
+    @cached_property
+    def _event_publisher(self) -> EventPublisher:
+        """Event publisher instance"""
+        assert self.id is not None
+        return EventPublisher(model_id=self.id)
+
     @classmethod
     @handle_api_error
     def get(cls, id_: UUID | str) -> Model:
@@ -196,7 +207,7 @@ class Model(
         if response.json()['data']['total'] == 0:
             raise_not_found('Model not found for the given identifier')
 
-        return cls._from_dict(data=response.json()['data']['items'][0])
+        return cls.get(id_=response.json()['data']['items'][0]['id'])
 
     @handle_api_error
     def create(self) -> Model:
@@ -267,11 +278,9 @@ class Model(
     @handle_api_error
     def model_deployment(self) -> ModelDeployment:
         """Fetch all the deployments for this model"""
-        url = f'{self._get_url(id_=self.id)}/deployment'
-        response = self._client().get(url=url)
-        return ModelDeployment._from_dict(  # pylint: disable=protected-access
-            data=response.json()['data']
-        )
+        assert self.id is not None
+
+        return ModelDeployment.of(model_id=self.id)
 
     @classmethod
     @handle_api_error
@@ -309,6 +318,38 @@ class Model(
         job_compact = JobCompactResp(**response.json()['data']['job'])
         return Job.get(id_=job_compact.id)
 
+    @handle_api_error
+    def publish(
+        self,
+        source: builtins.list[dict[str, Any]] | str | Path | pd.DataFrame,
+        environment: EnvType = EnvType.PRODUCTION,
+        dataset_name: str | None = None,
+        update: bool = False,
+    ) -> builtins.list[UUID] | Job:
+        """
+        Publish Pre-production or Production data
+
+        :param source: one of:
+            Path or str path: path for data file.
+            list[dict]: list of events (max 1000) PRE_PRODUCTION environment is not
+                supported
+            dataframe: events dataframe. EnvType.PRE_PRODUCTION not supported.
+        :param environment: Either EnvType.PRE_PRODUCTION or EnvType.PRODUCTION
+        :param dataset_name: Name of the dataset. Not supported for EnvType.PRODUCTION
+        :param update: flag indicating if the events are updates to previously
+            published rows
+
+        :return: list[UUID] for list of dicts or dataframe source and Job object for
+            file path source.
+        """
+
+        return self._event_publisher.publish(
+            source=source,
+            environment=environment,
+            dataset_name=dataset_name,
+            update=update,
+        )
+
     def add_artifact(
         self,
         model_dir: str | Path,
@@ -353,6 +394,33 @@ class Model(
 
         self._artifact.download(output_dir=output_dir)
 
+    def add_surrogate(
+        self,
+        deployment_params: DeploymentParams | None = None,
+    ) -> Job:
+        """
+        Add a new surrogate model
+
+        :param deployment_params: Model deployment parameters
+        :return: Async job
+        """
+        job = self._surrogate.add(deployment_params=deployment_params)
+        return job
+
+    @handle_api_error
+    def update_surrogate(
+        self,
+        deployment_params: DeploymentParams | None = None,
+    ) -> Job:
+        """
+        Update an existing surrogate model
+
+        :param deployment_params: Model deployment parameters
+        :return: Async job
+        """
+        job = self._surrogate.update(deployment_params=deployment_params)
+        return job
+
 
 @dataclass
 class ModelCompact:

fiddler3/entities/model_artifact.py

@@ -9,7 +9,7 @@ from uuid import UUID
 
 from fiddler3.connection import ConnectionMixin
 from fiddler3.decorators import handle_api_error
-from fiddler3.entities.files import File
+from fiddler3.entities.file import File
 from fiddler3.entities.job import Job
 from fiddler3.schemas.deployment_params import DeploymentParams
 from fiddler3.schemas.job import JobCompactResp
@@ -28,7 +28,7 @@ class ModelArtifact(ConnectionMixin):
         """
         self.model_id = model_id
 
-    def _get_method(self, update: bool = False) -> Callable:
+    def _get_http_method(self, update: bool = False) -> Callable:
         """Get HTTP method based on operation"""
         if update:
             return self._client().put
@@ -60,7 +60,7 @@ class ModelArtifact(ConnectionMixin):
             )
             file_path = shutil.make_archive(
                 base_name=str(Path(tmp) / 'files'),
-                format='tar',
+                format='gztar',
                 root_dir=str(model_dir),
                 base_dir='.',
             )
@@ -97,7 +97,7 @@ class ModelArtifact(ConnectionMixin):
         update: bool = False,
     ) -> Job:
         """Artifact deploy base method."""
-        method = self._get_method(update)
+        http_method = self._get_http_method(update)
         payload = {
             'file_id': file_id,
             'deployment_params': deployment_params.dict(exclude_unset=True)
@@ -105,7 +105,7 @@ class ModelArtifact(ConnectionMixin):
             else {},
         }
 
-        response = method(
+        response = http_method(
             url=f'/v3/models/{self.model_id}/deploy-artifact',
             data=payload,
         )

fiddler3/entities/model_deployment.py

@@ -37,7 +37,7 @@ class ModelDeployment(
         self._resp: ModelDeploymentResponse | None = None
 
     @staticmethod
-    def _get_url(model_id: UUID | str | None = None) -> str:
+    def _get_url(model_id: UUID | str) -> str:
         """Get model deployment url."""
         return f'v3/models/{model_id}/deployment'
 
@@ -110,3 +110,14 @@ class ModelDeployment(
             url=self._get_url(model_id=self.model_id), data=body
         )
         self._refresh_from_response(response=response)
+
+    @classmethod
+    def of(cls, model_id: UUID) -> ModelDeployment:
+        """
+        Get model deployment instance of the given model
+
+        :param model_id: Model identifier
+        :return: ModelDeployment instance
+        """
+        response = cls._client().get(url=cls._get_url(model_id=model_id))
+        return cls._from_dict(data=response.json()['data'])

fiddler3/entities/project.py

@@ -8,9 +8,9 @@ from uuid import UUID
 
 from fiddler3.decorators import handle_api_error
 from fiddler3.entities.base import BaseEntity
-from fiddler3.entities.helpers import raise_not_found
 from fiddler3.schemas.filter_query import OperatorType, QueryCondition, QueryRule
 from fiddler3.schemas.project import ProjectResp
+from fiddler3.utils.helpers import raise_not_found
 
 if typing.TYPE_CHECKING:
     from fiddler3.entities.model import ModelCompact

fiddler3/entities/{model_surrogate.py → surrogate.py}

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
-from typing import Any, Callable
+from typing import Any
 from uuid import UUID
 
+from fiddler3.connection import ConnectionMixin
 from fiddler3.decorators import handle_api_error
 from fiddler3.entities.job import Job
 from fiddler3.schemas.deployment_params import ArtifactType, DeploymentParams
@@ -12,28 +13,26 @@ from fiddler3.utils.logger import get_logger
 logger = get_logger(__name__)
 
 
-class SurrogateMixin:
-    id: UUID | None
-    _client: Callable
+class Surrogate(ConnectionMixin):
+    def __init__(self, model_id: UUID) -> None:
+        """
+        Surrogate model methods
 
-    def _check_id_attributes(self) -> None:
-        if not self.id:
-            raise AttributeError(
-                'This method is available only for model object generated from '
-                'API response.'
-            )
+        :param model_id: Model identifier
+        """
+        self.model_id = model_id
 
-    def _deploy_surrogate_model(
+    def _deploy(
         self,
         deployment_params: DeploymentParams | None = None,
         update: bool = False,
     ) -> Job:
         """
-        Add surrogate model to an existing model
+        Deploy surrogate model to an existing model
 
         :param deployment_params: Model deployment parameters
         :param update: Set True for re-generating surrogate model, otherwise False
-        :return: Async job uuid
+        :return: Async job
         """
         payload: dict[str, Any] = {}
 
@@ -43,22 +42,27 @@ class SurrogateMixin:
                 {'deployment_params': deployment_params.dict(exclude_unset=True)}
             )
 
-        url = f'/v3/models/{self.id}/deploy-surrogate'
-        method: Callable = self._client().put if update else self._client().post
-        response = method(url=url, data=payload)
+        url = f'/v3/models/{self.model_id}/deploy-surrogate'
+
+        if update:
+            http_method = self._client().put
+        else:
+            http_method = self._client().post
+
+        response = http_method(url=url, data=payload)
 
         job_compact = JobCompactResp(**response.json()['data']['job'])
 
         logger.info(
             'Model[%s] - Submitted job (%s) for deploying a surrogate model',
-            self.id,
+            self.model_id,
             job_compact.id,
         )
 
         return Job.get(id_=job_compact.id)
 
     @handle_api_error
-    def add_surrogate(
+    def add(
         self,
         deployment_params: DeploymentParams | None = None,
     ) -> Job:
@@ -66,16 +70,13 @@ class SurrogateMixin:
         Add a new surrogate.
 
         :param deployment_params: Model deployment parameters
-        :return: Async job.
+        :return: Async job
         """
-        self._check_id_attributes()
-        job = self._deploy_surrogate_model(
-            deployment_params=deployment_params, update=False
-        )
+        job = self._deploy(deployment_params=deployment_params, update=False)
         return job
 
     @handle_api_error
-    def update_surrogate(
+    def update(
         self,
         deployment_params: DeploymentParams | None = None,
     ) -> Job:
@@ -83,10 +84,7 @@ class SurrogateMixin:
         Update an existing surrogate.
 
         :param deployment_params: Model deployment parameters
-        :return: Async job.
+        :return: Async job
         """
-        self._check_id_attributes()
-        job = self._deploy_surrogate_model(
-            deployment_params=deployment_params, update=True
-        )
+        job = self._deploy(deployment_params=deployment_params, update=True)
         return job

fiddler3/entities/xai.py

@@ -74,7 +74,7 @@ class XaiMixin:
             'explanation_type': method,
         }
         if ref_data_source:
-            payload['ref_data_source'] = ref_data_source.dict()
+            payload['ref_data_source'] = ref_data_source.dict(exclude_none=True)
         if num_permutations:
             payload['num_permutations'] = num_permutations
         if ci_level:
@@ -114,7 +114,7 @@ class XaiMixin:
 
         payload: dict[str, Any] = {
             'model_id': self.id,
-            'data_source': data_source.dict(),
+            'data_source': data_source.dict(exclude_none=True),
             'protected_features': protected_features,
             'positive_outcome': positive_outcome,
         }
@@ -193,8 +193,8 @@ class XaiMixin:
         """
         self._check_id_attributes()
         output_dir = Path(output_dir)
-        if output_dir.exists():
-            raise ValueError(f'Output dir already exists {output_dir}')
+        if not output_dir.exists():
+            os.makedirs(output_dir)
         payload: dict[str, Any] = {
             'model_id': self.id,
             'query': query,
@@ -205,7 +205,6 @@ class XaiMixin:
         if columns:
             payload['columns'] = columns
 
-        os.makedirs(output_dir)
         file_path = os.path.join(output_dir, 'output.parquet')
         with self._client().post(url='/v3/slice-query/download', data=payload) as resp:
             # Download parquet file
@@ -314,7 +313,7 @@ class XaiMixin:
 
         payload: dict[str, Any] = {
             'model_id': self.id,
-            'data_source': data_source.dict(),
+            'data_source': data_source.dict(exclude_none=True),
         }
 
         if num_refs:
@@ -431,7 +430,7 @@ class XaiMixin:
 
         response = method(
             url='/v3/analytics/precompute-feature-impact',
-            params=payload,
+            data=payload,
         )
 
         job_compact = JobCompactResp(**response.json()['data']['job'])
@@ -487,7 +486,7 @@ class XaiMixin:
 
         response = method(
             url='/v3/analytics/precompute-feature-importance',
-            params=payload,
+            data=payload,
         )
 
         job_compact = JobCompactResp(**response.json()['data']['job'])
@@ -556,7 +555,7 @@ class XaiMixin:
 
         response = method(
             url='/v3/analytics/precompute-predictions',
-            params=payload,
+            data=payload,
         )
 
         job_compact = JobCompactResp(**response.json()['data']['job'])

fiddler3/libs/http_client.py

@@ -78,7 +78,7 @@ class RequestClient:
             request_headers.update(headers)
 
         content_type = request_headers.get('Content-Type')
-        if data and content_type == JSON_CONTENT_TYPE:
+        if data is not None and content_type == JSON_CONTENT_TYPE:
             data = simplejson.dumps(data, ignore_nan=True, cls=RequestClientJSONEncoder)  # type: ignore
 
         kwargs.setdefault('allow_redirects', True)

fiddler3/schemas/__init__.py

@@ -1,9 +0,0 @@
-"""Initialize all schemas."""
-from fiddler3.schemas.custom_features import *  # noqa
-from fiddler3.schemas.dataset import EnvType  # noqa
-from fiddler3.schemas.deployment_params import DeploymentParams  # noqa
-from fiddler3.schemas.model_schema import ModelSchema  # noqa
-from fiddler3.schemas.model_spec import ModelSpec  # noqa
-from fiddler3.schemas.model_task_params import ModelTaskParams  # noqa
-from fiddler3.schemas.xai import *  # noqa
-from fiddler3.schemas.xai_params import XaiParams  # noqa

fiddler3/schemas/alert_rule.py

@@ -30,3 +30,10 @@ class AlertRuleResp(BaseModel):
 
     created_at: datetime
     updated_at: datetime = Field(alias='last_updated')
+
+
+class NotificationConfig(BaseModel):
+    emails: Optional[List[str]]
+    pagerduty_services: Optional[List[str]]
+    pagerduty_severity: Optional[str]
+    webhooks: Optional[List[UUID]]

fiddler3/schemas/custom_features.py

@@ -1,19 +1,11 @@
-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
+from pydantic import BaseModel, validator
 
+from fiddler3.configs import DEFAULT_NUM_CLUSTERS, DEFAULT_NUM_TAGS
+from fiddler3.constants.model import CustomFeatureType
 
-class CustomFeatureType(str, Enum):
-    FROM_COLUMNS = 'FROM_COLUMNS'
-    FROM_VECTOR = 'FROM_VECTOR'
-    FROM_TEXT_EMBEDDING = 'FROM_TEXT_EMBEDDING'
-    FROM_IMAGE_EMBEDDING = 'FROM_IMAGE_EMBEDDING'
-    ENRICHMENT = 'ENRICHMENT'
+CustomFeatureTypeVar = TypeVar('CustomFeatureTypeVar', bound='CustomFeature')
 
 
 class CustomFeature(BaseModel):
@@ -22,6 +14,12 @@ class CustomFeature(BaseModel):
     n_clusters: Optional[int] = DEFAULT_NUM_CLUSTERS
     centroids: Optional[List] = None
 
+    @validator('n_clusters')
+    def validate_n_clusters(cls, value: int) -> int:  # noqa: N805
+        if value < 0:
+            raise ValueError('n_clusters must be greater than 0')
+        return value
+
     class Config:
         allow_mutation = False
 
@@ -80,6 +78,12 @@ class Multivariate(CustomFeature):
     columns: List[str]
     monitor_components: bool = False
 
+    @validator('columns')
+    def validate_columns(cls, value: List[str]) -> List[str]:  # noqa: N805
+        if len(value) < 2:
+            raise ValueError('Multivariate columns must be greater than 1')
+        return value
+
 
 class VectorFeature(CustomFeature):
     type: CustomFeatureType = CustomFeatureType.FROM_VECTOR
@@ -91,10 +95,28 @@ class TextEmbedding(VectorFeature):
     type: CustomFeatureType = CustomFeatureType.FROM_TEXT_EMBEDDING
     n_tags: Optional[int] = DEFAULT_NUM_TAGS
 
+    @validator('source_column')
+    def validate_source_column(cls, value: str) -> str:  # noqa: N805
+        if value is None:
+            raise ValueError('source_column must be specified')
+        return value
+
+    @validator('n_tags')
+    def validate_n_tags(cls, value: int) -> int:  # noqa: N805
+        if value < 0:
+            raise ValueError('n_tags must be greater than 0')
+        return value
+
 
 class ImageEmbedding(VectorFeature):
     type: CustomFeatureType = CustomFeatureType.FROM_IMAGE_EMBEDDING
 
+    @validator('source_column')
+    def validate_source_column(cls, value: str) -> str:  # noqa: N805
+        if value is None:
+            raise ValueError('source_column must be specified')
+        return value
+
 
 class Enrichment(CustomFeature):
     """

fiddler3/schemas/model_deployment.py

@@ -1,4 +1,5 @@
 from datetime import datetime
+from typing import Optional
 from uuid import UUID
 
 from fiddler3.schemas.base import BaseModel
@@ -16,10 +17,10 @@ class ModelDeploymentResponse(BaseModel):
     artifact_type: str
     deployment_type: str
     active: bool
-    image_uri: str
-    replicas: int
-    cpu: int
-    memory: int
+    image_uri: Optional[str]
+    replicas: Optional[int]
+    cpu: Optional[int]
+    memory: Optional[int]
     created_at: datetime
     updated_at: datetime
     created_by: UserCompactResp

fiddler3/schemas/webhook.py

@@ -5,7 +5,6 @@ from uuid import UUID
 from pydantic.fields import Field
 
 from fiddler3.schemas.base import BaseModel
-from fiddler3.schemas.user import UserCompactResp
 
 
 @enum.unique
@@ -22,5 +21,3 @@ class WebhookResp(BaseModel):
     provider: WebhookProvider
     created_at: datetime
     updated_at: datetime
-    created_by: UserCompactResp
-    updated_by: UserCompactResp