Add function endpoints to update title and description

Author: wvangeit

packages/service-library/src/servicelib/rabbitmq/rpc_interfaces/webserver/functions/functions_rpc_interface.py

@@ -170,6 +170,38 @@ async def list_function_job_collections(
     )
 
 
+@log_decorator(_logger, level=logging.DEBUG)
+async def update_function_title(
+    rabbitmq_rpc_client: RabbitMQRPCClient,
+    *,
+    function_id: FunctionID,
+    title: str,
+) -> RegisteredFunction:
+    result = await rabbitmq_rpc_client.request(
+        WEBSERVER_RPC_NAMESPACE,
+        TypeAdapter(RPCMethodName).validate_python("update_function_title"),
+        function_id=function_id,
+        title=title,
+    )
+    return TypeAdapter(RegisteredFunction).validate_python(result)
+
+
+@log_decorator(_logger, level=logging.DEBUG)
+async def update_function_description(
+    rabbitmq_rpc_client: RabbitMQRPCClient,
+    *,
+    function_id: FunctionID,
+    description: str,
+) -> RegisteredFunction:
+    result = await rabbitmq_rpc_client.request(
+        WEBSERVER_RPC_NAMESPACE,
+        TypeAdapter(RPCMethodName).validate_python("update_function_description"),
+        function_id=function_id,
+        description=description,
+    )
+    return TypeAdapter(RegisteredFunction).validate_python(result)
+
+
 @log_decorator(_logger, level=logging.DEBUG)
 async def run_function(
     rabbitmq_rpc_client: RabbitMQRPCClient,

services/api-server/src/simcore_service_api_server/api/routes/functions_routes.py

@@ -149,6 +149,46 @@ async def list_function_job_collections(
     )
 
 
+@function_router.patch(
+    "/{function_id:uuid}/title",
+    response_model=RegisteredFunction,
+    responses={**_COMMON_FUNCTION_ERROR_RESPONSES},
+    description="Update function",
+)
+async def update_function_title(
+    function_id: FunctionID,
+    wb_api_rpc: Annotated[WbApiRpcClient, Depends(get_wb_api_rpc_client)],
+    title: str,
+) -> RegisteredFunction:
+    returned_function = await wb_api_rpc.update_function_title(
+        function_id=function_id, title=title
+    )
+    assert (
+        returned_function.title == title
+    ), f"Function title was not updated. Expected {title} but got {returned_function.title}"  # nosec
+    return returned_function
+
+
+@function_router.patch(
+    "/{function_id:uuid}/description",
+    response_model=RegisteredFunction,
+    responses={**_COMMON_FUNCTION_ERROR_RESPONSES},
+    description="Update function",
+)
+async def update_function_description(
+    function_id: FunctionID,
+    wb_api_rpc: Annotated[WbApiRpcClient, Depends(get_wb_api_rpc_client)],
+    description: str,
+) -> RegisteredFunction:
+    returned_function = await wb_api_rpc.update_function_description(
+        function_id=function_id, description=description
+    )
+    assert (
+        returned_function.description == description
+    ), f"Function description was not updated. Expected {description} but got {returned_function.description}"  # nosec
+    return returned_function
+
+
 def _join_inputs(
     default_inputs: FunctionInputs | None,
     function_inputs: FunctionInputs | None,

services/api-server/src/simcore_service_api_server/services_rpc/wb_api_server.py

@@ -328,6 +328,24 @@ async def get_function_job(
             function_job_id=function_job_id,
         )
 
+    async def update_function_title(
+        self, *, function_id: FunctionID, title: str
+    ) -> RegisteredFunction:
+        return await functions_rpc_interface.update_function_title(
+            self._client,
+            function_id=function_id,
+            title=title,
+        )
+
+    async def update_function_description(
+        self, *, function_id: FunctionID, description: str
+    ) -> RegisteredFunction:
+        return await functions_rpc_interface.update_function_description(
+            self._client,
+            function_id=function_id,
+            description=description,
+        )
+
     async def delete_function_job(self, *, function_job_id: FunctionJobID) -> None:
         return await functions_rpc_interface.delete_function_job(
             self._client,

services/api-server/tests/unit/api_functions/conftest.py

@@ -0,0 +1,18 @@
+import pytest
+from pytest_simcore.helpers.monkeypatch_envs import setenvs_from_dict
+from pytest_simcore.helpers.typing_env import EnvVarsDict
+
+
+@pytest.fixture
+def app_environment(
+    app_environment: EnvVarsDict,
+    monkeypatch: pytest.MonkeyPatch,
+):
+    return setenvs_from_dict(
+        monkeypatch,
+        {
+            **app_environment,  # WARNING: AFTER env_devel_dict because HOST are set to 127.0.0.1 in here
+            "WEBSERVER_DEV_FEATURES_ENABLED": "1",
+            "WEBSERVER_FUNCTIONS": "1",
+        },
+    )

services/api-server/tests/unit/api_functions/test_api_routers_functions.py

@@ -228,6 +228,24 @@ async def delete_function_job_collection(
                 status_code=404, detail="Function job collection not found"
             )
 
+    async def update_function_title(
+        self, function_id: str, title: str
+    ) -> RegisteredFunction:
+        # Mimic updating the title of a function
+        if function_id not in self._functions:
+            raise HTTPException(status_code=404, detail="Function not found")
+        self._functions[function_id].title = title
+        return self._functions[function_id]
+
+    async def update_function_description(
+        self, function_id: str, description: str
+    ) -> RegisteredFunction:
+        # Mimic updating the description of a function
+        if function_id not in self._functions:
+            raise HTTPException(status_code=404, detail="Function not found")
+        self._functions[function_id].description = description
+        return self._functions[function_id]
+
 
 def test_register_function(api_app) -> None:
     client = TestClient(api_app)
@@ -335,6 +353,62 @@ def test_list_functions(api_app: FastAPI) -> None:
     assert data[0]["title"] == sample_function["title"]
 
 
+def test_update_function_title(api_app: FastAPI) -> None:
+    client = TestClient(api_app)
+    project_id = str(uuid4())
+    # Register a sample function
+    sample_function = {
+        "uid": None,
+        "title": "example_function",
+        "function_class": "project",
+        "project_id": project_id,
+        "description": "An example function",
+        "input_schema": JSONFunctionInputSchema().model_dump(),
+        "output_schema": JSONFunctionOutputSchema().model_dump(),
+        "default_inputs": None,
+    }
+    post_response = client.post("/functions", json=sample_function)
+    assert post_response.status_code == 200
+    data = post_response.json()
+    function_id = data["uid"]
+
+    # Update the function title
+    updated_title = {"title": "updated_example_function"}
+    response = client.patch(f"/functions/{function_id}/title", params=updated_title)
+    assert response.status_code == 200
+    data = response.json()
+    assert data["title"] == updated_title["title"]
+
+
+def test_update_function_description(api_app: FastAPI) -> None:
+    client = TestClient(api_app)
+    project_id = str(uuid4())
+    # Register a sample function
+    sample_function = {
+        "uid": None,
+        "title": "example_function",
+        "function_class": "project",
+        "project_id": project_id,
+        "description": "An example function",
+        "input_schema": JSONFunctionInputSchema().model_dump(),
+        "output_schema": JSONFunctionOutputSchema().model_dump(),
+        "default_inputs": None,
+    }
+    post_response = client.post("/functions", json=sample_function)
+    assert post_response.status_code == 200
+    data = post_response.json()
+    function_id = data["uid"]
+
+    # Update the function description
+    updated_description = {"description": "updated_example_function"}
+    response = client.patch(
+        f"/functions/{function_id}/description", params=updated_description
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["description"] == updated_description["description"]
+
+
 def test_get_function_input_schema(api_app: FastAPI) -> None:
     client = TestClient(api_app)
     project_id = str(uuid4())

services/web/server/src/simcore_service_webserver/functions/_functions_controller_rpc.py

@@ -238,6 +238,32 @@ async def delete_function_job_collection(
     )
 
 
+@router.expose()
+async def update_function_title(
+    app: web.Application, *, function_id: FunctionID, title: str
+) -> RegisteredFunction:
+    assert app
+    updated_function = await _functions_repository.update_function_title(
+        app=app,
+        function_id=function_id,
+        title=title,
+    )
+    return _decode_function(updated_function)
+
+
+@router.expose(reraise_if_error_type=(FunctionIDNotFoundError,))
+async def update_function_description(
+    app: web.Application, *, function_id: FunctionID, description: str
+) -> RegisteredFunction:
+    assert app
+    updated_function = await _functions_repository.update_function_description(
+        app=app,
+        function_id=function_id,
+        description=description,
+    )
+    return _decode_function(updated_function)
+
+
 @router.expose()
 async def find_cached_function_job(
     app: web.Application, *, function_id: FunctionID, inputs: FunctionInputs

services/web/server/src/simcore_service_webserver/functions/_functions_repository.py

@@ -331,6 +331,42 @@ async def delete_function(
         )
 
 
+async def update_function_title(
+    app: web.Application, *, function_id: FunctionID, title: str
+) -> RegisteredFunctionDB:
+    async with transaction_context(get_asyncpg_engine(app)) as conn:
+        result = await conn.stream(
+            functions_table.update()
+            .where(functions_table.c.uuid == function_id)
+            .values(title=title)
+            .returning(*_FUNCTIONS_TABLE_COLS)
+        )
+        row = await result.first()
+
+        if row is None:
+            raise FunctionIDNotFoundError(function_id=function_id)
+
+        return RegisteredFunctionDB.model_validate(dict(row))
+
+
+async def update_function_description(
+    app: web.Application, *, function_id: FunctionID, description: str
+) -> RegisteredFunctionDB:
+    async with transaction_context(get_asyncpg_engine(app)) as conn:
+        result = await conn.stream(
+            functions_table.update()
+            .where(functions_table.c.uuid == function_id)
+            .values(description=description)
+            .returning(*_FUNCTIONS_TABLE_COLS)
+        )
+        row = await result.first()
+
+        if row is None:
+            raise FunctionIDNotFoundError(function_id=function_id)
+
+        return RegisteredFunctionDB.model_validate(dict(row))
+
+
 async def get_function_job(
     app: web.Application,
     connection: AsyncConnection | None = None,

services/web/server/tests/unit/with_dbs/04/functions_rpc/test_functions_controller_rpc.py

@@ -240,6 +240,56 @@ async def test_list_functions_with_pagination(
     assert page_info.total == TOTAL_FUNCTIONS
 
 
+async def test_update_function_title(
+    client: TestClient, rpc_client: RabbitMQRPCClient, mock_function: ProjectFunction
+):
+    assert client.app
+    # Register the function first
+    registered_function = await functions_rpc.register_function(
+        rabbitmq_rpc_client=rpc_client, function=mock_function
+    )
+    assert registered_function.uid is not None
+
+    # Update the function's title
+    updated_title = "Updated Function Title"
+    registered_function.title = updated_title
+    updated_function = await functions_rpc.update_function_title(
+        rabbitmq_rpc_client=rpc_client,
+        function_id=registered_function.uid,
+        title=updated_title,
+    )
+
+    assert isinstance(updated_function, ProjectFunction)
+    assert updated_function.uid == registered_function.uid
+    # Assert the updated function's title matches the new title
+    assert updated_function.title == updated_title
+
+
+async def test_update_function_description(
+    client: TestClient, rpc_client: RabbitMQRPCClient, mock_function: ProjectFunction
+):
+    assert client.app
+    # Register the function first
+    registered_function = await functions_rpc.register_function(
+        rabbitmq_rpc_client=rpc_client, function=mock_function
+    )
+    assert registered_function.uid is not None
+
+    # Update the function's description
+    updated_description = "Updated Function Description"
+    registered_function.description = updated_description
+    updated_function = await functions_rpc.update_function_description(
+        rabbitmq_rpc_client=rpc_client,
+        function_id=registered_function.uid,
+        description=updated_description,
+    )
+
+    assert isinstance(updated_function, ProjectFunction)
+    assert updated_function.uid == registered_function.uid
+    # Assert the updated function's description matches the new description
+    assert updated_function.description == updated_description
+
+
 async def test_get_function_input_schema(
     client: TestClient, rpc_client: RabbitMQRPCClient, mock_function: ProjectFunction
 ):