fiddler-client 3.0.0.dev8__tar.gz → 3.0.0.dev10__tar.gz

{fiddler-client-3.0.0.dev8/fiddler_client.egg-info → fiddler-client-3.0.0.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fiddler-client
-Version: 3.0.0.dev8
+Version: 3.0.0.dev10
 Summary: Python client for Fiddler Platform
 Home-page: https://fiddler.ai
 Author: Fiddler Labs

fiddler-client-3.0.0.dev10/fiddler/VERSION

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

{fiddler-client-3.0.0.dev8 → fiddler-client-3.0.0.dev10}/fiddler/__init__.py

@@ -20,7 +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.custom_expression 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

{fiddler-client-3.0.0.dev8 → fiddler-client-3.0.0.dev10}/fiddler/configs.py

@@ -1,5 +1,5 @@
 DEFAULT_CONNECTION_TIMEOUT = 60  # In seconds
-MIN_SERVER_VERSION = '23.7.0'  # @TODO: Change this before 3.0 release
+MIN_SERVER_VERSION = '24.4.0'
 DEFAULT_PAGE_SIZE = 50
 JOB_POLL_INTERVAL = 3
 JOB_WAIT_TIMEOUT = 1800

{fiddler-client-3.0.0.dev8 → fiddler-client-3.0.0.dev10}/fiddler/constants/baseline.py

@@ -9,7 +9,6 @@ class BaselineType(str, enum.Enum):
 
 @enum.unique
 class WindowSize(enum.IntEnum):
-    FIVE_MINUTES = 300
     ONE_HOUR = 3600
     ONE_DAY = 86400
     ONE_WEEK = 604800

{fiddler-client-3.0.0.dev8 → fiddler-client-3.0.0.dev10}/fiddler/entities/alert_rule.py

@@ -24,7 +24,7 @@ class AlertRule(
     def __init__(  # pylint: disable=too-many-arguments
         self,
         name: str,
-        model_id: UUID,
+        model_id: UUID | str,
         metric_id: str | UUID,
         priority: Priority | str,
         compare_to: CompareTo | str,
@@ -33,7 +33,7 @@ class AlertRule(
         critical_threshold: float,
         warning_threshold: float | None = None,
         columns: list[str] | None = None,
-        baseline_id: UUID | None = None,
+        baseline_id: UUID | str | None = None,
         compare_bin_delta: int | None = None,
     ) -> None:
         """Construct a alert rule instance."""
@@ -140,18 +140,16 @@ class AlertRule(
     @handle_api_error
     def list(  # pylint: disable=too-many-arguments
         cls,
-        model_id: UUID | None = None,
-        project_id: UUID | None = None,
+        model_id: UUID | str,
         metric_id: UUID | str | None = None,
         columns: list[str] | None = None,
-        baseline_id: UUID | None = None,
+        baseline_id: UUID | str | None = None,
         ordering: list[str] | None = None,
     ) -> Iterator[AlertRule]:
         """
         Get a list of all alert rules in the organization.
 
         :param model_id: list from the specified model
-        :param project_id: list from the specified project
         :param metric_id: list rules set on the specified metric id
         :param columns: list rules set on the specified list of columns
         :param baseline_id: list rules set on the specified baseline_id
@@ -159,18 +157,10 @@ class AlertRule(
 
         :return: paginated list of alert rules for the specified filters
         """
-        rules: list[QueryRule | QueryCondition] = []
+        rules: list[QueryRule | QueryCondition] = [
+            QueryRule(field='model_id', operator=OperatorType.EQUAL, value=model_id)
+        ]
 
-        if model_id:
-            rules.append(
-                QueryRule(field='model_id', operator=OperatorType.EQUAL, value=model_id)
-            )
-        if project_id:
-            rules.append(
-                QueryRule(
-                    field='project_id', operator=OperatorType.EQUAL, value=project_id
-                )
-            )
         if baseline_id:
             rules.append(
                 QueryRule(

{fiddler-client-3.0.0.dev8 → fiddler-client-3.0.0.dev10}/fiddler/entities/baseline.py

@@ -22,10 +22,10 @@ class Baseline(
     def __init__(  # pylint: disable=too-many-arguments
         self,
         name: str,
-        model_id: UUID,
+        model_id: UUID | str,
         environment: EnvType,
         type_: str,
-        dataset_id: UUID | None = None,
+        dataset_id: UUID | str | None = None,
         start_time: int | None = None,
         end_time: int | None = None,
         offset: int | None = None,
@@ -134,27 +134,23 @@ class Baseline(
 
     @classmethod
     @handle_api_error
-    def from_name(cls, name: str, model_name: str, project_name: str) -> Baseline:
+    def from_name(cls, name: str, model_id: UUID | str) -> Baseline:
         """
-        Get the baseline instance using baseline name, model name and project name.
+        Get the baseline instance of a model from baseline name
 
         :param name: Baseline name
-        :param model_name: Name of the model associated with the baseline
-        :param project_name: Name of the project associated with the baseline
+        :param model_id: Model identifier
 
-        :return: Baseline instance for the provided params
+        :return: Baseline instance
         """
 
         _filter = QueryCondition(
             rules=[
                 QueryRule(field='name', operator=OperatorType.EQUAL, value=name),
                 QueryRule(
-                    field='project_name',
+                    field='model_id',
                     operator=OperatorType.EQUAL,
-                    value=project_name,
-                ),
-                QueryRule(
-                    field='model_name', operator=OperatorType.EQUAL, value=model_name
+                    value=model_id,
                 ),
             ]
         )
@@ -172,18 +168,14 @@ class Baseline(
     @handle_api_error
     def list(
         cls,
-        model_id: UUID | None = None,
+        model_id: UUID | str,
         type_: str | None = None,
         environment: EnvType | None = None,
     ) -> Iterator[Baseline]:
-        """Get a list of all baselines in the organization."""
+        """Get a list of all baselines of a model."""
 
         rules: list[QueryRule | QueryCondition] = []
 
-        if model_id:
-            rules.append(
-                QueryRule(field='model_id', operator=OperatorType.EQUAL, value=model_id)
-            )
         if type_:
             rules.append(
                 QueryRule(field='type', operator=OperatorType.EQUAL, value=type_)
@@ -200,13 +192,14 @@ class Baseline(
         _filter = QueryCondition(rules=rules)
         params: dict[str, Any] = {'filter': _filter.json()}
 
-        for baseline in cls._paginate(url=cls._get_url(), params=params):
+        url = f'/v3/models/{model_id}/baselines'
+        for baseline in cls._paginate(url=url, params=params):
             yield cls._from_dict(data=baseline)
 
     @handle_api_error
     def create(self) -> Baseline:
         """Create a new baseline."""
-        payload = {
+        payload: dict[str, Any] = {
             'name': self.name,
             'model_id': self.model_id,
             'type': self.type,

fiddler-client-3.0.0.dev8/fiddler/entities/custom_metric.py → fiddler-client-3.0.0.dev10/fiddler/entities/custom_expression.py

@@ -7,8 +7,9 @@ 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 (
+from fiddler.entities.model import ModelCompactMixin
+from fiddler.entities.project import ProjectCompactMixin
+from fiddler.schemas.custom_expression import (
     CustomExpressionResp,
     CustomMetricResp,
     SegmentResp,
@@ -17,11 +18,11 @@ from fiddler.schemas.filter_query import OperatorType, QueryCondition, QueryRule
 from fiddler.utils.helpers import raise_not_found
 
 
-class CustomExpression(BaseEntity):
+class CustomExpression(BaseEntity, ModelCompactMixin, ProjectCompactMixin):
     def __init__(
         self,
         name: str,
-        model_id: UUID,
+        model_id: UUID | str,
         definition: str,
         description: str | None = None,
     ) -> None:
@@ -37,10 +38,21 @@ class CustomExpression(BaseEntity):
         # Deserialized response object
         self._resp: CustomExpressionResp | None = None
 
+    @classmethod
+    def _get_url(cls, id_: UUID | str | None = None) -> str:
+        """Get custom expression resource/item url."""
+        url = f'/v3/{cls._get_url_path()}'
+        return url if not id_ else f'{url}/{id_}'
+
     @staticmethod
     @abstractmethod
-    def _get_url(id_: UUID | str | None = None) -> str:
-        """Get custom expression resource/item url."""
+    def _get_url_path() -> str:
+        """Get custom expression resource path"""
+
+    @staticmethod
+    @abstractmethod
+    def _get_display_name() -> str:
+        """Get custom expression display name"""
 
     def _refresh(self, data: dict) -> None:
         """Refresh the fields of this instance from the given response dictionary"""
@@ -65,14 +77,11 @@ class CustomExpression(BaseEntity):
 
         # 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,
+            model_id=resp_obj.model.id,
             definition=resp_obj.definition,
             description=resp_obj.description,
         )
@@ -103,15 +112,12 @@ class CustomExpression(BaseEntity):
 
     @classmethod
     @handle_api_error
-    def from_name(
-        cls, name: str, model_name: str, project_name: str
-    ) -> CustomExpression:
+    def from_name(cls, name: str, model_id: UUID | str) -> CustomExpression:
         """
-        Get the custom metric instance using custom metric name, model name and project name.
+        Get the custom metric instance of a model from custom metric 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
+        :param model_id: Model identifier
 
         :return: CustomMetric instance for the provided params
         """
@@ -119,13 +125,13 @@ class CustomExpression(BaseEntity):
         _filter = QueryCondition(
             rules=[
                 QueryRule(field='name', operator=OperatorType.EQUAL, value=name),
+                QueryRule(
+                    field='model_id', operator=OperatorType.EQUAL, value=model_id
+                ),
             ]
         )
         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(
@@ -133,7 +139,9 @@ class CustomExpression(BaseEntity):
             params=params,
         )
         if response.json()['data']['total'] == 0:
-            raise_not_found('Custom metric not found for the given identifier')
+            raise_not_found(
+                f'{cls._get_display_name()} not found for the given identifier'
+            )
 
         return cls._from_dict(data=response.json()['data']['items'][0])
 
@@ -141,32 +149,21 @@ class CustomExpression(BaseEntity):
     @handle_api_error
     def list(
         cls,
-        model_id: UUID,
+        model_id: UUID | str,
     ) -> 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,
-        }
+        url = f'/v3/models/{model_id}/{cls._get_url_path()}'
 
-        for custom_metric in cls._paginate(
-            url=cls._get_url(),
-            params=params,
-        ):
-            yield cls._from_dict(data=custom_metric)
+        for item in cls._paginate(url=url):
+            yield cls._from_dict(data=item)
 
     @handle_api_error
     def create(self) -> CustomExpression:
         """Create a new custom metric."""
-        model = Model.get(id_=self.model_id)
         payload = {
+            'model_id': self.model_id,
             'name': self.name,
-            'organization_name': self.get_organization_name(),
-            'project_name': model.project.name,
-            'model_name': model.name,
             'definition': self.definition,
         }
 
@@ -190,7 +187,11 @@ class CustomExpression(BaseEntity):
 
 class CustomMetric(CustomExpression):
     def __init__(
-        self, name: str, model_id: UUID, definition: str, description: str | None = None
+        self,
+        name: str,
+        model_id: UUID | str,
+        definition: str,
+        description: str | None = None,
     ) -> None:
         """Construct a custom metric instance."""
         super().__init__(name, model_id, definition, description)
@@ -199,15 +200,21 @@ class CustomMetric(CustomExpression):
         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_}'
+    def _get_url_path() -> str:
+        return 'custom-metrics'
+
+    @staticmethod
+    def _get_display_name() -> str:
+        return 'Custom metric'
 
 
 class Segment(CustomExpression):
     def __init__(
-        self, name: str, model_id: UUID, definition: str, description: str | None = None
+        self,
+        name: str,
+        model_id: UUID | str,
+        definition: str,
+        description: str | None = None,
     ) -> None:
         """Construct a segment instance."""
         super().__init__(name, model_id, definition, description)
@@ -216,7 +223,9 @@ class Segment(CustomExpression):
         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_}'
+    def _get_url_path() -> str:
+        return 'segments'
+
+    @staticmethod
+    def _get_display_name() -> str:
+        return 'Segment'

{fiddler-client-3.0.0.dev8 → fiddler-client-3.0.0.dev10}/fiddler/entities/dataset.py

@@ -72,13 +72,12 @@ class Dataset(BaseEntity, ProjectCompactMixin):
 
     @classmethod
     @handle_api_error
-    def from_name(cls, name: str, model_name: str, project_name: str) -> Dataset:
+    def from_name(cls, name: str, model_id: UUID | str) -> Dataset:
         """
         Get the dataset instance using dataset name.
 
         :param name: Dataset name
-        :param model_name: Name of the model associated with the dataset
-        :param project_name: name of the project associated with the dataset
+        :param model_id: Model identifier
 
         :return: Dataset instance for the provided params
         """
@@ -86,12 +85,9 @@ class Dataset(BaseEntity, ProjectCompactMixin):
             rules=[
                 QueryRule(field='name', operator=OperatorType.EQUAL, value=name),
                 QueryRule(
-                    field='project_name',
+                    field='model_id',
                     operator=OperatorType.EQUAL,
-                    value=project_name,
-                ),
-                QueryRule(
-                    field='model_name', operator=OperatorType.EQUAL, value=model_name
+                    value=model_id,
                 ),
             ]
         )
@@ -108,18 +104,16 @@ class Dataset(BaseEntity, ProjectCompactMixin):
 
     @classmethod
     @handle_api_error
-    def list(cls, model_id: UUID | str | None = None) -> Iterator[Dataset]:
+    def list(cls, model_id: UUID | str) -> Iterator[Dataset]:
         """
-        Get a list of all datasets in the organization.
+        Get a list of all datasets of a model.
 
         :param model_id: unique uuid format identifier for model
         :return: Iterator of datasets
         """
         params: dict[str, Any] = {'type': EnvType.PRE_PRODUCTION.value}
-        if model_id:
-            params['model_id'] = str(model_id)
-
-        for dataset in cls._paginate(url=cls._get_url(), params=params):
+        url = f'/v3/models/{model_id}/environments'
+        for dataset in cls._paginate(url=url, params=params):
             yield cls._from_dict(data=dataset)
 
 

{fiddler-client-3.0.0.dev8 → fiddler-client-3.0.0.dev10}/fiddler/entities/file.py

@@ -65,7 +65,6 @@ class File(BaseEntity, CreatedByMixin, UpdatedByMixin):
         chunk_size: int = MULTI_PART_CHUNK_SIZE,
     ) -> File:
         """Upload file. Single or multipart upload depends on file size"""
-        print(f'file size = {os.path.getsize(self.path)}, chunk_size = {chunk_size}')
         if os.path.getsize(self.path) < chunk_size:
             return self.single_upload()
 
@@ -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:
-            response = self._client().post(
-                url='/v3/files/upload',
-                files={
-                    'file': (self.name, io.BytesIO(f.read())),
-                },
-                headers={CONTENT_TYPE_HEADER_KEY: None},
-            )
+
+        response = self._client().post(
+            url='/v3/files/upload',
+            files={'file': (self.name, open(self.path, 'rb'))},
+            headers={CONTENT_TYPE_HEADER_KEY: None},
+        )
 
         self._refresh_from_response(response)
         return self

{fiddler-client-3.0.0.dev8 → fiddler-client-3.0.0.dev10}/fiddler/entities/model.py

@@ -49,7 +49,7 @@ class Model(
     def __init__(  # pylint: disable=too-many-arguments
         self,
         name: str,
-        project_id: UUID,
+        project_id: UUID | str,
         schema: ModelSchema,
         spec: ModelSpec,
         input_type: str = ModelInputType.TABULAR,
@@ -188,15 +188,21 @@ class Model(
 
     @classmethod
     @handle_api_error
-    def from_name(cls, name: str, project_name: str) -> Model:
-        """Get the model instance using model name and project name."""
+    def from_name(cls, name: str, project_id: UUID | str) -> Model:
+        """
+        Get the model instance from model name within a project.
+
+        :param name: Model name
+        :param project_id: Project identifier
+        :return: Model instance
+        """
         _filter = QueryCondition(
             rules=[
                 QueryRule(field='name', operator=OperatorType.EQUAL, value=name),
                 QueryRule(
-                    field='project_name',
+                    field='project_id',
                     operator=OperatorType.EQUAL,
-                    value=project_name,
+                    value=project_id,
                 ),
             ]
         )
@@ -251,7 +257,7 @@ class Model(
     @handle_api_error
     def list(
         cls,
-        project_id: UUID | None = None,
+        project_id: UUID | str,
     ) -> Iterator[ModelCompact]:
         """
         Get a list of all models with the given filters
@@ -259,9 +265,15 @@ class Model(
         :param project_id: Project identifier
         :return: ModelCompact iterator
         """
-        params = {}
-        if project_id:
-            params['project_id'] = project_id
+        _filter = QueryCondition(
+            rules=[
+                QueryRule(
+                    field='project_id', operator=OperatorType.EQUAL, value=project_id
+                ),
+            ]
+        )
+
+        params = {'filter': _filter.json()}
 
         for model in cls._paginate(url=cls._get_url(), params=params):
             yield ModelCompact(id=model['id'], name=model['name'])
@@ -273,6 +285,8 @@ class Model(
             Dataset,
         )
 
+        assert self.id is not None
+
         yield from Dataset.list(model_id=self.id)
 
     @property
@@ -282,6 +296,8 @@ class Model(
             Baseline,
         )
 
+        assert self.id is not None
+
         yield from Baseline.list(model_id=self.id)
 
     @cached_property
@@ -298,7 +314,7 @@ class Model(
         cls,
         source: pd.DataFrame | Path | str,
         name: str,
-        project_id: UUID,
+        project_id: UUID | str,
         spec: ModelSpec | None = None,
         input_type: str = ModelInputType.TABULAR,
         task: str = ModelTask.NOT_SET,
@@ -442,7 +458,7 @@ class Model(
 
     def add_surrogate(
         self,
-        dataset_id: UUID,
+        dataset_id: UUID | str,
         deployment_params: DeploymentParams | None = None,
     ) -> Job:
         """
@@ -460,7 +476,7 @@ class Model(
     @handle_api_error
     def update_surrogate(
         self,
-        dataset_id: UUID,
+        dataset_id: UUID | str,
         deployment_params: DeploymentParams | None = None,
     ) -> Job:
         """

{fiddler-client-3.0.0.dev8 → fiddler-client-3.0.0.dev10}/fiddler/entities/model_artifact.py

@@ -93,7 +93,7 @@ class ModelArtifact(ConnectionMixin):
 
     def _artifact_deploy(
         self,
-        file_id: UUID,
+        file_id: UUID | str,
         deployment_params: DeploymentParams | None = None,
         update: bool = False,
     ) -> Job:

{fiddler-client-3.0.0.dev8 → fiddler-client-3.0.0.dev10}/fiddler/entities/model_deployment.py

@@ -18,7 +18,7 @@ class ModelDeployment(
 ):  # pylint: disable=too-many-instance-attributes
     def __init__(  # pylint: disable=too-many-arguments
         self,
-        model_id: UUID,
+        model_id: UUID | str,
     ) -> None:
         """Construct a model deployment instance."""
         self.id: UUID | None = None  # pylint: disable=invalid-name

{fiddler-client-3.0.0.dev8 → fiddler-client-3.0.0.dev10}/fiddler/entities/project.py

@@ -124,6 +124,8 @@ class Project(BaseEntity):
             Model,
         )
 
+        assert self.id is not None
+
         yield from Model.list(project_id=self.id)
 
 

{fiddler-client-3.0.0.dev8 → fiddler-client-3.0.0.dev10}/fiddler/entities/surrogate.py

@@ -25,7 +25,7 @@ class Surrogate(ConnectionMixin):
 
     def _deploy(
         self,
-        dataset_id: UUID,
+        dataset_id: UUID | str,
         deployment_params: DeploymentParams | None = None,
         update: bool = False,
     ) -> Job:
@@ -71,7 +71,7 @@ class Surrogate(ConnectionMixin):
     @handle_api_error
     def add(
         self,
-        dataset_id: UUID,
+        dataset_id: UUID | str,
         deployment_params: DeploymentParams | None = None,
     ) -> Job:
         """
@@ -89,7 +89,7 @@ class Surrogate(ConnectionMixin):
     @handle_api_error
     def update(
         self,
-        dataset_id: UUID,
+        dataset_id: UUID | str,
         deployment_params: DeploymentParams | None = None,
     ) -> Job:
         """

{fiddler-client-3.0.0.dev8 → fiddler-client-3.0.0.dev10}/fiddler/entities/xai.py

@@ -382,7 +382,7 @@ class XaiMixin:
     @handle_api_error
     def precompute_feature_impact(  # pylint: disable=too-many-arguments
         self,
-        dataset_id: UUID,
+        dataset_id: UUID | str,
         num_samples: int | None = None,
         num_iterations: int | None = None,
         num_refs: int | None = None,
@@ -444,7 +444,7 @@ class XaiMixin:
     @handle_api_error
     def precompute_feature_importance(  # pylint: disable=too-many-arguments
         self,
-        dataset_id: UUID,
+        dataset_id: UUID | str,
         num_samples: int | None = None,
         num_iterations: int | None = None,
         num_refs: int | None = None,
@@ -528,7 +528,7 @@ class XaiMixin:
     @handle_api_error
     def precompute_predictions(
         self,
-        dataset_id: UUID,
+        dataset_id: UUID | str,
         chunk_size: int | None = None,
         update: bool = False,
     ) -> Job: