Refactored code base according to linting style

neukit/gui.py

@@ -1,10 +1,13 @@
 import gradio as gr
-from .utils import load_ct_to_numpy, load_pred_volume_to_numpy, nifti_to_glb
+
 from .inference import run_model
+from .utils import load_ct_to_numpy
+from .utils import load_pred_volume_to_numpy
+from .utils import nifti_to_glb
 
 
 class WebUI:
-    def __init__(self, model_name:str = None, cwd:str = "/home/user/app/"):
+    def __init__(self, model_name: str = None, cwd: str = "/home/user/app/"):
         # global states
         self.images = []
         self.pred_images = []
@@ -15,7 +18,7 @@ class WebUI:
         self.model_name = model_name
         self.cwd = cwd
 
-        self.class_name = "meningioma"  # default - but can be updated based on which task is chosen from dropdown
+        self.class_name = "meningioma"  # default
         self.class_names = {
             "meningioma": "MRI_Meningioma",
             "low-grade": "MRI_LGGlioma",
@@ -33,41 +36,55 @@ class WebUI:
         }
 
         # define widgets not to be rendered immediantly, but later on
-        self.slider = gr.Slider(1, self.nb_slider_items, value=1, step=1, label="Which 2D slice to show")
+        self.slider = gr.Slider(
+            1,
+            self.nb_slider_items,
+            value=1,
+            step=1,
+            label="Which 2D slice to show",
+        )
         self.volume_renderer = gr.Model3D(
             clear_color=[0.0, 0.0, 0.0, 0.0],
             label="3D Model",
             visible=True,
             elem_id="model-3d",
         ).style(height=512)
-    
+
     def set_class_name(self, value):
         print("Changed task to:", value)
         self.class_name = value
 
     def combine_ct_and_seg(self, img, pred):
         return (img, [(pred, self.class_name)])
-    
+
     def upload_file(self, file):
         return file.name
-    
+
     def process(self, mesh_file_name):
         path = mesh_file_name.name
-        run_model(path, model_path=self.cwd + "resources/models/", task=self.class_names[self.class_name], name=self.result_names[self.class_name])
+        run_model(
+            path,
+            model_path=self.cwd + "resources/models/",
+            task=self.class_names[self.class_name],
+            name=self.result_names[self.class_name],
+        )
         nifti_to_glb("prediction.nii.gz")
 
         self.images = load_ct_to_numpy(path)
         self.pred_images = load_pred_volume_to_numpy("./prediction.nii.gz")
         return "./prediction.obj"
-    
+
     def get_img_pred_pair(self, k):
         k = int(k) - 1
         out = [gr.AnnotatedImage.update(visible=False)] * self.nb_slider_items
-        out[k] = gr.AnnotatedImage.update(self.combine_ct_and_seg(self.images[k], self.pred_images[k]), visible=True)
+        out[k] = gr.AnnotatedImage.update(
+            self.combine_ct_and_seg(self.images[k], self.pred_images[k]),
+            visible=True,
+        )
         return out
 
     def run(self):
-        css="""
+        css = """
         #model-3d {
         height: 512px;
         }
@@ -87,7 +104,8 @@ class WebUI:
                 model_selector = gr.Dropdown(
                     list(self.class_names.keys()),
                     label="Task",
-                    info="Which task to perform - one model for each brain tumor type and brain extraction",
+                    info="Which task to perform - one model for"
+                    "each brain tumor type and brain extraction",
                     multiselect=False,
                     size="sm",
                 )
@@ -97,39 +115,53 @@ class WebUI:
                     outputs=None,
                 )
 
-                run_btn = gr.Button("Run analysis").style(full_width=False, size="lg")
+                run_btn = gr.Button("Run analysis").style(
+                    full_width=False, size="lg"
+                )
                 run_btn.click(
                     fn=lambda x: self.process(x),
                     inputs=file_output,
                     outputs=self.volume_renderer,
                 )
-            
+
             with gr.Row():
                 gr.Examples(
-                    examples=[self.cwd + "RegLib_C01_1.nii", self.cwd + "RegLib_C01_2.nii"],
+                    examples=[
+                        self.cwd + "RegLib_C01_1.nii",
+                        self.cwd + "RegLib_C01_2.nii",
+                    ],
                     inputs=file_output,
                     outputs=file_output,
                     fn=self.upload_file,
                     cache_examples=True,
                 )
-            
+
             with gr.Row():
                 with gr.Box():
                     with gr.Column():
                         image_boxes = []
                         for i in range(self.nb_slider_items):
                             visibility = True if i == 1 else False
-                            t = gr.AnnotatedImage(visible=visibility, elem_id="model-2d")\
-                                .style(color_map={self.class_name: "#ffae00"}, height=512, width=512)
+                            t = gr.AnnotatedImage(
+                                visible=visibility, elem_id="model-2d"
+                            ).style(
+                                color_map={self.class_name: "#ffae00"},
+                                height=512,
+                                width=512,
+                            )
                             image_boxes.append(t)
 
-                        self.slider.input(self.get_img_pred_pair, self.slider, image_boxes)
+                        self.slider.input(
+                            self.get_img_pred_pair, self.slider, image_boxes
+                        )
 
                         self.slider.render()
-                
+
                 with gr.Box():
                     self.volume_renderer.render()
 
-        # sharing app publicly -> share=True: https://gradio.app/sharing-your-app/
-        # inference times > 60 seconds -> need queue(): https://github.com/tloen/alpaca-lora/issues/60#issuecomment-1510006062
+        # sharing app publicly -> share=True:
+        # https://gradio.app/sharing-your-app/
+        # inference times > 60 seconds -> need queue():
+        # https://github.com/tloen/alpaca-lora/issues/60#issuecomment-1510006062
         demo.queue().launch(server_name="0.0.0.0", server_port=7860, share=True)

neukit/inference.py

@@ -1,23 +1,28 @@
-import os
-import shutil
 import configparser
 import logging
-import traceback
+import os
+import shutil
 
 
-def run_model(input_path: str, model_path: str, verbose: str = "info", task: str = "MRI_Meningioma", name: str = "Tumor"):
+def run_model(
+    input_path: str,
+    model_path: str,
+    verbose: str = "info",
+    task: str = "MRI_Meningioma",
+    name: str = "Tumor",
+):
     logging.basicConfig()
     logging.getLogger().setLevel(logging.WARNING)
 
-    if verbose == 'debug':
+    if verbose == "debug":
         logging.getLogger().setLevel(logging.DEBUG)
-    elif verbose == 'info':
+    elif verbose == "info":
         logging.getLogger().setLevel(logging.INFO)
-    elif verbose == 'error':
+    elif verbose == "error":
         logging.getLogger().setLevel(logging.ERROR)
     else:
         raise ValueError("Unsupported verbose value provided:", verbose)
-    
+
     # delete patient/result folder if they exist
     if os.path.exists("./patient/"):
         shutil.rmtree("./patient/")
@@ -25,33 +30,42 @@ def run_model(input_path: str, model_path: str, verbose: str = "info", task: str
         shutil.rmtree("./result/")
 
     try:
-        # create sequence folder, rename patient, and add to temporary patient directory
+        # setup temporary patient directory
         filename = input_path.split("/")[-1]
         splits = filename.split(".")
         extension = ".".join(splits[1:])
         patient_directory = "./patient/"
         os.makedirs(patient_directory + "T0/", exist_ok=True)
-        shutil.copy(input_path, patient_directory + "T0/" + splits[0] + "-t1gd." + extension)
-        
+        shutil.copy(
+            input_path,
+            patient_directory + "T0/" + splits[0] + "-t1gd." + extension,
+        )
+
         # define output directory to save results
         output_path = "./result/prediction-" + splits[0] + "/"
         os.makedirs(output_path, exist_ok=True)
 
         # Setting up the configuration file
         rads_config = configparser.ConfigParser()
-        rads_config.add_section('Default')
-        rads_config.set('Default', 'task', 'neuro_diagnosis')
-        rads_config.set('Default', 'caller', '')
-        rads_config.add_section('System')
-        rads_config.set('System', 'gpu_id', "-1")
-        rads_config.set('System', 'input_folder', patient_directory)
-        rads_config.set('System', 'output_folder', output_path)
-        rads_config.set('System', 'model_folder', model_path)
-        rads_config.set('System', 'pipeline_filename', os.path.join(model_path, task, 'pipeline.json'))
-        rads_config.add_section('Runtime')
-        rads_config.set('Runtime', 'reconstruction_method', 'thresholding')  # thresholding, probabilities
-        rads_config.set('Runtime', 'reconstruction_order', 'resample_first')
-        rads_config.set('Runtime', 'use_preprocessed_data', 'False')
+        rads_config.add_section("Default")
+        rads_config.set("Default", "task", "neuro_diagnosis")
+        rads_config.set("Default", "caller", "")
+        rads_config.add_section("System")
+        rads_config.set("System", "gpu_id", "-1")
+        rads_config.set("System", "input_folder", patient_directory)
+        rads_config.set("System", "output_folder", output_path)
+        rads_config.set("System", "model_folder", model_path)
+        rads_config.set(
+            "System",
+            "pipeline_filename",
+            os.path.join(model_path, task, "pipeline.json"),
+        )
+        rads_config.add_section("Runtime")
+        rads_config.set(
+            "Runtime", "reconstruction_method", "thresholding"
+        )  # thresholding, probabilities
+        rads_config.set("Runtime", "reconstruction_order", "resample_first")
+        rads_config.set("Runtime", "use_preprocessed_data", "False")
 
         with open("rads_config.ini", "w") as f:
             rads_config.write(f)
@@ -59,11 +73,20 @@ def run_model(input_path: str, model_path: str, verbose: str = "info", task: str
         # finally, run inference
         from raidionicsrads.compute import run_rads
 
-        run_rads(config_filename='rads_config.ini')
-        
+        run_rads(config_filename="rads_config.ini")
+
         # rename and move final result
-        os.rename("./result/prediction-" + splits[0] + "/T0/" + splits[0] + "-t1gd_annotation-" + name + ".nii.gz", "./prediction.nii.gz")
-    
+        os.rename(
+            "./result/prediction-"
+            + splits[0]
+            + "/T0/"
+            + splits[0]
+            + "-t1gd_annotation-"
+            + name
+            + ".nii.gz",
+            "./prediction.nii.gz",
+        )
+
     except Exception as e:
         print(e)
 

neukit/utils.py

@@ -1,5 +1,5 @@
-import numpy as np
 import nibabel as nib
+import numpy as np
 from nibabel.processing import resample_to_output
 from skimage.measure import marching_cubes
 
@@ -52,12 +52,16 @@ def nifti_to_glb(path, output="prediction.obj"):
     verts, faces, normals, values = marching_cubes(data, 0)
     faces += 1
 
-    with open(output, 'w') as thefile:
+    with open(output, "w") as thefile:
         for item in verts:
-            thefile.write("v {0} {1} {2}\n".format(item[0],item[1],item[2]))
+            thefile.write("v {0} {1} {2}\n".format(item[0], item[1], item[2]))
 
         for item in normals:
-            thefile.write("vn {0} {1} {2}\n".format(item[0],item[1],item[2]))
+            thefile.write("vn {0} {1} {2}\n".format(item[0], item[1], item[2]))
 
         for item in faces:
-            thefile.write("f {0}//{0} {1}//{1} {2}//{2}\n".format(item[0],item[1],item[2]))
+            thefile.write(
+                "f {0}//{0} {1}//{1} {2}//{2}\n".format(
+                    item[0], item[1], item[2]
+                )
+            )