From 3201359b22b8d2d1107669d06d7e4a6d3d256a45 Mon Sep 17 00:00:00 2001
From: Jaewon Chung <jaewonc78@gmail.com>
Date: Sat, 6 Apr 2024 02:01:44 -0400
Subject: [PATCH] Docs (#418)

* ndmg -> m2g

* black

* md format
---
 README.md                       |  48 +++--
 m2g/__init__.py                 |   2 +-
 m2g/functional/__init__.py      |   2 +-
 m2g/functional/m2g_func.py      | 327 ++++++++++++++++++++------------
 m2g/graph.py                    |   6 +-
 m2g/register.py                 |   8 +-
 m2g/scripts/m2g_bids.py         |  26 +--
 m2g/scripts/m2g_cloud.py        |  14 +-
 m2g/scripts/m2g_dwi_pipeline.py |  53 +++---
 m2g/stats/__init__.py           |   2 +
 m2g/stats/qa_fast.py            |  67 +++----
 m2g/stats/qa_reg.py             | 122 ++++++++----
 m2g/stats/qa_skullstrip.py      |  40 ++--
 m2g/stats/qa_tensor.py          |  22 +--
 m2g/stats/qa_tractography.py    | 134 ++++++++-----
 m2g/track.py                    |   2 +-
 m2g/utils/cloud_utils.py        |  10 +-
 m2g/utils/gen_utils.py          | 122 +++++++-----
 m2g/utils/qa_utils.py           |  45 +++--
 m2g/utils/reg_utils.py          |   5 +-
 20 files changed, 626 insertions(+), 431 deletions(-)

diff --git a/README.md b/README.md
index 73de1682c..d12c8cb64 100644
--- a/README.md
+++ b/README.md
@@ -29,10 +29,8 @@ NeuroData's MR Graphs package, **m2g**, is a turn-key pipeline which uses struct
 
 # Overview
 
-
 The **m2g** pipeline has been developed as a beginner-friendly solution for human connectome estimation by providing robust and reliable estimates of connectivity across a wide range of datasets. The pipelines are explained and derivatives analyzed in our pre-print, available on [BiorXiv](https://www.biorxiv.org/content/10.1101/2021.11.01.466686v1.full).
 
-
 # System Requirements
 
 The **m2g** pipeline:
@@ -43,26 +41,32 @@ The **m2g** pipeline:
 - has install instructions via a Dockerfile;
 - requires no non-standard hardware to run;
 - has key features built upon FSL, AFNI, INDI, Dipy, Nibabel, Nilearn, Networkx, Numpy, Scipy, Scikit-Learn, and others
-    - For Python package version numbers, see [requirements.txt](requirements.txt)
-    - For binaries required to install AFNI, FSL, INDI, ICA_AROMA, see the [Dockerfile](Dockerfile)
+  - For Python package version numbers, see [requirements.txt](requirements.txt)
+  - For binaries required to install AFNI, FSL, INDI, ICA_AROMA, see the [Dockerfile](Dockerfile)
 - takes approximately 1-core, < 16-GB of RAM, and 1-2 hours to run for most datasets (varies based on data).
 
 # Demo
+
 To install and run a tutorial of the latest Docker image of m2g, pull the docker image from DockerHub using the following command. Then enter it using `docker run`:
+
 ```
 docker pull neurodata/m2g:latest
 docker run -ti --entrypoint /bin/bash neurodata/m2g:latest
 ```
+
 Once inside of the Docker container, download a tutorial dataset of fMRI and diffusion MRI data from the `open-neurodata` AWS S3 bucket to the `/input` directory in your container (make sure you are connected to the internet):
+
 ```
 aws s3 sync --no-sign-request s3://open-neurodata/m2g/TUTORIAL /input
 ```
+
 Now you can run the `m2g` pipeline for both the functional and diffusion MRI data using the command below. The number of `seeds` is intentionally set lower than recommended, along with a larger than recommended `voxelsize` for a faster run time (approximately 25 minutes). For more information as to what these input arguments represent, see the Tutorial section below.
+
 ```
 m2g --participant_label 0025864 --session_label 1 --parcellation AAL_ --pipeline both --seeds 1 --voxelsize 4mm /input /output
 ```
-Once the pipeline is done running, the resulting outputs can be found in `/output/sub-0025864/ses-1/`, see Outputs section below for a description of each file.
 
+Once the pipeline is done running, the resulting outputs can be found in `/output/sub-0025864/ses-1/`, see Outputs section below for a description of each file.
 
 # Installation Guide
 
@@ -91,9 +95,12 @@ In order to create a docker container from the docker image and access it, use t
     docker run -it --entrypoint /bin/bash m2g:uniquelabel
 
 ## Local Installation [COMING SOON]
-Due to the versioning required for CPAC, along with `m2g-d`, we are currently working on streamlining the installation of `m2g`. Stay tuned for updates.
 
+We highly recommend the use of the Docker container provided above.
 
+Due to the versioning required for CPAC, along with `m2g-d`, we are currently working on streamlining the installation of `m2g`. Stay tuned for updates.
+
+- Requires numerous system level dependencies with specified versions. As such, CPAC on its own runs on a docker container, and we recommond the usage
 
 # Usage
 
@@ -103,7 +110,6 @@ The **m2g** pipeline can be used to generate connectomes as a command-line utili
 
 Note that more options are available which can be helpful if running on the Amazon cloud, which can be found and documented by running `m2g -h`.
 
-
 ## Docker Container Usage
 
 If running with the Docker container shown above, the `entrypoint` is already set to `m2g`, so the pipeline can be run directly from the host-system command line as follows:
@@ -114,15 +120,14 @@ This will run **m2g** on the local data and save the output files to the directo
 
 Also note that currently, running `m2g` on a single bids-formatted dataset directory only runs a single scan. To run the entire dataset, we recommend parallelizing on a high-performance cluster or using `m2g`'s s3 integration.
 
-
 # Tutorial
 
 ## Structural Connectome Pipeline (`m2g-d`)
 
 Once you have the pipeline up and running, you can run the structural connectome pipeline with:
-  
+
     m2g --pipeline dwi <input_directory> <output_directory>
-  
+
 We recommend specifying an atlas and lowering the default seed density on test runs (although, for real runs, we recommend using the default seeding -- lowering seeding simply decreases runtime):
 
     m2g --pipeline dwi --seeds 1 --parcellation Desikan <input_directory> <output_directory>
@@ -134,9 +139,9 @@ You can set a particular scan and session as well (recommended for batch scripts
 ## Functional Connectome Pipeline (`m2g-f`)
 
 Once you have the pipeline up and running, you can run the functional connectome pipeline with:
-  
+
     m2g --pipeline func <input_directory> <output_directory>
-  
+
 We recommend specifying an atlas and lowering the default seed density on test runs (although, for real runs, we recommend using the default seeding -- lowering seeding simply decreases runtime):
 
     m2g --pipeline func --seeds 1 --parcellation Desikan <input_directory> <output_directory>
@@ -145,15 +150,16 @@ You can set a particular scan and session as well (recommended for batch scripts
 
     m2g --pipeline func --seeds 1 --parcellation Desikan --participant_label <label> --session_label <label> <input_directory> <output_directory>
 
-
 ## Running both `m2g-d` and `m2g-f`
+
 Both pipelines can be run by setting the `pipeline` parameter to `both`:
-    
+
     m2g --pipeline both <input_directory> <output_directory>
 
 # Outputs
 
 ## Diffusion Pipeline
+
 The organization of the output files generated by the m2g-d pipeline are shown below. If you only care about the connectome edgelists (**m2g**'s fundamental output), you can find them in `/output/connectomes_d`.
 
 ```
@@ -165,7 +171,7 @@ res = The file has been resliced to the desired voxel size specified by the user
 
 /output
     /anat_d
-        
+
         /preproc
             t1w_aligned_mni.nii.gz = preprocessed t1w_brain anatomical image in mni space
             t1w_brain.nii.gz = t1w anatomical image with only the brain
@@ -204,7 +210,7 @@ res = The file has been resliced to the desired voxel size specified by the user
             nodif_B0_bet.nii.gz = nodif_B0 image with all non-brain matter removed
             nodif_B0_bet_mask.nii.gz = mask of nodif_B0_bet.nii.gz brain
             tensor_fa.nii.gz = tensor image fractional anisotropy map
-        
+
         /tensor
             Contains the rgb tensor file(s) for the dwi data if tractography is being done in MNI space
 
@@ -226,7 +232,7 @@ res = The file has been resliced to the desired voxel size specified by the user
             t1w_wm_in_dwi_2_nodif_B0_bet.png = overlay of white matter mask on top of registered anatomical image
         /skull_strip
             qa_skullstrip__<sub>_<ses>_T1w_reor_RAS_res.png = overlay of skullstripped anatomical image on top of original anatomical image
-    
+
     /tmp_d
         /reg_a (Intermediate files created during the processing of the anatomical data)
             mni2t1w_warp.nii.gz = nonlinear warp coefficients/fields for mni to t1w space
@@ -252,8 +258,8 @@ res = The file has been resliced to the desired voxel size specified by the user
 ```
 
 ## Functional Pipeline
-The organization of the output files generated by the m2g-f pipeline are shown below. If you only care about the connectome edgelists (**m2g**'s fundamental output), you can find them in `/output/connectomes_f`.
 
+The organization of the output files generated by the m2g-f pipeline are shown below. If you only care about the connectome edgelists (**m2g**'s fundamental output), you can find them in `/output/connectomes_f`.
 
 ```
 File labels that may appear on output files, these denote additional actions m2g may have done:
@@ -299,7 +305,7 @@ res = The file has been resliced to the desired voxel size specified by the user
     /func
         /preproc
             /coordinate_transformation
-                <subject>_<session>_task-rest_bold_calc_tshift_resample.aff12.1D = 
+                <subject>_<session>_task-rest_bold_calc_tshift_resample.aff12.1D =
             /frame_wise_displacement_jenkinson
                 FD_J.1D = vector containing Jenkinson measurement of framewise displacement for each frame of the functional image file
             /frame_wise_displacement_power
@@ -331,7 +337,7 @@ res = The file has been resliced to the desired voxel size specified by the user
                 <subject>_<session>_task-rest_bold_calc_tshift.nii.gz = slice time corrected functional image
         /register
             /functional_to_anat_linear_xfm
-                <subject>_<session>_task-rest_bold_calc_tshift_resample_volreg_calc_tstat_flirt.mat = 
+                <subject>_<session>_task-rest_bold_calc_tshift_resample_volreg_calc_tstat_flirt.mat =
             /functional_to_standard
                 bandpassed_demeaned_filtered_warp.nii.gz = bandpassed and demeaned filtered warp map for registering the functional image to MNI space
             /max_displacement
@@ -396,7 +402,7 @@ res = The file has been resliced to the desired voxel size specified by the user
             snr_s.png = sagittal view of signal to noise ratio for functional image
         /snr_val
             average_snr_file.txt = single value of average signal to noise ratio for functional image
-              
+
 ```
 
 ## Working with S3 Datasets
diff --git a/m2g/__init__.py b/m2g/__init__.py
index abffd369e..3c8b3f0e8 100644
--- a/m2g/__init__.py
+++ b/m2g/__init__.py
@@ -11,7 +11,7 @@
 
 # to call `m2g.graph`, etc
 __all__ = ["graph", "preproc", "register", "track"]  # modules
-__all__.extend(["functional","scripts", "stats", "utils"])  # subpackages
+__all__.extend(["functional", "scripts", "stats", "utils"])  # subpackages
 
 # import everything listed in __all__
 # TODO: maybe still change this
diff --git a/m2g/functional/__init__.py b/m2g/functional/__init__.py
index 93dcbc83c..b9c6e14fb 100644
--- a/m2g/functional/__init__.py
+++ b/m2g/functional/__init__.py
@@ -7,4 +7,4 @@
 m2g_func : top-level pipeline entrypoint
 """
 
-from . import m2g_func
\ No newline at end of file
+from . import m2g_func
diff --git a/m2g/functional/m2g_func.py b/m2g/functional/m2g_func.py
index 2d1a712d7..a213154ff 100644
--- a/m2g/functional/m2g_func.py
+++ b/m2g/functional/m2g_func.py
@@ -7,9 +7,10 @@
 import shutil
 import numpy as np
 
-def make_dataconfig(input_dir, sub, ses, anat, func, acquisition='alt+z', tr=2.0):
+
+def make_dataconfig(input_dir, sub, ses, anat, func, acquisition="alt+z", tr=2.0):
     """Generates the data_config file needed by cpac
-    
+
     Arguments:
         input_dir {str} -- Path of directory containing input files
         sub {int} -- subject number
@@ -18,61 +19,59 @@ def make_dataconfig(input_dir, sub, ses, anat, func, acquisition='alt+z', tr=2.0
         func {list} -- Path of functional nifti file
         acquisition {str} -- acquisition method for funcitonal scan
         tr {float} -- TR (seconds) of functional scan
-    
+
     Returns:
         None
     """
 
     for idx, funcf in enumerate(func):
-        # Extract information from the 
-        ffile = funcf.find('/func/sub-')
-        ffile = funcf[(ffile+6) :]
-        taskname = re.compile(r'task-(\w*)_')
-        acq = re.compile(r'_acq-(\w*)_bold')
+        # Extract information from the
+        ffile = funcf.find("/func/sub-")
+        ffile = funcf[(ffile + 6) :]
+        taskname = re.compile(r"task-(\w*)_")
+        acq = re.compile(r"_acq-(\w*)_bold")
         task = taskname.search(ffile)
         task = task.groups()[0]
         acq = acq.search(ffile)
         try:
             acq = acq.groups()[0]
             float(acq)
-            new_tr = str(float(acq)/1000)
-            print(f'TR extracted from filename of {ffile}')
+            new_tr = str(float(acq) / 1000)
+            print(f"TR extracted from filename of {ffile}")
         except:
-            print(f'No TR information found in {ffile}')
+            print(f"No TR information found in {ffile}")
             new_tr = tr
 
-
         if idx == 0:
-            Data = [{
-                'subject_id': sub,
-                'unique_id': f'ses-{ses}',
-                'anat': anat,
-                'func': {
+            Data = [
+                {
+                    "subject_id": sub,
+                    "unique_id": f"ses-{ses}",
+                    "anat": anat,
+                    "func": {
                         #'rest_run-1': {
-                        f'{task}-{acq}': {
-                            'scan': funcf,
-                            'scan_parameters': {
-                                'acquisition': acquisition,
-                                'tr': new_tr
+                        f"{task}-{acq}": {
+                            "scan": funcf,
+                            "scan_parameters": {
+                                "acquisition": acquisition,
+                                "tr": new_tr,
+                            },
                         }
-                    }
-                }    
-            }]
-        else:
-            Data[0]['func'][f'{task}-{acq}'] = {
-                'scan': funcf,
-                'scan_parameters': {
-                    'acquisition': acquisition,
-                    'tr': new_tr
+                    },
                 }
+            ]
+        else:
+            Data[0]["func"][f"{task}-{acq}"] = {
+                "scan": funcf,
+                "scan_parameters": {"acquisition": acquisition, "tr": new_tr},
             }
-    
-    config_file = f'{input_dir}/data_config.yaml'
-    with open(config_file,'w',encoding='utf-8') as outfile:
+
+    config_file = f"{input_dir}/data_config.yaml"
+    with open(config_file, "w", encoding="utf-8") as outfile:
         yaml.dump(Data, outfile, default_flow_style=False)
-    
+
     return config_file
-    
+
 
 def make_script(input_dir, output_dir, data_config, pipeline_config, mem_gb, n_cpus):
     """Make a bash script file for calling the m2g-f pipeline from CPAC
@@ -88,13 +87,15 @@ def make_script(input_dir, output_dir, data_config, pipeline_config, mem_gb, n_c
     Returns:
         _type_: _description_
     """
-    cpac_script = '/root/.m2g/cpac_script.sh'
-    with open(cpac_script,'w+',encoding='utf-8') as script:
-        script.write(f'''#! /bin/bash
+    cpac_script = "/root/.m2g/cpac_script.sh"
+    with open(cpac_script, "w+", encoding="utf-8") as script:
+        script.write(
+            f"""#! /bin/bash
         python3.7 /code/run.py --data_config_file {data_config} --pipeline_file {pipeline_config} --n_cpus {n_cpus} --mem_gb {mem_gb} {input_dir} {output_dir} participant
-        ''')
-    
-    run(f'chmod +x {cpac_script}')
+        """
+        )
+
+    run(f"chmod +x {cpac_script}")
 
     return cpac_script
 
@@ -107,14 +108,14 @@ def func_dir_reorg(outDir):
     """
     subj_pattern = r"(?<=sub-)(\w*)(?=/ses)"
     sesh_pattern = r"(?<=ses-)(\d*)"
-    atlas_pattern = r"(?<=Human..)\S*"#(?=/roi)"
+    atlas_pattern = r"(?<=Human..)\S*"  # (?=/roi)"
 
     # Convert connectomes into edgelists
-    for root, dirs, files in os.walk(outDir + '/output'):
+    for root, dirs, files in os.walk(outDir + "/output"):
         for file in files:
 
-            #Create non-absolute value connectome from timeseries
-            if file.endswith('roi_stats.npz'):
+            # Create non-absolute value connectome from timeseries
+            if file.endswith("roi_stats.npz"):
                 try:
                     sub = re.findall(subj_pattern, root)[0]
                     ses = re.findall(sesh_pattern, root)[0]
@@ -123,120 +124,192 @@ def func_dir_reorg(outDir):
                     edg_dir = f"{outDir}/connectomes_f/{atlas}"
                     subsesh = f"sub-{sub}_ses-{ses}"
 
-                    a = np.load(os.path.join(root,file))
-                    dat = a['arr_0'][1:,:]
+                    a = np.load(os.path.join(root, file))
+                    dat = a["arr_0"][1:, :]
                     my_data = np.corrcoef(dat.T)
                     my_data = np.nan_to_num(my_data).astype(object)
-                        
+
                     a = sum(range(1, len(my_data)))
-                    arr = np.zeros((a,3))
-                    z=0
+                    arr = np.zeros((a, 3))
+                    z = 0
                     for num in range(len(my_data)):
                         for j in range(len(my_data[num])):
                             if j > num:
-                                #print(f'{num+1} {i+1} {my_data[num][i]}')
-                                arr[z][0]= f'{num+1}'
-                                arr[z][1]= f'{j+1}'
+                                # print(f'{num+1} {i+1} {my_data[num][i]}')
+                                arr[z][0] = f"{num+1}"
+                                arr[z][1] = f"{j+1}"
                                 arr[z][2] = my_data[num][j]
-                                z=z+1
-                        
+                                z = z + 1
+
                     os.makedirs(f"{edg_dir}", exist_ok=True)
-                    np.savetxt(f"{edg_dir}/{subsesh}_func_{atlas}_edgelist.csv", arr,fmt='%d %d %f', delimiter=' ')
+                    np.savetxt(
+                        f"{edg_dir}/{subsesh}_func_{atlas}_edgelist.csv",
+                        arr,
+                        fmt="%d %d %f",
+                        delimiter=" ",
+                    )
 
                     my_data = np.abs(np.corrcoef(dat.T))
                     my_data = np.nan_to_num(my_data).astype(object)
-                
+
                     a = sum(range(1, len(my_data)))
-                    arr = np.zeros((a,3))
-                    z=0
+                    arr = np.zeros((a, 3))
+                    z = 0
                     for num in range(len(my_data)):
                         for j in range(len(my_data[num])):
                             if j > num:
-                                arr[z][0]= f'{num+1}'
-                                arr[z][1]= f'{j+1}'
+                                arr[z][0] = f"{num+1}"
+                                arr[z][1] = f"{j+1}"
                                 arr[z][2] = my_data[num][j]
-                                z=z+1
-                            
-                    np.savetxt(f"{edg_dir}/{subsesh}_func_{atlas}_abs_edgelist.csv", arr,fmt='%d %d %f', delimiter=' ')
+                                z = z + 1
+
+                    np.savetxt(
+                        f"{edg_dir}/{subsesh}_func_{atlas}_abs_edgelist.csv",
+                        arr,
+                        fmt="%d %d %f",
+                        delimiter=" ",
+                    )
 
                     print(f"{file} converted to edgelist")
 
-                    #Move roi-timeseries folders without stupid naming convention
-                    shutil.move(os.path.join(root), os.path.join("/", os.path.join(*root.split("/")[:-1]),atlas))
+                    # Move roi-timeseries folders without stupid naming convention
+                    shutil.move(
+                        os.path.join(root),
+                        os.path.join("/", os.path.join(*root.split("/")[:-1]), atlas),
+                    )
                 except:
                     print("Already converted roi_stats found")
 
-
-
-    #Reorganize the folder structure
-    reorg = {"anat_f":["anatomical_b","anatomical_w","anatomical_c","anatomical_r","anatomical_t",'anatomical_g',"seg_"],
-        "func/preproc":["coordinate","frame_w","functional_b","functional_f","functional_n","functional_p","motion","slice","raw"],
-        "func/register":['mean_functional',"functional_to",'functional_in', "max_", "movement_par","power_","roi"],
-        "qa_f":['mni_normalized_','carpet','csf_gm','mean_func_','rot_plot','trans_plot','skullstrip_vis', 'snr_']
+    # Reorganize the folder structure
+    reorg = {
+        "anat_f": [
+            "anatomical_b",
+            "anatomical_w",
+            "anatomical_c",
+            "anatomical_r",
+            "anatomical_t",
+            "anatomical_g",
+            "seg_",
+        ],
+        "func/preproc": [
+            "coordinate",
+            "frame_w",
+            "functional_b",
+            "functional_f",
+            "functional_n",
+            "functional_p",
+            "motion",
+            "slice",
+            "raw",
+        ],
+        "func/register": [
+            "mean_functional",
+            "functional_to",
+            "functional_in",
+            "max_",
+            "movement_par",
+            "power_",
+            "roi",
+        ],
+        "qa_f": [
+            "mni_normalized_",
+            "carpet",
+            "csf_gm",
+            "mean_func_",
+            "rot_plot",
+            "trans_plot",
+            "skullstrip_vis",
+            "snr_",
+        ],
     }
 
     moved = set()
     for root, dirs, files in os.walk(outDir, topdown=False):
-        if 'cpac_' and 'functional_pipeline_settings.yaml' in files:
-            os.makedirs(os.path.join(outDir,'log_f'), exist_ok=True)
+        if "cpac_" and "functional_pipeline_settings.yaml" in files:
+            os.makedirs(os.path.join(outDir, "log_f"), exist_ok=True)
             for i in files:
-                shutil.move(os.path.join(root,i),os.path.join(outDir,'log_f',i))
+                shutil.move(os.path.join(root, i), os.path.join(outDir, "log_f", i))
             moved.add(root)
-        if ('cpac_individual_timing_m2g.csv' in files) or ('pypeline.log' in files):
-            os.makedirs(os.path.join(outDir,'log_f'), exist_ok=True)
+        if ("cpac_individual_timing_m2g.csv" in files) or ("pypeline.log" in files):
+            os.makedirs(os.path.join(outDir, "log_f"), exist_ok=True)
             for i in files:
-                shutil.move(os.path.join(root,i),os.path.join(outDir,'log_f',i))
+                shutil.move(os.path.join(root, i), os.path.join(outDir, "log_f", i))
             moved.add(root)
 
-    for root, dirs, files in os.walk(outDir+'/output'):
-        if root not in moved and 'workingDirectory' not in root:
+    for root, dirs, files in os.walk(outDir + "/output"):
+        if root not in moved and "workingDirectory" not in root:
             for cat in reorg:
                 for nam in reorg[cat]:
-                    if nam in root.split('/')[-1]:
-                        #Get rid of the stupid in-between subdirectory
-                        if '_scan_rest-None' in dirs:
-                            _ = os.path.join(outDir,cat,root.split('/')[-1])
+                    if nam in root.split("/")[-1]:
+                        # Get rid of the stupid in-between subdirectory
+                        if "_scan_rest-None" in dirs:
+                            _ = os.path.join(outDir, cat, root.split("/")[-1])
                             os.makedirs(_, exist_ok=True)
-                            for fil in os.listdir(os.path.join(root, '_scan_rest-None')):
+                            for fil in os.listdir(
+                                os.path.join(root, "_scan_rest-None")
+                            ):
                                 try:
-                                    shutil.move(os.path.join(root,'_scan_rest-None',fil), _ )
+                                    shutil.move(
+                                        os.path.join(root, "_scan_rest-None", fil), _
+                                    )
                                 except:
-                                    print(f"Target: {_} already exists. Skipping file movement...")
+                                    print(
+                                        f"Target: {_} already exists. Skipping file movement..."
+                                    )
 
                             moved.add(root)
 
                         else:
-                            _ = os.path.join(outDir,cat)
-                            if cat != 'connectomes_f' and cat != 'log_f':
-                                os.makedirs(_,exist_ok=True)
+                            _ = os.path.join(outDir, cat)
+                            if cat != "connectomes_f" and cat != "log_f":
+                                os.makedirs(_, exist_ok=True)
                             try:
-                                shutil.move(root,_)
+                                shutil.move(root, _)
                             except:
-                                print(f"Target: {_} already exists. Skipping file movement...")
+                                print(
+                                    f"Target: {_} already exists. Skipping file movement..."
+                                )
 
                             moved.add(root)
-                            _ = os.path.join(_,root.split('/')[-1])
-                            
+                            _ = os.path.join(_, root.split("/")[-1])
+
                         for r, d, ff in os.walk(_):
-                            nono = ['_montage_','_selector_','ses-']
+                            nono = ["_montage_", "_selector_", "ses-"]
                             for i, element in enumerate(d):
                                 for q in nono:
                                     if q in element:
-                                        for f in os.listdir(os.path.join(r,d[i])):
+                                        for f in os.listdir(os.path.join(r, d[i])):
                                             try:
-                                                shutil.move(os.path.join(r,d[i],f),_)
+                                                shutil.move(os.path.join(r, d[i], f), _)
                                             except:
-                                                print(f"Target: {_} already exists. Skipping file movement...")
-                                        #os.rmdir(os.path.join(r,d[i]))
-                                        shutil.rmtree(os.path.join(r,d[i]), ignore_errors=True)
-    #get rid of cpac output folder
-    shutil.rmtree(os.path.join(outDir,'output'), ignore_errors=True)
-    shutil.rmtree(os.path.join(outDir, 'log'), ignore_errors=True)
-
-
-def m2g_func_worker(input_dir, output_dir, sub, ses, anat, bold, vox, parcellations, acquisition, tr, mem_gb, n_cpus):
+                                                print(
+                                                    f"Target: {_} already exists. Skipping file movement..."
+                                                )
+                                        # os.rmdir(os.path.join(r,d[i]))
+                                        shutil.rmtree(
+                                            os.path.join(r, d[i]), ignore_errors=True
+                                        )
+    # get rid of cpac output folder
+    shutil.rmtree(os.path.join(outDir, "output"), ignore_errors=True)
+    shutil.rmtree(os.path.join(outDir, "log"), ignore_errors=True)
+
+
+def m2g_func_worker(
+    input_dir,
+    output_dir,
+    sub,
+    ses,
+    anat,
+    bold,
+    vox,
+    parcellations,
+    acquisition,
+    tr,
+    mem_gb,
+    n_cpus,
+):
     """Creates the requisite files to run CPAC, then calls CPAC and runs it in a terminal
-    
+
     Arguments:
         input_dir {str} -- Path to input directory
         output_dir {str} -- Path to output directory
@@ -248,42 +321,44 @@ def m2g_func_worker(input_dir, output_dir, sub, ses, anat, bold, vox, parcellati
         acquisition {str} -- Acquisition method for funcitional scans
         tr {str} -- TR time, in seconds
     """
-    
-    pipeline_config='/m2g/m2g/functional/m2g_pipeline.yaml'
+
+    pipeline_config = "/m2g/m2g/functional/m2g_pipeline.yaml"
 
     # If parcellations specified, create dictionary to alter yaml file
     if parcellations:
-        os.makedirs(f'{output_dir}',exist_ok=True)
+        os.makedirs(f"{output_dir}", exist_ok=True)
         parcs = {}
 
         for p in parcellations:
-            parcs[p]='Avg'
-    
+            parcs[p] = "Avg"
+
         # Read in desired parcellations
-        with open(pipeline_config,'r',encoding='utf-8') as func_config:
+        with open(pipeline_config, "r", encoding="utf-8") as func_config:
             config = yaml.safe_load(func_config)
 
         # Replace 'tsa_roi_paths'
-        config['tsa_roi_paths'][0] = parcs
+        config["tsa_roi_paths"][0] = parcs
 
         # Change voxel size to match user input
-        config['resolution_for_anat'] = vox
-        config['resolution_for_func_preproc'] = vox
-        config['resolution_for_func_derivative'] = vox
+        config["resolution_for_anat"] = vox
+        config["resolution_for_func_preproc"] = vox
+        config["resolution_for_func_derivative"] = vox
 
         # Create new pipeline yaml file in a different location
-        pipeline_config=f'{output_dir}/functional_pipeline_settings.yaml'
+        pipeline_config = f"{output_dir}/functional_pipeline_settings.yaml"
 
-        with open(pipeline_config,'w',encoding='utf-8') as outfile:
+        with open(pipeline_config, "w", encoding="utf-8") as outfile:
             yaml.dump(config, outfile, default_flow_style=False)
 
-    if not isinstance(bold,list):
+    if not isinstance(bold, list):
         bold = (bold,)
-        print('Single functional nifti file found')
+        print("Single functional nifti file found")
 
     data_config = make_dataconfig(input_dir, sub, ses, anat, bold, acquisition, tr)
-    cpac_script = make_script(input_dir, output_dir, data_config, pipeline_config,mem_gb, n_cpus)
-    
+    cpac_script = make_script(
+        input_dir, output_dir, data_config, pipeline_config, mem_gb, n_cpus
+    )
+
     # Run pipeline with resource monitor
-    #subprocess.Popen(['free','-m','-c',f'{itterations}','-s',f'{period}'])
+    # subprocess.Popen(['free','-m','-c',f'{itterations}','-s',f'{period}'])
     subprocess.call([cpac_script], shell=True)
diff --git a/m2g/graph.py b/m2g/graph.py
index 53b49ee5f..e8e67fa67 100644
--- a/m2g/graph.py
+++ b/m2g/graph.py
@@ -32,6 +32,7 @@
 from graspologic.utils import ptr
 from graspologic.plot import heatmap
 
+
 class GraphTools:
     """Initializes the graph with nodes corresponding to the number of ROIS
 
@@ -75,8 +76,8 @@ def __init__(
     ):
 
         self.edge_dict = defaultdict(int)
-        #self.roi_file = rois
-        #self.roi_img = nib.load(self.roi_file)
+        # self.roi_file = rois
+        # self.roi_img = nib.load(self.roi_file)
         self.rois = nib.load(rois)
         self.rois = self.rois.get_data().astype("int")
         # self.n_ids = self.rois[self.rois > 0]
@@ -308,4 +309,3 @@ def summary(self):
         """
         print("\nGraph Summary:")
         print(nx.info(self.g))
-
diff --git a/m2g/register.py b/m2g/register.py
index ec4a84c12..c6edbe434 100644
--- a/m2g/register.py
+++ b/m2g/register.py
@@ -65,7 +65,7 @@ def direct_streamline_norm(streams, fa_path, outdir: Path):
 
     # Warp streamlines
     adjusted_affine = affine_map.affine.copy()
-    adjusted_affine[1][3] = -adjusted_affine[1][3] / vox_size ** 2
+    adjusted_affine[1][3] = -adjusted_affine[1][3] / vox_size**2
     mni_streamlines = deform_streamlines(
         streamlines.streamlines,
         deform_field=mapping.get_forward_field()[-1:],
@@ -152,7 +152,6 @@ def __init__(
         self.qa = str(outdir / "qa_d")
         self.qa_reg = str(Path(self.qa) / "reg")
 
-
         self.simple = simple
         self.nodif_B0 = nodif_B0
         self.nodif_B0_mask = nodif_B0_mask
@@ -231,8 +230,7 @@ def gen_tissue(self):
         location indicated by self.map_path
         """
 
-
-        #TODO: Why is the t1w skullstripped here? Shouldn't this be part of the preprocessing?
+        # TODO: Why is the t1w skullstripped here? Shouldn't this be part of the preprocessing?
         # BET needed for this, as afni 3dautomask only works on 4d volumes
         print("Extracting brain from raw T1w image...")
         reg_utils.t1w_skullstrip(self.t1w, self.t1w_brain, self.skull)
@@ -347,7 +345,7 @@ def t1w2dwi_align(self):
                 )
 
                 # Get mat from MNI -> T1
-                #TODO: I don't think the resulting matrix is used anywhere? Double check and then remove is useless...
+                # TODO: I don't think the resulting matrix is used anywhere? Double check and then remove is useless...
                 cmd = f"convert_xfm -omat {self.mni2t1_xfm_init} -inverse {self.t12mni_xfm_init}"
                 print(cmd)
                 gen_utils.run(cmd)
diff --git a/m2g/scripts/m2g_bids.py b/m2g/scripts/m2g_bids.py
index 990c562fe..bc59166a2 100644
--- a/m2g/scripts/m2g_bids.py
+++ b/m2g/scripts/m2g_bids.py
@@ -95,7 +95,7 @@ def get_atlas(atlas_dir, vox_size):
 def get_atlas_dir():
     """
     Gets the location of m2g's atlases.
-    
+
     Returns
     -------
     str
@@ -108,8 +108,7 @@ def get_atlas_dir():
 
 
 def main():
-    """Starting point of the m2g pipeline, assuming that you are using a BIDS organized dataset
-    """
+    """Starting point of the m2g pipeline, assuming that you are using a BIDS organized dataset"""
     parser = ArgumentParser(
         description="This is an end-to-end connectome estimation pipeline from fMRI and diffusion weighted MRI data."
     )
@@ -174,7 +173,7 @@ def main():
         "--tr",
         action="store",
         help="functional scan TR (seconds), default is 2.0",
-        default=2.0
+        default=2.0,
     )
     parser.add_argument(
         "--push_location",
@@ -345,10 +344,14 @@ def main():
     )
 
     # ---------------- Grab parcellations, atlases, mask --------------- #
-    #TODO: Test that you can locate parcellations elsewhere
+    # TODO: Test that you can locate parcellations elsewhere
     # get parcellations, atlas, and mask, then stick it into constant_kwargs
     atlas_dir = get_atlas_dir()
-    parcellations, atlas, mask, = get_atlas(atlas_dir, constant_kwargs["vox_size"])
+    (
+        parcellations,
+        atlas,
+        mask,
+    ) = get_atlas(atlas_dir, constant_kwargs["vox_size"])
     if parcellation_name is not None:  # filter parcellations
         parcellations = [
             file_
@@ -364,7 +367,7 @@ def main():
 
     # ------- Check if they have selected the functional pipeline ------ #
     if pipe == "func" or pipe == "both":
-        
+
         sweeper = DirectorySweeper(
             input_dir, subjects=subjects, sessions=sessions, pipeline="func"
         )
@@ -393,16 +396,15 @@ def main():
                 mem_gb,
                 n_cpus,
             )
-            
+
             print(
                 f"""
                 Functional Pipeline completed!
                 """
             )
-            #Reorganize output files from CPAC to a more user-friendly version
+            # Reorganize output files from CPAC to a more user-friendly version
             func_dir_reorg(outDir)
 
-
             if push_location:
                 print(f"Pushing to s3 at {push_location}.")
                 push_buck, push_remo = cloud_utils.parse_path(push_location)
@@ -414,10 +416,9 @@ def main():
                     session=session,
                     creds=creds,
                 )
-        if pipe != 'both':
+        if pipe != "both":
             sys.exit(0)
 
-    
     # ------------ Continue DWI pipeline ------------ #
 
     constant_kwargs.update(atlas_info)
@@ -443,7 +444,6 @@ def main():
                 session=session,
                 creds=creds,
             )
-            
 
 
 if __name__ == "__main__":
diff --git a/m2g/scripts/m2g_cloud.py b/m2g/scripts/m2g_cloud.py
index 704e8ce61..2b3a7b60a 100644
--- a/m2g/scripts/m2g_cloud.py
+++ b/m2g/scripts/m2g_cloud.py
@@ -149,14 +149,14 @@ def crawl_bucket(bucket, path, jobdir):
     # set up bucket crawl
     subj_pattern = r"(?<=sub-)(\w*)(?=/ses)"
     sesh_pattern = r"(?<=ses-)(\d*)"
-    all_subfiles = get_matching_s3_objects(bucket, path + "/sub-", '.nii.gz')
+    all_subfiles = get_matching_s3_objects(bucket, path + "/sub-", ".nii.gz")
     subjs = list(set(re.findall(subj_pattern, obj)[0] for obj in all_subfiles))
     seshs = OrderedDict()
 
     # populate seshs
     for subj in subjs:
         prefix = f"{path}/sub-{subj}/"
-        all_seshfiles = get_matching_s3_objects(bucket, prefix, '.nii.gz')
+        all_seshfiles = get_matching_s3_objects(bucket, prefix, ".nii.gz")
         sesh = list(set([re.findall(sesh_pattern, obj)[0] for obj in all_seshfiles]))
         if sesh != []:
             seshs[subj] = sesh
@@ -399,7 +399,7 @@ def kill_jobs(jobdir, reason='"Killing job"'):
         batch.terminate_job(jobId=jid, reason=reason)
 
 
-#%%
+# %%
 def main():
     parser = ArgumentParser(
         description="This is a pipeline for running BIDs-formatted diffusion MRI datasets through AWS S3 to produce connectomes."
@@ -442,7 +442,7 @@ def main():
         action="store",
         help="""Pipline to use when analyzing the input data, 
         either func or dwi. If  Default is dwi.""",
-        default="dwi"
+        default="dwi",
     )
     parser.add_argument(
         "--acquisition",
@@ -457,7 +457,7 @@ def main():
         seqplus - Sequential in the plus direction
         seqminus - Sequential in the minus direction,
         default is alt+z. For more information:https://fcp-indi.github.io/docs/user/func.html""",
-        default="alt+z"
+        default="alt+z",
     )
     parser.add_argument(
         "--tr",
@@ -474,7 +474,7 @@ def main():
     parser.add_argument(
         "--n_cpus",
         action="store",
-        help="Number of cpus that the functional pipeline has access to. Not required for dwi pipeline. Default is 2 cpus."
+        help="Number of cpus that the functional pipeline has access to. Not required for dwi pipeline. Default is 2 cpus.",
     )
     parser.add_argument(
         "--parcellation",
@@ -521,7 +521,7 @@ def main():
     )
 
     result = parser.parse_args()
-    
+
     state = result.state
     bucket = result.bucket
     path = result.bidsdir
diff --git a/m2g/scripts/m2g_dwi_pipeline.py b/m2g/scripts/m2g_dwi_pipeline.py
index fa109c97e..34cf210f1 100644
--- a/m2g/scripts/m2g_dwi_pipeline.py
+++ b/m2g/scripts/m2g_dwi_pipeline.py
@@ -133,7 +133,9 @@ def m2g_dwi_worker(
     # make output directory
     print("Adding directory tree...")
     parcellations = gen_utils.as_list(parcellations)
-    init_dirs = gen_utils.make_initial_directories(outdir, dwi, parcellations=parcellations)
+    init_dirs = gen_utils.make_initial_directories(
+        outdir, dwi, parcellations=parcellations
+    )
 
     warm_welcome = welcome_message(init_dirs["connectomes"])
     print(warm_welcome)
@@ -141,8 +143,8 @@ def m2g_dwi_worker(
     # -------- Preprocessing Steps --------------------------------- #
 
     # set up directories
-    #prep_dwi: Path = outdir / "dwi/preproc"
-    eddy_corrected_data: Path = init_dirs['dwi_dirs'][1] / "eddy_corrected_data.nii.gz"
+    # prep_dwi: Path = outdir / "dwi/preproc"
+    eddy_corrected_data: Path = init_dirs["dwi_dirs"][1] / "eddy_corrected_data.nii.gz"
 
     # check that skipping eddy correct is possible
     if skipeddy:
@@ -153,13 +155,15 @@ def m2g_dwi_worker(
 
     # if we're not skipping eddy correct, perform it
     if not skipeddy:
-        init_dirs['dwi_dirs'][1] = gen_utils.as_directory(init_dirs['dwi_dirs'][1], remove=True, return_as_path=True)
+        init_dirs["dwi_dirs"][1] = gen_utils.as_directory(
+            init_dirs["dwi_dirs"][1], remove=True, return_as_path=True
+        )
         preproc.eddy_correct(dwi, str(eddy_corrected_data), 0)
 
     # copy bval/bvec files to output directory
-    bvec_scaled = str(init_dirs['dwi_dirs'][1] / 'bvec_scaled.bvec')
-    fbval = str(init_dirs['dwi_dirs'][1] / 'bval.bval')
-    fbvec = str(init_dirs['dwi_dirs'][1] / 'bvec.bvec')
+    bvec_scaled = str(init_dirs["dwi_dirs"][1] / "bvec_scaled.bvec")
+    fbval = str(init_dirs["dwi_dirs"][1] / "bval.bval")
+    fbvec = str(init_dirs["dwi_dirs"][1] / "bvec.bvec")
     shutil.copyfile(bvecs, fbvec)
     shutil.copyfile(bvals, fbval)
 
@@ -182,7 +186,7 @@ def m2g_dwi_worker(
 
     # Check orientation (eddy_corrected_data)
     eddy_corrected_data, bvecs = gen_utils.reorient_dwi(
-        eddy_corrected_data, bvec_scaled, init_dirs['dwi_dirs'][1]
+        eddy_corrected_data, bvec_scaled, init_dirs["dwi_dirs"][1]
     )
 
     # Check dimensions
@@ -196,7 +200,7 @@ def m2g_dwi_worker(
     print("fbvec: ", fbvec)
     print("eddy_corrected_data: ", eddy_corrected_data)
     gtab, nodif_B0, nodif_B0_mask = gen_utils.make_gtab_and_bmask(
-        fbval, fbvec, eddy_corrected_data, init_dirs['dwi_dirs'][1]
+        fbval, fbvec, eddy_corrected_data, init_dirs["dwi_dirs"][1]
     )
 
     # Get B0 header and affine
@@ -207,12 +211,12 @@ def m2g_dwi_worker(
 
     # define registration directory locations
     # TODO: possibly just pull these from a container generated by `gen_utils.make_initial_directories`
-    #reg_dirs = ["anat/preproc", "anat/registered", "tmp/reg_a", "tmp/reg_m"]
-    #reg_dirs = [outdir / loc for loc in reg_dirs]
-    prep_anat = init_dirs['anat_dirs'][0]
-    reg_anat = init_dirs['anat_dirs'][1]
-    tmp_rega = init_dirs['tmp_dirs'][0]
-    tmp_regm = init_dirs['tmp_dirs'][1]
+    # reg_dirs = ["anat/preproc", "anat/registered", "tmp/reg_a", "tmp/reg_m"]
+    # reg_dirs = [outdir / loc for loc in reg_dirs]
+    prep_anat = init_dirs["anat_dirs"][0]
+    reg_anat = init_dirs["anat_dirs"][1]
+    tmp_rega = init_dirs["tmp_dirs"][0]
+    tmp_regm = init_dirs["tmp_dirs"][1]
 
     if not skipreg:
         for dir_ in [prep_anat, reg_anat]:
@@ -273,8 +277,8 @@ def m2g_dwi_worker(
     # -------- Tensor Fitting and Fiber Tractography ---------------- #
 
     # initial path setup
-    #prep_track: Path = outdir / "dwi/fiber"
-    prep_track = init_dirs['dwi_dirs'][0]
+    # prep_track: Path = outdir / "dwi/fiber"
+    prep_track = init_dirs["dwi_dirs"][0]
     start_time = time.time()
     qa_tensor = str(init_dirs["qa_dirs"][6] / "/Tractography_Model_Peak_Directions.png")
 
@@ -312,7 +316,7 @@ def m2g_dwi_worker(
     print("Streamlines complete")
     print(f"Tractography runtime: {np.round(time.time() - start_time, 1)}")
 
-    #TODO: Get rid of native_dsn once and for all?
+    # TODO: Get rid of native_dsn once and for all?
     if reg_style == "native_dsn":
         fa_path = track.tens_mod_fa_est(gtab, eddy_corrected_data, nodif_B0_mask)
         # Normalize streamlines
@@ -331,8 +335,6 @@ def m2g_dwi_worker(
     elif reg_style == "native_dsn":
         tracks = streamlines_mni
 
-
-
     for idx, parc in enumerate(parcellations):
         print(f"Generating graph for {parc} parcellation...")
         print(f"Applying native-space alignment to {parcellations[idx]}")
@@ -340,10 +342,10 @@ def m2g_dwi_worker(
             tracks = streamlines
         elif reg_style == "native_dsn":
             tracks = streamlines_mni
-        #rois = nib.load(labels_im_file_list[idx]).get_fdata().astype(int)
+        # rois = nib.load(labels_im_file_list[idx]).get_fdata().astype(int)
         g1 = graph.GraphTools(
             attr=parcellations[idx],
-            rois=labels_im_file_list[idx],#rois,
+            rois=labels_im_file_list[idx],  # rois,
             tracks=tracks,
             affine=np.eye(4),
             outdir=outdir,
@@ -352,16 +354,15 @@ def m2g_dwi_worker(
         )
         g1.g = g1.make_graph()
         g1.summary()
-        g1.save_graph_png(init_dirs["qa_dirs"][3],init_dirs["connectomes"][idx])
+        g1.save_graph_png(init_dirs["qa_dirs"][3], init_dirs["connectomes"][idx])
         g1.save_graph(init_dirs["connectomes"][idx])
 
-
     exe_time = datetime.now() - startTime
 
     if "M2G_URL" in os.environ:
         print("Note: tractography QA does not work in a Docker environment.")
     else:
-        #TODO: Check that this still works
+        # TODO: Check that this still works
         qa_tractography_out = outdir / "qa/fibers"
         qa_tractography(streams, str(qa_tractography_out), str(eddy_corrected_data))
         print("QA tractography Completed.")
@@ -376,7 +377,6 @@ def m2g_dwi_worker(
     )
 
 
-
 def welcome_message(connectomes):
 
     line = """\n~~~~~~~~~~~~~~~~\n 
@@ -390,4 +390,3 @@ def welcome_message(connectomes):
     line += "~~~~~~~~~~~~~~~~\n"
 
     return line
-
diff --git a/m2g/stats/__init__.py b/m2g/stats/__init__.py
index 562ded3f6..4d72546fa 100644
--- a/m2g/stats/__init__.py
+++ b/m2g/stats/__init__.py
@@ -2,7 +2,9 @@
 m2g.stats
 ~~~~~~~~~~~~
 """
+
 import warnings
+
 warnings.simplefilter("ignore")
 # Prevent typing multilevel imports
 
diff --git a/m2g/stats/qa_fast.py b/m2g/stats/qa_fast.py
index 5a4f44799..a82125d1a 100644
--- a/m2g/stats/qa_fast.py
+++ b/m2g/stats/qa_fast.py
@@ -11,7 +11,7 @@ def qa_fast_png(csf, gm, wm, outdir):
     FAST (FMRIB's Automated Segmentation Tool)
     segments a 3D image of the brain into different tissue types (Grey Matter, White Matter, CSF, etc.)
     Mark different colors of white matter, gray matter, cerebrospinal fluid in a '3 by 3' picture, i.e. QA for FAST
-    
+
     Parameters
     ---------------
     csf: str
@@ -23,25 +23,27 @@ def qa_fast_png(csf, gm, wm, outdir):
     outdir: str
     the path to save QA graph
     """
-    
+
     # load data
     gm_data = nb.load(gm).get_data()
     csf_data = nb.load(csf).get_data()
     wm_data = nb.load(wm).get_data()
-    
+
     # set Color map
-    cmap1 = LinearSegmentedColormap.from_list('mycmap1', ['white', 'blue'])
-    cmap2 = LinearSegmentedColormap.from_list('mycmap2', ['white', 'magenta'])
-    cmap3 = LinearSegmentedColormap.from_list('mycmap2', ['white', 'green'])
-    
-    
+    cmap1 = LinearSegmentedColormap.from_list("mycmap1", ["white", "blue"])
+    cmap2 = LinearSegmentedColormap.from_list("mycmap2", ["white", "magenta"])
+    cmap3 = LinearSegmentedColormap.from_list("mycmap2", ["white", "green"])
+
     overlay = plt.figure()
     overlay.set_size_inches(12.5, 10.5, forward=True)
-    plt.title(f'Qa for FAST(segments a 3D image of the brain into different tissue types)\n (scan volume:{gm_data.shape}) \n', fontsize=22)
+    plt.title(
+        f"Qa for FAST(segments a 3D image of the brain into different tissue types)\n (scan volume:{gm_data.shape}) \n",
+        fontsize=22,
+    )
     plt.xticks([])
     plt.yticks([])
-    plt.axis('off')
-    
+    plt.axis("off")
+
     # Determine whether the input data types are consistent. If they are inconsistent, an error is reported.
     if gm_data.shape != csf_data.shape:
         raise ValueError("GM and CSF are not the same shape.")
@@ -49,7 +51,7 @@ def qa_fast_png(csf, gm, wm, outdir):
         raise ValueError("GM and WM are not the same shape.")
     elif wm_data.shape != csf_data.shape:
         raise ValueError("WM and CSF are not the same shape.")
-    
+
     # Set the 3D matrix cutting position in three directions
     shape = csf_data.shape
     index = [0.35, 0.51, 0.65]
@@ -57,17 +59,16 @@ def qa_fast_png(csf, gm, wm, outdir):
     y = [int(shape[1] * index[0]), int(shape[1] * index[1]), int(shape[1] * index[2])]
     z = [int(shape[2] * index[0]), int(shape[2] * index[1]), int(shape[2] * index[2])]
     coords = (x, y, z)
-    
+
     # Set labels for the y-axis
     labs = [
         "Sagittal Slice",
         "Coronal Slice",
         "Axial Slice",
     ]
-    
-    
+
     var = ["X", "Y", "Z"]
-    
+
     # Generate 3 by 3 picture
     idx = 0
     for i, coord in enumerate(coords):
@@ -88,37 +89,37 @@ def qa_fast_png(csf, gm, wm, outdir):
                 gm_slice = ndimage.rotate(gm_data[:, :, pos], 90)
                 wm_slice = ndimage.rotate(wm_data[:, :, pos], 90)
 
-            # set y labels    
+            # set y labels
             if idx % 3 == 1:
                 plt.ylabel(labs[i])
-            
+
             #  padding pictures to make them the same size
-            csf_slice = (csf_slice*255).astype(np.uint8)
-            gm_slice = (gm_slice*255).astype(np.uint8)
-            wm_slice = (wm_slice*255).astype(np.uint8)
+            csf_slice = (csf_slice * 255).astype(np.uint8)
+            gm_slice = (gm_slice * 255).astype(np.uint8)
+            wm_slice = (wm_slice * 255).astype(np.uint8)
             csf_slice = pad_im(csf_slice, max(shape), 0, False)
             gm_slice = pad_im(gm_slice, max(shape), 0, False)
             wm_slice = pad_im(wm_slice, max(shape), 0, False)
-            
+
             # hide axes
             ax.set_xticks([])
             ax.set_yticks([])
-            ax.spines['top'].set_visible(False)
-            ax.spines['right'].set_visible(False)
-            ax.spines['bottom'].set_visible(False)
-            ax.spines['left'].set_visible(False)
-            
+            ax.spines["top"].set_visible(False)
+            ax.spines["right"].set_visible(False)
+            ax.spines["bottom"].set_visible(False)
+            ax.spines["left"].set_visible(False)
+
             # display image
             ax.imshow(csf_slice, interpolation="none", cmap=cmap1, alpha=1)
             ax.imshow(gm_slice, interpolation="none", cmap=cmap2, alpha=0.5)
             ax.imshow(wm_slice, interpolation="none", cmap=cmap3, alpha=0.3)
-           
+
             # Legend of white matter(WM), gray matter(GM) and cerebrospinal fluid(csf)
             if idx == 3:
-                plt.plot(0, 0, "-", c='green', label='wm')
-                plt.plot(0, 0, "-", c='pink', label='gm')
-                plt.plot(0, 0, "-", c='blue', label='csf')
-                plt.legend(loc='upper right',fontsize=15,bbox_to_anchor=(1.5,1.2))
-                
+                plt.plot(0, 0, "-", c="green", label="wm")
+                plt.plot(0, 0, "-", c="pink", label="gm")
+                plt.plot(0, 0, "-", c="blue", label="csf")
+                plt.legend(loc="upper right", fontsize=15, bbox_to_anchor=(1.5, 1.2))
+
     # save figure
     overlay.savefig(f"{outdir}", format="png")
diff --git a/m2g/stats/qa_reg.py b/m2g/stats/qa_reg.py
index e8065f0d7..d2b5fb326 100644
--- a/m2g/stats/qa_reg.py
+++ b/m2g/stats/qa_reg.py
@@ -21,6 +21,7 @@
 from scipy import ndimage
 from matplotlib.colors import LinearSegmentedColormap
 import matplotlib as mpl
+
 mpl.use("Agg")  # very important above pyplot import
 from nilearn.plotting.edge_detect import _edge_map as edge_map
 import matplotlib.pyplot as plt
@@ -31,7 +32,7 @@ def reg_mri_pngs(
 ):
     """
     A function to create and save registered brain slice figures.
-    
+
     Parameter
     ---------
     mri: nifti file
@@ -39,14 +40,14 @@ def reg_mri_pngs(
     atlas: nifti file
         the reference brain file used in each registration step.
     outdir: str
-        directory where output png file is saved. 
+        directory where output png file is saved.
     loc: int
         which dimension of the 4d brain data to use
     mean: bool
         whether to calculate the mean of the 4d brain data
         If False, the loc=0 dimension of the data (mri_data[:, :, :, loc]) is used
     minthr: int
-        lower percentile threshold 
+        lower percentile threshold
     maxthr: int
         upper percentile threshold
     """
@@ -65,26 +66,30 @@ def reg_mri_pngs(
 
     fig = plot_overlays(atlas_data, mr_data, [cmap1, cmap2], minthr, maxthr, edge)
     # name and save the file
-    fig.savefig(outdir + "/" + get_filename(mri) + "_2_" + get_filename(atlas) + ".png", format="png")
-    
+    fig.savefig(
+        outdir + "/" + get_filename(mri) + "_2_" + get_filename(atlas) + ".png",
+        format="png",
+    )
+
     plt.close()
 
+
 def plot_brain(brain, minthr=2, maxthr=95, edge=False):
     """
     A function to plot a brain.
-    
+
     Parameter
     ---------
     brain: str, nifti image, numpy.ndarray
         an object to open the data for a registered brain. Can be a string (path to a brain file),
         nibabel.nifti1.nifti1image, or a numpy.ndarray.
     minthr: int
-        lower percentile threshold 
+        lower percentile threshold
     maxthr: int
         upper percentile threshold
     edge: bool
         whether to use normalized luminance data
-        If None, the respective min and max of the color array is used. 
+        If None, the respective min and max of the color array is used.
     Returns
     ---------
     fbr: matplotlib.figure.Figure
@@ -99,9 +104,21 @@ def plot_brain(brain, minthr=2, maxthr=95, edge=False):
         z = [88, 103, 107]
     else:
         brain_volume = brain.shape
-        x = [int(brain_volume[0] * 0.35), int(brain_volume[0] * 0.51), int(brain_volume[0] * 0.65)]
-        y = [int(brain_volume[1] * 0.35), int(brain_volume[1] * 0.51), int(brain_volume[1] * 0.65)]
-        z = [int(brain_volume[2] * 0.35), int(brain_volume[2] * 0.51), int(brain_volume[2] * 0.65)]
+        x = [
+            int(brain_volume[0] * 0.35),
+            int(brain_volume[0] * 0.51),
+            int(brain_volume[0] * 0.65),
+        ]
+        y = [
+            int(brain_volume[1] * 0.35),
+            int(brain_volume[1] * 0.51),
+            int(brain_volume[1] * 0.65),
+        ]
+        z = [
+            int(brain_volume[2] * 0.35),
+            int(brain_volume[2] * 0.51),
+            int(brain_volume[2] * 0.65),
+        ]
     coords = (x, y, z)
 
     labs = [
@@ -152,7 +169,7 @@ def plot_brain(brain, minthr=2, maxthr=95, edge=False):
 def plot_overlays(atlas, b0, cmaps=None, minthr=2, maxthr=95, edge=False):
     """
     A function to plot the overlay figures of registered and reference brain slices.
-    
+
     Parameter
     ---------
     atlas: str, nifti image, numpy.ndarray
@@ -165,12 +182,12 @@ def plot_overlays(atlas, b0, cmaps=None, minthr=2, maxthr=95, edge=False):
 
     cmap: Colormap objects based on lookup tables using linear segments.
     minthr: int
-        lower percentile threshold 
+        lower percentile threshold
     maxthr: int
         upper percentile threshold
     edge: bool
         whether to use normalized luminance data
-        If None, the respective min and max of the color array is used. 
+        If None, the respective min and max of the color array is used.
 
     Returns
     ---------
@@ -194,18 +211,42 @@ def plot_overlays(atlas, b0, cmaps=None, minthr=2, maxthr=95, edge=False):
         y = [82, 107, 142]
         z = [88, 103, 107]
     else:
-        x = [int(brain_volume[0] * 0.35), int(brain_volume[0] * 0.51), int(brain_volume[0] * 0.65)]
-        y = [int(brain_volume[1] * 0.35), int(brain_volume[1] * 0.51), int(brain_volume[1] * 0.65)]
-        z = [int(brain_volume[2] * 0.35), int(brain_volume[2] * 0.51), int(brain_volume[2] * 0.65)]
+        x = [
+            int(brain_volume[0] * 0.35),
+            int(brain_volume[0] * 0.51),
+            int(brain_volume[0] * 0.65),
+        ]
+        y = [
+            int(brain_volume[1] * 0.35),
+            int(brain_volume[1] * 0.51),
+            int(brain_volume[1] * 0.65),
+        ]
+        z = [
+            int(brain_volume[2] * 0.35),
+            int(brain_volume[2] * 0.51),
+            int(brain_volume[2] * 0.65),
+        ]
     coords = (x, y, z)
-    
+
     atlas = pad_im(atlas, max(brain_volume[0:3]), 0, False)
     b0 = pad_im(b0, max(brain_volume[0:3]), 0, False)
-    x = [int(max(brain_volume[0:3]) * 0.35), int(max(brain_volume[0:3]) * 0.51), int(max(brain_volume[0:3]) * 0.65)]
-    y = [int(max(brain_volume[0:3]) * 0.35), int(max(brain_volume[0:3]) * 0.51), int(max(brain_volume[0:3]) * 0.65)]
-    z = [int(max(brain_volume[0:3]) * 0.35), int(max(brain_volume[0:3]) * 0.51), int(max(brain_volume[0:3]) * 0.65)]
+    x = [
+        int(max(brain_volume[0:3]) * 0.35),
+        int(max(brain_volume[0:3]) * 0.51),
+        int(max(brain_volume[0:3]) * 0.65),
+    ]
+    y = [
+        int(max(brain_volume[0:3]) * 0.35),
+        int(max(brain_volume[0:3]) * 0.51),
+        int(max(brain_volume[0:3]) * 0.65),
+    ]
+    z = [
+        int(max(brain_volume[0:3]) * 0.35),
+        int(max(brain_volume[0:3]) * 0.51),
+        int(max(brain_volume[0:3]) * 0.65),
+    ]
     coords = (x, y, z)
-    
+
     labs = [
         "Sagittal Slice",
         "Coronal Slice",
@@ -244,34 +285,33 @@ def plot_overlays(atlas, b0, cmaps=None, minthr=2, maxthr=95, edge=False):
                 image = edge_map(image).data
                 image[image > 0] = max_val
                 image[image == 0] = min_val
-            #Set the axis invisible
+            # Set the axis invisible
             plt.xticks([])
             plt.yticks([])
-            
-            #Set the frame invisible
-            ax.spines['top'].set_visible(False)
-            ax.spines['right'].set_visible(False)
-            ax.spines['bottom'].set_visible(False)
-            ax.spines['left'].set_visible(False)
-            
+
+            # Set the frame invisible
+            ax.spines["top"].set_visible(False)
+            ax.spines["right"].set_visible(False)
+            ax.spines["bottom"].set_visible(False)
+            ax.spines["left"].set_visible(False)
+
             ax.imshow(atl, interpolation="none", cmap=cmaps[0], alpha=0.9)
             ax.imshow(
                 opaque_colorscale(
                     cmaps[1], image, alpha=0.9, vmin=min_val, vmax=max_val
                 )
             )
-            
-            #set the legend
+
+            # set the legend
             if idx == 3:
-                plt.plot(0,0,"-",c="pink",label='registered')
-                plt.plot(0,0,"-",c="green",label='reference')
-                plt.legend(loc='best',fontsize=12,bbox_to_anchor=(1.5,1.5))
-            
-    #Set title for the whole picture
-    a,b,c = brain_volume
-    title = 'QA For Registration\nVolume:'+ str(a) +'*'+ str(b) + '*' + str(c)+'\n'
-    foverlay.suptitle(title,fontsize=24)
+                plt.plot(0, 0, "-", c="pink", label="registered")
+                plt.plot(0, 0, "-", c="green", label="reference")
+                plt.legend(loc="best", fontsize=12, bbox_to_anchor=(1.5, 1.5))
+
+    # Set title for the whole picture
+    a, b, c = brain_volume
+    title = "QA For Registration\nVolume:" + str(a) + "*" + str(b) + "*" + str(c) + "\n"
+    foverlay.suptitle(title, fontsize=24)
     foverlay.set_size_inches(12.5, 10.5, forward=True)
     foverlay.tight_layout()
     return foverlay
-
diff --git a/m2g/stats/qa_skullstrip.py b/m2g/stats/qa_skullstrip.py
index 59f1eb593..404efd4a1 100644
--- a/m2g/stats/qa_skullstrip.py
+++ b/m2g/stats/qa_skullstrip.py
@@ -30,11 +30,9 @@
 from m2g.utils.gen_utils import get_filename, get_braindata
 
 
-
-
-
 def gen_overlay_pngs(
-    brain, original, outdir, loc=0, mean=False, minthr=2, maxthr=95, edge=False):
+    brain, original, outdir, loc=0, mean=False, minthr=2, maxthr=95, edge=False
+):
     """Generate a QA image for skullstrip.
     will call the function plot_overlays_skullstrip
 
@@ -73,10 +71,9 @@ def gen_overlay_pngs(
     fig.savefig(f"{outdir}/qa_skullstrip__{original_name}.png", format="png")
 
 
-
-
-
-def plot_overlays_skullstrip(brain, original, cmaps=None, minthr=2, maxthr=95, edge=False):
+def plot_overlays_skullstrip(
+    brain, original, cmaps=None, minthr=2, maxthr=95, edge=False
+):
     """Shows the skull-stripped brain (green) overlaid on the original t1w (magenta)
 
     Parameter
@@ -112,8 +109,7 @@ def plot_overlays_skullstrip(brain, original, cmaps=None, minthr=2, maxthr=95, e
     if original.shape != brain.shape:
         raise ValueError("Two files are not the same shape.")
     brain = pad_im(brain, max(brain_shape[0:3]), pad_val=0, rgb=False)
-    original = pad_im(original,max(brain_shape[0:3]), pad_val=0, rgb=False)
-
+    original = pad_im(original, max(brain_shape[0:3]), pad_val=0, rgb=False)
 
     if cmaps is None:
         cmap1 = LinearSegmentedColormap.from_list("mycmap1", ["white", "magenta"])
@@ -166,30 +162,33 @@ def plot_overlays_skullstrip(brain, original, cmaps=None, minthr=2, maxthr=95, e
             plt.yticks([])
 
             # Set the frame invisible
-            ax.spines['top'].set_visible(False)
-            ax.spines['right'].set_visible(False)
-            ax.spines['bottom'].set_visible(False)
-            ax.spines['left'].set_visible(False)
+            ax.spines["top"].set_visible(False)
+            ax.spines["right"].set_visible(False)
+            ax.spines["bottom"].set_visible(False)
+            ax.spines["left"].set_visible(False)
             ax.imshow(atl, interpolation="none", cmap=cmaps[0], alpha=0.9)
             ax.imshow(
                 opaque_colorscale(
                     cmaps[1], image, alpha=0.9, vmin=min_val, vmax=max_val
                 )
             )
-            if idx ==3:
-                plt.plot(0, 0, "-", c="magenta", label='skull')
-                plt.plot(0, 0, "-", c="green", label='brain')
+            if idx == 3:
+                plt.plot(0, 0, "-", c="magenta", label="skull")
+                plt.plot(0, 0, "-", c="green", label="brain")
                 # box = ax.get_position()
                 # ax.set_position([box.x0, box.y0, box.width, box.height*0.8])
-                plt.legend(loc='best', fontsize=15, frameon=False, bbox_to_anchor=(1.5, 1.5))
+                plt.legend(
+                    loc="best", fontsize=15, frameon=False, bbox_to_anchor=(1.5, 1.5)
+                )
 
     # Set title for the whole picture
     a, b, c = brain_shape
-    title = 'Skullstrip QA. Scan Volume : ' + str(a) + '*' + str(b) + '*' + str(c)
+    title = "Skullstrip QA. Scan Volume : " + str(a) + "*" + str(b) + "*" + str(c)
     foverlay.suptitle(title, fontsize=24)
     foverlay.set_size_inches(12.5, 10.5, forward=True)
     return foverlay
 
+
 def get_true_volume(brain_volume):
     """returns percentile dimensions to slice actual brain volume for qa_skullstrip plotting
 
@@ -208,7 +207,8 @@ def get_true_volume(brain_volume):
     z = get_range(true_volume, 2)
     return x, y, z
 
-def get_range(array,i):
+
+def get_range(array, i):
     """get percentiles of array
 
     Parameter
diff --git a/m2g/stats/qa_tensor.py b/m2g/stats/qa_tensor.py
index 41a7cd6bd..085d28733 100644
--- a/m2g/stats/qa_tensor.py
+++ b/m2g/stats/qa_tensor.py
@@ -30,20 +30,20 @@
 def generate_3_d_directions(peak_dirs, peak_values):
     """
     Generates 3-d data required for plotting directions for the entire brain volume
-    
+
     Parameters
     -----------
     peak_dirs: np array
         peak_dirs from tractography model (x,y,z directional vectors)
     peak_values: np array
         peak_values from tractography model (magnitude)
-    
+
     Returns
     -----------
     centers: np array
         cartesian coordinates
     directions: np array
-        vector directions (x,y,z) in flattened format 
+        vector directions (x,y,z) in flattened format
     directions_colors: np array
         vector directions encoded as RGB colors in flattened format
     heights: np array
@@ -80,22 +80,22 @@ def generate_3_d_directions(peak_dirs, peak_values):
 def plot_directions(peak_dirs, peak_values, x_angle, y_angle, size=(300, 300)):
     """
     Opens a 3-d fury window of the maximum peaks visualized
-    
-    To show a slice, provide a sliced volume of the peak_dirs and peak_values and adjust the x_angle and y_angle 
+
+    To show a slice, provide a sliced volume of the peak_dirs and peak_values and adjust the x_angle and y_angle
     See Tractography Directional Field QA Tutorial for examples
-    
+
     Parameters
     -----------
     peak_dirs: np array
-        peak directional vector (x,y,z)  
+        peak directional vector (x,y,z)
     peak_values: np array
-        peak values/magnitude 
+        peak values/magnitude
     x_angle: int
         angle to rotate image along x axis
     y_angle: int
         angle to rotate image along y axis
     size: tuple
-        size of fury window 
+        size of fury window
     """
     centers, directions, directions_colors, heights = generate_3_d_directions(
         peak_dirs, peak_values
@@ -114,13 +114,13 @@ def plot_directions(peak_dirs, peak_values, x_angle, y_angle, size=(300, 300)):
 def create_qa_figure(peak_dirs, peak_values, output_dir, model):
     """
     Creates a 9x9 figure of the 3-d volume and saves it
-    
+
     Parameters
     -----------
     peak_dirs: np array
         peak directional vector (x,y,z)
     peak_values: np array
-        peak values/magnitude 
+        peak values/magnitude
     output_dir: str
         location to save qa figure
     model: str
diff --git a/m2g/stats/qa_tractography.py b/m2g/stats/qa_tractography.py
index 15be504da..bb34dcab9 100644
--- a/m2g/stats/qa_tractography.py
+++ b/m2g/stats/qa_tractography.py
@@ -8,7 +8,8 @@
 from PIL import Image
 from matplotlib.colors import LinearSegmentedColormap
 
-def combine_plot(qa_out_path,brain_path):
+
+def combine_plot(qa_out_path, brain_path):
     """
     Combine the nine plots produced by qa_tractography function into one image.
 
@@ -19,57 +20,72 @@ def combine_plot(qa_out_path,brain_path):
     brain_path : str
         Path for the reference brain scan, in order to get the scan volume.
     """
-    
-    #Get the scan volume of the brain.
+
+    # Get the scan volume of the brain.
     brain_ref = nib.load(brain_path)
     brain_ref_shape = brain_ref.shape[0:3]
-    
-    plots_list = ['Rotate_Z_axis_000000.png','Rotate_Z_axis_000001.png','Rotate_Z_axis_000002.png',
-                 'Rotate_Y_axis_000000.png','Rotate_Y_axis_000001.png','Rotate_Y_axis_000002.png',
-                 'Rotate_X_axis_000000.png','Rotate_X_axis_000001.png','Rotate_X_axis_000002.png']
-    y_labels = ["Rotate with Z axis","Rotate with Y axis","Rotate with X axis"]
-    x_labels = ["angle=0","angle=120","angle=240"]
-    
-    #Temporary list to store the image nparray:
-    im_arr=[] 
-    
-    fig= plt.figure()
-    plt.title(f'QA_tractography. Scan volume = {brain_ref_shape} \n\n', fontsize=60,fontweight='bold')
+
+    plots_list = [
+        "Rotate_Z_axis_000000.png",
+        "Rotate_Z_axis_000001.png",
+        "Rotate_Z_axis_000002.png",
+        "Rotate_Y_axis_000000.png",
+        "Rotate_Y_axis_000001.png",
+        "Rotate_Y_axis_000002.png",
+        "Rotate_X_axis_000000.png",
+        "Rotate_X_axis_000001.png",
+        "Rotate_X_axis_000002.png",
+    ]
+    y_labels = ["Rotate with Z axis", "Rotate with Y axis", "Rotate with X axis"]
+    x_labels = ["angle=0", "angle=120", "angle=240"]
+
+    # Temporary list to store the image nparray:
+    im_arr = []
+
+    fig = plt.figure()
+    plt.title(
+        f"QA_tractography. Scan volume = {brain_ref_shape} \n\n",
+        fontsize=60,
+        fontweight="bold",
+    )
     plt.xticks([])
     plt.yticks([])
     plt.axis("off")
 
     j = 0
     for i in range(9):
-        #Load in the nine images into a nparray one by one.
+        # Load in the nine images into a nparray one by one.
         im_arr = np.array(Image.open(qa_out_path + "/" + plots_list[i]))
-        #Change the background of the image into black:
-        im_arr = np.where(im_arr<=0.01, 255, im_arr) 
-        ax = fig.add_subplot(3,3,i+1)
-        ax.imshow(im_arr,interpolation="none",alpha=0.9)
-        
-        #Set the X labels and Y labels
-        if i<3:
-            ax.set_title(x_labels[i],fontsize=60,fontweight='bold')
+        # Change the background of the image into black:
+        im_arr = np.where(im_arr <= 0.01, 255, im_arr)
+        ax = fig.add_subplot(3, 3, i + 1)
+        ax.imshow(im_arr, interpolation="none", alpha=0.9)
+
+        # Set the X labels and Y labels
+        if i < 3:
+            ax.set_title(x_labels[i], fontsize=60, fontweight="bold")
         if i % 3 == 0:
-            ax.set_ylabel(y_labels[j],fontsize=60,fontweight='bold')
+            ax.set_ylabel(y_labels[j], fontsize=60, fontweight="bold")
             j = j + 1
         plt.xticks([])
         plt.yticks([])
-            
-    fig.set_size_inches(40, 40, forward = True)
-    fig.savefig(qa_out_path + "/" + 'qa_tractography.png', format='png')
 
-    #Delete the Nine images which used to generate the qa_tractography.png 
+    fig.set_size_inches(40, 40, forward=True)
+    fig.savefig(qa_out_path + "/" + "qa_tractography.png", format="png")
+
+    # Delete the Nine images which used to generate the qa_tractography.png
     for plot in plots_list:
         if os.path.exists(qa_out_path + "/" + plot):
             os.remove(qa_out_path + "/" + plot)
         else:
-            print('No such file generated from streamlines window. Please check if the streamline.trk files is generated from the pipeline correctly or not')
+            print(
+                "No such file generated from streamlines window. Please check if the streamline.trk files is generated from the pipeline correctly or not"
+            )
 
-def qa_tractography(stream_path,qa_out_path,brain_path):
+
+def qa_tractography(stream_path, qa_out_path, brain_path):
     """
-    Visualize the streamlines, 
+    Visualize the streamlines,
     then using window.record to get nine snapshots of the 3D streamslines.
 
     Parameters
@@ -81,11 +97,11 @@ def qa_tractography(stream_path,qa_out_path,brain_path):
     brain_path : str
         Path for the reference brain scan, in order to get the scan volume.
     """
-    
-    #Use window to visualize the streamlines
+
+    # Use window to visualize the streamlines
     r = window.renderer()
-    
-    #Load the streamline.trk file
+
+    # Load the streamline.trk file
     streamlines_mni_load = nib.streamlines.load(stream_path).streamlines
     streamlines_mni_in = Streamlines(streamlines_mni_load)
     streamlines_actor = actor.line(
@@ -97,14 +113,44 @@ def qa_tractography(stream_path,qa_out_path,brain_path):
         fake_tube=True,
         opacity=0.3,
     )
-    
+
     r.add(streamlines_actor)
-    #window.show(r)
-        
+    # window.show(r)
+
     showmng = window.ShowManager(r)
-    #window.record function can rotate the 3D-image, then get the snapshot of the specific angle. 
-    window.record(r,cam_pos = (70.03, 64.97, 269.80), cam_view = (0,1,0),path_numbering= True,out_path = qa_out_path + '/Rotate_Z_axis_', az_ang=120,n_frames=3,reset_camera=True,size=(600,600))
-    window.record(r,cam_pos = (70.03, 64.97, 269.80), cam_view = (1,0,0),path_numbering= True,out_path = qa_out_path + '/Rotate_Y_axis_', az_ang=120,n_frames=3,reset_camera=True,size=(600,600))
-    window.record(r,cam_pos = (70.03, 64.97, 269.80), cam_view = (0,0,1),path_numbering= True,out_path = qa_out_path + '/Rotate_X_axis_', az_ang=120,n_frames=3,reset_camera=True,size=(600,600))
+    # window.record function can rotate the 3D-image, then get the snapshot of the specific angle.
+    window.record(
+        r,
+        cam_pos=(70.03, 64.97, 269.80),
+        cam_view=(0, 1, 0),
+        path_numbering=True,
+        out_path=qa_out_path + "/Rotate_Z_axis_",
+        az_ang=120,
+        n_frames=3,
+        reset_camera=True,
+        size=(600, 600),
+    )
+    window.record(
+        r,
+        cam_pos=(70.03, 64.97, 269.80),
+        cam_view=(1, 0, 0),
+        path_numbering=True,
+        out_path=qa_out_path + "/Rotate_Y_axis_",
+        az_ang=120,
+        n_frames=3,
+        reset_camera=True,
+        size=(600, 600),
+    )
+    window.record(
+        r,
+        cam_pos=(70.03, 64.97, 269.80),
+        cam_view=(0, 0, 1),
+        path_numbering=True,
+        out_path=qa_out_path + "/Rotate_X_axis_",
+        az_ang=120,
+        n_frames=3,
+        reset_camera=True,
+        size=(600, 600),
+    )
     showmng.exit()
-    combine_plot(qa_out_path,brain_path)
\ No newline at end of file
+    combine_plot(qa_out_path, brain_path)
diff --git a/m2g/track.py b/m2g/track.py
index f622e8535..395bf2aad 100644
--- a/m2g/track.py
+++ b/m2g/track.py
@@ -150,7 +150,7 @@ def __init__(
         mod_func : str
             Diffusion model: csd or csa
         qa_tensor: str
-            path to store the qa for tensor/directions of model 
+            path to store the qa for tensor/directions of model
         seeds : ndarray
             ndarray of seeds for tractography
         stream_affine : ndarray
diff --git a/m2g/utils/cloud_utils.py b/m2g/utils/cloud_utils.py
index deb118ede..bd1fb4be5 100644
--- a/m2g/utils/cloud_utils.py
+++ b/m2g/utils/cloud_utils.py
@@ -68,13 +68,13 @@ def s3_client(service="s3"):
 def parse_path(s3_datapath):
     """
     Return bucket and prefix from full s3 path.
-    
+
     Parameters
     ----------
     s3_datapath : str
-        path to a bucket. 
+        path to a bucket.
         Should be of the form s3://bucket/prefix/.
-    
+
     Returns
     -------
     tuple
@@ -117,7 +117,9 @@ def get_matching_s3_objects(bucket, prefix="", suffix=""):
         try:
             contents = resp["Contents"]
         except KeyError:
-            print("No contents found. Check that both the path to your files on your s3 bucket and your aws credentials are correct.")
+            print(
+                "No contents found. Check that both the path to your files on your s3 bucket and your aws credentials are correct."
+            )
             return
 
         for obj in contents:
diff --git a/m2g/utils/gen_utils.py b/m2g/utils/gen_utils.py
index 8a1d13297..fcd57a112 100644
--- a/m2g/utils/gen_utils.py
+++ b/m2g/utils/gen_utils.py
@@ -37,13 +37,13 @@
 class DirectorySweeper:
     """
     Class for parsing through a BIDs-formatted directory tree.
-    
+
     Parameters
     ----------
     bdir : str
         BIDs-formatted directory containing dwi data.
     subjects : list or str, optional
-        The subjects to run m2g on. 
+        The subjects to run m2g on.
         If None, parse through the whole directory.
     sessions : list or str, optional
         The sessions to run m2g with.
@@ -52,7 +52,7 @@ class DirectorySweeper:
         The pipeline you are using, 'func' or 'dwi', default is 'dwi'
     """
 
-    def __init__(self, bdir, subjects=None, sessions=None, pipeline='dwi'):
+    def __init__(self, bdir, subjects=None, sessions=None, pipeline="dwi"):
         self.bdir = bdir
         self.layout = bids.BIDSLayout(bdir)
         if subjects is None:
@@ -61,15 +61,17 @@ def __init__(self, bdir, subjects=None, sessions=None, pipeline='dwi'):
             sessions = self.layout.get_sessions()
 
         # get list of subject / session pairs
-        self.pairs = self.get_pairs(subjects=subjects, sessions=sessions, pipeline=pipeline)
+        self.pairs = self.get_pairs(
+            subjects=subjects, sessions=sessions, pipeline=pipeline
+        )
 
     def __repr__(self):
         return str(self.layout)
 
-    def get_pairs(self, subjects, sessions, pipeline='dwi'):
+    def get_pairs(self, subjects, sessions, pipeline="dwi"):
         """
         Return subject/session pairs.
-        
+
         Parameters
         ----------
         subjects : str or list
@@ -78,7 +80,7 @@ def get_pairs(self, subjects, sessions, pipeline='dwi'):
             Sessions to retrieve.
         pipeline : str, optional
         The pipeline you are using, 'func' or 'dwi', default is 'dwi'
-        
+
         Returns
         -------
         list
@@ -87,9 +89,9 @@ def get_pairs(self, subjects, sessions, pipeline='dwi'):
         """
         pairs = []
         # Change suffix to be 'bold' because prefixes aren't a thing
-        if pipeline == 'func':
-            pipeline='bold'
-        
+        if pipeline == "func":
+            pipeline = "bold"
+
         kwargs = dict(
             suffix=pipeline,
             extension=["nii", "nii.gz"],
@@ -105,10 +107,10 @@ def get_pairs(self, subjects, sessions, pipeline='dwi'):
             raise ValueError(f"No pairs found for {self}")
         return pairs
 
-    def get_files(self, subject, session, pipeline='dwi'):
+    def get_files(self, subject, session, pipeline="dwi"):
         """
         Retrieve all relevant files from a dataframe.
-        
+
         Parameters
         ----------
         subject : str
@@ -117,27 +119,40 @@ def get_files(self, subject, session, pipeline='dwi'):
             Session to get files for.
         pipeline : str, optional
         The pipeline you are using, 'func' or 'dwi', default is 'dwi'
-        
+
         Returns
         -------
         dict
             Dictionary of all files from a single session.
         """
 
-        if pipeline == 'func':
-            func = self.layout.get(return_type='filename', session=session, subject=subject, suffix='bold')
-            if len(func) == 1: #TODO:Account for one or multiple functional scans per anatomical image
+        if pipeline == "func":
+            func = self.layout.get(
+                return_type="filename", session=session, subject=subject, suffix="bold"
+            )
+            if (
+                len(func) == 1
+            ):  # TODO:Account for one or multiple functional scans per anatomical image
                 [func] = func
-            [anat] = self.layout.get(return_type="filename", session=session, subject=subject, suffix=['T1w','t1w'])
+            [anat] = self.layout.get(
+                return_type="filename",
+                session=session,
+                subject=subject,
+                suffix=["T1w", "t1w"],
+            )
             files = {"func": func, "t1w": anat}
-        else:#TODO: allow for more than one dwi scan to exist in the dwi directory for processing
-            bval, bvec, dwi = self.layout.get(return_type="filename", session=session, subject=subject, suffix='dwi')
-            [anat] = self.layout.get(return_type="filename", session=session, subject=subject, suffix='T1w')
+        else:  # TODO: allow for more than one dwi scan to exist in the dwi directory for processing
+            bval, bvec, dwi = self.layout.get(
+                return_type="filename", session=session, subject=subject, suffix="dwi"
+            )
+            [anat] = self.layout.get(
+                return_type="filename", session=session, subject=subject, suffix="T1w"
+            )
             files = {"dwi": dwi, "bvals": bval, "bvecs": bvec, "t1w": anat}
 
         return files
 
-    def get_dir_info(self, pipeline='dwi'):
+    def get_dir_info(self, pipeline="dwi"):
         """
         Parse an entire BIDSLayout for scan parameters.
 
@@ -145,11 +160,11 @@ def get_dir_info(self, pipeline='dwi'):
         ----------
         pipeline : str, optional
         The pipeline you are using, 'func' or 'dwi', default is 'dwi'
-        
+
         Returns
         -------
         list
-            List of SubSesFiles namedtuples. 
+            List of SubSesFiles namedtuples.
             SubSesFile.files is a dictionary of files.
             SubSesFile.subject is the subject string.
             SubSesFile.session is the session string.
@@ -158,7 +173,7 @@ def get_dir_info(self, pipeline='dwi'):
         scans = []
         SubSesFiles = namedtuple("SubSesFiles", ["subject", "session", "files"])
 
-        #remove duplicate subject/session pairs for either 
+        # remove duplicate subject/session pairs for either
         self.pairs = list(set(self.pairs))
         # append subject, session, and files for each relevant session to scans
         for subject, session in self.pairs:
@@ -177,10 +192,10 @@ def get_dir_info(self, pipeline='dwi'):
         return scans
 
 
-def make_initial_directories(outdir: Path, dwi:Path, parcellations=[]) -> None:
+def make_initial_directories(outdir: Path, dwi: Path, parcellations=[]) -> None:
     """
     Make starting directory tree.
-    
+
     Parameters
     ----------
     outdir : Path
@@ -190,7 +205,7 @@ def make_initial_directories(outdir: Path, dwi:Path, parcellations=[]) -> None:
     parcellations : list, optional
         Set of all parcellations we're using, by default []
     """
-    
+
     # populate connectome_dir with folder for each parcellation
     connectome_dirs = []
     for parc in parcellations:
@@ -198,30 +213,33 @@ def make_initial_directories(outdir: Path, dwi:Path, parcellations=[]) -> None:
         p = str(f"connectomes_d/{name}")
         connectome_dirs.append(p)
 
-    init_dirs = {'anat_dirs':["anat_d/preproc", "anat_d/registered"],
-    'dwi_dirs':["dwi/fiber", "dwi/preproc", "dwi/tensor"],
-    'qa_dirs':["qa_d/adjacency",
-        "qa_d/fibers",
-        "qa_d/graphs",
-        "qa_d/graphs_plotting",
-        "qa_d/mri",
-        "qa_d/reg",
-        "qa_d/tensor",],
-    'tmp_dirs':["tmp_d/reg_a", "tmp_d/reg_m"],
-    "connectome_dirs":connectome_dirs,
-    "connectomes":[]}
-
+    init_dirs = {
+        "anat_dirs": ["anat_d/preproc", "anat_d/registered"],
+        "dwi_dirs": ["dwi/fiber", "dwi/preproc", "dwi/tensor"],
+        "qa_dirs": [
+            "qa_d/adjacency",
+            "qa_d/fibers",
+            "qa_d/graphs",
+            "qa_d/graphs_plotting",
+            "qa_d/mri",
+            "qa_d/reg",
+            "qa_d/tensor",
+        ],
+        "tmp_dirs": ["tmp_d/reg_a", "tmp_d/reg_m"],
+        "connectome_dirs": connectome_dirs,
+        "connectomes": [],
+    }
 
     # create directories
     for cat in init_dirs:
-        replace=[]
+        replace = []
         for p in init_dirs[cat]:
             full_path = outdir / p
             full_path.mkdir(parents=True, exist_ok=True)
             replace.append(full_path)
         init_dirs[cat] = replace
 
-    init_dirs['outdir'] = outdir
+    init_dirs["outdir"] = outdir
 
     # generate list of connectome file locations
     dwi_name = get_filename(dwi)
@@ -232,7 +250,7 @@ def make_initial_directories(outdir: Path, dwi:Path, parcellations=[]) -> None:
         connectome = f"{dwi_name}_{name}_connectome.csv"
         connectomes.append(str(folder / connectome))
 
-    init_dirs['connectomes'] = connectomes
+    init_dirs["connectomes"] = connectomes
 
     return init_dirs
 
@@ -248,14 +266,14 @@ def has_files(dirname: Path):
 def as_directory(dir_, remove=False, return_as_path=False):
     """
     Convenience function to make a directory while returning it.
-    
+
     Parameters
     ----------
     dir_ : str, Path
         File location to directory.
     remove : bool, optional
         Whether to remove a previously existing directory, by default False
-    
+
     Returns
     -------
     str
@@ -326,7 +344,7 @@ def print_arguments(inputs=[], outputs=[]):
     ----------
     inputs : List[int]
         Set of integer locations of file inputs to functions.
-    
+
     outputs : List[int]
         Set of integer locations of locations of file outputs generated by functions.
 
@@ -390,12 +408,12 @@ def is_bids(input_dir):
     """
     Make sure that the input data is BIDs-formatted.
     If it's BIDs-formatted, except for a `dataset_description.json` file, return True.
-    
+
     Returns
     -------
     bool
         True if the input directory is BIDs-formatted
-    
+
     Raises
     ------
     ValueError
@@ -415,7 +433,7 @@ def is_bids(input_dir):
 def create_datadescript(input_dir):
     """
     Creates a simple `data_description.json` file in the root of the input directory. Necessary for proper BIDs formatting.
-    
+
     Parameters
     ----------
     input_dir : str
@@ -477,7 +495,7 @@ def run(cmd):
     Print the command.
     Execute a command string on the shell (on bash).
     Exists so that the shell prints out commands as m2g calls them.
-    
+
     Parameters
     ----------
     cmd : str
@@ -673,7 +691,7 @@ def make_gtab_and_bmask(fbval: str, fbvec: str, dwi_file: str, preproc_dir: Path
 
 
 def normalize_xform(img):
-    """ Set identical, valid qform and sform matrices in an image
+    """Set identical, valid qform and sform matrices in an image
     Selects the best available affine (sform > qform > shape-based), and
     coerces it to be qform-compatible (no shears).
     The resulting image represents this same affine as both qform and sform,
@@ -826,7 +844,7 @@ def match_target_vox_res(img_file: str, vox_size, outdir: Path, sens):
         path to file to be resliced
     vox_size : str
         target voxel resolution ('4mm', '2mm', or '1mm')
-    preproc_dir : 
+    preproc_dir :
     sens : str
         type of data being analyzed ('dwi' or 'anat')
 
diff --git a/m2g/utils/qa_utils.py b/m2g/utils/qa_utils.py
index 8bb8ad48b..68674f7d5 100644
--- a/m2g/utils/qa_utils.py
+++ b/m2g/utils/qa_utils.py
@@ -8,6 +8,7 @@
 
 import numpy as np
 
+
 def get_min_max(data, minthr=2, maxthr=95):
     """
     A function to find min,max values at designated percentile thresholds
@@ -16,10 +17,10 @@ def get_min_max(data, minthr=2, maxthr=95):
     data: np array
         3-d regmri data to threshold.
     minthr: int
-        lower percentile threshold 
+        lower percentile threshold
     maxthr: int
         upper percentile threshold
-    
+
     Returns
     -----------
     min_max: tuple
@@ -27,21 +28,22 @@ def get_min_max(data, minthr=2, maxthr=95):
     """
     min_val = np.percentile(data, minthr)
     max_val = np.percentile(data, maxthr)
-    
+
     min_max = (min_val.astype(float), max_val.astype(float))
     return min_max
 
+
 def opaque_colorscale(basemap, reference, vmin=None, vmax=None, alpha=1):
     """
     A function to return a colorscale, with opacities
     dependent on reference intensities.
-    
+
     Parameters
     ---------
     basemap: matplotlib colormap
         the colormap to use for this colorscale.
     reference: np array
-        the reference matrix.        
+        the reference matrix.
     Returns
     ---------
     cmap = matplotlib colormap
@@ -50,22 +52,23 @@ def opaque_colorscale(basemap, reference, vmin=None, vmax=None, alpha=1):
         reference[reference > vmax] = vmax
     if vmax is not None:
         reference[reference < vmin] = vmin
-        
+
     cmap = basemap(reference)
     maxval = np.nanmax(reference)
-    
+
     # all values beteween 0 opacity and 1
     opaque_scale = alpha * reference / float(maxval)
-    
+
     # remaps intensities
     cmap[:, :, 3] = opaque_scale
-    
+
     return cmap
 
-def pad_im(image,max_dim,pad_val=255,rgb=False):
+
+def pad_im(image, max_dim, pad_val=255, rgb=False):
     """
     Pads an image to be same dimensions as given max_dim
-    
+
     Parameters
     -----------
     image: np array
@@ -73,7 +76,7 @@ def pad_im(image,max_dim,pad_val=255,rgb=False):
     max_dim: int
         dimension to pad up to
     pad_val: int
-        value to pad with. default is 255 (white) background  
+        value to pad with. default is 255 (white) background
     rgb: boolean
         flag to indicate if RGB and last dimension should not be padded
     Returns
@@ -83,11 +86,15 @@ def pad_im(image,max_dim,pad_val=255,rgb=False):
     """
     pad_width = []
     for i in range(image.ndim):
-        pad_width.append(((max_dim-image.shape[i])//2,(max_dim-image.shape[i])//2))
+        pad_width.append(
+            ((max_dim - image.shape[i]) // 2, (max_dim - image.shape[i]) // 2)
+        )
     if rgb:
-        pad_width[-1] = (0,0)
-        
-    pad_width = tuple(pad_width)   
-    padded_image = np.pad(image, pad_width=pad_width, mode='constant', constant_values=pad_val)
-    
-    return padded_image
\ No newline at end of file
+        pad_width[-1] = (0, 0)
+
+    pad_width = tuple(pad_width)
+    padded_image = np.pad(
+        image, pad_width=pad_width, mode="constant", constant_values=pad_val
+    )
+
+    return padded_image
diff --git a/m2g/utils/reg_utils.py b/m2g/utils/reg_utils.py
index 6629d8dc7..ffd6d722a 100644
--- a/m2g/utils/reg_utils.py
+++ b/m2g/utils/reg_utils.py
@@ -249,8 +249,9 @@ def skullstrip_check(dmrireg, parcellations, outdir, prep_anat, vox_size, reg_st
         num2 = len(np.unique(n_ids_2))
 
         if num != num2:
-            print('''WARNING: The atlas has lost an roi due to alignment! A file containing the lost ROI values will be generated in the
-            same folder as the connectome output. Try rerunning m2g with the appropriate --skull flag.'''
+            print(
+                """WARNING: The atlas has lost an roi due to alignment! A file containing the lost ROI values will be generated in the
+            same folder as the connectome output. Try rerunning m2g with the appropriate --skull flag."""
             )
 
         labels_im_file_list.append(labels_im_file_dwi)