Add proper callback message

Signed-off-by: M Q <[email protected]>

Author: MMelQin

platforms/aidoc/README.md

@@ -66,7 +66,7 @@ Open another console window and change directory to the same as this file.
 
 Set the environment vars so that the test script can get the input DCM and write the callback contents.
 Also, once the Restful app completes each processing, the Spleen Seg app's output will also be saved in
-the output folder speficied below (the script passes the output folder via the Rest API).
+the output folder specified below (the script passes the output folder via the Rest API).
 
 ```
 export HOLOSCAN_INPUT_PATH=dcm
@@ -79,7 +79,7 @@ Run the test script, and examine its console output.
 source test_endpoints.sh
 ```
 
-Once the script completes, examine the `output` folder, which should conatain the following (dcm file
+Once the script completes, examine the `output` folder, which should contain the following (dcm file
 name will be different)
 
 ```

platforms/aidoc/restful_app/ai_spleen_seg_app/__init__.py

@@ -12,7 +12,11 @@
 import os
 import sys
 
+from .app import AISpleenSegApp
+
 _current_dir = os.path.abspath(os.path.dirname(__file__))
 if sys.path and os.path.abspath(sys.path[0]) != _current_dir:
     sys.path.insert(0, _current_dir)
 del _current_dir
+
+__all__ = ["AISpleenSegApp"]

platforms/aidoc/restful_app/ai_spleen_seg_app/__main__.py

@@ -11,7 +11,7 @@
 
 import logging
 
-from app import AISpleenSegApp
+from .app import AISpleenSegApp
 
 if __name__ == "__main__":
     logging.info(f"Begin {__name__}")

platforms/aidoc/restful_app/ai_spleen_seg_app/app.py

@@ -9,12 +9,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import json
 import logging
+import os
 from pathlib import Path
+from typing import List, Union
 
 # Required for setting SegmentDescription attributes. Direct import as this is not part of App SDK package.
 from pydicom.sr.codedict import codes
-from reporter_operator import ExecutionStatusReporterOperator
 
 from monai.deploy.conditions import CountCondition
 from monai.deploy.core import AppContext, Application
@@ -33,10 +35,15 @@
 )
 from monai.deploy.operators.stl_conversion_operator import STLConversionOperator
 
+from .results_message import (
+    AggregatedResults,
+    AlgorithmClass,
+    DetailedResult,
+    MeasurementResult,
+    Results,
+)
+
 
-# @resource(cpu=1, gpu=1, memory="7Gi")
-# pip_packages can be a string that is a path(str) to requirements.txt file or a list of packages.
-# The monai pkg is not required by this class, instead by the included operators.
 class AISpleenSegApp(Application):
     """Demonstrates inference with built-in MONAI Bundle inference operator with DICOM files as input/output
 
@@ -57,13 +64,68 @@ def __init__(self, *args, status_callback=None, **kwargs):
         """Creates an application instance."""
         self._logger = logging.getLogger("{}.{}".format(__name__, type(self).__name__))
         self._status_callback = status_callback
+        self._app_input_path = None  # to be set in compose
+        self._app_output_path = None  # to be set in compose
         super().__init__(*args, **kwargs)
 
+    def _get_files_in_folder(self, folder_path: Union[str, Path]) -> List[str]:
+        """Traverses a folder and returns a list of full paths of all files.
+
+        Args:
+            folder_path (Union[str, Path]): The path to the folder to traverse.
+
+        Returns:
+            List[str]: A list of absolute paths to the files in the folder.
+        """
+        if not os.path.isdir(folder_path):
+            self._logger.warning(f"Output folder '{folder_path}' not found, returning empty file list.")
+            return []
+
+        file_paths = []
+        for root, _, files in os.walk(folder_path):
+            for file in files:
+                full_path = os.path.abspath(os.path.join(root, file))
+                file_paths.append(full_path)
+        return file_paths
+
     def run(self, *args, **kwargs):
         # This method calls the base class to run. Can be omitted if simply calling through.
         self._logger.info(f"Begin {self.run.__name__}")
-        # The try...except block is removed as the reporter operator will handle status reporting.
-        super().run(*args, **kwargs)
+        try:
+            super().run(*args, **kwargs)
+
+            if self._status_callback:
+                # Create the results object using the Pydantic models
+                ai_results = Results(
+                    aggregated_results=AggregatedResults(
+                        name="Spleen Segmentation",
+                        algorithm_class={AlgorithmClass.MEASUREMENT},
+                    ),
+                    detailed_results={
+                        "Spleen Segmentation": DetailedResult(
+                            measurement=MeasurementResult(
+                                measurements_text="Spleen segmentation completed successfully.",
+                            )
+                        )
+                    },
+                )
+
+                output_files = self._get_files_in_folder(self._app_output_path)
+
+                callback_msg_dict = {
+                    "run_success": True,
+                    "output_files": output_files,
+                    "error_message": None,
+                    "error_code": None,
+                    "result": ai_results.model_dump_json(),
+                }
+                self._status_callback(json.dumps(callback_msg_dict))
+
+        except Exception as e:
+            self._logger.error(f"Error in {self.run.__name__}: {e}")
+            # Let the caller to handle and report the error
+            raise e
+
         self._logger.info(f"End {self.run.__name__}")
 
     def compose(self):
@@ -73,12 +135,12 @@ def compose(self):
 
         # Use Commandline options over environment variables to init context.
         app_context: AppContext = Application.init_app_context(self.argv)
-        app_input_path = Path(app_context.input_path)
-        app_output_path = Path(app_context.output_path)
+        self._app_input_path = Path(app_context.input_path)
+        self._app_output_path = Path(app_context.output_path)
 
         # Create the custom operator(s) as well as SDK built-in operator(s).
         study_loader_op = DICOMDataLoaderOperator(
-            self, CountCondition(self, 1), input_folder=app_input_path, name="study_loader_op"
+            self, CountCondition(self, 1), input_folder=self._app_input_path, name="study_loader_op"
         )
         series_selector_op = DICOMSeriesSelectorOperator(self, rules=Sample_Rules_Text, name="series_selector_op")
         series_to_vol_op = DICOMSeriesToVolumeOperator(self, name="series_to_vol_op")
@@ -122,11 +184,11 @@ def compose(self):
             self,
             segment_descriptions=segment_descriptions,
             custom_tags=custom_tags,
-            output_folder=app_output_path,
+            output_folder=self._app_output_path,
             name="dicom_seg_writer",
         )
 
-        reporter_op = ExecutionStatusReporterOperator(self, status_callback=self._status_callback)
+        # reporter_op = ExecutionStatusReporterOperator(self, status_callback=self._status_callback)
 
         # Create the processing pipeline, by specifying the source and destination operators, and
         # ensuring the output from the former matches the input of the latter, in both name and type.
@@ -143,13 +205,13 @@ def compose(self):
         # Create the surface mesh STL conversion operator and add it to the app execution flow, if needed, by
         # uncommenting the following couple lines.
         stl_conversion_op = STLConversionOperator(
-            self, output_file=app_output_path.joinpath("stl/spleen.stl"), name="stl_conversion_op"
+            self, output_file=self._app_output_path.joinpath("stl/spleen.stl"), name="stl_conversion_op"
         )
         self.add_flow(bundle_spleen_seg_op, stl_conversion_op, {("pred", "image")})
 
         # Connect the reporter operator to the end of the pipeline.
         # It will be triggered after the DICOM SEG file is written.
-        self.add_flow(stl_conversion_op, reporter_op, {("stl_bytes", "data")})
+        # self.add_flow(stl_conversion_op, reporter_op, {("stl_bytes", "data")})
 
         logging.info(f"End {self.compose.__name__}")
 

platforms/aidoc/restful_app/ai_spleen_seg_app/reporter_operator.py

@@ -11,6 +11,7 @@
 
 import argparse
 import importlib
+import json
 import logging
 import os
 import sys
@@ -23,11 +24,12 @@
 # The MONAI Deploy application to be wrapped.
 # This can be changed to any other application in the repository.
 # Provide the module path and the class name of the application.
-APP_MODULE_NAME = "ai_spleen_seg_app.app"
+
+APP_MODULE_NAME = "ai_spleen_seg_app"
 APP_CLASS_NAME = "AISpleenSegApp"
 
 # Flask application setup
-app = Flask(__name__)
+restful_app = Flask(__name__)
 logging.basicConfig(stream=sys.stdout, level=logging.INFO)
 
 # Global state to track processing status. A lock is used for thread safety.
@@ -54,15 +56,15 @@ def run_processing(input_folder, output_folder, callback_url):
     """
 
     # Define the callback function that the MONAI Deploy app will call.
-    def app_status_callback(summary):
+    def app_status_callback(summary: str):
         """Callback function to handle the final status from the application."""
         logging.info(f"Received status from application: {summary}")
         if callback_url:
             try:
                 logging.info(f"Sending final status callback to {callback_url}")
                 # Here you could map the summary to the expected format of the callback.
                 # For now, we'll just forward the summary.
-                requests.post(callback_url, json=summary, timeout=5)
+                requests.post(callback_url, data=summary, timeout=5)
                 logging.info("Sent final status callback.")
             except Exception as e:
                 logging.error(f"Failed to send callback to {callback_url}: {e}")
@@ -84,28 +86,33 @@ def app_status_callback(summary):
         app_class = getattr(module, APP_CLASS_NAME)
         monai_app = app_class(status_callback=app_status_callback)
 
-        # Run the MONAI Deploy application.
+        # Run the MONAI Deploy application which calls the callback if successful.
         logging.info("Running the MONAI Deploy application.")
         monai_app.run()
         logging.info("Processing completed successfully.")
 
     except Exception as e:
         logging.error(f"An error occurred during processing: {e}")
-        # If the app fails to even start, we need to report a failure.
-        app_status_callback({"status": "Failure", "message": f"Application failed to run: {e}"})
+        # If the app fails, we need to handle it here and report a failure.
+        callback_msg = {
+            "run_success": False,
+            "error_message": f"Error during processing: {e}",
+            "error_code": 500,
+        }
+        app_status_callback(json.dumps(callback_msg))
 
     finally:
         set_processing_status("IDLE")
         logging.info("Processor is now IDLE.")
 
 
-@app.route("/status", methods=["GET"])
+@restful_app.route("/status", methods=["GET"])
 def status():
     """Endpoint to check the current processing status."""
     return jsonify({"status": get_processing_status()})
 
 
-@app.route("/process", methods=["POST"])
+@restful_app.route("/process", methods=["POST"])
 def process():
     """Endpoint to start a new processing job."""
     if get_processing_status() == "BUSY":
@@ -144,4 +151,4 @@ def process():
     args = parser.parse_args()
     host = args.host or os.environ.get("FLASK_HOST", "0.0.0.0")
     port = args.port or int(os.environ.get("FLASK_PORT", 5000))
-    app.run(host=host, port=port)
+    restful_app.run(host=host, port=port)

platforms/aidoc/restful_app/app.py

@@ -1,5 +1,5 @@
 #!/bin/bash
-export HOLOSCAN_INPUT_PATH="$(pwd)/../monai-deploy-app-sdk/inputs/spleen_ct_tcia"
-export HOLOSCAN_MODEL_PATH="$(pwd)/../monai-deploy-app-sdk/models/spleen_ct"
-export HOLOSCAN_OUTPUT_PATH="$(pwd)/output_spleen"
-export HOLOSCAN_LOG_LEVEL=INFO
+export HOLOSCAN_INPUT_PATH="/home/mqin/src//monai-deploy-app-sdk/inputs/spleen_ct_tcia"
+export HOLOSCAN_MODEL_PATH="/home/mqin/src//monai-deploy-app-sdk/models/spleen_ct"
+export HOLOSCAN_OUTPUT_PATH="./output_spleen"
+export HOLOSCAN_LOG_LEVEL=DEBUG

platforms/aidoc/restful_app/env_settings_repo.sh

@@ -7,8 +7,10 @@ Pillow>=8.0.0
 numpy-stl>=2.12.0
 trimesh>=3.8.11
 nibabel>=3.2.1
-torch>=1.12.0
-monai>=1.0.0
+torch>=2.4.1
+monai>=1.5.0
 Flask==2.2.2
 requests>=2.32
-Werkzeug==2.2.3
+types-requests>=2.32.0
+Werkzeug==2.2.3
+pydantic>=2.9.0