fiddler-client 3.0.0.dev3__py3-none-any.whl → 3.0.0.dev5__py3-none-any.whl

fiddler/VERSION

@@ -1 +1 @@
-3.0.0.dev3
+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/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/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/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/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/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/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"""

fiddler/tests/apis/test_custom_metric.py

@@ -0,0 +1,352 @@
+from http import HTTPStatus
+from uuid import UUID
+
+import pytest
+import responses
+from responses import matchers
+
+from fiddler.entities.custom_metric import CustomMetric
+from fiddler.exceptions import Conflict, NotFound
+from fiddler.tests.apis.test_model import API_RESPONSE_200 as MODEL_API_RESPONSE_200
+from fiddler.tests.apis.test_model import (
+    API_RESPONSE_FROM_NAME as MODEL_API_RESPONSE_FROM_NAME,
+)
+from fiddler.tests.constants import MODEL_ID, MODEL_NAME, ORG_NAME, PROJECT_NAME, URL
+
+CUSTOM_METRIC_ID = '7057867c-6dd8-4915-89f2-a5f253dd4a3a'
+CUSTOM_METRIC_NAME = 'xyzabc'
+
+API_RESPONSE_200 = {
+    'data': {
+        'description': 'meh',
+        'definition': "average(\"Age\")",
+        'created_by': {
+            'id': 2,
+            'full_name': 'Nikhil Singh',
+            'email': 'nikhil@fiddler.ai',
+        },
+        'name': CUSTOM_METRIC_NAME,
+        'id': CUSTOM_METRIC_ID,
+        'organization_name': ORG_NAME,
+        'model_name': MODEL_NAME,
+        'project_name': PROJECT_NAME,
+        'created_at': '2024-02-13T07:56:04.275549+00:00',
+    },
+    'api_version': '2.0',
+    'kind': 'NORMAL',
+}
+
+API_RESPONSE_404 = {
+    'error': {
+        'code': 404,
+        'message': "CustomMetric({'uuid': UUID('7057867c-6dd8-4915-89f2-a5f253dd4a3a')}) not found",
+        'errors': [
+            {
+                'reason': 'ObjectNotFound',
+                'message': "CustomMetric({'uuid': UUID('7057867c-6dd8-4915-89f2-a5f253dd4a3a')}) not found",
+                'help': '',
+            }
+        ],
+    },
+    'api_version': '2.0',
+    'kind': 'ERROR',
+}
+
+API_RESPONSE_FROM_NAME = {
+    'data': {
+        'page_size': 100,
+        'total': 1,
+        'item_count': 1,
+        'page_count': 1,
+        'page_index': 1,
+        'offset': 0,
+        'items': [API_RESPONSE_200['data']],
+    }
+}
+
+EMPTY_LIST_API_RESPONSE = {
+    'data': {
+        'page_size': 100,
+        'total': 0,
+        'item_count': 0,
+        'page_count': 1,
+        'page_index': 1,
+        'offset': 0,
+        'items': [],
+    }
+}
+
+LIST_API_RESPONSE = {
+    'data': {
+        'page_size': 100,
+        'total': 2,
+        'item_count': 2,
+        'page_count': 1,
+        'page_index': 1,
+        'offset': 0,
+        'items': [
+            API_RESPONSE_200['data'],
+            {
+                'description': 'meh',
+                'definition': "average(\"Age\")",
+                'created_by': {
+                    'id': 2,
+                    'full_name': 'Nikhil Singh',
+                    'email': 'nikhil@fiddler.ai',
+                },
+                'name': 'abcxyz',
+                'id': 'a509c450-c00b-4b5c-9a96-89c43e287e5a',
+                'organization_name': ORG_NAME,
+                'model_name': MODEL_NAME,
+                'project_name': PROJECT_NAME,
+                'created_at': '2024-02-12T07:56:04.275549+00:00',
+            },
+        ],
+    }
+}
+
+API_RESPONSE_409 = {
+    'error': {
+        'code': 409,
+        'message': 'Custom metric with the same name already exists for this model',
+        'errors': [
+            {
+                'reason': 'Conflict',
+                'message': 'Custom metric with the same name already exists for this model',
+                'help': '',
+            }
+        ],
+    },
+    'api_version': '2.0',
+    'kind': 'ERROR',
+}
+
+
+@responses.activate
+def test_get_custom_metric() -> None:
+    responses.get(
+        url=f'{URL}/v2/custom-metrics/{CUSTOM_METRIC_ID}',
+        json=API_RESPONSE_200,
+    )
+
+    responses.get(
+        url=f'{URL}/v3/models',
+        json=MODEL_API_RESPONSE_FROM_NAME,
+    )
+
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=MODEL_API_RESPONSE_200,
+    )
+
+    cm = CustomMetric.get(id_=CUSTOM_METRIC_ID)
+    assert isinstance(cm, CustomMetric)
+
+
+@responses.activate
+def test_get_cm_not_found() -> None:
+    responses.get(
+        url=f'{URL}/v2/custom-metrics/{CUSTOM_METRIC_ID}',
+        json=API_RESPONSE_404,
+        status=HTTPStatus.NOT_FOUND,
+    )
+
+    with pytest.raises(NotFound):
+        CustomMetric.get(id_=CUSTOM_METRIC_ID)
+
+
+@responses.activate
+def test_cm_from_name() -> None:
+    params = {
+        'filter': '{"condition": "AND", "rules": [{"field": "name", "operator": "equal", "value": "xyzabc"}]}',
+        'model_name': 'bank_churn',
+        'organization_name': 'fiddler_dev',
+        'project_name': 'bank_churn',
+    }
+
+    responses.get(
+        url=f'{URL}/v2/custom-metrics',
+        json=API_RESPONSE_FROM_NAME,
+        match=[matchers.query_param_matcher(params)],
+    )
+    responses.get(
+        url=f'{URL}/v3/models',
+        json=MODEL_API_RESPONSE_FROM_NAME,
+    )
+
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=MODEL_API_RESPONSE_200,
+    )
+    cm = CustomMetric.from_name(
+        name=CUSTOM_METRIC_NAME,
+        model_name=MODEL_NAME,
+        project_name=PROJECT_NAME,
+    )
+    assert isinstance(cm, CustomMetric)
+
+
+@responses.activate
+def test_cm_from_name_not_found() -> None:
+    params = {
+        'filter': '{"condition": "AND", "rules": [{"field": "name", "operator": "equal", "value": "xyzabc"}]}',
+        'model_name': 'bank_churn',
+        'organization_name': 'fiddler_dev',
+        'project_name': 'bank_churn',
+    }
+    responses.get(
+        url=f'{URL}/v2/custom-metrics',
+        json=EMPTY_LIST_API_RESPONSE,
+        match=[matchers.query_param_matcher(params)],
+    )
+    with pytest.raises(NotFound):
+        CustomMetric.from_name(
+            name=CUSTOM_METRIC_NAME,
+            model_name=MODEL_NAME,
+            project_name=PROJECT_NAME,
+        )
+
+
+@responses.activate
+def test_cm_list_empty() -> None:
+    responses.get(
+        url=f'{URL}/v2/custom-metrics',
+        json=EMPTY_LIST_API_RESPONSE,
+    )
+
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=MODEL_API_RESPONSE_200,
+    )
+
+    assert len(list(CustomMetric.list(model_id=MODEL_ID))) == 0
+
+
+@responses.activate
+def test_cm_list_success() -> None:
+    params = {
+        'organization_name': ORG_NAME,
+        'project_name': PROJECT_NAME,
+        'model_name': MODEL_NAME,
+        'limit': 50,
+        'offset': 0,
+    }
+
+    responses.get(
+        url=f'{URL}/v2/custom-metrics',
+        json=LIST_API_RESPONSE,
+        match=[matchers.query_param_matcher(params)],
+    )
+
+    responses.get(
+        url=f'{URL}/v3/models',
+        json=MODEL_API_RESPONSE_FROM_NAME,
+    )
+
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=MODEL_API_RESPONSE_200,
+    )
+
+    for cm in CustomMetric.list(model_id=MODEL_ID):
+        assert isinstance(cm, CustomMetric)
+
+
+@responses.activate
+def test_cm_create() -> None:
+    responses.post(
+        url=f'{URL}/v2/custom-metrics',
+        json=API_RESPONSE_200,
+    )
+
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=MODEL_API_RESPONSE_200,
+    )
+
+    custom_metric = CustomMetric(
+        name=CUSTOM_METRIC_NAME,
+        model_id=MODEL_ID,
+        definition="average(\"Age\")",
+        description='meh',
+    ).create()
+
+    assert isinstance(custom_metric, CustomMetric)
+    assert custom_metric.id == UUID(CUSTOM_METRIC_ID)
+    assert custom_metric.name == CUSTOM_METRIC_NAME
+    assert custom_metric.model_id
+
+
+@responses.activate
+def test_cm_create_conflict() -> None:
+    responses.post(
+        url=f'{URL}/v2/custom-metrics',
+        json=API_RESPONSE_409,
+        status=HTTPStatus.CONFLICT,
+    )
+
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=MODEL_API_RESPONSE_200,
+    )
+
+    with pytest.raises(Conflict):
+        CustomMetric(
+            name=CUSTOM_METRIC_NAME,
+            model_id=MODEL_ID,
+            definition="average(\"Age\")",
+            description='meh',
+        ).create()
+
+
+@responses.activate
+def test_delete_cm() -> None:
+    responses.get(
+        url=f'{URL}/v2/custom-metrics/{CUSTOM_METRIC_ID}',
+        json=API_RESPONSE_200,
+    )
+
+    responses.get(
+        url=f'{URL}/v3/models',
+        json=MODEL_API_RESPONSE_FROM_NAME,
+    )
+
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=MODEL_API_RESPONSE_200,
+    )
+    custom_metric = CustomMetric.get(id_=CUSTOM_METRIC_ID)
+
+    responses.delete(
+        url=f'{URL}/v2/custom-metrics/{CUSTOM_METRIC_ID}',
+    )
+
+    custom_metric.delete()
+
+
+@responses.activate
+def test_delete_cm_not_found() -> None:
+    responses.get(
+        url=f'{URL}/v2/custom-metrics/{CUSTOM_METRIC_ID}',
+        json=API_RESPONSE_200,
+    )
+
+    responses.get(
+        url=f'{URL}/v3/models',
+        json=MODEL_API_RESPONSE_FROM_NAME,
+    )
+
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=MODEL_API_RESPONSE_200,
+    )
+    custom_metric = CustomMetric.get(id_=CUSTOM_METRIC_ID)
+
+    responses.delete(
+        url=f'{URL}/v2/custom-metrics/{CUSTOM_METRIC_ID}',
+        json=API_RESPONSE_404,
+        status=HTTPStatus.NOT_FOUND,
+    )
+
+    with pytest.raises(NotFound):
+        custom_metric.delete()

fiddler/tests/test_utils.py

@@ -6,7 +6,7 @@ import pandas as pd
 import pytest
 
 from fiddler.schemas.server_info import Version
-from fiddler.utils.helpers import group_by
+from fiddler.utils.helpers import group_by, try_series_retype
 from fiddler.utils.validations import validate_artifact_dir
 from fiddler.utils.version import match_semver
 
@@ -66,3 +66,34 @@ def test_group_by_helper() -> None:
             ]
         )
     )
+
+
+def test_try_series_retype() -> None:
+    series = pd.Series([1, 2, 3], dtype='float')
+    series = try_series_retype(series, 'int')
+    assert series.dtype == 'int'
+
+    series = pd.Series([1, 2, None])
+    series = try_series_retype(series, 'int')
+    assert series.dtype == 'float'
+
+
+def test_try_series_retype_str_or_unkown() -> None:
+    series = pd.Series(['HIGH', 'MEDIUM', '', None], dtype='str')
+    series = try_series_retype(series, 'str')
+    assert series.dtype == 'object'
+
+
+def test_try_series_retype_timestamp() -> None:
+    series = pd.Series(
+        ['2023-11-12 09:15:32.23', '2023-12-11 09:15:32.45'], dtype='str'
+    )
+    series = try_series_retype(series, 'timestamp')
+    assert series.dtype == 'datetime64[ns]'
+
+
+def test_try_series_retype_timestamp_error() -> None:
+    series = pd.Series(['2023-11-12 09:15:32.23', None], dtype='str')
+
+    with pytest.raises(TypeError):
+        try_series_retype(series, 'timestamp')

fiddler/utils/helpers.py

@@ -17,7 +17,7 @@ logger = get_logger(__name__)
 
 def try_series_retype(series: pd.Series, new_type: str) -> pd.DataFrame | pd.Series:
     """Retype series."""
-    if new_type in ['unknown', 'str']:
+    if new_type in ['unknown', 'str', 'vector']:
         # Do not retype data
         return series
 

{fiddler_client-3.0.0.dev3.dist-info → fiddler_client-3.0.0.dev5.dist-info}/METADATA

@@ -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.dist-info → fiddler_client-3.0.0.dev5.dist-info}/RECORD

@@ -1,6 +1,5 @@
-fiddler/VERSION,sha256=yO0l7dPNd5kEmvr-FF91Tc-71LgfA35oMSIFv--D6Vg,11
-fiddler/__init__.py,sha256=ld-wK07BBilK902CLMDq1t0UA4kjrCYy2FYOtY44-s4,3270
-fiddler/_version.py,sha256=yJge9cTI7RlcMxUwRv_9Rr7NuUL4zJTXfcamq-ObEkU,27
+fiddler/VERSION,sha256=UQ3IJpH6gZGP-vWjehD7g68w-idDM4WCOAjN3EGl-xk,11
+fiddler/__init__.py,sha256=VCfPx51-NUioKq0OZSKmQTq0Qd20G088BcZt4CIzmG0,3378
 fiddler/configs.py,sha256=s8nKw_2gCEKYk8dnmRxd92J8rCl08V4vPcH0xATT4Lw,258
 fiddler/connection.py,sha256=pYaOyyJytsljofaMyRPV-Vs_i4wHKO48BxIJMqEBxHg,5760
 fiddler/decorators.py,sha256=tWZliQQeUGwY0rU52FO9JXuOBueQXVEJywEbrgUEw1U,1820
@@ -9,7 +8,7 @@ fiddler/version.py,sha256=8fyg3UhFpqghMpxbtYIwNcB1lhCG6yTkPBbDS7IrwxY,140
 fiddler/constants/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fiddler/constants/alert_rule.py,sha256=cmFq-VKAlQbRKEkTtMmVNdD5R52uMI2zJai6TESFwfs,512
 fiddler/constants/baseline.py,sha256=NhmiGf73gy2IHKKpbm64HCE4eJfbxkAPy3uk_Z-6qSo,321
-fiddler/constants/common.py,sha256=4C14p_Kdng3canYWDyT244ikhFH6jo8oAfoYkZaq5vw,610
+fiddler/constants/common.py,sha256=pfUe_aA3GCDJcnXxOQXyv8TEBoHePbh8nJz0GTaSDCs,543
 fiddler/constants/dataset.py,sha256=ZxPmzycSlrKpUYShpfTDqfmz8LAebzyBtIV_dBy-pRI,126
 fiddler/constants/events.py,sha256=3SgjNo4IS-_Nod8wbj98di4B4GctF9R414MZxfQ4MkU,114
 fiddler/constants/job.py,sha256=tMT0vr3x3IiCTQcifP2s1-VWC5gskflKexfU_VfDIzA,233
@@ -21,12 +20,13 @@ fiddler/entities/alert_record.py,sha256=RcDACWDNpntkiId-JpkLQvVeIbuaZAzn6AWl2zYI
 fiddler/entities/alert_rule.py,sha256=hdIJ6n2lTCPRRTdyf-x9yVDjCaYlgYzu0jxa7iBbQkc,11908
 fiddler/entities/base.py,sha256=YCTLt1ta8UbD7u-5BW7v_ocA4S7LevEncI5XPS_SB60,2106
 fiddler/entities/baseline.py,sha256=1y2bFIapzlDSBd4EUfNy6e-Q8fm3t0AGAZTdiz97hXQ,8157
+fiddler/entities/custom_metric.py,sha256=Oxcnx-o1D4WowDIa5nclGDbw5eYwpemlIyhDhjyq0Ow,6802
 fiddler/entities/dataset.py,sha256=dmOWae2IxwoIbIRX62fCtjr6uNrht3mSuFw_QTnvZwI,4712
 fiddler/entities/events.py,sha256=usFxs8Cq0ds1MIrOjZT5jVt3XDXMdGYakOoNFnTFQ8Y,4370
-fiddler/entities/file.py,sha256=14DzU3Cs86IWEgXsfGggPlmsGBpiCsO8qareimc6p34,4846
+fiddler/entities/file.py,sha256=U8IlMYl2iOdGwRWSCYmVbvFlx3rVJM-Xxr0soqLux0U,4667
 fiddler/entities/job.py,sha256=Feiqo6ns4bRcp2uaV-kuGYAKs90-aYXvzqqi1yLivYE,5220
 fiddler/entities/model.py,sha256=TiI-n6TfFP8gdML_kbrowBotFIsRqb2UmiClkyzXn3c,16499
-fiddler/entities/model_artifact.py,sha256=6sDTUwKwKXdnBml8xj-2SErxO_IP3RRPO-4NSz2VViU,5459
+fiddler/entities/model_artifact.py,sha256=ktyFkg-nUPtdpSUGNXHfLOwSMiBaaRkdU0s9DQ67lLs,5514
 fiddler/entities/model_deployment.py,sha256=JefFd7uUgPaxWhtVTJZqTMCLWz_18DM8o2zZmY_Hn6c,3757
 fiddler/entities/organization.py,sha256=XvUAdBUOYXzdmblxIs4hi0mAg45NtAwy5DBaMiqi47o,1074
 fiddler/entities/project.py,sha256=_ONa4srk6zrDl6o6-BznmjiINn7TDabYSsWxve7BZxw,4595
@@ -35,7 +35,7 @@ fiddler/entities/user.py,sha256=ev_Xx9QHAdEHYzNDafzQihXOcD8ME5XkpKgc8MiqCnw,1243
 fiddler/entities/webhook.py,sha256=I-mcl92Tg2-oUUqNMOeDPBe0XawVYhNcTGXHBway7_A,3798
 fiddler/entities/xai.py,sha256=t5LOOWRtr0KnNJHOPfdhrH1WdNT6MBpAZoQ8Teiu9a8,20232
 fiddler/libs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fiddler/libs/http_client.py,sha256=NvENXPm5w713OH9l6yq_KcJmXm4N1AsetYRIHY4oNBQ,7072
+fiddler/libs/http_client.py,sha256=bl2V-q66NoPHm950CiDqOoF-kCPztYWUYNy9hVUsbqg,6027
 fiddler/libs/json_encoder.py,sha256=brsrWySvtZdaBArIkqKM5WwJUbvZf6ZbKozn1CewjOc,512
 fiddler/libs/semver.py,sha256=3HbXG1S-ABIxL3E0FHSm5OR_YrhYtCB2Q3XJ8-tywts,15995
 fiddler/packtools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -49,6 +49,7 @@ fiddler/schemas/alert_rule.py,sha256=-V0AibEImrfcEZfJ4J_Ed5SuZISOGsk-nIoVlX5mOOg
 fiddler/schemas/base.py,sha256=upzAmneEz169h_w-UDH_tY0Abo7DeK68YOZ5qVwIMa8,189
 fiddler/schemas/baseline.py,sha256=0z7ohzDmUKENmlVZDFx4vB-0SRVTOKaeM1N-pDSCIDk,923
 fiddler/schemas/custom_features.py,sha256=G0UqikCyvhnLg6oUAutvq4mEsGgVcLkPlJaMCbRZj68,5382
+fiddler/schemas/custom_metric.py,sha256=SEadAmmBxHHQV9z2gCvbY19zJfLel_tpEiy1jJTjt7s,475
 fiddler/schemas/dataset.py,sha256=rGmpMrMfPLSs9d3_sxDTjrKqWp-o-bCe9pf_nlYyHfw,657
 fiddler/schemas/events.py,sha256=dH6SGPBO_rgGZetIhSo4Fq0L1pTU7TEKR7zW7gg3fnI,409
 fiddler/schemas/file.py,sha256=z_7bOxKbwQsgI8F7MMQvC6RE5dgdzYCMyD5XcBirjCc,462
@@ -73,12 +74,13 @@ fiddler/tests/constants.py,sha256=-_uoidMv6eQ-ldHCN5u_uBXuX3aS4YuylaUSbBfGHYY,10
 fiddler/tests/test_connection.py,sha256=d8WoB0QRZEObWfeRAZRXRm1kw9wfEysmeo4Bld7x8js,1865
 fiddler/tests/test_json_encoder.py,sha256=GJeFT5tTA4RTfZn1q2xm1V5SEj5DNsW3LeHPVfFxcFw,783
 fiddler/tests/test_logger.py,sha256=StDWgtVoBOplRsvcH44Su-ikOWcafT29Kof-K-jiTxc,312
-fiddler/tests/test_utils.py,sha256=Rr50DIxghloxtCNiri1ToD2EKp9Xf9r95lPX-Fg9naM,2366
+fiddler/tests/test_utils.py,sha256=AF6y7UfboEkCa-nNw0aF30SdHC7yW2Hh78J4H_4s78k,3333
 fiddler/tests/utils.py,sha256=FEDbASW4pYZktdEK2FLnIDyZCwBzpb60m6EzkvOkwSc,335
 fiddler/tests/apis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fiddler/tests/apis/test_alert_record.py,sha256=_0EBRDn87TqTiO1KYEHKQQVtVZjj4lYjbt8Ix-RRTSg,3118
 fiddler/tests/apis/test_alert_rule.py,sha256=wBZVU4pwPLS3QJMbO06k9DsyJJb5hI4SxPqU0RjOIWM,11197
 fiddler/tests/apis/test_baseline.py,sha256=6KRXol1AxVwyfGH9epTGd_U4_5b-IVU4ArTWRbuJ0nc,7580
+fiddler/tests/apis/test_custom_metric.py,sha256=I2-CqEScMOaGJsQ-jZmZlzfh35OtilJqzk6RXH3UR6A,8942
 fiddler/tests/apis/test_dataset.py,sha256=k-H2o1txgxN0kmsHNAC5ZYqB3atPM2Vlx3TwqcTZrcw,4765
 fiddler/tests/apis/test_events.py,sha256=e5sd3dIfMPyHoX-jX1QjCP90D-2ijJq1NERGbbfmSls,4510
 fiddler/tests/apis/test_files.py,sha256=-BisPck7bHMSW3N40ffdQJe027Qe3079tjTlU2OI9DU,4501
@@ -93,13 +95,13 @@ fiddler/tests/apis/test_project.py,sha256=IEYT3imD4dZJg-OT888G4jQJ_AxxHN5_VkCHcm
 fiddler/tests/apis/test_webhook.py,sha256=DTaEI9r2lossAaXb3b1CX4C8L3bYAzZmLIWH8VeauUs,6440
 fiddler/tests/apis/test_xai.py,sha256=5TzRv3jSTn2xi3qpwPyKyybEVjHcSyszSHTLzuXU30s,28537
 fiddler/utils/__init__.py,sha256=ooAJR6_tVaF6UKZriz5ynZPj8IeCzaDIPKV23F-e4Fk,53
-fiddler/utils/helpers.py,sha256=9cfAdpkIg16VPVv7jZzcHpJ5H5yi4bBPHKppAAZV734,2898
+fiddler/utils/helpers.py,sha256=Xl_T_se9SOeMTmVJAOVzzmkekUsmpFMlAb2KvPCWfTw,2908
 fiddler/utils/logger.py,sha256=FdJ3LkS9dbRjWsw5oJmNNsd7q0XRVEIvx5-TWys7L0k,669
 fiddler/utils/model_generator.py,sha256=TwQMQDpy-0gcq6HyL68s37N-sk_nGPq33mmppK6i7hI,2203
 fiddler/utils/validations.py,sha256=i8NtgrpCsitq6BPa5lygpKDh07oaOXu7PAlCIcMvqzY,408
 fiddler/utils/version.py,sha256=iC8Ry7UFl9EJW_xU1WbzO_l4yK6V7eQ6U5exB3xT864,531
-fiddler_client-3.0.0.dev3.dist-info/LICENSE.txt,sha256=w8-LUAb_VLBWSsCNmih0pAqLIicJfGu8OJXpDjkIg_o,559
-fiddler_client-3.0.0.dev3.dist-info/METADATA,sha256=Mg2x1U2ToKTJjZKEiK4D2aVsqVyNAlRK2ff0NZ2oUNg,20593
-fiddler_client-3.0.0.dev3.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-fiddler_client-3.0.0.dev3.dist-info/top_level.txt,sha256=ndC6LqvKmrTTs8czRlBOYdYgSqZbHuMf0zHt_HWpzzk,8
-fiddler_client-3.0.0.dev3.dist-info/RECORD,,
+fiddler_client-3.0.0.dev5.dist-info/LICENSE.txt,sha256=w8-LUAb_VLBWSsCNmih0pAqLIicJfGu8OJXpDjkIg_o,559
+fiddler_client-3.0.0.dev5.dist-info/METADATA,sha256=iyTcPoK3ebTms6F_Tmm3csGfUcmxgy-Ced_ASIAg4s4,20679
+fiddler_client-3.0.0.dev5.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+fiddler_client-3.0.0.dev5.dist-info/top_level.txt,sha256=ndC6LqvKmrTTs8czRlBOYdYgSqZbHuMf0zHt_HWpzzk,8
+fiddler_client-3.0.0.dev5.dist-info/RECORD,,

fiddler/_version.py

@@ -1 +0,0 @@
-__version__ = '3.0.0.dev3'