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

fiddler3/entities/model_deployment.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+from uuid import UUID
+
+from fiddler3.decorators import handle_api_error
+from fiddler3.entities.base import BaseEntity
+from fiddler3.entities.project import ProjectCompactMixin
+from fiddler3.schemas.model_deployment import ModelDeploymentResponse
+from fiddler3.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class ModelDeployment(
+    BaseEntity, ProjectCompactMixin
+):  # pylint: disable=too-many-instance-attributes
+    def __init__(  # pylint: disable=too-many-arguments
+        self,
+        model_id: UUID,
+    ) -> None:
+        """Construct a model deployment instance."""
+        self.id: UUID | None = None  # pylint: disable=invalid-name
+        self.model_id = model_id
+        self.artifact_type: str | None = None
+        self.deployment_type: str | None = None
+        self.active: bool | None = None
+        self.image_uri: str | None = None
+        self.replicas: int | None = None
+        self.cpu: int | None = None
+        self.memory: int | None = None
+        self.created_at: datetime | None = None
+        self.updated_at: datetime | None = None
+
+        # Deserialized response object
+        self._resp: ModelDeploymentResponse | None = None
+
+    @staticmethod
+    def _get_url(model_id: UUID | str | None = None) -> str:
+        """Get model deployment url."""
+        return f'v3/models/{model_id}/deployment'
+
+    @classmethod
+    def _from_dict(cls, data: dict) -> ModelDeployment:
+        """Build entity object from the given dictionary."""
+
+        # Deserialize the response
+        resp_obj = ModelDeploymentResponse(**data)
+        # Initialize
+        instance = cls(
+            model_id=resp_obj.model.id,
+        )
+
+        # Add remaining fields
+        fields = [
+            'id',
+            'artifact_type',
+            'deployment_type',
+            'active',
+            'image_uri',
+            'replicas',
+            'cpu',
+            'memory',
+            '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 = ModelDeploymentResponse(**data)
+
+        fields = [
+            'id',
+            'artifact_type',
+            'deployment_type',
+            'active',
+            'image_uri',
+            'replicas',
+            'cpu',
+            'memory',
+            'created_at',
+            'updated_at',
+        ]
+        for field in fields:
+            setattr(self, field, getattr(resp_obj, field, None))
+
+        self._resp = resp_obj
+
+    @handle_api_error
+    def update(self) -> None:
+        """Update an existing model deployment."""
+        body: dict[str, Any] = {
+            'artifact_type': self.artifact_type,
+            'deployment_type': self.deployment_type,
+            'active': self.active,
+            'image_uri': self.image_uri,
+            'replicas': self.replicas,
+            'cpu': self.cpu,
+            'memory': self.memory,
+        }
+
+        response = self._client().patch(
+            url=self._get_url(model_id=self.model_id), data=body
+        )
+        self._refresh_from_response(response=response)

fiddler3/entities/model_surrogate.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from typing import Any, Callable
+from uuid import UUID
+
+from fiddler3.decorators import handle_api_error
+from fiddler3.entities.job import Job
+from fiddler3.schemas.deployment_params import ArtifactType, DeploymentParams
+from fiddler3.schemas.job import JobCompactResp
+from fiddler3.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class SurrogateMixin:
+    id: UUID | None
+    _client: Callable
+
+    def _check_id_attributes(self) -> None:
+        if not self.id:
+            raise AttributeError(
+                'This method is available only for model object generated from '
+                'API response.'
+            )
+
+    def _deploy_surrogate_model(
+        self,
+        deployment_params: DeploymentParams | None = None,
+        update: bool = False,
+    ) -> Job:
+        """
+        Add 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
+        """
+        payload: dict[str, Any] = {}
+
+        if deployment_params:
+            deployment_params.artifact_type = ArtifactType.SURROGATE
+            payload.update(
+                {'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)
+
+        job_compact = JobCompactResp(**response.json()['data']['job'])
+
+        logger.info(
+            'Model[%s] - Submitted job (%s) for deploying a surrogate model',
+            self.id,
+            job_compact.id,
+        )
+
+        return Job.get(id_=job_compact.id)
+
+    @handle_api_error
+    def add_surrogate(
+        self,
+        deployment_params: DeploymentParams | None = None,
+    ) -> Job:
+        """
+        Add a new surrogate.
+
+        :param deployment_params: Model deployment parameters
+        :return: Async job.
+        """
+        self._check_id_attributes()
+        job = self._deploy_surrogate_model(
+            deployment_params=deployment_params, update=False
+        )
+        return job
+
+    @handle_api_error
+    def update_surrogate(
+        self,
+        deployment_params: DeploymentParams | None = None,
+    ) -> Job:
+        """
+        Update an existing surrogate.
+
+        :param deployment_params: Model deployment parameters
+        :return: Async job.
+        """
+        self._check_id_attributes()
+        job = self._deploy_surrogate_model(
+            deployment_params=deployment_params, update=True
+        )
+        return job

fiddler3/entities/organization.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from datetime import datetime
+from uuid import UUID
+
+from fiddler3.entities.base import BaseEntity
+from fiddler3.schemas.organization import OrganizationResp
+
+
+class Organization(BaseEntity):
+    def __init__(self) -> None:
+        """Construct a organization instance"""
+
+        self.name: str | None = None
+        self.id: UUID | None = None
+        self.created_at: datetime | None = None
+        self.updated_at: datetime | None = None
+
+        # Deserialized response object
+        self._resp: OrganizationResp | None = None
+
+    @classmethod
+    def _from_dict(cls, data: dict) -> Organization:
+        """Build entity object from the given dictionary"""
+
+        # Deserialize the response
+        resp_obj = OrganizationResp(**data)
+
+        # Initialize
+        instance = cls()
+
+        # Add remaining fields
+        fields = ['id', 'name', 'created_at', 'updated_at']
+        for field in fields:
+            setattr(instance, field, getattr(resp_obj, field, None))
+
+        instance._resp = resp_obj
+        return instance

fiddler3/entities/project.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import typing
+from dataclasses import dataclass
 from datetime import datetime
 from typing import Iterator
 from uuid import UUID
@@ -7,13 +9,18 @@ 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.project import ProjectResponse
+from fiddler3.schemas.filter_query import OperatorType, QueryCondition, QueryRule
+from fiddler3.schemas.project import ProjectResp
+
+if typing.TYPE_CHECKING:
+    from fiddler3.entities.model import ModelCompact
 
 
 class Project(BaseEntity):
     def __init__(self, name: str) -> None:
         """
         Construct a project instance
+
         :param name: Slug like name
         """
         self.name = name
@@ -23,7 +30,7 @@ class Project(BaseEntity):
         self.updated_at: datetime | None = None
 
         # Deserialized response object
-        self._resp: ProjectResponse | None = None
+        self._resp: ProjectResp | None = None
 
     @staticmethod
     def _get_url(id_: UUID | str | None = None) -> str:
@@ -36,7 +43,7 @@ class Project(BaseEntity):
         """Build entity object from the given dictionary"""
 
         # Deserialize the response
-        resp_obj = ProjectResponse(**data)
+        resp_obj = ProjectResp(**data)
 
         # Initialize
         instance = cls(
@@ -51,6 +58,22 @@ class Project(BaseEntity):
         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 = ProjectResp(**data)
+
+        fields = [
+            'id',
+            'name',
+            '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) -> Project:
@@ -62,7 +85,13 @@ class Project(BaseEntity):
     @handle_api_error
     def from_name(cls, name: str) -> Project:
         """Get the project instance using project name"""
-        response = cls._client().get(url=cls._get_url(), params={'name': name})
+        _filter = QueryCondition(
+            rules=[QueryRule(field='name', operator=OperatorType.EQUAL, value=name)]
+        )
+
+        response = cls._client().get(
+            url=cls._get_url(), params={'filter': _filter.json()}
+        )
         if response.json()['data']['total'] == 0:
             raise_not_found('Project not found for the given identifier')
 
@@ -71,9 +100,7 @@ class Project(BaseEntity):
     @classmethod
     @handle_api_error
     def list(cls) -> Iterator[Project]:
-        """
-        Get a list of all projects in the organization
-        """
+        """Get a list of all projects in the organization"""
         for project in cls._paginate(url=cls._get_url()):
             yield cls._from_dict(data=project)
 
@@ -81,10 +108,44 @@ class Project(BaseEntity):
     def create(self) -> Project:
         """Create a new project"""
         response = self._client().post(url=self._get_url(), data={'name': self.name})
-        return self._from_response(response=response)
+        self._refresh_from_response(response=response)
+        return self
 
     @handle_api_error
     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}')
+
+    @property
+    def models(self) -> Iterator[ModelCompact]:
+        """Fetch all the models of this project"""
+        from fiddler3.entities.model import (  # pylint: disable=import-outside-toplevel
+            Model,
+        )
+
+        yield from Model.list(project_id=self.id)
+
+
+@dataclass
+class ProjectCompact:
+    id: UUID
+    name: str
+
+    def fetch(self) -> Project:
+        """Fetch project instance"""
+        return Project.get(id_=self.id)
+
+
+class ProjectCompactMixin:
+    @property
+    def project(self) -> ProjectCompact:
+        """Project instance"""
+        response = getattr(self, '_resp', None)
+        if not response or not hasattr(response, 'project'):
+            raise AttributeError(
+                'This property is available only for objects generated from API '
+                'response.'
+            )
+
+        return ProjectCompact(id=response.project.id, name=response.project.name)

fiddler3/entities/user.py

@@ -0,0 +1,45 @@
+from dataclasses import dataclass
+from uuid import UUID
+
+
+@dataclass
+class UserCompact:
+    id: UUID
+    full_name: str
+    email: str
+
+
+class CreatedByMixin:
+    @property
+    def created_by(self) -> UserCompact:
+        """Model instance"""
+        response = getattr(self, '_resp', None)
+        if not response or not hasattr(response, 'created_by'):
+            raise AttributeError(
+                'This property is available only for objects generated from API '
+                'response.'
+            )
+
+        return UserCompact(
+            id=response.created_by.id,
+            full_name=response.created_by.full_name,
+            email=response.created_by.email,
+        )
+
+
+class UpdatedByMixin:
+    @property
+    def updated_by(self) -> UserCompact:
+        """Model instance"""
+        response = getattr(self, '_resp', None)
+        if not response or not hasattr(response, 'updated_by'):
+            raise AttributeError(
+                'This property is available only for objects generated from API '
+                'response.'
+            )
+
+        return UserCompact(
+            id=response.updated_by.id,
+            full_name=response.updated_by.full_name,
+            email=response.updated_by.email,
+        )