feature: [VRD-894] New classes for PipelineStep, PipelineGraph, and RegisteredPipeline

client/verta/docs/python.rst

@@ -29,6 +29,7 @@ Verta
         endpoint
         environment
         integrations
+        pipeline
         registry
         runtime
         tracking

client/verta/tests/unit_tests/conftest.py

@@ -2,7 +2,10 @@
 
 """Pytest fixtures for use in client unit tests."""
 
+import json
 import os
+import random
+from typing import Any, Callable, Dict, Optional
 from unittest.mock import patch
 
 import pytest
@@ -13,7 +16,8 @@
 from verta.client import Client
 from verta.credentials import EmailCredentials
 from verta.endpoint import Endpoint
-from verta.registry.entities import RegisteredModelVersion
+from verta.pipeline import PipelineGraph, PipelineStep
+from verta.registry.entities import RegisteredModel, RegisteredModelVersion
 
 
 @pytest.fixture(scope="session")
@@ -64,15 +68,151 @@ def __repr__(self):  # avoid network calls when displaying test results
 
 
 @pytest.fixture(scope="session")
-def mock_registered_model_version(mock_conn, mock_config):
-    """Return a mocked object of the RegisteredModelVersion class for use in tests"""
+def make_mock_simple_pipeline_definition() -> Callable:
+    """Return a callable function for creating a simple mocked pipeline
+    definition.
+
+    For use in tests, including a parameter for the pipeline
+    id to ensure consistency in tests that mock creation of a pipeline
+    object from a pipeline definition.
+    """
+
+    def simple_pipeline_definition(id: int) -> Dict[str, Any]:
+        return {
+            "graph": [
+                {"predecessors": [], "name": "step1"},
+                {"predecessors": ["step1"], "name": "step2"},
+            ],
+            "pipeline_version_id": id,
+            "steps": [
+                {
+                    "model_version_id": 1,
+                    "name": "step1",
+                },
+                {
+                    "model_version_id": 2,
+                    "name": "step2",
+                },
+            ],
+        }
+
+    return simple_pipeline_definition
+
+
+@pytest.fixture(scope="session")
+def make_mock_registered_model(mock_conn, mock_config) -> Callable:
+    """Return a callable function for creating mocked objects of the
+    RegisteredModel class.
+    """
+
+    class MockRegisteredModel(RegisteredModel):
+        def __repr__(self):  # avoid network calls when displaying test results
+            return object.__repr__(self)
+
+    def _make_mock_registered_model(id: int, name: str):
+        """Return a mocked RegisteredModel object."""
+
+        return MockRegisteredModel(
+            mock_conn,
+            mock_config,
+            _RegistryService.RegisteredModel(
+                id=id,
+                name=name,
+            ),
+        )
+
+    return _make_mock_registered_model
+
+
+@pytest.fixture(scope="session")
+def make_mock_registered_model_version(
+    mock_conn, mock_config, make_mock_simple_pipeline_definition
+) -> Callable:
+    """Return a callable function for creating mocked objects of the
+    RegisteredModelVersion class.
+    """
 
     class MockRegisteredModelVersion(RegisteredModelVersion):
         def __repr__(self):  # avoid network calls when displaying test results
             return object.__repr__(self)
 
-    return MockRegisteredModelVersion(
-        mock_conn,
-        mock_config,
-        _RegistryService.ModelVersion(id=555, registered_model_id=123),
-    )
+        def _get_artifact(self, key=None, artifact_type=None):
+            if key == "pipeline.json":
+                return json.dumps(
+                    make_mock_simple_pipeline_definition(id=self.id)
+                ).encode("utf-8")
+
+    def _make_mock_registered_model_version():
+        """Return a mocked ``RegisteredModelVersion``.
+
+        ``id`` and ``registered_model_id`` will be random and unique for the
+        test session.
+
+        """
+        ids = set()
+        model_ver_id = random.randint(1, 1000000)
+        while model_ver_id in ids:
+            model_ver_id = random.randint(1, 1000000)
+        ids.add(model_ver_id)
+
+        reg_model_id = random.randint(1, 1000000)
+        while reg_model_id in ids:
+            reg_model_id = random.randint(1, 1000000)
+        ids.add(reg_model_id)
+
+        return MockRegisteredModelVersion(
+            mock_conn,
+            mock_config,
+            _RegistryService.ModelVersion(
+                id=model_ver_id,
+                registered_model_id=reg_model_id,
+                version="test_model_version_name",
+            ),
+        )
+
+    return _make_mock_registered_model_version
+
+
+@pytest.fixture(scope="session")
+def make_mock_pipeline_step(make_mock_registered_model_version) -> Callable:
+    """Return a callable function for creating mocked objects of the PipelineStep
+    class.
+
+    The optional `name` parameter is for use in tests where names must be
+    known for assertions.
+    """
+
+    class MockPipelineStep(PipelineStep):
+        def __repr__(self):  # avoid network calls when displaying test results
+            return object.__repr__(self)
+
+    def _make_mock_pipeline_step(name: Optional[str] = None):
+        return MockPipelineStep(
+            registered_model_version=make_mock_registered_model_version(),
+            name=name if name else "test_pipeline_step_name",
+            predecessors=set(),
+        )
+
+    return _make_mock_pipeline_step
+
+
+@pytest.fixture(scope="session")
+def make_mock_pipeline_graph(make_mock_pipeline_step) -> Callable:
+    """Return a callable function for creating mocked objects of the PipelineGraph
+    class.
+    """
+
+    class MockPipelineGraph(PipelineGraph):
+        def __repr__(self):  # avoid network calls when displaying test results
+            return object.__repr__(self)
+
+    def _make_mock_pipeline_graph():
+        step1 = make_mock_pipeline_step()
+        step1.set_name("step1")
+        step2 = make_mock_pipeline_step()
+        step2.set_name("step2")
+        step3 = make_mock_pipeline_step()
+        step3.set_name("step3")
+        return MockPipelineGraph(steps={step1, step2, step3})
+
+    return _make_mock_pipeline_graph

client/verta/tests/unit_tests/deployment/test_build.py

@@ -60,14 +60,15 @@ def test_endpoint_get_current_build(
 @settings(suppress_health_check=[HealthCheck.function_scoped_fixture])
 @given(build_dicts=st.lists(build_dict(), unique_by=lambda d: d["id"]))
 def test_model_version_list_builds(
-    mock_registered_model_version,
+    make_mock_registered_model_version,
     mock_conn,
     mocked_responses,
     build_dicts,
 ):
     """Verify we can construct Build objects from list_builds()."""
+    rmv = make_mock_registered_model_version()
     registry_url = f"{mock_conn.scheme}://{mock_conn.socket}/api/v1/registry"
-    model_version_url = f"{registry_url}/registered_models/{mock_registered_model_version.registered_model_id}"
+    model_version_url = f"{registry_url}/registered_models/{rmv.registered_model_id}"
     deployment_url = f"{mock_conn.scheme}://{mock_conn.socket}/api/v1/deployment"
     list_builds_url = f"{deployment_url}/builds"
 
@@ -77,7 +78,7 @@ def test_model_version_list_builds(
             status=200,
             match=[
                 query_param_matcher(
-                    {"model_version_id": mock_registered_model_version.id},
+                    {"model_version_id": rmv.id},
                 ),
             ],
             json={"builds": build_dicts},
@@ -88,7 +89,7 @@ def test_model_version_list_builds(
             json={"workspace_id": "123"},
         )
 
-        builds = mock_registered_model_version.list_builds()
+        builds = rmv.list_builds()
 
     # verify builds are ordered by creation date
     assert [b.id for b in builds] == [

client/verta/tests/unit_tests/deployment/test_endpoint.py

@@ -145,7 +145,7 @@ def test_kafka_cluster_config_id_default(
         mock_endpoint,
         mock_conn,
         mocked_responses,
-        mock_registered_model_version,
+        make_mock_registered_model_version,
     ) -> None:
         """Verify that, while updating an endpoint, not including a `cluster_config_id`
         in the KafkaSettings results in the correct sequence of HTTP requests, including
@@ -181,7 +181,7 @@ def test_kafka_cluster_config_id_default(
             )
 
             mock_endpoint.update(
-                mock_registered_model_version, kafka_settings=kafka_settings
+                make_mock_registered_model_version(), kafka_settings=kafka_settings
             )
             _responses.assert_call_count(get_configs_url, 1)
 
@@ -193,7 +193,7 @@ def test_kafka_cluster_config_id_value(
         mock_endpoint,
         mock_conn,
         mocked_responses,
-        mock_registered_model_version,
+        make_mock_registered_model_version,
     ) -> None:
         """Verify that, while updating an endpoint, the provided value for
         `cluster_config_id` is used, resulting in the correct sequence of HTTP
@@ -226,7 +226,7 @@ def test_kafka_cluster_config_id_value(
                 url=stages_url + f"/{STAGE_ID}", status=200, json={"id": STAGE_ID}
             )
             mock_endpoint.update(
-                mock_registered_model_version, kafka_settings=kafka_settings
+                make_mock_registered_model_version(), kafka_settings=kafka_settings
             )
 
     @settings(suppress_health_check=[HealthCheck.function_scoped_fixture])
@@ -241,7 +241,7 @@ def test_kafka_config_missing_config_id_exception(
         mock_endpoint,
         mock_conn,
         mocked_responses,
-        mock_registered_model_version,
+        make_mock_registered_model_version,
     ) -> None:
         """In the unlikely evert the ID of a found Kafka config is missing from the
         backend response, the expected exception is raised.
@@ -259,7 +259,7 @@ def test_kafka_config_missing_config_id_exception(
             _responses.get(url=get_configs_url, status=200, json=kafka_configs_response)
             with pytest.raises(RuntimeError) as err:
                 mock_endpoint.update(
-                    mock_registered_model_version, kafka_settings=kafka_settings
+                    make_mock_registered_model_version(), kafka_settings=kafka_settings
                 )
             assert (
                 str(err.value)
@@ -275,7 +275,7 @@ def test_no_kafka_configs_found_exception(
         mock_endpoint,
         mock_conn,
         mocked_responses,
-        mock_registered_model_version,
+        make_mock_registered_model_version,
     ) -> None:
         """If no valid Kafka configurations are found, the expected exception is raised."""
         deployment_url = f"{mock_conn.scheme}://{mock_conn.socket}/api/v1/deployment"
@@ -290,7 +290,7 @@ def test_no_kafka_configs_found_exception(
             _responses.get(url=get_configs_url, status=200, json={"configurations": []})
             with pytest.raises(RuntimeError) as err:
                 mock_endpoint.update(
-                    mock_registered_model_version, kafka_settings=kafka_settings
+                    make_mock_registered_model_version(), kafka_settings=kafka_settings
                 )
             assert (
                 str(err.value)