114 singularity integration

README.md

@@ -53,6 +53,9 @@ pip install brats
 - **Docker**: Installation instructions on the official [website](https://docs.docker.com/get-docker/)
 - **NVIDIA Container Toolkit**: Refer to the [NVIDIA install guide](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html) and the official [GitHub page](https://github.com/NVIDIA/nvidia-container-toolkit)
 
+## Singularity Support
+BraTS orchestrator also supports Singularity as an alternative to Docker.  
+To enable Singularity, install it following the [official guide](https://docs.sylabs.io/guides/3.0/user-guide/installation.html) and set the environment variable `BRATS_ORCHESTRATOR_BACKEND=singularity`.
 
 ## Available Algorithms and Usage
 

brats/constants.py

@@ -4,6 +4,16 @@
 # TASK ENUM
 
 
+class Backends(str, Enum):
+    """Available backends for running the algorithms."""
+
+    DOCKER = "docker"
+    """Run the algorithms using Docker containers."""
+
+    SINGULARITY = "singularity"
+    """Run the algorithms using Singularity containers."""
+
+
 class Task(str, Enum):
     """Available tasks."""
 

brats/core/brats_algorithm.py

@@ -7,9 +7,10 @@
 
 from loguru import logger
 
-from brats.core.docker import run_container
+from brats.core.docker import run_container as run_docker_container
+from brats.core.singularity import run_container as run_singularity_container
 from brats.utils.algorithm_config import load_algorithms
-from brats.constants import OUTPUT_NAME_SCHEMA, Algorithms, Task
+from brats.constants import OUTPUT_NAME_SCHEMA, Algorithms, Task, Backends
 from brats.utils.data_handling import InferenceSetup
 from brats.utils.exceptions import AlgorithmConfigException
 
@@ -163,6 +164,7 @@ def _infer_single(
         inputs: dict[str, Path | str],
         output_file: Path | str,
         log_file: Optional[Path | str] = None,
+        backend: str = "docker",
     ) -> None:
         """
         Perform a single inference run with the provided inputs and save the output in the specified file.
@@ -171,6 +173,7 @@ def _infer_single(
             inputs (dict[str, Path  |  str]): Input Images for the task
             output_file (Path | str): File to save the output
             log_file (Optional[Path  |  str], optional): Log file with extra information. Defaults to None.
+            backend (str, optional): Backend to use for inference. Defaults to "docker".
         """
         with InferenceSetup(log_file=log_file) as (tmp_data_folder, tmp_output_folder):
             logger.info(f"Performing single inference")
@@ -184,14 +187,25 @@ def _infer_single(
                 inputs=inputs,
                 subject_modality_separator=self.algorithm.run_args.subject_modality_separator,
             )
+            backend_dispatch = {
+                Backends.DOCKER: run_docker_container,
+                Backends.SINGULARITY: run_singularity_container,
+            }
 
-            run_container(
+            # Get the function for the selected backend
+            runner = backend_dispatch.get(backend)
+
+            if runner is None:
+                raise ValueError(f"Unsupported backend: {backend}")
+
+            runner(
                 algorithm=self.algorithm,
                 data_path=tmp_data_folder,
                 output_path=tmp_output_folder,
                 cuda_devices=self.cuda_devices,
                 force_cpu=self.force_cpu,
             )
+
             self._process_single_output(
                 tmp_output_folder=tmp_output_folder,
                 subject_id=subject_id,
@@ -204,13 +218,15 @@ def _infer_batch(
         data_folder: Path | str,
         output_folder: Path | str,
         log_file: Optional[Path | str] = None,
+        backend: str = "docker",
     ):
         """Perform a batch inference run with the provided inputs and save the outputs in the specified folder.
 
         Args:
             data_folder (Path | str): Folder with the input data
             output_folder (Path | str): Folder to save the outputs
             log_file (Optional[Path  |  str], optional): Log file with extra information. Defaults to None.
+            backend (str, optional): Backend to use for inference. Defaults to "docker".
         """
         with InferenceSetup(log_file=log_file) as (tmp_data_folder, tmp_output_folder):
 
@@ -226,9 +242,18 @@ def _infer_batch(
                 input_name_schema=self.algorithm.run_args.input_name_schema,
             )
             logger.info(f"Standardized input names to match algorithm requirements.")
+            backend_dispatch = {
+                Backends.DOCKER: run_docker_container,
+                Backends.SINGULARITY: run_singularity_container,
+            }
+
+            # Get the function for the selected backend
+            runner = backend_dispatch.get(backend)
 
+            if runner is None:
+                raise ValueError(f"Unsupported backend: {backend}")
             # run inference in container
-            run_container(
+            runner(
                 algorithm=self.algorithm,
                 data_path=tmp_data_folder,
                 output_path=tmp_output_folder,

brats/core/inpainting_algorithms.py

@@ -10,6 +10,7 @@
 from brats.core.brats_algorithm import BraTSAlgorithm
 from brats.constants import INPAINTING_ALGORITHMS, InpaintingAlgorithms, Task
 from brats.utils.data_handling import input_sanity_check
+import os
 
 
 class Inpainter(BraTSAlgorithm):
@@ -102,6 +103,7 @@ def infer_single(
         mask: Path | str,
         output_file: Path | str,
         log_file: Optional[Path | str] = None,
+        backend: Optional[str] = None,
     ) -> None:
         """Perform inpainting task on a single subject with the provided images and save the result to the output file.
 
@@ -110,18 +112,28 @@ def infer_single(
             mask (Path | str): Path to the mask image
             output_file (Path | str): Path to save the segmentation
             log_file (Path | str, optional): Save logs to this file
+            backend (str, optional): Backend to use for inference. Defaults to "docker".
         """
+        if backend is None:
+            backend_env = os.environ.get("BRATS_ORCHESTRATOR_BACKEND")
+            if backend_env:
+                backend = backend_env
+            else:
+                backend = "docker"
+
         self._infer_single(
             inputs={"t1n": t1n, "mask": mask},
             output_file=output_file,
             log_file=log_file,
+            backend=backend,
         )
 
     def infer_batch(
         self,
         data_folder: Path | str,
         output_folder: Path | str,
         log_file: Path | str | None = None,
+        backend: Optional[str] = None,
     ) -> None:
         """Perform inpainting on a batch of subjects with the provided images and save the results to the output folder. \n
         Requires the following structure:\n
@@ -139,7 +151,18 @@ def infer_batch(
             data_folder (Path | str): Folder containing the subjects with required structure
             output_folder (Path | str): Output folder to save the segmentations
             log_file (Path | str, optional): Save logs to this file
+            backend (str, optional): Backend to use for inference. Defaults to "docker".
         """
+        if backend is None:
+            backend_env = os.environ.get("BRATS_ORCHESTRATOR_BACKEND")
+            if backend_env:
+                backend = backend_env
+            else:
+                backend = "docker"
+
         return self._infer_batch(
-            data_folder=data_folder, output_folder=output_folder, log_file=log_file
+            data_folder=data_folder,
+            output_folder=output_folder,
+            log_file=log_file,
+            backend=backend,
         )

brats/core/missing_mri_algorithms.py

@@ -10,6 +10,7 @@
 from brats.constants import MISSING_MRI_ALGORITHMS, MissingMRIAlgorithms, Task
 from brats.core.brats_algorithm import BraTSAlgorithm
 from brats.utils.data_handling import input_sanity_check
+import os
 
 
 class MissingMRI(BraTSAlgorithm):
@@ -116,6 +117,7 @@ def infer_single(
         t2f: Optional[Union[Path, str]] = None,
         t2w: Optional[Union[Path, str]] = None,
         log_file: Optional[Path | str] = None,
+        backend: Optional[str] = None,
     ) -> None:
         """
         Perform synthesis of the missing modality for a single subject with the provided images and save the result to the output file.
@@ -129,7 +131,8 @@ def infer_single(
             t1n (Optional[Union[Path, str]], optional): Path to the T1n image. Defaults to None.
             t2f (Optional[Union[Path, str]], optional): Path to the T2f image. Defaults to None.
             t2w (Optional[Union[Path, str]], optional): Path to the T2w image. Defaults to None.
-            log_file (Optional[Path | str], optional): Save logs to this file. Defaults to None
+            log_file (Optional[Path | str], optional): Save logs to this file. Defaults to None.
+            backend (str, optional): Backend to use for inference. Defaults to "docker".
         """
 
         inputs = {"t1c": t1c, "t1n": t1n, "t2f": t2f, "t2w": t2w}
@@ -141,17 +144,26 @@ def infer_single(
             len(inputs) == 3
         ), "Exactly 3 inputs are required to perform synthesis of the missing modality"
 
+        if backend is None:
+            backend_env = os.environ.get("BRATS_ORCHESTRATOR_BACKEND")
+            if backend_env:
+                backend = backend_env
+            else:
+                backend = "docker"
+
         self._infer_single(
             inputs=inputs,
             output_file=output_file,
             log_file=log_file,
+            backend=backend,
         )
 
     def infer_batch(
         self,
         data_folder: Path | str,
         output_folder: Path | str,
         log_file: Path | str | None = None,
+        backend: Optional[str] = None,
     ) -> None:
         """Perform synthesis on a batch of subjects with the provided images and save the results to the output folder. \n
 
@@ -170,7 +182,18 @@ def infer_batch(
             data_folder (Path | str): Folder containing the subjects with required structure
             output_folder (Path | str): Output folder to save the segmentation
             log_file (Path | str, optional): Save logs to this file
+            backend (str, optional): Backend to use for inference. Defaults to "docker".
         """
+        if backend is None:
+            backend_env = os.environ.get("BRATS_ORCHESTRATOR_BACKEND")
+            if backend_env:
+                backend = backend_env
+            else:
+                backend = "docker"
+
         return self._infer_batch(
-            data_folder=data_folder, output_folder=output_folder, log_file=log_file
+            data_folder=data_folder,
+            output_folder=output_folder,
+            log_file=log_file,
+            backend=backend,
         )

brats/core/segmentation_algorithms.py

@@ -29,6 +29,7 @@
 )
 from brats.core.brats_algorithm import BraTSAlgorithm
 from brats.utils.data_handling import input_sanity_check
+import os
 
 
 class SegmentationAlgorithm(BraTSAlgorithm):
@@ -165,6 +166,7 @@ def infer_single(
         t2w: Path | str,
         output_file: Path | str,
         log_file: Optional[Path | str] = None,
+        backend: Optional[str] = None,
     ) -> None:
         """Perform segmentation on a single subject with the provided images and save the result to the output file.
 
@@ -175,18 +177,28 @@ def infer_single(
             t2w (Path | str): Path to the T2w image
             output_file (Path | str): Path to save the segmentation
             log_file (Path | str, optional): Save logs to this file
+            backend (str, optional): Backend to use for inference. Defaults to "docker".
         """
+        if backend is None:
+            backend_env = os.environ.get("BRATS_ORCHESTRATOR_BACKEND")
+            if backend_env:
+                backend = backend_env
+            else:
+                backend = "docker"
+
         self._infer_single(
             inputs={"t1c": t1c, "t1n": t1n, "t2f": t2f, "t2w": t2w},
             output_file=output_file,
             log_file=log_file,
+            backend=backend,
         )
 
     def infer_batch(
         self,
         data_folder: Path | str,
         output_folder: Path | str,
         log_file: Path | str | None = None,
+        backend: Optional[str] = None,
     ) -> None:
         """Perform segmentation on a batch of subjects with the provided images and save the results to the output folder. \n
         Requires the following structure:\n
@@ -205,9 +217,20 @@ def infer_batch(
             data_folder (Path | str): Folder containing the subjects with required structure
             output_folder (Path | str): Output folder to save the segmentations
             log_file (Path | str, optional): Save logs to this file
+            backend (str, optional): Backend to use for inference. Defaults to "docker".
         """
+        if backend is None:
+            backend_env = os.environ.get("BRATS_ORCHESTRATOR_BACKEND")
+            if backend_env:
+                backend = backend_env
+            else:
+                backend = "docker"
+
         return self._infer_batch(
-            data_folder=data_folder, output_folder=output_folder, log_file=log_file
+            data_folder=data_folder,
+            output_folder=output_folder,
+            log_file=log_file,
+            backend=backend,
         )