Changes based on Mads comments wrt functions api

Author: wvangeit

packages/models-library/src/models_library/api_schemas_webserver/functions_wb_schema.py

@@ -17,6 +17,8 @@
 
 
 class FunctionSchema(BaseModel):
+    """Schema for function input/output"""
+
     schema_dict: dict[str, Any] | None  # JSON Schema
 
 
@@ -163,3 +165,52 @@ class FunctionJobCollectionDB(BaseModel):
 
 class FunctionJobCollectionStatus(BaseModel):
     status: list[str]
+
+
+class FunctionNotFoundError(Exception):
+    """Exception raised when a function is not found"""
+
+    def __init__(self, function_id: FunctionID):
+        self.function_id = function_id
+        super().__init__(f"Function {function_id} not found")
+
+
+class FunctionJobNotFoundError(Exception):
+    """Exception raised when a function job is not found"""
+
+    def __init__(self, function_job_id: FunctionJobID):
+        self.function_job_id = function_job_id
+        super().__init__(f"Function job {function_job_id} not found")
+
+
+class FunctionJobCollectionNotFoundError(Exception):
+    """Exception raised when a function job collection is not found"""
+
+    def __init__(self, function_job_collection_id: FunctionJobCollectionID):
+        self.function_job_collection_id = function_job_collection_id
+        super().__init__(
+            f"Function job collection {function_job_collection_id} not found"
+        )
+
+
+class RegisterFunctionWithUIDError(Exception):
+    """Exception raised when registering a function with a UID"""
+
+    def __init__(self):
+        super().__init__("Cannot register Function with a UID")
+
+
+class UnsupportedFunctionClassError(Exception):
+    """Exception raised when a function class is not supported"""
+
+    def __init__(self, function_class: str):
+        self.function_class = function_class
+        super().__init__(f"Function class {function_class} is not supported")
+
+
+class UnsupportedFunctionJobClassError(Exception):
+    """Exception raised when a function job class is not supported"""
+
+    def __init__(self, function_job_class: str):
+        self.function_job_class = function_job_class
+        super().__init__(f"Function job class {function_job_class} is not supported")

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

@@ -18,6 +18,8 @@
     ProjectFunctionJob,
     SolverFunction,
     SolverFunctionJob,
+    UnsupportedFunctionClassError,
+    UnsupportedFunctionJobClassError,
 )
 from models_library.rest_pagination import (
     PageMetaInfoLimitOffset,
@@ -32,12 +34,6 @@
 # pylint: disable=no-else-return
 
 
-@router.expose()
-async def ping(app: web.Application) -> str:
-    assert app
-    return "pong from webserver"
-
-
 @router.expose()
 async def register_function(app: web.Application, *, function: Function) -> Function:
     assert app
@@ -72,8 +68,7 @@ def _decode_function(
             default_inputs=function.default_inputs,
         )
     else:
-        msg = f"Unsupported function class: [{function.function_class}]"
-        raise TypeError(msg)
+        raise UnsupportedFunctionClassError(function_class=function.function_class)
 
 
 def _encode_function(
@@ -91,8 +86,7 @@ def _encode_function(
             }
         )
     else:
-        msg = f"Unsupported function class: {function.function_class}"
-        raise TypeError(msg)
+        raise UnsupportedFunctionClassError(function_class=function.function_class)
 
     return FunctionDB(
         uuid=function.uid,
@@ -142,8 +136,9 @@ def _decode_functionjob(
             solver_job_id=functionjob_db.class_specific_data["solver_job_id"],
         )
     else:
-        msg = f"Unsupported function class: [{functionjob_db.function_class}]"
-        raise TypeError(msg)
+        raise UnsupportedFunctionJobClassError(
+            function_job_class=functionjob_db.function_class
+        )
 
 
 def _encode_functionjob(
@@ -178,8 +173,9 @@ def _encode_functionjob(
             function_class=functionjob.function_class,
         )
     else:
-        msg = f"Unsupported function class: [{functionjob.function_class}]"
-        raise TypeError(msg)
+        raise UnsupportedFunctionJobClassError(
+            function_job_class=functionjob.function_class
+        )
 
 
 @router.expose()
@@ -355,8 +351,9 @@ async def find_cached_function_job(
             solver_job_id=returned_function_job.class_specific_data["solver_job_id"],
         )
     else:
-        msg = f"Unsupported function class: [{returned_function_job.function_class}]"
-        raise TypeError(msg)
+        raise UnsupportedFunctionJobClassError(
+            function_job_class=returned_function_job.function_class
+        )
 
 
 @router.expose()

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

@@ -7,8 +7,12 @@
     FunctionInputs,
     FunctionJobCollection,
     FunctionJobCollectionDB,
+    FunctionJobCollectionNotFoundError,
     FunctionJobDB,
     FunctionJobID,
+    FunctionJobNotFoundError,
+    FunctionNotFoundError,
+    RegisterFunctionWithUIDError,
 )
 from models_library.rest_pagination import (
     PageMetaInfoLimitOffset,
@@ -52,8 +56,7 @@ async def register_function(
 ) -> FunctionDB:
 
     if function.uuid is not None:
-        msg = "Function uid is not None. Cannot register function."
-        raise ValueError(msg)
+        raise RegisterFunctionWithUIDError
 
     async with transaction_context(get_asyncpg_engine(app), connection) as conn:
         result = await conn.stream(
@@ -79,9 +82,10 @@ async def register_function(
         )
         row = await result.first()
 
-        if row is None:
-            msg = "No row was returned from the database after creating function."
-            raise ValueError(msg)
+        assert row is not None, (
+            "No row was returned from the database after creating function."
+            f" Function: {function}"
+        )  # nosec
 
         return FunctionDB.model_validate(dict(row))
 
@@ -100,9 +104,7 @@ async def get_function(
         row = await result.first()
 
         if row is None:
-            msg = f"No function found with id {function_id}."
-            raise web.HTTPNotFound(reason=msg)
-
+            raise FunctionNotFoundError(function_id=function_id)
         return FunctionDB.model_validate(dict(row))
 
 
@@ -258,9 +260,10 @@ async def register_function_job(
         )
         row = await result.first()
 
-        if row is None:
-            msg = "No row was returned from the database after creating function job."
-            raise ValueError(msg)
+        assert row is not None, (
+            "No row was returned from the database after creating function job."
+            f" Function job: {function_job}"
+        )  # nosec
 
         return FunctionJobDB.model_validate(dict(row))
 
@@ -281,8 +284,7 @@ async def get_function_job(
         row = await result.first()
 
         if row is None:
-            msg = f"No function job found with id {function_job_id}."
-            raise web.HTTPNotFound(reason=msg)
+            raise FunctionJobNotFoundError(function_job_id=function_job_id)
 
         return FunctionJobDB.model_validate(dict(row))
 
@@ -319,13 +321,19 @@ async def find_cached_function_job(
 
         rows = await result.all()
 
-        if rows is None:
+        if rows is None or len(rows) == 0:
             return None
 
-        for row in rows:
-            job = FunctionJobDB.model_validate(dict(row))
-            if job.inputs == inputs:
-                return job
+        assert len(rows) == 1, (
+            "More than one function job found with the same function id and inputs."
+            f" Function id: {function_id}, Inputs: {inputs}"
+        )  # nosec
+
+        row = rows[0]
+
+        job = FunctionJobDB.model_validate(dict(row))
+        if job.inputs == inputs:
+            return job
 
         return None
 
@@ -346,8 +354,9 @@ async def get_function_job_collection(
         row = await result.first()
 
         if row is None:
-            msg = f"No function job collection found with id {function_job_collection_id}."
-            raise web.HTTPNotFound(reason=msg)
+            raise FunctionJobCollectionNotFoundError(
+                function_job_collection_id=function_job_collection_id
+            )
 
         # Retrieve associated job ids from the join table
         job_result = await conn.stream(
@@ -383,9 +392,10 @@ async def register_function_job_collection(
         )
         row = await result.first()
 
-        if row is None:
-            msg = "No row was returned from the database after creating function job collection."
-            raise ValueError(msg)
+        assert row is not None, (
+            "No row was returned from the database after creating function job collection."
+            f" Function job collection: {function_job_collection}"
+        )  # nosec
 
         for job_id in function_job_collection.job_ids:
             await conn.execute(

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

@@ -3,11 +3,12 @@
 
 import pytest
 import simcore_service_webserver.functions._functions_controller_rpc as functions_rpc
-from aiohttp import web
 from models_library.api_schemas_webserver.functions_wb_schema import (
     Function,
     FunctionInputSchema,
     FunctionJobCollection,
+    FunctionJobNotFoundError,
+    FunctionNotFoundError,
     FunctionOutputSchema,
     ProjectFunction,
     ProjectFunctionJob,
@@ -89,7 +90,7 @@ async def test_get_function(client, mock_function):
 @pytest.mark.asyncio
 async def test_get_function_not_found(client):
     # Attempt to retrieve a function that does not exist
-    with pytest.raises(web.HTTPNotFound):
+    with pytest.raises(FunctionNotFoundError):
         await functions_rpc.get_function(app=client.app, function_id=uuid4())
 
 
@@ -225,7 +226,7 @@ async def test_delete_function(client, mock_function):
     )
 
     # Attempt to retrieve the deleted function
-    with pytest.raises(web.HTTPNotFound):
+    with pytest.raises(FunctionNotFoundError):
         await functions_rpc.get_function(
             app=client.app, function_id=registered_function.uid
         )
@@ -298,7 +299,7 @@ async def test_get_function_job(client, mock_function):
 @pytest.mark.asyncio
 async def test_get_function_job_not_found(client):
     # Attempt to retrieve a function job that does not exist
-    with pytest.raises(web.HTTPNotFound):
+    with pytest.raises(FunctionJobNotFoundError):
         await functions_rpc.get_function_job(app=client.app, function_job_id=uuid4())
 
 
@@ -365,7 +366,7 @@ async def test_delete_function_job(client, mock_function):
     )
 
     # Attempt to retrieve the deleted job
-    with pytest.raises(web.HTTPNotFound):
+    with pytest.raises(FunctionJobNotFoundError):
         await functions_rpc.get_function_job(
             app=client.app, function_job_id=registered_job.uid
         )
@@ -427,7 +428,7 @@ async def test_function_job_collection(client, mock_function):
         app=client.app, function_job_collection_id=registered_collection.uid
     )
     # Attempt to retrieve the deleted collection
-    with pytest.raises(web.HTTPNotFound):
+    with pytest.raises(FunctionJobNotFoundError):
         await functions_rpc.get_function_job(
             app=client.app, function_job_id=registered_collection.uid
         )