Added command line option support for ease of running python app directly

Signed-off-by: M Q <mingmelvinq@nvidia.com>

Author: MMelQin

examples/apps/ai_livertumor_seg_app/app.py

@@ -46,7 +46,8 @@ def compose(self):
         """Creates the app specific operators and chain them up in the processing DAG."""
 
         self._logger.info(f"Begin {self.compose.__name__}")
-        app_context = AppContext({})  # Let it figure out all the attributes without overriding
+        # Use command line options over environment variables to init context.
+        app_context = Application.init_app_context(self.argv)
         app_input_path = Path(app_context.input_path)
         app_output_path = Path(app_context.output_path)
         model_path = Path(app_context.model_path)

examples/apps/ai_multi_ai_app/app.py

@@ -86,7 +86,8 @@ def compose(self):
 
         logging.info(f"Begin {self.compose.__name__}")
 
-        app_context = AppContext({})  # Let it figure out all the attributes without overriding
+        # Use command line options over environment variables to init context.
+        app_context = Application.init_app_context(self.argv)
         app_input_path = Path(app_context.input_path)
         app_output_path = Path(app_context.output_path)
 

examples/apps/ai_pancreas_seg_app/app.py

@@ -68,7 +68,8 @@ def compose(self):
 
         logging.info(f"Begin {self.compose.__name__}")
 
-        app_context = AppContext({})  # Let it figure out all the attributes without overriding
+        # Use command line options over environment variables to init context.
+        app_context = Application.init_app_context(self.argv)
         app_input_path = Path(app_context.input_path)
         app_output_path = Path(app_context.output_path)
 

examples/apps/ai_spleen_seg_app/app.py

@@ -66,7 +66,8 @@ def compose(self):
 
         logging.info(f"Begin {self.compose.__name__}")
 
-        app_context = AppContext({})  # Let it figure out all the attributes without overriding
+        # Use Commandline options over environment variables to init context.
+        app_context = Application.init_app_context(self.argv)
         app_input_path = Path(app_context.input_path)
         app_output_path = Path(app_context.output_path)
 

examples/apps/ai_unetr_seg_app/app.py

@@ -46,7 +46,8 @@ def compose(self):
         """Creates the app specific operators and chain them up in the processing DAG."""
 
         self._logger.info(f"Begin {self.compose.__name__}")
-        app_context = AppContext({})  # Let it figure out all the attributes without overriding
+        # Use command line options over environment variables to init context.
+        app_context = Application.init_app_context(self.argv)
         app_input_path = Path(app_context.input_path)
         app_output_path = Path(app_context.output_path)
         model_path = Path(app_context.model_path)

examples/apps/breast_density_classifer_app/app.py

@@ -28,7 +28,8 @@ def compose(self):
         """Creates the app specific operators and chain them up in the processing DAG."""
         logging.info(f"Begin {self.compose.__name__}")
 
-        app_context = AppContext({})  # Let it figure out all the attributes without overriding
+        # Use command line options over environment variables to init context.
+        app_context = Application.init_app_context(self.argv)
         app_input_path = Path(app_context.input_path)
         app_output_path = Path(app_context.output_path)
         model_path = Path(app_context.model_path)

examples/apps/dicom_series_to_image_app/app.py

@@ -26,7 +26,8 @@ class App(Application):
     """
 
     def compose(self):
-        app_context = AppContext({})  # Let it figure out the data paths using well-known env vars etc.
+        # Use command line options over environment variables to init context.
+        app_context = Application.init_app_context(self.argv)
         input_dcm_folder = Path(app_context.input_path)
         output_folder = Path(app_context.output_path)
         print(f"input_dcm_folder: {input_dcm_folder}")

examples/apps/mednist_classifier_monaideploy/mednist_classifier_monaideploy.py

@@ -24,6 +24,7 @@
 MEDNIST_CLASSES = ["AbdomenCT", "BreastMRI", "CXR", "ChestCT", "Hand", "HeadCT"]
 
 
+# Decorator support is not available in this version of the SDK, to be re-introduced later
 # @md.env(pip_packages=["pillow"])
 class LoadPILOperator(Operator):
     """Load image from the given input (DataPath) and set numpy array to the output (Image)."""
@@ -200,13 +201,15 @@ def compute(self, op_input, op_output, context):
             json.dump(result, fp)
 
 
+# Decorator support is not available in this version of the SDK, to be re-introduced later
 # @md.resource(cpu=1, gpu=1, memory="1Gi")
 # @md.env(pip_packages=["pydicom >= 2.3.0", "highdicom>=0.18.2"])  # because of the use of DICOM writer operator
 class App(Application):
     """Application class for the MedNIST classifier."""
 
     def compose(self):
-        app_context = AppContext({})  # Let it figure out all the attributes without overriding
+        # Use Commandline options over environment variables to init context.
+        app_context = Application.init_app_context(self.argv)
         app_input_path = Path(app_context.input_path)
         app_output_path = Path(app_context.output_path)
         model_path = Path(app_context.model_path)

examples/apps/simple_imaging_app/app.py

@@ -20,8 +20,8 @@
 from monai.deploy.core import AppContext, Application
 
 
+# Decorator support is not available in this version of the SDK, to be re-introduced later
 # @resource(cpu=1)
-# # pip_packages can be a string that is a path(str) to requirements.txt file or a list of packages.
 # @env(pip_packages=["scikit-image >= 0.17.2"])
 class App(Application):
     """This is a very basic application.
@@ -42,10 +42,12 @@ def compose(self):
         Each operator has a single input and a single output port.
         Each operator performs some kind of image processing function.
         """
-        app_context = AppContext({})  # Let it figure out all the attributes without overriding
+
+        # Use Commandline options over environment variables to init context.
+        app_context = Application.init_app_context(self.argv)
         sample_data_path = Path(app_context.input_path)
         output_data_path = Path(app_context.output_path)
-        print(f"sample_data_path: {sample_data_path}")
+        logging.info(f"sample_data_path: {sample_data_path}")
 
         # Please note that the Application object, self, is passed as the first positonal argument
         # and the others as kwargs.
@@ -70,7 +72,7 @@ def compose(self):
                     "in1",
                 )
             },
-        )  # Using port name is optional for single port cases
+        )
 
 
 if __name__ == "__main__":

monai/deploy/core/__init__.py

@@ -24,15 +24,22 @@
     InputContext
     OutputContext
     RuntimeEnv
+    init_app_context
+    parse_args
 """
 
 # Need to import explicit ones to quiet mypy complaints
 from holoscan.core import *
 from holoscan.core import Application, Condition, ConditionType, Fragment, Operator, OperatorSpec
 
-from .app_context import AppContext
+from .app_context import AppContext, init_app_context
+from .arg_parser import parse_args
 from .domain.datapath import DataPath
 from .domain.image import Image
 from .io_type import IOType
 from .models import Model, ModelFactory, NamedModel, TorchScriptModel, TritonModel
 from .runtime_env import RuntimeEnv
+
+# Add the function to the existing Application class, which could've been used as helper func too.
+# It is well understood that deriving from the Application base is a better approach, but maybe later.
+Application.init_app_context = init_app_context

monai/deploy/core/app_context.py

@@ -9,9 +9,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import logging
 from os.path import abspath
-from typing import Dict, Optional
+from typing import Dict, List, Optional
 
+from .arg_parser import parse_args, set_up_logging
 from .models.factory import ModelFactory
 from .models.model import Model
 from .runtime_env import RuntimeEnv
@@ -55,3 +57,26 @@ def __repr__(self):
             f"AppContext(input_path={self.input_path}, output_path={self.output_path}, "
             f"model_path={self.model_path}, workdir={self.workdir})"
         )
+
+
+def init_app_context(argv: Optional[List[str]] = None, runtime_env: Optional[RuntimeEnv] = None) -> AppContext:
+    """Initializes the app context with arguments and well-known environment variables.
+
+    The arguments, if passed in, override the attributes set with environment variables.
+
+    Args:
+        argv (Optional[List[str]], optional): arguments passed to the program. Defaults to None.
+
+    Returns:
+        AppContext: the AppContext object
+    """
+
+    args = parse_args(argv)
+    set_up_logging(args.log_level)
+    logging.info(f"Parsed args: {args}")
+
+    # The parsed args from the command line override that from the environment variables
+    app_context = AppContext({key: val for key, val in vars(args).items() if val}, runtime_env)
+    logging.info(f"AppContext object: {app_context}")
+
+    return app_context

monai/deploy/core/arg_parser.py

@@ -0,0 +1,93 @@
+# Copyright 2021-2023 MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import argparse
+import json
+import logging.config
+from pathlib import Path
+from typing import List, Optional, Union
+
+from monai.deploy.utils import argparse_types
+
+LOG_CONFIG_FILENAME = "logging.json"
+
+
+def parse_args(argv: Optional[List[str]] = None) -> argparse.Namespace:
+    """Parses the arguments passed to the application.
+
+    Args:
+        argv (Optional[List[str]], optional): The command line arguments to parse. The first item should be the path to the python executable. If not specified, ``sys.argv`` is used. Defaults to None.
+
+    Returns:
+        argparse.Namespace: parsed arguments.
+    """
+    if argv is None:
+        import sys
+
+        argv = sys.argv
+    argv = list(argv)  # copy argv for manipulation to avoid side-effects
+
+    # We have intentionally not set the default using `default="INFO"` here so that the default
+    # value from here doesn't override the value in `LOG_CONFIG_FILENAME` unless the user indends to do
+    # so. If the user doesn't use this flag to set log level, this argument is set to "None"
+    # and the logging level specified in `LOG_CONFIG_FILENAME` is used.
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser.add_argument(
+        "-l",
+        "--log-level",
+        dest="log_level",
+        type=str.upper,
+        choices=["DEBUG", "INFO", "WARN", "ERROR", "CRITICAL"],
+        help="Set the logging level (default: INFO)",
+    )
+    parser.add_argument(
+        "--input", "-i", type=argparse_types.valid_existing_path, help="Path to input folder/file (default: input)"
+    )
+    parser.add_argument(
+        "--output", "-o", type=argparse_types.valid_dir_path, help="Path to output folder (default: output)"
+    )
+    parser.add_argument(
+        "--model", "-m", type=argparse_types.valid_existing_path, help="Path to model(s) folder/file (default: models)"
+    )
+    parser.add_argument(
+        "--workdir",
+        "-w",
+        type=argparse_types.valid_dir_path,
+        help="Path to workspace folder (default: A temporary '.monai_workdir' folder in the current folder)",
+    )
+
+    args = parser.parse_args(argv[1:])
+    args.argv = argv  # save argv for later use in runpy
+
+    return args
+
+
+def set_up_logging(level: Optional[str], config_path: Union[str, Path] = LOG_CONFIG_FILENAME):
+    """Initializes the logger and sets up logging level.
+
+    Args:
+        level (str): A logging level (DEBUG, INFO, WARN, ERROR, CRITICAL).
+        log_config_path (str): A path to logging config file.
+    """
+    # Default log config path
+    log_config_path = Path(__file__).absolute().parent.parent / LOG_CONFIG_FILENAME
+
+    config_path = Path(config_path)
+
+    # If a logging config file that is specified by `log_config_path` exists in the current folder,
+    # it overrides the default one
+    if config_path.exists():
+        log_config_path = config_path
+
+    config_dict = json.loads(log_config_path.read_bytes())
+
+    if level is not None and "root" in config_dict:
+        config_dict["root"]["level"] = level
+    logging.config.dictConfig(config_dict)

monai/deploy/core/runtime_env.py

@@ -13,10 +13,6 @@
 from abc import ABC
 from typing import Dict, Optional, Tuple
 
-# from monai.deploy.core.datastores.factory import DatastoreFactory
-# from monai.deploy.core.executors.factory import ExecutorFactory
-# from monai.deploy.core.graphs.factory import GraphFactory
-
 
 class RuntimeEnv(ABC):
     """Class responsible for managing run time settings.
@@ -30,18 +26,12 @@ class RuntimeEnv(ABC):
         "output": ("HOLOSCAN_OUTPUT_PATH", "output"),
         "model": ("HOLOSCAN_MODEL_PATH", "models"),
         "workdir": ("HOLOSCAN_WORKDIR", ""),
-        # "graph": ("MONAI_GRAPH", GraphFactory.DEFAULT),  # The 'MONAI_GRAPH' is not part of MAP spec.
-        # "datastore": ("MONAI_DATASTORE", DatastoreFactory.DEFAULT),  # The 'MONAI_DATASTORE' is not part of MAP spec.
-        # "executor": ("MONAI_EXECUTOR", ExecutorFactory.DEFAULT),  # The 'MONAI_EXECUTOR' is not part of MAP spec.
     }
 
     input: str = ""
     output: str = ""
     model: str = ""
     workdir: str = ""
-    # graph: str = ""
-    # datastore: str = ""
-    # executor: str = ""
 
     def __init__(self, defaults: Optional[Dict[str, Tuple[str, ...]]] = None):
         if defaults is None: