start fixing find_cache method

Author: bisgaard-itis

services/web/server/src/simcore_service_webserver/functions/_controller/_functions_rpc.py

@@ -3,6 +3,7 @@
 from aiohttp import web
 from models_library.functions import (
     BatchCreateRegisteredFunctionJobs,
+    BatchGetCachedRegisteredFunctionJobs,
     BatchUpdateRegisteredFunctionJobs,
     Function,
     FunctionAccessRights,
@@ -490,17 +491,23 @@ async def find_cached_function_jobs(
     function_id: FunctionID,
     inputs: FunctionInputsList,
     status_filter: list[FunctionJobStatus] | None,
-) -> list[RegisteredFunctionJob | None]:
-    jobs = await _functions_service.find_cached_function_jobs(
-        app=app,
-        user_id=user_id,
-        product_name=product_name,
-        function_id=function_id,
-        inputs=inputs,
-        status_filter=status_filter,
-    )
-    assert len(jobs) == len(inputs)  # nosec
-    return jobs
+) -> BatchGetCachedRegisteredFunctionJobs:
+    retrieved_cached_function_jobs = (
+        await _functions_service.batch_find_cached_function_jobs(
+            app=app,
+            user_id=user_id,
+            product_name=product_name,
+            function_id=function_id,
+            inputs=inputs,
+            status_filter=status_filter,
+        )
+    )
+    assert len(retrieved_cached_function_jobs.found_items) + len(
+        retrieved_cached_function_jobs.missing_identifiers
+    ) == len(
+        inputs
+    )  # nosec
+    return retrieved_cached_function_jobs
 
 
 @router.expose(reraise_if_error_type=(FunctionIDNotFoundError,))

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

@@ -7,6 +7,7 @@
 from aiohttp import web
 from models_library.functions import (
     BatchCreateRegisteredFunctionJobsDB,
+    BatchGetCachedRegisteredFunctionJobsDB,
     BatchUpdateRegisteredFunctionJobsDB,
     FunctionClass,
     FunctionClassSpecificData,
@@ -318,7 +319,7 @@ async def delete_function_job(
         )
 
 
-async def find_cached_function_jobs(
+async def batch_find_cached_function_jobs(
     app: web.Application,
     connection: AsyncConnection | None = None,
     *,
@@ -327,7 +328,7 @@ async def find_cached_function_jobs(
     product_name: ProductName,
     inputs: FunctionInputsList,
     status_filter: list[FunctionJobStatus] | None = None,
-) -> list[RegisteredFunctionJobDB | None]:
+) -> BatchGetCachedRegisteredFunctionJobsDB:
     async with pass_or_acquire_connection(get_asyncpg_engine(app), connection) as conn:
         # Get user groups for access check
         user_groups = await list_all_user_groups_ids(app, user_id=user_id)
@@ -378,8 +379,16 @@ async def find_cached_function_jobs(
             for row in results
         }
 
-        # Return results in the same order as inputs, with None for missing jobs
-        return [jobs_by_input.get(json_input, None) for json_input in json_inputs]
+        return BatchGetCachedRegisteredFunctionJobsDB(
+            found_items=[
+                jobs_by_input[input_]
+                for input_ in json_inputs
+                if input_ in jobs_by_input
+            ],
+            missing_identifiers=[
+                input_ for input_ in inputs if json.dumps(input_) not in jobs_by_input
+            ],
+        )
 
 
 async def get_function_job_status(

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

@@ -4,6 +4,7 @@
 from models_library.basic_types import IDStr
 from models_library.functions import (
     BatchCreateRegisteredFunctionJobs,
+    BatchGetCachedRegisteredFunctionJobs,
     BatchUpdateRegisteredFunctionJobs,
     Function,
     FunctionClass,
@@ -448,30 +449,34 @@ async def update_function(
     return _decode_function(updated_function)
 
 
-async def find_cached_function_jobs(
+async def batch_find_cached_function_jobs(
     app: web.Application,
     *,
     user_id: UserID,
     product_name: ProductName,
     function_id: FunctionID,
     inputs: FunctionInputsList,
     status_filter: list[FunctionJobStatus] | None = None,
-) -> list[RegisteredFunctionJob | None]:
-    returned_function_jobs = await _function_jobs_repository.find_cached_function_jobs(
-        app=app,
-        user_id=user_id,
-        product_name=product_name,
-        function_id=function_id,
-        inputs=inputs,
-        status_filter=status_filter,
+) -> BatchGetCachedRegisteredFunctionJobs:
+    returned_function_jobs = (
+        await _function_jobs_repository.batch_find_cached_function_jobs(
+            app=app,
+            user_id=user_id,
+            product_name=product_name,
+            function_id=function_id,
+            inputs=inputs,
+            status_filter=status_filter,
+        )
     )
-    assert len(returned_function_jobs) == len(inputs)  # nosec
+    assert len(returned_function_jobs.found_items) + len(
+        returned_function_jobs.missing_identifiers
+    ) == len(
+        inputs
+    )  # nosec
 
     def _map_db_model_to_domain_model(
-        job: RegisteredFunctionJobDB | None,
-    ) -> RegisteredFunctionJob | None:
-        if job is None:
-            return None
+        job: RegisteredFunctionJobDB,
+    ) -> RegisteredFunctionJob:
         if job.function_class == FunctionClass.PROJECT:
             return RegisteredProjectFunctionJob(
                 uid=job.uuid,
@@ -502,7 +507,13 @@ def _map_db_model_to_domain_model(
             )
         raise UnsupportedFunctionJobClassError(function_job_class=job.function_class)
 
-    return [_map_db_model_to_domain_model(job) for job in returned_function_jobs]
+    return BatchGetCachedRegisteredFunctionJobs(
+        found_items=[
+            _map_db_model_to_domain_model(job)
+            for job in returned_function_jobs.found_items
+        ],
+        missing_identifiers=returned_function_jobs.missing_identifiers,
+    )
 
 
 async def get_function_input_schema(

services/web/server/tests/unit/with_dbs/04/functions/wb-api-server/test_function_jobs_controller_rpc.py

@@ -464,12 +464,13 @@ async def test_find_cached_function_jobs(
     )
 
     # Assert the cached jobs contain the registered job
-    assert cached_jobs is not None
-    assert len(cached_jobs) == 2
-    job0 = cached_jobs[0]
+    assert cached_jobs.found_items is not None
+    assert len(cached_jobs.found_items) == 1
+    job0 = cached_jobs.found_items[0]
     assert job0 is not None
     assert job0.inputs == {"input1": 1}
-    assert cached_jobs[1] is None
+    assert len(cached_jobs.missing_identifiers) == 1
+    assert cached_jobs.missing_identifiers[0] == {"input1": 10}
 
     cached_jobs = await webserver_rpc_client.functions.find_cached_function_jobs(
         function_id=registered_function.uid,
@@ -479,8 +480,8 @@ async def test_find_cached_function_jobs(
     )
 
     # Assert the cached jobs does not contain the registered job for the other user
-    assert len(cached_jobs) == 2
-    assert all(elm is None for elm in cached_jobs)
+    assert len(cached_jobs.missing_identifiers) == 2
+    assert len(cached_jobs.found_items) == 0
 
 
 @pytest.mark.parametrize(
@@ -541,8 +542,8 @@ async def test_find_cached_function_jobs_with_status(
         inputs=[input_],
         status_filter=[status],
     )
-    assert len(cached_jobs) == 1
-    cached_job = cached_jobs[0]
+    assert len(cached_jobs.found_items) == 1
+    cached_job = cached_jobs.found_items[0]
     assert cached_job is not None
     assert cached_job.inputs == input_
     cached_job_status = await webserver_rpc_client.functions.get_function_job_status(