feat: add ServicePort model and get_service_ports function for handling service inputs and outputs

Author: pcrespov

packages/models-library/src/models_library/services_io.py

@@ -30,8 +30,6 @@ class BaseServiceIOModel(BaseModel):
     Base class for service input/outputs
     """
 
-    ## management
-
     ### human readable descriptors
     display_order: float | None = Field(
         None,

services/catalog/src/simcore_service_catalog/api/_dependencies/services.py

@@ -95,9 +95,9 @@ async def get_service_from_manifest(
         return cast(
             ServiceMetaDataPublished,
             await manifest.get_service(
+                director_client=director_client,
                 key=service_key,
                 version=service_version,
-                director_client=director_client,
             ),
         )
 

services/catalog/src/simcore_service_catalog/models/services_ports.py

@@ -0,0 +1,15 @@
+from typing import Annotated, Literal
+
+from models_library.services_io import ServiceInput, ServiceOutput
+from pydantic import BaseModel, Field
+
+
+class ServicePort(BaseModel):
+    kind: Annotated[
+        Literal["input", "output"],
+        Field(description="Whether this is an input or output port"),
+    ]
+    key: Annotated[
+        str, Field(description="The unique identifier for this port within the service")
+    ]
+    port: ServiceInput | ServiceOutput

services/catalog/src/simcore_service_catalog/service/manifest.py

@@ -36,6 +36,7 @@
 
 from .._constants import DIRECTOR_CACHING_TTL
 from ..clients.director import DirectorClient
+from ..models.services_ports import ServicePort
 from .function_services import get_function_service, is_function_service
 
 _logger = logging.getLogger(__name__)
@@ -123,3 +124,40 @@ async def get_batch_services(
         tasks_group_prefix="manifest.get_batch_services",
     )
     return batch
+
+
+async def get_service_ports(
+    director_client: DirectorClient,
+    *,
+    key: ServiceKey,
+    version: ServiceVersion,
+) -> list[ServicePort]:
+    """Retrieves all ports (inputs and outputs) from a service"""
+    ports = []
+    service = await get_service(
+        director_client=director_client,
+        key=key,
+        version=version,
+    )
+
+    if service.inputs:
+        for input_name, service_input in service.inputs.items():
+            ports.append(
+                ServicePort(
+                    kind="input",
+                    key=input_name,
+                    port=service_input,
+                )
+            )
+
+    if service.outputs:
+        for output_name, service_output in service.outputs.items():
+            ports.append(
+                ServicePort(
+                    kind="output",
+                    key=output_name,
+                    port=service_output,
+                )
+            )
+
+    return ports

services/catalog/tests/unit/test_service_manifest.py

@@ -31,19 +31,31 @@ def app_environment(
     )
 
 
-async def test_services_manifest_api(
+@pytest.fixture
+async def director_client(
     repository_lifespan_disabled: None,
     rabbitmq_and_rpc_setup_disabled: None,
     mocked_director_rest_api: MockRouter,
     app: FastAPI,
-):
-    director_api = get_director_client(app)
+) -> DirectorClient:
+    _client = get_director_client(app)
+    assert app.state.director_api == _client
+    assert isinstance(_client, DirectorClient)
+    return _client
 
-    assert app.state.director_api == director_api
-    assert isinstance(director_api, DirectorClient)
 
-    # LIST
-    all_services_map = await manifest.get_services_map(director_api)
+@pytest.fixture
+async def all_services_map(
+    director_client: DirectorClient,
+) -> manifest.ServiceMetaDataPublishedDict:
+    return await manifest.get_services_map(director_client)
+
+
+async def test_get_services_map(
+    mocked_director_rest_api: MockRouter,
+    director_client: DirectorClient,
+):
+    all_services_map = await manifest.get_services_map(director_client)
     assert mocked_director_rest_api["list_services"].called
 
     for service in all_services_map.values():
@@ -57,22 +69,69 @@ async def test_services_manifest_api(
     }
     assert len(services_image_digest) < len(all_services_map)
 
-    # GET
+
+async def test_get_service(
+    mocked_director_rest_api: MockRouter,
+    director_client: DirectorClient,
+    all_services_map: manifest.ServiceMetaDataPublishedDict,
+):
+
     for expected_service in all_services_map.values():
         service = await manifest.get_service(
             key=expected_service.key,
             version=expected_service.version,
-            director_client=director_api,
+            director_client=director_client,
         )
 
         assert service == expected_service
         if not is_function_service(service.key):
             assert mocked_director_rest_api["get_service"].called
 
-    # BATCH
+
+async def test_get_service_ports(
+    director_client: DirectorClient,
+    all_services_map: manifest.ServiceMetaDataPublishedDict,
+):
+
+    for expected_service in all_services_map.values():
+        ports = await manifest.get_service_ports(
+            key=expected_service.key,
+            version=expected_service.version,
+            director_client=director_client,
+        )
+
+        # Verify all ports are properly retrieved
+        assert isinstance(ports, list)
+
+        # Check input ports
+        input_ports = [p for p in ports if p.kind == "input"]
+        if expected_service.inputs:
+            assert len(input_ports) == len(expected_service.inputs)
+            for port in input_ports:
+                assert port.key in expected_service.inputs
+                assert port.port == expected_service.inputs[port.key]
+        else:
+            assert not input_ports
+
+        # Check output ports
+        output_ports = [p for p in ports if p.kind == "output"]
+        if expected_service.outputs:
+            assert len(output_ports) == len(expected_service.outputs)
+            for port in output_ports:
+                assert port.key in expected_service.outputs
+                assert port.port == expected_service.outputs[port.key]
+        else:
+            assert not output_ports
+
+
+async def test_get_batch_services(
+    director_client: DirectorClient,
+    all_services_map: manifest.ServiceMetaDataPublishedDict,
+):
+
     for expected_services in toolz.partition(2, all_services_map.values()):
         selection = [(s.key, s.version) for s in expected_services]
-        got_services = await manifest.get_batch_services(selection, director_api)
+        got_services = await manifest.get_batch_services(selection, director_client)
 
         assert [(s.key, s.version) for s in got_services] == selection