fiddler-client 2.4.0.dev2__py3-none-any.whl → 2.5.0.dev2__py3-none-any.whl

fiddler3/tests/apis/test_files.py

@@ -0,0 +1,164 @@
+import os
+from pathlib import Path
+from uuid import UUID
+
+import responses
+
+from fiddler3.entities.file import File
+from fiddler3.tests.constants import URL, USER_EMAIL, USER_ID, USER_NAME
+
+FILE_NAME = 'model.yaml'
+FILE_ID = 'f34ff7db-9653-49b5-b3d8-02c9670513a3'
+
+SINGLE_UPLOAD_200_RESPONSE = {
+    'api_version': '3.0',
+    'data': {
+        'created_at': '2023-11-22 16:50:57.705784',
+        'updated_at': '2023-11-22 16:50:57.705784',
+        'filename': FILE_NAME,
+        'id': FILE_ID,
+        'status': 'SUCCESSFUL',
+        'type': 'CSV',
+        'created_by': {
+            'id': USER_ID,
+            'full_name': USER_NAME,
+            'email': USER_EMAIL,
+        },
+        'updated_by': {
+            'id': USER_ID,
+            'full_name': USER_NAME,
+            'email': USER_EMAIL,
+        },
+    },
+    'kind': 'NORMAL',
+}
+
+MULTIPART_INIT_200_RESPONSE = {
+    'api_version': '3.0',
+    'data': {
+        'created_at': '2023-11-22 16:50:57.705784',
+        'updated_at': '2023-11-22 16:50:57.705784',
+        'filename': FILE_NAME,
+        'id': FILE_ID,
+        'status': 'SUCCESSFUL',
+        'type': 'CSV',
+        'created_by': {
+            'id': USER_ID,
+            'full_name': USER_NAME,
+            'email': USER_EMAIL,
+        },
+        'updated_by': {
+            'id': USER_ID,
+            'full_name': USER_NAME,
+            'email': USER_EMAIL,
+        },
+    },
+    'kind': 'NORMAL',
+}
+
+MULTIPART_UPLOAD_200_RESPONSE = {
+    'data': {'part_id': 'e887e82d-1f49-4de4-aca6-5dcdefa5f36c'},
+    'api_version': '3.0',
+    'kind': 'NORMAL',
+}
+MULTIPART_COMPLETE_200_RESPONSE = {
+    'api_version': '3.0',
+    'data': {
+        'created_at': '2023-11-22 16:50:57.705784',
+        'updated_at': '2023-11-22 16:50:57.705784',
+        'filename': FILE_NAME,
+        'id': FILE_ID,
+        'status': 'SUCCESSFUL',
+        'type': 'CSV',
+        'created_by': {
+            'id': USER_ID,
+            'full_name': USER_NAME,
+            'email': USER_EMAIL,
+        },
+        'updated_by': {
+            'id': USER_ID,
+            'full_name': USER_NAME,
+            'email': USER_EMAIL,
+        },
+    },
+    'kind': 'NORMAL',
+}
+
+BASE_TEST_DIR = Path(__file__).resolve().parent.parent
+FILE_PATH = BASE_TEST_DIR / 'artifact_test_dir' / 'model.yaml'
+
+
+@responses.activate
+def test_single_upload_success() -> None:
+    responses.post(
+        url=f'{URL}/v3/files/upload',
+        json=SINGLE_UPLOAD_200_RESPONSE,
+    )
+    file = File(path=FILE_PATH, name=FILE_NAME).single_upload()
+    assert isinstance(file, File)
+    assert file.id == UUID(FILE_ID)
+
+    file = File(
+        path=str(FILE_PATH),
+    ).single_upload()
+    assert isinstance(file, File)
+    assert file.id == UUID(FILE_ID)
+
+
+@responses.activate
+def test_multipart_upload_success() -> None:
+    responses.post(
+        url=f'{URL}/v3/files/multipart-init',
+        json=MULTIPART_INIT_200_RESPONSE,
+    )
+    responses.post(
+        url=f'{URL}/v3/files/multipart-upload',
+        json=MULTIPART_UPLOAD_200_RESPONSE,
+    )
+    responses.post(
+        url=f'{URL}/v3/files/multipart-complete',
+        json=MULTIPART_COMPLETE_200_RESPONSE,
+    )
+
+    file = File(path=FILE_PATH, name=FILE_NAME).multipart_upload()
+    assert isinstance(file, File)
+    assert file.id == UUID(FILE_ID)
+
+
+@responses.activate
+def test_file_upload() -> None:
+    multipart_init_resp = responses.post(
+        url=f'{URL}/v3/files/multipart-init',
+        json=MULTIPART_INIT_200_RESPONSE,
+    )
+    multipart_upload_resp = responses.post(
+        url=f'{URL}/v3/files/multipart-upload',
+        json=MULTIPART_UPLOAD_200_RESPONSE,
+    )
+    multipart_complete_resp = responses.post(
+        url=f'{URL}/v3/files/multipart-complete',
+        json=MULTIPART_COMPLETE_200_RESPONSE,
+    )
+    single_upload_resp = responses.post(
+        url=f'{URL}/v3/files/upload',
+        json=SINGLE_UPLOAD_200_RESPONSE,
+    )
+    chunk_size = os.path.getsize(FILE_PATH) // 2 + 1
+
+    file_multi = File(path=FILE_PATH, name=FILE_NAME).upload(
+        chunk_size=chunk_size,
+    )
+
+    assert isinstance(file_multi, File)
+    assert multipart_init_resp.call_count == 1
+    assert multipart_upload_resp.call_count == 2
+    assert multipart_complete_resp.call_count == 1
+    assert single_upload_resp.call_count == 0
+
+    chunk_size = os.path.getsize(FILE_PATH) + 1
+    file_single = File(path=FILE_PATH, name=FILE_NAME).upload(
+        chunk_size=chunk_size,
+    )
+
+    assert isinstance(file_single, File)
+    assert single_upload_resp.call_count == 1

fiddler3/tests/apis/test_model.py

@@ -8,12 +8,14 @@ from responses import matchers
 
 from fiddler3.entities.job import Job
 from fiddler3.entities.model import Model, ModelCompact
+from fiddler3.entities.model_deployment import ModelDeployment
 from fiddler3.exceptions import Conflict, NotFound
 from fiddler3.schemas.model_schema import ModelSchema
 from fiddler3.schemas.model_spec import ModelSpec
 from fiddler3.tests.constants import (
     JOB_ID,
     JOB_NAME,
+    MODEL_DEPLOYMENT_ID,
     MODEL_ID,
     MODEL_NAME,
     ORG_ID,
@@ -193,14 +195,6 @@ API_RESPONSE_200 = {
             'full_name': USER_NAME,
             'email': USER_EMAIL,
         },
-        'input_cols': [
-            MODEL_SCHEMA['columns'][0],
-            MODEL_SCHEMA['columns'][1],
-        ],
-        'output_cols': [MODEL_SCHEMA['columns'][2]],
-        'target_cols': [MODEL_SCHEMA['columns'][4]],
-        'metadata_cols': [],
-        'decision_cols': [MODEL_SCHEMA['columns'][3]],
         'is_binary_ranking_model': False,
     },
 }
@@ -263,6 +257,40 @@ DELETE_202_RESPONSE = {
     'kind': 'NORMAL',
 }
 
+DEPLOYMENT_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,
+        },
+    },
+}
+
 
 @responses.activate
 def test_add_model_success() -> None:
@@ -329,6 +357,10 @@ def test_model_from_name_success() -> None:
         json=API_RESPONSE_FROM_NAME,
         match=[matchers.query_param_matcher(params)],
     )
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=API_RESPONSE_200,
+    )
     model = Model.from_name(name=MODEL_NAME, project_name=PROJECT_NAME)
     assert isinstance(model, Model)
 
@@ -455,7 +487,7 @@ def test_update_model_not_found() -> None:
 
 @responses.activate
 def test_datasets_property(mocker: MockerFixture) -> None:
-    mock_fn = mocker.patch('fiddler3.entities.Dataset.list')
+    mock_fn = mocker.patch('fiddler3.entities.dataset.Dataset.list')
 
     responses.get(
         url=f'{URL}/v3/models/{MODEL_ID}',
@@ -466,3 +498,22 @@ def test_datasets_property(mocker: MockerFixture) -> None:
     _ = list(model.datasets)
 
     mock_fn.assert_called_with(model_id=UUID(MODEL_ID))
+
+
+@responses.activate
+def test_model_deployment_property() -> None:
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=API_RESPONSE_200,
+    )
+    model = Model.get(id_=MODEL_ID)
+
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}/deployment',
+        json=DEPLOYMENT_RESPONSE_200,
+    )
+    model_deployment = model.model_deployment
+    assert isinstance(model_deployment, ModelDeployment)
+    assert model_deployment.id == UUID(MODEL_DEPLOYMENT_ID)
+    assert model_deployment.cpu == 300
+    assert model_deployment.artifact_type == 'SURROGATE'

fiddler3/tests/apis/test_model_artifact.py

@@ -12,6 +12,7 @@ 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_files import SINGLE_UPLOAD_200_RESPONSE
 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
 
@@ -54,6 +55,11 @@ MODEL_DIR = os.path.join(BASE_TEST_DIR, 'artifact_test_dir')
 
 @responses.activate
 def test_add_model_artifact() -> None:
+    responses.post(
+        url=f'{URL}/v3/files/upload',
+        json=SINGLE_UPLOAD_200_RESPONSE,
+    )
+
     responses.get(
         url=f'{URL}/v3/models/{MODEL_ID}',
         json=API_RESPONSE_200,
@@ -77,6 +83,11 @@ def test_add_model_artifact() -> None:
 
 @responses.activate
 def test_add_model_artifact_not_found() -> None:
+    responses.post(
+        url=f'{URL}/v3/files/upload',
+        json=SINGLE_UPLOAD_200_RESPONSE,
+    )
+
     responses.get(
         url=f'{URL}/v3/models/{MODEL_ID}',
         json=API_RESPONSE_200,
@@ -96,6 +107,11 @@ def test_add_model_artifact_not_found() -> None:
 
 @responses.activate
 def test_update_model_artifact() -> None:
+    responses.post(
+        url=f'{URL}/v3/files/upload',
+        json=SINGLE_UPLOAD_200_RESPONSE,
+    )
+
     responses.get(
         url=f'{URL}/v3/models/{MODEL_ID}',
         json=API_RESPONSE_200,
@@ -119,6 +135,11 @@ def test_update_model_artifact() -> None:
 
 @responses.activate
 def test_update_model_artifact_not_found() -> None:
+    responses.post(
+        url=f'{URL}/v3/files/upload',
+        json=SINGLE_UPLOAD_200_RESPONSE,
+    )
+
     responses.get(
         url=f'{URL}/v3/models/{MODEL_ID}',
         json=API_RESPONSE_200,

fiddler3/tests/apis/test_project.py

@@ -203,7 +203,7 @@ def test_project_list_empty() -> None:
 @responses.activate
 def test_delete_project_success() -> None:
     responses.delete(
-        url=f'{URL}/v2/projects/{PROJECT_ID}',
+        url=f'{URL}/v2/projects/{ORG_NAME}:{PROJECT_NAME}',
         json={},
     )
     project = Project(name=PROJECT_NAME)
@@ -215,7 +215,7 @@ def test_delete_project_success() -> None:
 @responses.activate
 def test_delete_project_not_found() -> None:
     responses.delete(
-        url=f'{URL}/v2/projects/{PROJECT_ID}',
+        url=f'{URL}/v2/projects/{ORG_NAME}:{PROJECT_NAME}',
         json=API_RESPONSE_404,
         status=HTTPStatus.NOT_FOUND,
     )
@@ -227,7 +227,7 @@ def test_delete_project_not_found() -> None:
 
 
 def test_models_property(mocker: MockerFixture) -> None:
-    mock_fn = mocker.patch('fiddler3.entities.Model.list')
+    mock_fn = mocker.patch('fiddler3.entities.model.Model.list')
 
     project = Project(name=PROJECT_NAME)
     project.id = UUID(PROJECT_ID)

fiddler3/tests/apis/test_webhook.py

@@ -0,0 +1,257 @@
+import json
+from datetime import datetime
+from http import HTTPStatus
+from uuid import UUID
+
+import pytest
+import responses
+
+from fiddler3.entities.webhook import Webhook
+from fiddler3.exceptions import Conflict, NotFound
+from fiddler3.tests.constants import (
+    ORG_NAME,
+    URL,
+    WEBHOOK_ID,
+    WEBHOOK_NAME,
+    WEBHOOK_PROVIDER,
+    WEBHOOK_URL,
+)
+
+API_RESPONSE_200 = {
+    'data': {
+        'id': 1,
+        'uuid': WEBHOOK_ID,
+        'name': WEBHOOK_NAME,
+        'url': WEBHOOK_URL,
+        'provider': WEBHOOK_PROVIDER,
+        'created_at': '2023-12-18T10:23:51.232768+00:00',
+        'updated_at': '2023-12-18T10:23:51.232768+00:00',
+        'organization_name': ORG_NAME,
+    },
+    'api_version': '2.0',
+    'kind': 'NORMAL',
+}
+
+API_RESPONSE_404 = {
+    'error': {
+        'code': 404,
+        'message': "WebhookConfig({'uuid': '128e4df4-91a8-8d61-d9e2-222eecb829f2'}) not found",
+        'errors': [
+            {
+                'reason': 'ObjectNotFound',
+                'message': "WebhookConfig({'uuid': '128e4df4-91a8-8d61-d9e2-222eecb829f2'}) not found",
+                'help': '',
+            }
+        ],
+    },
+    'api_version': '2.0',
+    'kind': 'ERROR',
+}
+
+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'],
+            {
+                'id': 2,
+                'uuid': '2531bfd9-2ca2-4a7b-bb5a-136c8da09ca1',
+                'name': 'test_webhook_config_name2',
+                'url': WEBHOOK_URL,
+                'provider': WEBHOOK_PROVIDER,
+                'created_at': '2023-12-18T10:23:51.232768+00:00',
+                'updated_at': '2023-12-18T10:23:51.232768+00:00',
+                'organization_name': ORG_NAME,
+            },
+        ],
+    }
+}
+
+API_RESPONSE_EMPTY_LIST = {
+    'data': {
+        'page_size': 100,
+        'total': 0,
+        'item_count': 0,
+        'page_count': 1,
+        'page_index': 1,
+        'offset': 0,
+        'items': [],
+    }
+}
+
+API_RESPONSE_409 = {
+    'error': {
+        'code': 409,
+        'message': f'A webhook integration with the provided name ({WEBHOOK_NAME}) \
+                    already exists. Webhook names must be unique.',
+        'errors': [
+            {
+                'reason': 'Conflict',
+                'message': f'A webhook integration with the provided name \
+                        ({WEBHOOK_NAME}) already exists. Webhook names must be unique.',
+                'help': '',
+            }
+        ],
+    }
+}
+
+
+@responses.activate
+def test_get_webhook_success() -> None:
+    responses.get(
+        url=f'{URL}/v2/webhooks/{WEBHOOK_ID}',
+        json=API_RESPONSE_200,
+    )
+    webhook = Webhook.get(id_=WEBHOOK_ID)
+    assert isinstance(webhook, Webhook)
+
+
+@responses.activate
+def test_get_webhook_not_found() -> None:
+    webhook_id = '128e4df4-91a8-8d61-d9e2-222eecb829f2'
+    responses.get(
+        url=f'{URL}/v2/webhooks/{webhook_id}',
+        json=API_RESPONSE_404,
+        status=HTTPStatus.NOT_FOUND,
+    )
+
+    with pytest.raises(NotFound):
+        Webhook.get(id_=webhook_id)
+
+
+@responses.activate
+def test_webhook_list_success() -> None:
+    responses.get(
+        url=f'{URL}/v2/webhooks',
+        json=LIST_API_RESPONSE,
+    )
+    for webhook in Webhook.list():
+        assert isinstance(webhook, Webhook)
+
+
+@responses.activate
+def test_webhook_list_empty() -> None:
+    resp = API_RESPONSE_EMPTY_LIST
+
+    responses.get(
+        url=f'{URL}/v2/webhooks',
+        json=resp,
+    )
+    assert len(list(Webhook.list())) == 0
+
+
+@responses.activate
+def test_add_webhook_success() -> None:
+    responses.post(
+        url=f'{URL}/v2/webhooks',
+        json=API_RESPONSE_200,
+    )
+    webhook = Webhook(
+        name=WEBHOOK_NAME, url=WEBHOOK_URL, provider=WEBHOOK_PROVIDER
+    ).create()
+    assert isinstance(webhook, Webhook)
+    assert webhook.id == UUID(WEBHOOK_ID)
+    assert webhook.name == WEBHOOK_NAME
+    assert webhook.created_at == datetime.fromisoformat(
+        API_RESPONSE_200['data']['created_at']
+    )
+    assert webhook.updated_at == datetime.fromisoformat(
+        API_RESPONSE_200['data']['updated_at']
+    )
+
+    assert json.loads(responses.calls[0].request.body) == {
+        'name': WEBHOOK_NAME,
+        'url': WEBHOOK_URL,
+        'provider': WEBHOOK_PROVIDER,
+    }
+
+
+@responses.activate
+def test_add_webhook_conflict() -> None:
+    responses.post(
+        url=f'{URL}/v2/webhooks', json=API_RESPONSE_409, status=HTTPStatus.CONFLICT
+    )
+
+    with pytest.raises(Conflict):
+        Webhook(
+            name=WEBHOOK_NAME,
+            url=WEBHOOK_URL,
+            provider=WEBHOOK_PROVIDER,
+        ).create()
+
+
+@responses.activate
+def test_update_webhook_success(mocker) -> None:
+    responses.get(
+        url=f'{URL}/v2/webhooks/{WEBHOOK_ID}',
+        json=API_RESPONSE_200,
+    )
+    webhook = Webhook.get(id_=WEBHOOK_ID)
+
+    mocker.patch.dict(API_RESPONSE_200['data'], {'name': 'test1'})
+    responses.patch(
+        url=f'{URL}/v2/webhooks/{WEBHOOK_ID}',
+        json=API_RESPONSE_200,
+    )
+    webhook.name = 'test1'
+
+    webhook.update()
+    assert isinstance(webhook, Webhook)
+    assert webhook.name == 'test1'
+
+
+@responses.activate
+def test_update_webhook_not_found() -> None:
+    responses.get(
+        url=f'{URL}/v2/webhooks/{WEBHOOK_ID}',
+        json=API_RESPONSE_200,
+    )
+
+    responses.patch(
+        url=f'{URL}/v2/webhooks/{WEBHOOK_ID}',
+        json=API_RESPONSE_404,
+        status=HTTPStatus.NOT_FOUND,
+    )
+
+    with pytest.raises(NotFound):
+        webhook = Webhook.get(id_=WEBHOOK_ID)
+        webhook.update()
+
+
+@responses.activate
+def test_delete_webhook() -> None:
+    responses.get(
+        url=f'{URL}/v2/webhooks/{WEBHOOK_ID}',
+        json=API_RESPONSE_200,
+    )
+    webhook = Webhook.get(id_=WEBHOOK_ID)
+
+    responses.delete(
+        url=f'{URL}/v2/webhooks/{WEBHOOK_ID}',
+        json={},
+    )
+    response = webhook.delete()
+    assert response is None
+
+
+@responses.activate
+def test_delete_webhook_not_found() -> None:
+    responses.get(
+        url=f'{URL}/v2/webhooks/{WEBHOOK_ID}',
+        json=API_RESPONSE_200,
+    )
+    webhook = Webhook.get(id_=WEBHOOK_ID)
+
+    responses.delete(
+        url=f'{URL}/v2/webhooks/{WEBHOOK_ID}',
+        json=API_RESPONSE_404,
+        status=HTTPStatus.NOT_FOUND,
+    )
+
+    with pytest.raises(NotFound):
+        webhook.delete()