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

fiddler3/entities/model.py

@@ -4,6 +4,7 @@ import builtins
 import typing
 from dataclasses import dataclass
 from datetime import datetime
+from functools import cached_property
 from pathlib import Path
 from typing import Any, Iterator
 from uuid import UUID
@@ -13,17 +14,20 @@ import pandas as pd
 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.job import Job
-from fiddler3.entities.model_artifact import ArtifactMixin
+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.user import CreatedByMixin, UpdatedByMixin
 from fiddler3.entities.xai import XaiMixin
+from fiddler3.schemas.deployment_params import DeploymentParams
 from fiddler3.schemas.filter_query import OperatorType, QueryCondition, QueryRule
 from fiddler3.schemas.job import JobCompactResp
 from fiddler3.schemas.model import ModelResp
-from fiddler3.schemas.model_schema import Column, ModelSchema
+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
@@ -35,12 +39,12 @@ if typing.TYPE_CHECKING:
 
 class Model(
     BaseEntity,
-    ArtifactMixin,
     CreatedByMixin,
     ProjectCompactMixin,
     UpdatedByMixin,
     SurrogateMixin,
     XaiMixin,
+    EventMixin,
 ):  # pylint: disable=too-many-ancestors
     def __init__(  # pylint: disable=too-many-arguments
         self,
@@ -74,11 +78,6 @@ class Model(
         self.id: UUID | None = None
         self.artifact_status: str | None = None
         self.artifact_files: list[dict] | None = None
-        self.input_cols: list[Column] | None = None
-        self.output_cols: list[Column] | None = None
-        self.target_cols: list[Column] | None = None
-        self.metadata_cols: list[Column] | None = None
-        self.decision_cols: list[Column] | None = None
         self.is_binary_ranking_model: bool | None = None
         self.created_at: datetime | None = None
         self.updated_at: datetime | None = None
@@ -122,11 +121,6 @@ class Model(
             'updated_at',
             'artifact_status',
             'artifact_files',
-            'input_cols',
-            'output_cols',
-            'target_cols',
-            'metadata_cols',
-            'decision_cols',
             'is_binary_ranking_model',
         ]
         for field in fields:
@@ -160,11 +154,6 @@ class Model(
             'updated_at',
             'artifact_status',
             'artifact_files',
-            'input_cols',
-            'output_cols',
-            'target_cols',
-            'metadata_cols',
-            'decision_cols',
             'is_binary_ranking_model',
         ]
         for field in fields:
@@ -172,6 +161,12 @@ class Model(
 
         self._resp = resp_obj
 
+    @cached_property
+    def _artifact(self) -> ModelArtifact:
+        """Model artifact instance"""
+        assert self.id is not None
+        return ModelArtifact(model_id=self.id)
+
     @classmethod
     @handle_api_error
     def get(cls, id_: UUID | str) -> Model:
@@ -268,6 +263,16 @@ class Model(
 
         yield from Dataset.list(model_id=self.id)
 
+    @property
+    @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']
+        )
+
     @classmethod
     @handle_api_error
     def generate_schema(
@@ -304,6 +309,50 @@ class Model(
         job_compact = JobCompactResp(**response.json()['data']['job'])
         return Job.get(id_=job_compact.id)
 
+    def add_artifact(
+        self,
+        model_dir: str | Path,
+        deployment_params: DeploymentParams | None = None,
+    ) -> Job:
+        """
+        Upload and deploy model artifact.
+
+        :param model_dir: Path to model artifact tar file
+        :param deployment_params: Model deployment parameters
+        :return: Async job instance
+        """
+        return self._artifact.add(
+            model_dir=model_dir, deployment_params=deployment_params
+        )
+
+    def update_artifact(
+        self,
+        model_dir: str | Path,
+        deployment_params: DeploymentParams | None = None,
+    ) -> Job:
+        """
+        Update existing model artifact.
+
+        :param model_dir: Path to model artifact tar file
+        :param deployment_params: Model deployment parameters
+        :return: Async job instance
+        """
+        return self._artifact.update(
+            model_dir=model_dir, deployment_params=deployment_params
+        )
+
+    def download_artifact(
+        self,
+        output_dir: str | Path,
+    ) -> None:
+        """
+        Download existing model artifact.
+
+        :param output_dir: Path to download model artifact tar file
+        """
+
+        self._artifact.download(output_dir=output_dir)
+
 
 @dataclass
 class ModelCompact:

fiddler3/entities/model_artifact.py

@@ -1,36 +1,38 @@
 from __future__ import annotations
 
-import json
-import math
 import os
 import shutil
 import tempfile
 from pathlib import Path
-from typing import Any, Callable
+from typing import Callable
 from uuid import UUID
 
-from fiddler3.constants.common import (
-    CONTENT_TYPE_OCTET_STREAM_HEADER,
-    MULTI_PART_CHUNK_SIZE,
-)
+from fiddler3.connection import ConnectionMixin
 from fiddler3.decorators import handle_api_error
+from fiddler3.entities.files import File
 from fiddler3.entities.job import Job
-from fiddler3.schemas.deployment_params import ArtifactType, DeploymentParams
+from fiddler3.schemas.deployment_params import DeploymentParams
 from fiddler3.schemas.job import JobCompactResp
-from fiddler3.schemas.model_artifact import ModelArtifactDeployMultiPartUploadResp
 from fiddler3.utils.logger import get_logger
 from fiddler3.utils.validations import validate_artifact_dir
 
 logger = get_logger(__name__)
 
 
-class ArtifactMixin:
-    id: UUID | None
-    _client: Callable
+class ModelArtifact(ConnectionMixin):
+    def __init__(self, model_id: UUID) -> None:
+        """
+        Model artifact methods
+
+        :param model_id: Model identifier
+        """
+        self.model_id = model_id
 
     def _get_method(self, update: bool = False) -> Callable:
-        """Get HTTP method"""
-        return self._client().put if update else self._client().post
+        """Get HTTP method based on operation"""
+        if update:
+            return self._client().put
+        return self._client().post
 
     def _deploy_model_artifact(
         self,
@@ -49,20 +51,11 @@ class ArtifactMixin:
         model_dir = Path(model_dir)
         validate_artifact_dir(model_dir)
 
-        if (
-            deployment_params
-            and deployment_params.artifact_type.upper() == ArtifactType.SURROGATE
-        ):
-            raise ValueError(
-                f'{ArtifactType.SURROGATE} artifact_type is an invalid value for this '
-                f'method. Use {ArtifactType.PYTHON_PACKAGE} instead.'
-            )
-
         with tempfile.TemporaryDirectory() as tmp:
             # Archive model artifact directory
             logger.info(
                 'Model[%s] - Tarring model artifact directory - %s',
-                self.id,
+                self.model_id,
                 model_dir,
             )
             file_path = shutil.make_archive(
@@ -74,208 +67,54 @@ class ArtifactMixin:
 
             logger.info(
                 'Model[%s] - Model artifact tar file created at %s',
-                self.id,
+                self.model_id,
                 file_path,
             )
 
-            # Choose deployer based on archive file size
-            if os.path.getsize(file_path) < MULTI_PART_CHUNK_SIZE:
-                job = self._artifact_deploy(
-                    file_path=Path(file_path),
-                    deployment_params=deployment_params,
-                    update=update,
-                )
-            else:
-                job = self._artifact_deploy_multipart(
-                    file_path=Path(file_path),
-                    deployment_params=deployment_params,
-                    update=update,
-                )
+            # Upload file
+            file = File(path=file_path).upload()
+
+            # Deploy artifact
+            assert file.id is not None
+            job = self._artifact_deploy(
+                file_id=file.id,
+                deployment_params=deployment_params,
+                update=update,
+            )
 
         logger.info(
             'Model[%s] - Submitted job (%s) for deploying model artifact',
-            self.id,
+            self.model_id,
             job.id,
         )
 
         return job
 
-    def _initialize_multi_part_upload(self, update: bool = False) -> str:
-        """
-        Initialize multi-part upload request
-
-        :return: Multi-part upload id
-        """
-        logger.info(
-            'Model[%s] - Initializing multi-part model upload',
-            self.id,
-        )
-
-        method = self._get_method(update)
-
-        response = method(url=f'/v3/models/{self.id}/deploy-artifact-multi-part-init')
-
-        response_data = response.json().get('data', {})
-
-        logger.info(
-            'Model[%s] - Multi-part model upload initialized',
-            self.id,
-        )
-        return response_data.get('upload_id', '')
-
-    def _upload_multi_part_chunk(
-        self, data: bytes, upload_id: str, part_number: int, update: bool
-    ) -> dict:
-        """
-        Upload data chunk
-
-        :param data: Data chunk
-        :param upload_id: Multi-part upload id
-        :param part_number: Chunk part number
-        :return: Part details
-        """
-        method = self._get_method(update)
-
-        response = method(
-            url=f'/v3/models/{self.id}/deploy-artifact-multi-part-upload',
-            params={
-                'upload_id': upload_id,
-                'part_number': part_number,
-            },
-            data=data,
-            headers=CONTENT_TYPE_OCTET_STREAM_HEADER,
-        )
-        response_data = ModelArtifactDeployMultiPartUploadResp(
-            **response.json()['data']
-        )
-
-        return {
-            'etag': response_data.etag,
-            'part_number': response_data.part_number,
-        }
-
-    def _complete_multi_part_upload(
+    def _artifact_deploy(
         self,
-        upload_id: str,
-        parts: list[dict],
-        update: bool,
+        file_id: UUID,
         deployment_params: DeploymentParams | None = None,
+        update: bool = False,
     ) -> Job:
-        """
-        Complete multi-part upload request and deploy model artifact
-
-        :param upload_id: Multi-part upload id
-        :param parts: List of all parts
-        :param deployment_params: Deployment parameters
-        :return: Async job
-        """
+        """Artifact deploy base method."""
         method = self._get_method(update)
-        payload: dict[str, Any] = {
-            'upload_id': upload_id,
-            'parts': parts,
+        payload = {
+            'file_id': file_id,
+            'deployment_params': deployment_params.dict(exclude_unset=True)
+            if deployment_params
+            else {},
         }
 
-        if deployment_params:
-            payload['deployment_params'] = deployment_params.dict(exclude_unset=True)
-
         response = method(
-            url=f'/v3/models/{self.id}/deploy-artifact-multi-part-complete',
+            url=f'/v3/models/{self.model_id}/deploy-artifact',
             data=payload,
         )
 
-        logger.info(
-            'Model[%s] - Multi-part model upload completed',
-            self.id,
-        )
-        job_compact = JobCompactResp(**response.json()['data']['job'])
-        return Job.get(id_=job_compact.id)
-
-    def _artifact_deploy_multipart(
-        self,
-        file_path: Path,
-        deployment_params: DeploymentParams | None = None,
-        update: bool = False,
-    ) -> Job:
-        """
-        Upload and deploy model artifact
-
-        :param file_path: Path to model artifact tar file
-        :param deployment_params: Model deployment parameters
-        :param update: Flag for add or update artifacts
-        :return: Async job uuid
-        """
-        # 1. Initialize multi-part upload request
-        upload_id = self._initialize_multi_part_upload(update)
-        part_number = 1
-        parts = []
-        file_size = os.path.getsize(file_path)
-        total_chunks = math.ceil(file_size / MULTI_PART_CHUNK_SIZE)
-
-        # 2. Chunk and upload
-        with open(file_path, 'rb') as f:
-            while True:
-                data = f.read(MULTI_PART_CHUNK_SIZE)
-                if not data:
-                    break
-
-                logger.info(
-                    'Model[%s] - Uploading multi-part chunk - %d/%d',
-                    self.id,
-                    part_number,
-                    total_chunks,
-                )
-
-                part = self._upload_multi_part_chunk(
-                    data=data,
-                    upload_id=upload_id,
-                    part_number=part_number,
-                    update=update,
-                )
-                parts.append(part)
-                logger.info(
-                    'Model[%s] - Uploaded multi-part chunk - %d/%d',
-                    self.id,
-                    part_number,
-                    total_chunks,
-                )
-                part_number += 1
-
-        # 3: Complete the upload
-        return self._complete_multi_part_upload(
-            upload_id=upload_id,
-            parts=parts,
-            update=update,
-            deployment_params=deployment_params,
-        )
-
-    def _artifact_deploy(
-        self,
-        file_path: Path,
-        deployment_params: DeploymentParams | None = None,
-        update: bool = False,
-    ) -> Job:
-        """Artifact deploy base method."""
-        method = self._get_method(update)
-        params = {}
-        if deployment_params:
-            params['deployment_params'] = json.dumps(
-                deployment_params.dict(exclude_unset=True)
-            )
-
-        with open(file_path, 'rb') as f:
-            data = f.read()
-            response = method(
-                url=f'/v3/models/{self.id}/deploy-artifact',
-                params=params,
-                data=data,
-                headers=CONTENT_TYPE_OCTET_STREAM_HEADER,
-            )
-
         job_compact = JobCompactResp(**response.json()['data']['job'])
         return Job.get(id_=job_compact.id)
 
     @handle_api_error
-    def add_artifact(
+    def add(
         self,
         model_dir: str | Path,
         deployment_params: DeploymentParams | None = None,
@@ -285,16 +124,14 @@ class ArtifactMixin:
 
         :param model_dir: Path to model artifact tar file
         :param deployment_params: Model deployment parameters
-        :return: Async job.
+        :return: Async job instance
         """
-        self._check_id_attributes()
-        job = self._deploy_model_artifact(
+        return self._deploy_model_artifact(
             model_dir=model_dir, deployment_params=deployment_params
         )
-        return job
 
     @handle_api_error
-    def update_artifact(
+    def update(
         self,
         model_dir: str | Path,
         deployment_params: DeploymentParams | None = None,
@@ -304,16 +141,14 @@ class ArtifactMixin:
 
         :param model_dir: Path to model artifact tar file
         :param deployment_params: Model deployment parameters
-        :return: Async job.
+        :return: Async job instance
         """
-        self._check_id_attributes()
-        job = self._deploy_model_artifact(
+        return self._deploy_model_artifact(
             model_dir=model_dir, deployment_params=deployment_params, update=True
         )
-        return job
 
     @handle_api_error
-    def download_artifact(
+    def download(
         self,
         output_dir: str | Path,
     ) -> None:
@@ -322,7 +157,7 @@ class ArtifactMixin:
 
         :param output_dir: Path to download model artifact tar file
         """
-        self._check_id_attributes()
+
         output_dir = Path(output_dir)
         if output_dir.exists():
             raise ValueError(f'Output dir already exists {output_dir}')
@@ -332,7 +167,7 @@ class ArtifactMixin:
             tar_file_path = os.path.join(tmp_dir, 'artifact.tar')
 
             with self._client().get(
-                url=f'/v3/models/{self.id}/download-artifact'
+                url=f'/v3/models/{self.model_id}/download-artifact'
             ) as resp:
                 resp.raise_for_status()
                 with open(tar_file_path, mode='wb') as f:
@@ -341,10 +176,3 @@ class ArtifactMixin:
                             f.write(chunk)
             os.makedirs(output_dir, exist_ok=True)
             shutil.unpack_archive(tar_file_path, extract_dir=output_dir, format='tar')
-
-    def _check_id_attributes(self) -> None:
-        if not self.id:
-            raise AttributeError(
-                'This method is available only for model object generated from '
-                'API response.'
-            )

fiddler3/entities/project.py

@@ -115,7 +115,7 @@ class Project(BaseEntity):
     def delete(self) -> None:
         """Delete project"""
         # @TODO - Switch this to v3 once we have the endpoint
-        self._client().delete(url=f'/v2/projects/{self.id}')
+        self._client().delete(url=f'/v2/projects/{self.organization_name}:{self.name}')
 
     @property
     def models(self) -> Iterator[ModelCompact]:

fiddler3/entities/webhook.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any, Iterator
+from uuid import UUID
+
+from fiddler3.decorators import handle_api_error
+from fiddler3.entities.base import BaseEntity
+from fiddler3.schemas.webhook import WebhookProvider, WebhookResp
+
+
+class Webhook(BaseEntity):
+    def __init__(self, name: str, url: str, provider: WebhookProvider | str) -> None:
+        """
+        Construct a webhook instance
+
+        :param name: Slug like name
+        """
+        self.name = name
+        self.url = url
+        # provider is 'SLACK' or 'OTHER' as of Aug 2023.
+        self.provider = provider
+
+        self.id: UUID | None = None
+        self.created_at: datetime | None = None
+        self.updated_at: datetime | None = None
+
+        # Deserialized response object
+        self._resp: WebhookResp | None = None
+
+    @staticmethod
+    def _get_url(id_: UUID | str | None = None) -> str:
+        """Get webhook resource/item url"""
+        url = '/v2/webhooks'
+        return url if not id_ else f'{url}/{id_}'
+
+    @classmethod
+    def _from_dict(cls, data: dict) -> Webhook:
+        """Build entity object from the given dictionary"""
+
+        # Deserialize the response
+        resp_obj = WebhookResp(**data)
+
+        # Initialize
+        instance = cls(name=resp_obj.name, url=resp_obj.url, provider=resp_obj.provider)
+        # Add remaining fields
+        fields = ['id', 'created_at', 'updated_at']
+        for field in fields:
+            setattr(instance, field, getattr(resp_obj, field, None))
+
+        instance._resp = resp_obj
+        return instance
+
+    def _refresh(self, data: dict) -> None:
+        """Refresh the fields of this instance from the given response dictionary"""
+        # Deserialize the response
+        resp_obj = WebhookResp(**data)
+
+        fields = [
+            'id',
+            'name',
+            'url',
+            'provider',
+            'created_at',
+            'updated_at',
+        ]
+        for field in fields:
+            setattr(self, field, getattr(resp_obj, field, None))
+
+        self._resp = resp_obj
+
+    @classmethod
+    @handle_api_error
+    def get(cls, id_: UUID | str) -> Webhook:
+        """
+        Get the webhook instance using webhook id
+
+        :params uuid: UUID belongs to the Webhook
+        :returns: `Webhook` object
+        """
+        response = cls._client().get(url=cls._get_url(id_))
+        return cls._from_response(response=response)
+
+    @classmethod
+    @handle_api_error
+    def list(cls) -> Iterator[Webhook]:
+        """Get a list of all webhooks in the organization"""
+        for webhook in cls._paginate(url=cls._get_url()):
+            yield cls._from_dict(data=webhook)
+
+    @handle_api_error
+    def create(self) -> Webhook:
+        """
+        Create 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': self.name,
+            'url': self.url,
+            'provider': self.provider,
+        }
+        response = self._client().post(url=self._get_url(), data=request_body)
+        self._refresh_from_response(response=response)
+        return self
+
+    @handle_api_error
+    def update(self) -> None:
+        """Update an existing webhook."""
+        body: dict[str, Any] = {
+            'name': self.name,
+            'url': self.url,
+            'provider': self.provider,
+        }
+
+        response = self._client().patch(url=self._get_url(id_=self.id), data=body)
+        self._refresh_from_response(response=response)
+
+    @handle_api_error
+    def delete(self) -> None:
+        """Delete an existing webhook."""
+
+        self._client().delete(url=self._get_url(id_=self.id))