First batch of changes requested by GHK for functions API

Author: wvangeit

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

@@ -3,6 +3,7 @@
 from typing import Annotated, Any, Literal, TypeAlias
 from uuid import UUID
 
+from common_library.errors_classes import OsparcErrorMixin
 from models_library import projects
 from models_library.services_types import ServiceKey, ServiceVersion
 from pydantic import BaseModel, Field
@@ -66,6 +67,7 @@ class FunctionClass(str, Enum):
 
 
 # TODO, use InputTypes here, but api is throwing weird errors and asking for dict for elements  # noqa: FIX002
+# see here https://github.com/ITISFoundation/osparc-simcore/issues/7659
 FunctionInputs: TypeAlias = dict[str, Any] | None
 
 FunctionInputsList: TypeAlias = list[FunctionInputs]
@@ -203,86 +205,52 @@ class FunctionJobCollectionStatus(BaseModel):
     status: list[str]
 
 
-class FunctionIDNotFoundError(Exception):
+class FunctionBaseError(OsparcErrorMixin, Exception):
+    pass
+
+
+class FunctionIDNotFoundError(FunctionBaseError):
     """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")
+    msg_template: str = "Function {function_id} not found"
 
 
-class FunctionJobIDNotFoundError(Exception):
+class FunctionJobIDNotFoundError(FunctionBaseError):
     """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")
+    msg_template: str = "Function job {function_job_id} not found"
 
 
-class FunctionJobCollectionIDNotFoundError(Exception):
+class FunctionJobCollectionIDNotFoundError(FunctionBaseError):
     """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 RegisterFunctionWithIDError(Exception):
-    """Exception raised when registering a function with a UID"""
-
-    def __init__(self):
-        super().__init__("Cannot register Function with a UID")
-
+    msg_template: str = "Function job collection {function_job_collection_id} not found"
 
-class RegisterFunctionJobWithIDError(Exception):
-    """Exception raised when registering a function job with a UID"""
 
-    def __init__(self):
-        super().__init__("Cannot register FunctionJob with a UID")
-
-
-class RegisterFunctionJobCollectionWithIDError(Exception):
-    """Exception raised when registering a function job collection with a UID"""
-
-    def __init__(self):
-        super().__init__("Cannot register FunctionJobCollection with a UID")
-
-
-class UnsupportedFunctionClassError(Exception):
+class UnsupportedFunctionClassError(FunctionBaseError):
     """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")
+    msg_template: str = "Function class {function_class} is not supported"
 
 
-class UnsupportedFunctionJobClassError(Exception):
+class UnsupportedFunctionJobClassError(FunctionBaseError):
     """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")
+    msg_template: str = "Function job class {function_job_class} is not supported"
 
 
-class UnsupportedFunctionFunctionJobClassCombinationError(Exception):
+class UnsupportedFunctionFunctionJobClassCombinationError(FunctionBaseError):
     """Exception raised when a function / function job class combination is not supported"""
 
-    def __init__(self, function_class: str, function_job_class: str):
-        self.function_class = function_class
-        self.function_job_class = function_job_class
-        super().__init__(
-            f"Function class {function_class} and function job class {function_job_class} combination is not supported"
-        )
+    msg_template: str = (
+        "Function class {function_class} and function job class {function_job_class} combination is not supported"
+    )
 
 
-class FunctionInputsValidationError(Exception):
+class FunctionInputsValidationError(FunctionBaseError):
     """Exception raised when validating function inputs"""
 
-    def __init__(self, error: str):
-        self.errors = error
-        super().__init__(f"Function inputs validation failed: {error}")
+    msg_template: str = "Function inputs validation failed: {error}"
 
 
 class FunctionJobDB(BaseModel):

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

@@ -31,13 +31,14 @@ async def register_function(
     *,
     function: Function,
 ) -> RegisteredFunction:
-    result: RegisteredFunction = await rabbitmq_rpc_client.request(
+    result = await rabbitmq_rpc_client.request(
         WEBSERVER_RPC_NAMESPACE,
         TypeAdapter(RPCMethodName).validate_python("register_function"),
         function=function,
     )
-    TypeAdapter(Function).validate_python(result)  # Validates the result as a Function
-    return result
+    return TypeAdapter(RegisteredFunction).validate_python(
+        result
+    )  # Validates the result as a RegisteredFunction
 
 
 @log_decorator(_logger, level=logging.DEBUG)
@@ -46,13 +47,12 @@ async def get_function(
     *,
     function_id: FunctionID,
 ) -> RegisteredFunction:
-    result: RegisteredFunction = await rabbitmq_rpc_client.request(
+    result = await rabbitmq_rpc_client.request(
         WEBSERVER_RPC_NAMESPACE,
         TypeAdapter(RPCMethodName).validate_python("get_function"),
         function_id=function_id,
     )
-    TypeAdapter(Function).validate_python(result)
-    return result
+    return TypeAdapter(RegisteredFunction).validate_python(result)
 
 
 @log_decorator(_logger, level=logging.DEBUG)
@@ -61,13 +61,12 @@ async def get_function_input_schema(
     *,
     function_id: FunctionID,
 ) -> FunctionInputSchema:
-    result: FunctionInputSchema = await rabbitmq_rpc_client.request(
+    result = await rabbitmq_rpc_client.request(
         WEBSERVER_RPC_NAMESPACE,
         TypeAdapter(RPCMethodName).validate_python("get_function_input_schema"),
         function_id=function_id,
     )
-    TypeAdapter(FunctionInputSchema).validate_python(result)
-    return result
+    return TypeAdapter(FunctionInputSchema).validate_python(result)
 
 
 @log_decorator(_logger, level=logging.DEBUG)
@@ -76,13 +75,12 @@ async def get_function_output_schema(
     *,
     function_id: FunctionID,
 ) -> FunctionOutputSchema:
-    result: FunctionOutputSchema = await rabbitmq_rpc_client.request(
+    result = await rabbitmq_rpc_client.request(
         WEBSERVER_RPC_NAMESPACE,
         TypeAdapter(RPCMethodName).validate_python("get_function_output_schema"),
         function_id=function_id,
     )
-    TypeAdapter(FunctionOutputSchema).validate_python(result)
-    return result
+    return TypeAdapter(FunctionOutputSchema).validate_python(result)
 
 
 @log_decorator(_logger, level=logging.DEBUG)
@@ -91,7 +89,7 @@ async def delete_function(
     *,
     function_id: FunctionID,
 ) -> None:
-    result: None = await rabbitmq_rpc_client.request(
+    result = await rabbitmq_rpc_client.request(
         WEBSERVER_RPC_NAMESPACE,
         TypeAdapter(RPCMethodName).validate_python("delete_function"),
         function_id=function_id,
@@ -138,12 +136,16 @@ async def list_function_jobs(
             pagination_limit=pagination_limit,
         )
     )
-    assert isinstance(result, tuple)
-    TypeAdapter(list[RegisteredFunctionJob]).validate_python(
-        result[0]
-    )  # Validates the result as a list of RegisteredFunctionJobs
+    assert isinstance(result, tuple)  # nosec
+    assert isinstance(result[0], list)  # nosec
+    assert all(
+        TypeAdapter(RegisteredFunctionJob).validate_python(item) for item in result[0]
+    )  # nosec
     assert isinstance(result[1], PageMetaInfoLimitOffset)  # nosec
-    return result
+    return (
+        TypeAdapter(list[RegisteredFunctionJob]).validate_python(result[0]),
+        TypeAdapter(PageMetaInfoLimitOffset).validate_python(result[1]),
+    )
 
 
 @log_decorator(_logger, level=logging.DEBUG)
@@ -153,20 +155,19 @@ async def list_function_job_collections(
     pagination_limit: int,
     pagination_offset: int,
 ) -> tuple[list[RegisteredFunctionJobCollection], PageMetaInfoLimitOffset]:
-    result: tuple[list[RegisteredFunctionJobCollection], PageMetaInfoLimitOffset] = (
-        await rabbitmq_rpc_client.request(
-            WEBSERVER_RPC_NAMESPACE,
-            TypeAdapter(RPCMethodName).validate_python("list_function_job_collections"),
-            pagination_offset=pagination_offset,
-            pagination_limit=pagination_limit,
-        )
+    result = await rabbitmq_rpc_client.request(
+        WEBSERVER_RPC_NAMESPACE,
+        TypeAdapter(RPCMethodName).validate_python("list_function_job_collections"),
+        pagination_offset=pagination_offset,
+        pagination_limit=pagination_limit,
     )
     assert isinstance(result, tuple)
-    TypeAdapter(list[RegisteredFunctionJobCollection]).validate_python(
-        result[0]
-    )  # Validates the result as a list of RegisteredFunctionJobCollections
-    assert isinstance(result[1], PageMetaInfoLimitOffset)  # nosec
-    return result
+    return (
+        TypeAdapter(list[RegisteredFunctionJobCollection]).validate_python(
+            result[0]
+        ),  # Validates the result as a list of RegisteredFunctionJobCollections
+        TypeAdapter(PageMetaInfoLimitOffset).validate_python(result[1]),  # nosec
+    )
 
 
 @log_decorator(_logger, level=logging.DEBUG)
@@ -176,16 +177,15 @@ async def run_function(
     function_id: FunctionID,
     inputs: FunctionInputs,
 ) -> RegisteredFunctionJob:
-    result: RegisteredFunctionJob = await rabbitmq_rpc_client.request(
+    result = await rabbitmq_rpc_client.request(
         WEBSERVER_RPC_NAMESPACE,
         TypeAdapter(RPCMethodName).validate_python("run_function"),
         function_id=function_id,
         inputs=inputs,
     )
-    TypeAdapter(RegisteredFunctionJob).validate_python(
+    return TypeAdapter(RegisteredFunctionJob).validate_python(
         result
-    )  # Validates the result as a FunctionJob
-    return result
+    )  # Validates the result as a RegisteredFunctionJob
 
 
 @log_decorator(_logger, level=logging.DEBUG)
@@ -194,15 +194,14 @@ async def register_function_job(
     *,
     function_job: FunctionJob,
 ) -> RegisteredFunctionJob:
-    result: RegisteredFunctionJob = await rabbitmq_rpc_client.request(
+    result = await rabbitmq_rpc_client.request(
         WEBSERVER_RPC_NAMESPACE,
         TypeAdapter(RPCMethodName).validate_python("register_function_job"),
         function_job=function_job,
     )
-    TypeAdapter(RegisteredFunctionJob).validate_python(
+    return TypeAdapter(RegisteredFunctionJob).validate_python(
         result
     )  # Validates the result as a RegisteredFunctionJob
-    return result
 
 
 @log_decorator(_logger, level=logging.DEBUG)
@@ -211,14 +210,13 @@ async def get_function_job(
     *,
     function_job_id: FunctionJobID,
 ) -> RegisteredFunctionJob:
-    result: RegisteredFunctionJob = await rabbitmq_rpc_client.request(
+    result = await rabbitmq_rpc_client.request(
         WEBSERVER_RPC_NAMESPACE,
         TypeAdapter(RPCMethodName).validate_python("get_function_job"),
         function_job_id=function_job_id,
     )
 
-    TypeAdapter(RegisteredFunctionJob).validate_python(result)
-    return result
+    return TypeAdapter(RegisteredFunctionJob).validate_python(result)
 
 
 @log_decorator(_logger, level=logging.DEBUG)
@@ -233,7 +231,6 @@ async def delete_function_job(
         function_job_id=function_job_id,
     )
     assert result is None  # nosec
-    return result
 
 
 @log_decorator(_logger, level=logging.DEBUG)
@@ -243,16 +240,15 @@ async def find_cached_function_job(
     function_id: FunctionID,
     inputs: FunctionInputs,
 ) -> RegisteredFunctionJob | None:
-    result: RegisteredFunctionJob | None = await rabbitmq_rpc_client.request(
+    result = await rabbitmq_rpc_client.request(
         WEBSERVER_RPC_NAMESPACE,
         TypeAdapter(RPCMethodName).validate_python("find_cached_function_job"),
         function_id=function_id,
         inputs=inputs,
     )
     if result is None:
         return None
-    TypeAdapter(RegisteredFunctionJob).validate_python(result)
-    return result
+    return TypeAdapter(RegisteredFunctionJob).validate_python(result)
 
 
 @log_decorator(_logger, level=logging.DEBUG)
@@ -261,13 +257,12 @@ async def register_function_job_collection(
     *,
     function_job_collection: FunctionJobCollection,
 ) -> RegisteredFunctionJobCollection:
-    result: RegisteredFunctionJobCollection = await rabbitmq_rpc_client.request(
+    result = await rabbitmq_rpc_client.request(
         WEBSERVER_RPC_NAMESPACE,
         TypeAdapter(RPCMethodName).validate_python("register_function_job_collection"),
         function_job_collection=function_job_collection,
     )
-    TypeAdapter(RegisteredFunctionJobCollection).validate_python(result)
-    return result
+    return TypeAdapter(RegisteredFunctionJobCollection).validate_python(result)
 
 
 @log_decorator(_logger, level=logging.DEBUG)
@@ -276,13 +271,12 @@ async def get_function_job_collection(
     *,
     function_job_collection_id: FunctionJobCollectionID,
 ) -> RegisteredFunctionJobCollection:
-    result: RegisteredFunctionJobCollection = await rabbitmq_rpc_client.request(
+    result = await rabbitmq_rpc_client.request(
         WEBSERVER_RPC_NAMESPACE,
         TypeAdapter(RPCMethodName).validate_python("get_function_job_collection"),
         function_job_collection_id=function_job_collection_id,
     )
-    TypeAdapter(RegisteredFunctionJobCollection).validate_python(result)
-    return result
+    return TypeAdapter(RegisteredFunctionJobCollection).validate_python(result)
 
 
 @log_decorator(_logger, level=logging.DEBUG)
@@ -291,10 +285,9 @@ async def delete_function_job_collection(
     *,
     function_job_collection_id: FunctionJobCollectionID,
 ) -> None:
-    result: None = await rabbitmq_rpc_client.request(
+    result = await rabbitmq_rpc_client.request(
         WEBSERVER_RPC_NAMESPACE,
         TypeAdapter(RPCMethodName).validate_python("delete_function_job_collection"),
         function_job_collection_id=function_job_collection_id,
     )
-    assert result is None
-    return result
+    assert result is None  # nosec