fiddler-client 3.0.0.dev3__tar.gz → 3.0.0.dev5__tar.gz

{fiddler-client-3.0.0.dev3/fiddler_client.egg-info → fiddler-client-3.0.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fiddler-client
-Version: 3.0.0.dev3
+Version: 3.0.0.dev5
 Summary: Python client for Fiddler Platform
 Home-page: https://fiddler.ai
 Author: Fiddler Labs
@@ -49,6 +49,10 @@ Version History
     - Add percentage violation metrics for alert
     - Support for alert revisions
 
+### 2.4.1
+  - ### **Modifications**
+    - Fix slice query with `vector` type columns
+
 ### 2.4.0
   - ### **New Features**
     - Add support for segments

{fiddler-client-3.0.0.dev3 → fiddler-client-3.0.0.dev5}/PUBLIC.md

@@ -26,6 +26,10 @@ Version History
     - Add percentage violation metrics for alert
     - Support for alert revisions
 
+### 2.4.1
+  - ### **Modifications**
+    - Fix slice query with `vector` type columns
+
 ### 2.4.0
   - ### **New Features**
     - Add support for segments

fiddler-client-3.0.0.dev5/fiddler/VERSION

@@ -0,0 +1 @@
+3.0.0.dev5

{fiddler-client-3.0.0.dev3 → fiddler-client-3.0.0.dev5}/fiddler/__init__.py

@@ -20,6 +20,7 @@ from fiddler.constants.xai import ExplainMethod  # noqa
 from fiddler.entities.alert_record import AlertRecord  # noqa
 from fiddler.entities.alert_rule import AlertRule  # noqa
 from fiddler.entities.baseline import Baseline  # noqa
+from fiddler.entities.custom_metric import CustomMetric, Segment  # noqa
 from fiddler.entities.dataset import Dataset  # noqa
 from fiddler.entities.file import File  # noqa
 from fiddler.entities.job import Job  # noqa
@@ -103,11 +104,13 @@ __all__ = [
     'AlertRule',
     'Baseline',
     'Dataset',
+    'CustomMetric',
     'File',
     'Job',
     'Model',
     'ModelDeployment',
     'Project',
+    'Segment',
     'Webhook',
     # Exceptions
     'NotFound',

{fiddler-client-3.0.0.dev3 → fiddler-client-3.0.0.dev5}/fiddler/constants/common.py

@@ -11,5 +11,4 @@ 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

fiddler-client-3.0.0.dev5/fiddler/entities/custom_metric.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from datetime import datetime
+from typing import Any, Iterator
+from uuid import UUID
+
+from fiddler.decorators import handle_api_error
+from fiddler.entities.base import BaseEntity
+from fiddler.entities.model import Model
+from fiddler.schemas.custom_metric import (
+    CustomExpressionResp,
+    CustomMetricResp,
+    SegmentResp,
+)
+from fiddler.schemas.filter_query import OperatorType, QueryCondition, QueryRule
+from fiddler.utils.helpers import raise_not_found
+
+
+class CustomExpression(BaseEntity):
+    def __init__(
+        self,
+        name: str,
+        model_id: UUID,
+        definition: str,
+        description: str | None = None,
+    ) -> None:
+        """Construct a custom expression instance."""
+        self.name = name
+        self.model_id = model_id
+        self.definition = definition
+        self.description = description
+
+        self.id: UUID | None = None
+        self.created_at: datetime | None = None
+
+        # Deserialized response object
+        self._resp: CustomExpressionResp | None = None
+
+    @staticmethod
+    @abstractmethod
+    def _get_url(id_: UUID | str | None = None) -> str:
+        """Get custom expression resource/item url."""
+
+    def _refresh(self, data: dict) -> None:
+        """Refresh the fields of this instance from the given response dictionary"""
+        # Deserialize the response
+        resp_obj = CustomMetricResp(**data)
+        assert self.model_id
+        fields = [
+            'id',
+            'name',
+            'definition',
+            'description',
+            'created_at',
+        ]
+        for field in fields:
+            setattr(self, field, getattr(resp_obj, field, None))
+
+        self._resp = resp_obj
+
+    @classmethod
+    def _from_dict(cls, data: dict) -> CustomExpression:
+        """Build entity object from the given dictionary."""
+
+        # Deserialize the response
+        resp_obj = CustomMetricResp(**data)
+        model = Model.from_name(
+            name=resp_obj.model_name, project_name=resp_obj.project_name
+        )
+        assert model.id
+        # Initialize
+        instance = cls(
+            name=resp_obj.name,
+            model_id=model.id,
+            definition=resp_obj.definition,
+            description=resp_obj.description,
+        )
+
+        # Add remaining fields
+        fields = [
+            'id',
+            'created_at',
+        ]
+        for field in fields:
+            setattr(instance, field, getattr(resp_obj, field, None))
+
+        instance._resp = resp_obj
+
+        return instance
+
+    @classmethod
+    @handle_api_error
+    def get(cls, id_: UUID | str) -> CustomExpression:
+        """
+        Get the CustomMetric instance using custom metric id.
+
+        :param id_: unique uuid format identifier for custom metric
+        :return: CustomMetric instance
+        """
+        response = cls._client().get(url=cls._get_url(id_=id_))
+        return cls._from_response(response=response)
+
+    @classmethod
+    @handle_api_error
+    def from_name(
+        cls, name: str, model_name: str, project_name: str
+    ) -> CustomExpression:
+        """
+        Get the custom metric instance using custom metric name, model name and project name.
+
+        :param name: Custom metric name
+        :param model_name: Name of the model associated with the custom metric
+        :param project_name: Name of the project associated with the custom metric
+
+        :return: CustomMetric instance for the provided params
+        """
+
+        _filter = QueryCondition(
+            rules=[
+                QueryRule(field='name', operator=OperatorType.EQUAL, value=name),
+            ]
+        )
+        params: dict[str, Any] = {
+            'filter': _filter.json(),
+            'organization_name': cls.get_organization_name(),
+            'project_name': project_name,
+            'model_name': model_name,
+        }
+
+        response = cls._client().get(
+            url=cls._get_url(),
+            params=params,
+        )
+        if response.json()['data']['total'] == 0:
+            raise_not_found('Custom metric not found for the given identifier')
+
+        return cls._from_dict(data=response.json()['data']['items'][0])
+
+    @classmethod
+    @handle_api_error
+    def list(
+        cls,
+        model_id: UUID,
+    ) -> Iterator[CustomExpression]:
+        """Get a list of all custom metrics in the organization."""
+
+        model = Model.get(id_=model_id)
+        params: dict[str, Any] = {
+            'organization_name': cls.get_organization_name(),
+            'project_name': model.project.name,
+            'model_name': model.name,
+        }
+
+        for custom_metric in cls._paginate(
+            url=cls._get_url(),
+            params=params,
+        ):
+            yield cls._from_dict(data=custom_metric)
+
+    @handle_api_error
+    def create(self) -> CustomExpression:
+        """Create a new custom metric."""
+        model = Model.get(id_=self.model_id)
+        payload = {
+            'name': self.name,
+            'organization_name': self.get_organization_name(),
+            'project_name': model.project.name,
+            'model_name': model.name,
+            'definition': self.definition,
+        }
+
+        if self.description:
+            payload['description'] = self.description
+
+        response = self._client().post(
+            url=self._get_url(),
+            data=payload,
+        )
+        self._refresh_from_response(response=response)
+        return self
+
+    @handle_api_error
+    def delete(self) -> None:
+        """Delete a custom metric."""
+        assert self.id is not None
+
+        self._client().delete(url=self._get_url(id_=self.id))
+
+
+class CustomMetric(CustomExpression):
+    def __init__(
+        self, name: str, model_id: UUID, definition: str, description: str | None = None
+    ) -> None:
+        """Construct a custom metric instance."""
+        super().__init__(name, model_id, definition, description)
+
+        # Deserialized response object
+        self._resp: CustomMetricResp | None = None
+
+    @staticmethod
+    def _get_url(id_: UUID | str | None = None) -> str:
+        """Get custom metric resource/item url."""
+        url = '/v2/custom-metrics'
+        return url if not id_ else f'{url}/{id_}'
+
+
+class Segment(CustomExpression):
+    def __init__(
+        self, name: str, model_id: UUID, definition: str, description: str | None = None
+    ) -> None:
+        """Construct a segment instance."""
+        super().__init__(name, model_id, definition, description)
+
+        # Deserialized response object
+        self._resp: SegmentResp | None = None
+
+    @staticmethod
+    def _get_url(id_: UUID | str | None = None) -> str:
+        """Get segment resource/item url."""
+        url = '/v2/segments'
+        return url if not id_ else f'{url}/{id_}'

{fiddler-client-3.0.0.dev3 → fiddler-client-3.0.0.dev5}/fiddler/entities/file.py

@@ -8,7 +8,6 @@ from typing import Any
 from uuid import UUID
 
 from requests import Response
-from requests_toolbelt import MultipartEncoder
 
 from fiddler.constants.common import MULTI_PART_CHUNK_SIZE
 from fiddler.decorators import handle_api_error
@@ -74,14 +73,12 @@ class File(BaseEntity, CreatedByMixin, UpdatedByMixin):
     @handle_api_error
     def single_upload(self) -> File:
         """Single part file upload"""
-        with open(self.path, 'rb') as f:
-            multipart_data = MultipartEncoder(fields={'file': (self.name, f)})
 
-            response = self._client().post(
-                url='/v3/files/upload',
-                data=multipart_data,
-                headers={'Content-Type': multipart_data.content_type},
-            )
+        response = self._client().post(
+            url='/v3/files/upload',
+            files={'file': (self.name, open(self.path, 'rb'))},
+            headers={'Content-Type': None},
+        )
 
         self._refresh_from_response(response)
         return self

{fiddler-client-3.0.0.dev3 → fiddler-client-3.0.0.dev5}/fiddler/entities/model_artifact.py

@@ -66,9 +66,10 @@ class ModelArtifact(ConnectionMixin):
             )
 
             logger.info(
-                'Model[%s] - Model artifact tar file created at %s',
+                'Model[%s] - Model artifact tar file created at %s - %d bytes',
                 self.model_id,
                 file_path,
+                os.path.getsize(file_path),
             )
 
             # Upload file

{fiddler-client-3.0.0.dev3 → fiddler-client-3.0.0.dev5}/fiddler/libs/http_client.py

@@ -7,7 +7,6 @@ from urllib.parse import urljoin
 import requests
 import simplejson
 from requests.adapters import HTTPAdapter
-from requests_toolbelt.multipart.encoder import MultipartEncoder
 
 from fiddler.constants.common import JSON_CONTENT_TYPE
 from fiddler.exceptions import (  # pylint: disable=redefined-builtin
@@ -51,7 +50,6 @@ class RequestClient:
         headers: dict | None = None,
         data: dict | bytes | None = None,
         timeout: int | None = None,
-        files_encoders: dict[str, MultipartEncoder] | None = None,
         **kwargs: Any,
     ) -> requests.Response:
         """
@@ -63,9 +61,6 @@ class RequestClient:
         :param headers: Request headers
         :param data: Dict/binary data
         :param timeout: Request timeout in seconds
-        :param files_encoders:  Dictionary of 'filename': file-like-objects
-            for multipart encoding upload. Make sure all MultipartEncoder values have
-            same content_type.
         """
         logger.debug('Making %s call to %s', method, url)
 
@@ -87,31 +82,16 @@ class RequestClient:
         # So setting that as default here
         kwargs.setdefault('verify', self.session.verify)
         try:
-            if files_encoders:
-                encoders = list(files_encoders.values())
-                if encoders:
-                    request_headers['Content-Type'] = encoders[0].content_type
-                response = self.session.request(
-                    method,
-                    full_url,
-                    params=params,
-                    files=files_encoders,
-                    headers=request_headers,
-                    timeout=timeout,
-                    proxies=self.proxies,
-                    **kwargs,
-                )
-            else:
-                response = self.session.request(
-                    method,
-                    full_url,
-                    params=params,
-                    data=data,
-                    headers=request_headers,
-                    timeout=timeout,
-                    proxies=self.proxies,
-                    **kwargs,
-                )
+            response = self.session.request(
+                method,
+                full_url,
+                params=params,
+                data=data,
+                headers=request_headers,
+                timeout=timeout,
+                proxies=self.proxies,
+                **kwargs,
+            )
 
         except requests.Timeout as exc:
             logger.error('%s call failed with Timeout error for URL %s', method, url)
@@ -173,7 +153,6 @@ class RequestClient:
         headers: dict | None = None,
         timeout: int | None = None,
         data: dict | bytes | None = None,
-        files_encoders: dict[str, MultipartEncoder] | None = None,
         **kwargs: dict[str, Any],
     ) -> requests.Response:
         """Construct a post request instance."""
@@ -184,7 +163,6 @@ class RequestClient:
             headers=headers,
             timeout=timeout,
             data=data,
-            files_encoders=files_encoders,
             **kwargs,
         )
 

fiddler-client-3.0.0.dev5/fiddler/schemas/custom_metric.py

@@ -0,0 +1,23 @@
+from datetime import datetime
+from typing import Optional
+from uuid import UUID
+
+from fiddler.schemas.base import BaseModel
+
+
+class CustomExpressionResp(BaseModel):
+    id: UUID
+    name: str
+    model_name: str
+    project_name: str
+    definition: str
+    description: Optional[str]
+    created_at: datetime
+
+
+class CustomMetricResp(CustomExpressionResp):
+    """Custom metric response object"""
+
+
+class SegmentResp(CustomExpressionResp):
+    """Segment response object"""