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

fiddler3/tests/apis/test_mixin.py

@@ -0,0 +1,77 @@
+from unittest import mock
+
+import pytest
+
+from fiddler3.constants.dataset import EnvType
+from fiddler3.entities.baseline import BaselineCompact, BaselineCompactMixin
+from fiddler3.entities.dataset import DatasetCompact, DatasetCompactMixin
+from fiddler3.entities.model import ModelCompact, ModelCompactMixin
+from fiddler3.entities.project import ProjectCompact, ProjectCompactMixin
+from fiddler3.entities.user import CreatedByMixin, UpdatedByMixin, UserCompact
+from fiddler3.schemas.baseline import BaselineCompactResp
+from fiddler3.schemas.dataset import DatasetCompactResp
+from fiddler3.schemas.model import ModelCompactResp
+from fiddler3.schemas.project import ProjectCompactResp
+from fiddler3.schemas.user import UserCompactResp
+from fiddler3.tests.constants import (
+    BASELINE_ID,
+    BASELINE_NAME,
+    DATASET_ID,
+    DATASET_NAME,
+    MODEL_ID,
+    MODEL_NAME,
+    PROJECT_ID,
+    PROJECT_NAME,
+    USER_EMAIL,
+    USER_ID,
+    USER_NAME,
+)
+
+
+class DummyEntity(
+    ModelCompactMixin,
+    ProjectCompactMixin,
+    DatasetCompactMixin,
+    BaselineCompactMixin,
+    CreatedByMixin,
+    UpdatedByMixin,
+):
+    def __init__(self) -> None:
+        self._resp = mock.MagicMock()
+        self._resp.project = ProjectCompactResp(id=PROJECT_ID, name=PROJECT_NAME)
+        self._resp.model = ModelCompactResp(id=MODEL_ID, name=MODEL_NAME)
+        self._resp.dataset = DatasetCompactResp(
+            id=DATASET_ID, name=DATASET_NAME, type=EnvType.PRE_PRODUCTION
+        )
+        self._resp.baseline = BaselineCompactResp(id=BASELINE_ID, name=BASELINE_NAME)
+        self._resp.created_by = UserCompactResp(
+            id=USER_ID, full_name=USER_NAME, email=USER_EMAIL
+        )
+        self._resp.updated_by = UserCompactResp(
+            id=USER_ID, full_name=USER_NAME, email=USER_EMAIL
+        )
+
+
+@pytest.fixture()
+def entity() -> DummyEntity:
+    dummy_entity = DummyEntity()
+    yield dummy_entity
+
+
+@pytest.mark.parametrize(
+    ('property_name', 'class_name'),
+    [
+        ('project', ProjectCompact),
+        ('dataset', DatasetCompact),
+        ('model', ModelCompact),
+        ('baseline', BaselineCompact),
+        ('created_by', UserCompact),
+        ('updated_by', UserCompact),
+    ],
+)
+def test_mixins(entity: DummyEntity, property_name: str, class_name: type) -> None:
+    assert isinstance(getattr(entity, property_name), class_name)
+
+    entity._resp = None
+    with pytest.raises(AttributeError):
+        _ = getattr(entity, property_name)

fiddler3/tests/apis/test_model.py

@@ -3,10 +3,11 @@ from uuid import UUID
 
 import pytest
 import responses
+from pytest_mock import MockerFixture
 from responses import matchers
 
 from fiddler3.entities.job import Job
-from fiddler3.entities.model import Model
+from fiddler3.entities.model import Model, ModelCompact
 from fiddler3.exceptions import Conflict, NotFound
 from fiddler3.schemas.model_schema import ModelSchema
 from fiddler3.schemas.model_spec import ModelSpec
@@ -235,14 +236,27 @@ API_RESPONSE_404 = {
 API_RESPONSE_FROM_NAME = {
     'data': {
         'page_size': 100,
-        'total': 2,
-        'item_count': 2,
+        'total': 1,
+        'item_count': 1,
         'page_count': 1,
         'page_index': 1,
         'offset': 0,
         'items': [API_RESPONSE_200['data']],
     }
 }
+LIST_API_RESPONSE = {
+    'data': {
+        'page_size': 100,
+        'total': 1,
+        'item_count': 1,
+        'page_count': 1,
+        'page_index': 1,
+        'offset': 0,
+        'items': [
+            API_RESPONSE_200['data'],
+        ],
+    }
+}
 DELETE_202_RESPONSE = {
     'data': {'job': {'id': JOB_ID, 'name': f'Deleting model {MODEL_NAME}'}},
     'api_version': '3.0',
@@ -307,13 +321,15 @@ def test_get_model_not_found() -> None:
 
 @responses.activate
 def test_model_from_name_success() -> None:
-    params = {'name': PROJECT_NAME, 'project_name': PROJECT_NAME}
+    params = {
+        'filter': '{"condition": "AND", "rules": [{"field": "name", "operator": "equal", "value": "bank_churn"}, {"field": "project_name", "operator": "equal", "value": "bank_churn"}]}'
+    }
     responses.get(
         url=f'{URL}/v3/models',
         json=API_RESPONSE_FROM_NAME,
         match=[matchers.query_param_matcher(params)],
     )
-    model = Model.from_name(model_name=MODEL_NAME, project_name=PROJECT_NAME)
+    model = Model.from_name(name=MODEL_NAME, project_name=PROJECT_NAME)
     assert isinstance(model, Model)
 
 
@@ -324,7 +340,9 @@ def test_model_from_name_not_found() -> None:
     resp['data']['item_count'] = 0
     resp['data']['items'] = []
 
-    params = {'name': PROJECT_NAME, 'project_name': PROJECT_NAME}
+    params = {
+        'filter': '{"condition": "AND", "rules": [{"field": "name", "operator": "equal", "value": "bank_churn"}, {"field": "project_name", "operator": "equal", "value": "bank_churn"}]}'
+    }
     responses.get(
         url=f'{URL}/v3/models',
         json=resp,
@@ -332,7 +350,33 @@ def test_model_from_name_not_found() -> None:
     )
 
     with pytest.raises(NotFound):
-        Model.from_name(model_name=MODEL_NAME, project_name=PROJECT_NAME)
+        Model.from_name(name=MODEL_NAME, project_name=PROJECT_NAME)
+
+
+@responses.activate
+def test_model_list_success() -> None:
+    params = {'project_id': str(PROJECT_ID), 'limit': 50, 'offset': 0}
+    responses.get(
+        url=f'{URL}/v3/models',
+        json=LIST_API_RESPONSE,
+        match=[matchers.query_param_matcher(params)],
+    )
+    models = Model.list(project_id=PROJECT_ID)
+    for model in models:
+        assert isinstance(model, ModelCompact)
+
+
+@responses.activate
+def test_model_list_success() -> None:
+    params = {'project_id': str(PROJECT_ID), 'limit': 50, 'offset': 0}
+    responses.get(
+        url=f'{URL}/v3/models',
+        json=LIST_API_RESPONSE,
+        match=[matchers.query_param_matcher(params)],
+    )
+    models = Model.list(project_id=PROJECT_ID)
+    for model in models:
+        assert isinstance(model, ModelCompact)
 
 
 @responses.activate
@@ -371,3 +415,54 @@ def test_delete_model_not_found() -> None:
 
     with pytest.raises(NotFound):
         model.delete()
+
+
+@responses.activate
+def test_update_model_success(mocker) -> None:
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=API_RESPONSE_200,
+    )
+    model = Model.get(id_=MODEL_ID)
+    mocker.patch.dict(API_RESPONSE_200['data'], {'description': 'Test model update'})
+
+    responses.patch(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=API_RESPONSE_200,
+    )
+    model.description = 'Test model update'
+
+    model.update()
+    assert model.description == 'Test model update'
+
+
+@responses.activate
+def test_update_model_not_found() -> None:
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=API_RESPONSE_200,
+    )
+    model = Model.get(id_=MODEL_ID)
+
+    responses.patch(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=API_RESPONSE_404,
+        status=HTTPStatus.NOT_FOUND,
+    )
+    with pytest.raises(NotFound):
+        model.update()
+
+
+@responses.activate
+def test_datasets_property(mocker: MockerFixture) -> None:
+    mock_fn = mocker.patch('fiddler3.entities.Dataset.list')
+
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=API_RESPONSE_200,
+    )
+    model = Model.get(id_=MODEL_ID)
+
+    _ = list(model.datasets)
+
+    mock_fn.assert_called_with(model_id=UUID(MODEL_ID))

fiddler3/tests/apis/test_model_artifact.py

@@ -0,0 +1,175 @@
+import io
+import os
+import shutil
+import tarfile
+from http import HTTPStatus
+from pathlib import Path
+
+import pytest
+import responses
+
+from fiddler3.entities.job import Job
+from fiddler3.entities.model import Model
+from fiddler3.exceptions import NotFound
+from fiddler3.schemas.deployment_params import DeploymentParams
+from fiddler3.tests.apis.test_model import API_RESPONSE_200, API_RESPONSE_404
+from fiddler3.tests.constants import JOB_ID, MODEL_ID, MODEL_NAME, PROJECT_NAME, URL
+
+ARTIFACT_202_RESPONSE = {
+    'data': {'job': {'id': JOB_ID, 'name': 'Deploy artifact model - manual'}},
+    'api_version': '3.0',
+    'kind': 'NORMAL',
+}
+MODEL_ARTIFACT_JOB_API_RESPONSE_200 = {
+    'api_version': '3.0',
+    'kind': 'NORMAL',
+    'data': {
+        'name': 'Deploy artifact model - manual',
+        'id': JOB_ID,
+        'status': 'SUCCESS',
+        'progress': 100.0,
+        'error_message': None,
+        'error_reason': None,
+    },
+}
+
+DOWNLOAD_RESPONSE_404 = {
+    'error': {
+        'code': 404,
+        'message': f'Model artifact not found for {PROJECT_NAME}/{MODEL_NAME}',
+        'errors': [
+            {
+                'reason': 'ObjectNotFound',
+                'message': 'Model artifact not found for {PROJECT_NAME}/{MODEL_NAME}',
+                'help': '',
+            }
+        ],
+    }
+}
+DEPLOYMENT_PARAMS = {'deployment_type': 'MANUAL', 'cpu': 1000}
+
+BASE_TEST_DIR = f'{Path(__file__).resolve().parent.parent}'
+MODEL_DIR = os.path.join(BASE_TEST_DIR, 'artifact_test_dir')
+
+
+@responses.activate
+def test_add_model_artifact() -> None:
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=API_RESPONSE_200,
+    )
+    model = Model.get(id_=MODEL_ID)
+
+    responses.post(
+        url=f'{URL}/v3/models/{MODEL_ID}/deploy-artifact',
+        json=ARTIFACT_202_RESPONSE,
+    )
+    responses.get(
+        url=f'{URL}/v3/jobs/{JOB_ID}',
+        json=MODEL_ARTIFACT_JOB_API_RESPONSE_200,
+    )
+
+    job_obj = model.add_artifact(
+        model_dir=MODEL_DIR, deployment_params=DeploymentParams(**DEPLOYMENT_PARAMS)
+    )
+    assert isinstance(job_obj, Job)
+
+
+@responses.activate
+def test_add_model_artifact_not_found() -> None:
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=API_RESPONSE_200,
+    )
+    model = Model.get(id_=MODEL_ID)
+
+    responses.post(
+        url=f'{URL}/v3/models/{MODEL_ID}/deploy-artifact',
+        json=API_RESPONSE_404,
+        status=HTTPStatus.NOT_FOUND,
+    )
+    with pytest.raises(NotFound):
+        model.add_artifact(
+            model_dir=MODEL_DIR, deployment_params=DeploymentParams(**DEPLOYMENT_PARAMS)
+        )
+
+
+@responses.activate
+def test_update_model_artifact() -> None:
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=API_RESPONSE_200,
+    )
+    model = Model.get(id_=MODEL_ID)
+
+    responses.put(
+        url=f'{URL}/v3/models/{MODEL_ID}/deploy-artifact',
+        json=ARTIFACT_202_RESPONSE,
+    )
+    responses.get(
+        url=f'{URL}/v3/jobs/{JOB_ID}',
+        json=MODEL_ARTIFACT_JOB_API_RESPONSE_200,
+    )
+    job_obj = model.update_artifact(
+        model_dir=MODEL_DIR, deployment_params=DeploymentParams(**DEPLOYMENT_PARAMS)
+    )
+
+    assert isinstance(job_obj, Job)
+
+
+@responses.activate
+def test_update_model_artifact_not_found() -> None:
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=API_RESPONSE_200,
+    )
+
+    model = Model.get(id_=MODEL_ID)
+    responses.put(
+        url=f'{URL}/v3/models/{MODEL_ID}/deploy-artifact',
+        json=API_RESPONSE_404,
+        status=HTTPStatus.NOT_FOUND,
+    )
+
+    with pytest.raises(NotFound):
+        model.update_artifact(
+            model_dir=MODEL_DIR, deployment_params=DeploymentParams(**DEPLOYMENT_PARAMS)
+        )
+
+
+@responses.activate
+def test_download_model_artifact() -> None:
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=API_RESPONSE_200,
+    )
+    model = Model.get(id_=MODEL_ID)
+
+    output_dir = os.path.join(BASE_TEST_DIR, 'test_download')
+    tar_file_path = os.path.join(BASE_TEST_DIR, 'artifact.tar')
+    with tarfile.open(tar_file_path, 'w:gz') as tar:
+        tar.add(MODEL_DIR, arcname=os.path.basename(MODEL_DIR))
+    with open(tar_file_path, 'rb') as tar_file:
+        data = io.BufferedReader(tar_file)
+        responses.get(url=f'{URL}/v3/models/{MODEL_ID}/download-artifact', body=data)
+        model.download_artifact(output_dir=output_dir)
+    shutil.rmtree(str(output_dir))
+    os.remove(tar_file_path)
+
+
+@responses.activate
+def test_download_model_artifact_not_found() -> None:
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=API_RESPONSE_200,
+    )
+    model = Model.get(id_=MODEL_ID)
+    output_dir = os.path.join(BASE_TEST_DIR, 'test_download')
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}/download-artifact',
+        json=DOWNLOAD_RESPONSE_404,
+        status=HTTPStatus.NOT_FOUND,
+    )
+
+    with pytest.raises(NotFound):
+        model.download_artifact(output_dir=output_dir)

fiddler3/tests/apis/test_model_deployment.py

@@ -0,0 +1,98 @@
+from http import HTTPStatus
+
+import pytest
+import responses
+
+from fiddler3.entities.model_deployment import ModelDeployment
+from fiddler3.exceptions import NotFound
+from fiddler3.tests.constants import (
+    MODEL_DEPLOYMENT_ID,
+    MODEL_ID,
+    MODEL_NAME,
+    ORG_ID,
+    ORG_NAME,
+    PROJECT_ID,
+    PROJECT_NAME,
+    URL,
+    USER_EMAIL,
+    USER_ID,
+    USER_NAME,
+)
+
+API_RESPONSE_200 = {
+    'data': {
+        'id': MODEL_DEPLOYMENT_ID,
+        'model': {'id': MODEL_ID, 'name': MODEL_NAME},
+        'project': {
+            'id': PROJECT_ID,
+            'name': PROJECT_NAME,
+        },
+        'organization': {
+            'id': ORG_ID,
+            'name': ORG_NAME,
+        },
+        'artifact_type': 'SURROGATE',
+        'deployment_type': 'BASE_CONTAINER',
+        'active': True,
+        'image_uri': '',
+        'replicas': 1,
+        'cpu': 300,
+        'memory': 100,
+        'created_at': '2023-11-22 16:50:57.705784',
+        'updated_at': '2023-11-22 16:50:57.705784',
+        'created_by': {
+            'id': USER_ID,
+            'full_name': USER_NAME,
+            'email': USER_EMAIL,
+        },
+        'updated_by': {
+            'id': USER_ID,
+            'full_name': USER_NAME,
+            'email': USER_EMAIL,
+        },
+    },
+}
+
+API_RESPONSE_404 = {
+    'error': {
+        'code': 404,
+        'message': 'Model deployment not found for the given identifier',
+        'errors': [
+            {
+                'reason': 'ObjectNotFound',
+                'message': 'Model deployment not found for the given identifier',
+                'help': '',
+            }
+        ],
+    }
+}
+
+
+@responses.activate
+def test_update_model_deployment_success() -> None:
+    model_deployment = ModelDeployment(model_id=MODEL_ID)
+
+    responses.patch(
+        url=f'{URL}/v3/models/{MODEL_ID}/deployment',
+        json=API_RESPONSE_200,
+    )
+    model_deployment.cpu = 300
+    model_deployment.active = True
+
+    model_deployment.update()
+    assert isinstance(model_deployment, ModelDeployment)
+    assert model_deployment.cpu == 300
+    assert model_deployment.active
+
+
+@responses.activate
+def test_update_model_deployment_not_found() -> None:
+    responses.patch(
+        url=f'{URL}/v3/models/{MODEL_ID}/deployment',
+        json=API_RESPONSE_404,
+        status=HTTPStatus.NOT_FOUND,
+    )
+
+    with pytest.raises(NotFound):
+        model_deployment = ModelDeployment(model_id=MODEL_ID)
+        model_deployment.update()

fiddler3/tests/apis/test_model_surrogate.py

@@ -0,0 +1,159 @@
+from http import HTTPStatus
+
+import pytest
+import responses
+
+from fiddler3.entities.job import Job
+from fiddler3.entities.model import Model
+from fiddler3.exceptions import NotFound
+from fiddler3.schemas.deployment_params import DeploymentParams
+from fiddler3.tests.apis.test_model import API_RESPONSE_200
+from fiddler3.tests.constants import JOB_ID, MODEL_ID, MODEL_NAME, URL
+
+SURROGATE_202_RESPONSE = {
+    'data': {
+        'job': {
+            'id': JOB_ID,
+            'name': 'Add model surrogate - manual',
+        }
+    },
+    'api_version': '3.0',
+    'kind': 'NORMAL',
+}
+
+SURROGATE_JOB_API_RESPONSE_200 = {
+    'api_version': '3.0',
+    'kind': 'NORMAL',
+    'data': {
+        'name': 'Add model surrogate - manual',
+        'id': JOB_ID,
+        'status': 'SUCCESS',
+        'progress': 100.0,
+        'error_message': None,
+        'error_reason': None,
+    },
+}
+
+SURROGATE_JOB_API_RESPONSE_400 = (
+    {
+        'error': {
+            'code': 400,
+            'message': f'Model {MODEL_NAME}/'
+            f'{MODEL_NAME} already has artifact. Please '
+            f'use update_model_artifact or update_model_surrogate '
+            f'instead',
+            'errors': [
+                {
+                    'reason': 'BadRequest',
+                    'message': f'Model {MODEL_NAME}/'
+                    f'{MODEL_NAME} already has artifact. '
+                    f'Please use update_model_artifact or '
+                    f'update_model_surrogate instead',
+                    'help': '',
+                }
+            ],
+        },
+        'api_version': '3.0',
+        'kind': 'ERROR',
+    },
+)
+
+API_RESPONSE_404 = {
+    'error': {
+        'code': 404,
+        'message': 'Model not found for the given identifier',
+        'errors': [
+            {
+                'reason': 'ObjectNotFound',
+                'message': 'Model not found for the given identifier',
+                'help': '',
+            }
+        ],
+    }
+}
+
+DEPLOYMENT_PARAMS = {'deployment_type': 'MANUAL', 'cpu': 1000}
+
+
+@responses.activate
+def test_add_model_surrogate() -> None:
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=API_RESPONSE_200,
+    )
+    model = Model.get(id_=MODEL_ID)
+
+    responses.post(
+        url=f'{URL}/v3/models/{MODEL_ID}/deploy-surrogate',
+        json=SURROGATE_202_RESPONSE,
+    )
+
+    responses.get(
+        url=f'{URL}/v3/jobs/{JOB_ID}',
+        json=SURROGATE_JOB_API_RESPONSE_200,
+    )
+
+    job_obj = model.add_surrogate(
+        deployment_params=DeploymentParams(**DEPLOYMENT_PARAMS)
+    )
+    assert isinstance(job_obj, Job)
+
+
+@responses.activate
+def test_add_model_surrogate_no_model() -> None:
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=API_RESPONSE_200,
+    )
+    model = Model.get(id_=MODEL_ID)
+
+    responses.post(
+        url=f'{URL}/v3/models/{MODEL_ID}/deploy-surrogate',
+        json=API_RESPONSE_404,
+        status=HTTPStatus.NOT_FOUND,
+    )
+
+    with pytest.raises(NotFound):
+        model.add_surrogate(deployment_params=DeploymentParams(**DEPLOYMENT_PARAMS))
+
+
+@responses.activate
+def test_update_model_surrogate() -> None:
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=API_RESPONSE_200,
+    )
+    model = Model.get(id_=MODEL_ID)
+
+    responses.put(
+        url=f'{URL}/v3/models/{MODEL_ID}/deploy-surrogate',
+        json=SURROGATE_202_RESPONSE,
+    )
+
+    responses.get(
+        url=f'{URL}/v3/jobs/{JOB_ID}',
+        json=SURROGATE_JOB_API_RESPONSE_200,
+    )
+
+    job_obj = model.update_surrogate(
+        deployment_params=DeploymentParams(**DEPLOYMENT_PARAMS)
+    )
+    assert isinstance(job_obj, Job)
+
+
+@responses.activate
+def test_update_model_surrogate_no_model() -> None:
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=API_RESPONSE_200,
+    )
+    model = Model.get(id_=MODEL_ID)
+
+    responses.put(
+        url=f'{URL}/v3/models/{MODEL_ID}/deploy-surrogate',
+        json=API_RESPONSE_404,
+        status=HTTPStatus.NOT_FOUND,
+    )
+
+    with pytest.raises(NotFound):
+        model.update_surrogate(deployment_params=DeploymentParams(**DEPLOYMENT_PARAMS))