oceanproc 0.1.0__py3-none-any.whl

oceanproc/firstlevel/tests/test_run_glm.py

@@ -0,0 +1,165 @@
+import random
+import re
+import itertools
+from ..run_glm import *
+import pytest
+import pandas as pd
+import numpy as np
+from scipy import signal
+
+TR = 1.2
+
+# define some fixtures
+@pytest.fixture
+def confounds_df():
+    df = pd.DataFrame(data={"framewise_displacement": np.random.rand(50), 
+                            "global_signal": np.random.rand(50) * 5000,
+                            "volterra": np.ones(50)}) 
+    return df
+
+
+@pytest.fixture
+def confounds_columns(confounds_df):
+    cols = [col for col in confounds_df.columns if "volterra" not in col]
+    return cols
+
+
+@pytest.fixture
+def random_fdata():
+    return np.random.rand(50, 91282)
+
+
+@pytest.fixture
+def random_eventdf():
+    d = {"trial_type": random.choices(('a','b','c'), k=50), #<-- 50 random a, b, or c
+         "onset": np.linspace(0, 60, 50), #<-- 50 intervals of 1.2 seconds}
+         "duration": np.ones(50)} #<-- 50 random correct, incorrect
+    return pd.DataFrame(data=d)
+
+@pytest.fixture
+def random_signaldf():
+    d = {"flat_signal": np.ones(50) * 50, 
+         "random_signal": np.random.rand(50) * 50,
+         "sine_signal": np.sin(np.linspace(-np.pi, np.pi, 50))}
+    return pd.DataFrame(data=d)
+
+def test_make_option():
+    assert make_option(True) == " "
+    assert make_option(True, key="myopt") == "--myopt "
+    assert make_option(['1','2','3']) == " 1 2 3"
+    assert make_option("hello") == " hello"
+    assert make_option("hello", key="myopt") == "--myopt hello"
+
+
+@pytest.mark.parametrize("demean,linear_trend,spike_threshold,volterra_expansion,volterra_columns",
+                         [(False, False, None, None, None),
+                          (True, False, None, None, None),
+                          (False, True, None, None, None),
+                          (True, True, None, None, None),
+                          (True, True, 0.5, None, None),
+                          (True, True, 0.5, 1, ["volterra"]),
+                          (True, True, 0.5, 3, ["volterra"])])
+def test_make_noise_ts(tmp_path,
+                       confounds_df,
+                       confounds_columns,
+                       demean,
+                       linear_trend,
+                       spike_threshold,
+                       volterra_expansion,
+                       volterra_columns):
+    confounds_file = tmp_path / "tmp.tsv"
+    confounds_df.to_csv(confounds_file, sep='\t')
+    noise_ts = make_noise_ts(confounds_file,
+                       confounds_columns,
+                       demean,
+                       linear_trend,
+                       spike_threshold,
+                       volterra_expansion,
+                       volterra_columns)
+    if spike_threshold:
+        assert spike_threshold > 0
+        spike_column_num = (noise_ts.loc[:, "framewise_displacement"] > spike_threshold).sum()
+        assert len([col for col in noise_ts.columns if "spike" in col]) == spike_column_num
+       
+    assert "volterra_expansion" in locals() and "volterra_columns" in locals()
+    if volterra_expansion:
+        for i in range(volterra_expansion):
+            # Check that each volterra column has been shifted appropriately
+            assert (noise_ts.loc[0:i, f"volterra_{i+1}"] == 0).all()
+
+@pytest.mark.parametrize("fir,hrf,fir_list,hrf_list",
+                         [(None, None, None, None),
+                          (3, None, ['a', 'b'], None),
+                          (3, None, None, None),
+                          (3, (5, 10), None, None),
+                          (3, (5, 10), ['a','b'], None),
+                          (3, (5, 10), None, ['a','b']),
+                          (3, (5, 10), ['a','b'], ['a','b'])])
+def test_events_to_design(tmp_path, 
+                          random_fdata, 
+                          random_eventdf,
+                          fir,
+                          hrf,
+                          fir_list,
+                          hrf_list):
+    def run(): 
+        return events_to_design(func_data,
+                                TR,
+                                event_file,
+                                fir=fir,
+                                hrf=hrf,
+                                fir_list=fir_list,
+                                hrf_list=hrf_list)
+    func_data = random_fdata
+    event_file = tmp_path / "events.tsv"
+    random_eventdf.to_csv(event_file, sep='\t')
+    # both fir and hrf specified, but no list of columns for either
+    if (fir and hrf) and not (fir_list or hrf_list): 
+        with pytest.raises(RuntimeError):
+            events_df, run_conditions = run()
+        return
+    # fir_list, hrf_list have overlapping column names
+    elif (fir_list and hrf_list) and not set(fir_list).isdisjoint(hrf_list): 
+        with pytest.raises(RuntimeError):
+            events_df, run_conditions = run()
+        return
+    events_df, run_conditions = run()
+    if fir_list: # Check if a_00, a_01, ... a_nn exist, and if the number of a columns matches the fir int
+        pattern = re.compile(f"{fir_list[0]}_\\d\\d")
+        assert len([col for col in events_df.columns if re.match(pattern, col)]) == fir
+
+
+@pytest.mark.parametrize("demean,linear_trend,spike_threshold,volterra_expansion,volterra_columns",
+                         [(False, False, None, None, None),
+                          (True, False, None, None, None),
+                          (False, True, None, None, None),
+                          (True, True, None, None, None),
+                          (True, True, 0.5, None, None),
+                          (True, True, 0.5, 1, ["volterra"]),
+                          (True, True, 0.5, 3, ["volterra"])])
+def test_nuisance_regression(tmp_path,
+                             confounds_df,
+                             confounds_columns,
+                             random_fdata,
+                             demean,
+                             linear_trend,
+                             spike_threshold,
+                             volterra_expansion,
+                             volterra_columns):
+    confounds_file = tmp_path / "tmp.tsv"
+    confounds_df.to_csv(confounds_file, sep='\t')
+    noise_ts = make_noise_ts(confounds_file,
+                       confounds_columns,
+                       demean,
+                       linear_trend,
+                       spike_threshold,
+                       volterra_expansion,
+                       volterra_columns)
+    data_minus_residuals = nuisance_regression(random_fdata, noise_ts)
+     
+
+# def test_hrf_convolve_features(tmp_path, 
+                               # random_signaldf):
+    # cfeats = hrf_convolve_features(random_signaldf)
+    # for col in random_signaldf.columns:
+        # recovered, remainder = signal.deconvolve(cfeats[col], )

oceanproc/fmriprep_wrapper.py

@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+
+from pathlib import Path
+import logging
+from .utils import exit_program_early, make_option, prepare_subprocess_logging, flags, debug_logging, log_linebreak
+import shlex
+import shutil
+from subprocess import Popen, PIPE
+from matplotlib import pyplot as plt
+from bs4 import BeautifulSoup as bsoup
+from pathlib import Path
+import pandas as pd
+import numpy as np
+import json
+import os
+import copy
+
+logger = logging.getLogger(__name__)
+plt.set_loglevel("warning")
+
+@debug_logging
+def run_fmri_prep(subject:str,
+                  bids_path:Path,
+                  derivs_path:Path,
+                  option_chain:str,
+                  remove_work_folder:Path=None):
+    """
+    Run fmriprep with parameters.
+
+    :param subject: Name of subject (ex. if path contains 'sub-5000', subject='5000')
+    :type subject: str
+    :param bids_path: Path to BIDS-compliant raw data folder.
+    :type bids_path: pathlib.Path
+    :param derivs_path: Path to BIDS-compliant derivatives folder.
+    :type derivs_path: pathlib.Path
+    :param option_chain: String containing generated list of options built by make_option().
+    :type option_chain: str
+    :param remove_work_folder: Path to the working directory that will be deleted upon completion or error (default None)
+    :type remove_work_folder: str
+    :raise RuntimeError: If fmriprep throws an error, or exits with a non-zero exit code.
+    """
+    clean_up = lambda : shutil.rmtree(remove_work_folder) if remove_work_folder else None
+
+    log_linebreak()
+    logger.info("####### Starting fMRIPrep #######\n")
+    if not bids_path.exists():
+        exit_program_early(f"Bids path {bids_path} does not exist.")
+    elif not derivs_path.exists():
+        exit_program_early(f"Derivatives path {derivs_path} does not exist.")
+    elif shutil.which('fmriprep-docker') == None:
+        exit_program_early("Cannot locate program 'fmriprep-docker', make sure it is in your PATH.")
+
+    
+
+    uid = Popen(["id", "-u"], stdout=PIPE).stdout.read().decode("utf-8").strip()
+    gid = Popen(["id", "-g"], stdout=PIPE).stdout.read().decode("utf-8").strip()
+    cifti_out_res = '91k'
+
+    helper_command = shlex.split(f"""{shutil.which('fmriprep-docker')} 
+                                 --user {uid}:{gid}
+                                 --participant-label={subject}
+                                 --cifti-output={cifti_out_res}
+                                 --use-syn-sdc=warn
+                                 {option_chain}
+                                 {str(bids_path)}
+                                 {str(derivs_path)}
+                                 participant""")
+    try:
+        command_str = " ".join(helper_command)
+        logger.info(f"Running fmriprep-docker with the following command: \n  {command_str} \n")
+        prepare_subprocess_logging(logger)
+        with Popen(helper_command, stdout=PIPE) as p:
+            while p.poll() == None:
+                for line in p.stdout:
+                    logger.info(line.decode("utf-8", "ignore"))
+            prepare_subprocess_logging(logger, stop=True)
+            p.kill()
+            if p.poll() != 0:
+                raise RuntimeError("'fmriprep-docker' has ended with a non-zero exit code.")
+    except RuntimeError as e:
+        prepare_subprocess_logging(logger, stop=True)
+        logger.exception(e, stack_info=True) 
+        exit_program_early("Program 'fmriprep-docker' has run into an error.", 
+                           None if flags.debug else clean_up)
+    if not flags.debug:
+        clean_up()
+
+
+@debug_logging
+def add_fd_plot_to_report(subject:str,
+                          session:str,
+                          derivs_path:Path):
+    """
+    Reads each confounds file in the fmriprep functional output, plots the framewise
+    displacement, and adds this figure into the output report
+
+    :param subject: Name of subject (ex. if path contains 'sub-5000', subject='5000')
+    :type subject: str
+    :param session: Session name (ex. 'ses-01', session would be '01')
+    :type session: str
+    :param derivs_path: Path to BIDS-compliant derivatives folder.
+    :type derivs_path: pathlib.Path
+    """
+    
+    func_path = derivs_path / f"sub-{subject}" / f"ses-{session}" / "func"
+    figures_path = derivs_path / f"sub-{subject}" / "figures"
+    report_path = derivs_path / f"sub-{subject}.html"
+
+    for p in [func_path, figures_path, report_path]:
+        if not p.exists():
+            exit_program_early(f"Expected Path {str(p)} does not exist.")
+    
+    log_linebreak()
+    logger.info("####### Appending FD Plots to fMRIPrep Report #######\n")
+
+    logger.debug(f"parsing the fMRIPrep html report file: {report_path}")
+    report_file = open(report_path, "r")
+    soup = bsoup(report_file.read(), 'html.parser')
+    report_file.close()
+
+    for f in func_path.glob("*desc-confounds_timeseries.tsv"): 
+        logger.info(f"plotting framewise displacement from confounds file:{f}")
+        try :                                                                                                    
+            run = f.name.split("run-")[-1].split("_")[0]  
+            task = f.name.split("task-")[-1].split("_")[0]  
+
+            # read the repetition time from the json files for the BOLD data                                                                                               
+            bold_js = list(f.parent.glob(f"*task-{task}*run-{run}*bold.json"))[0] 
+            logger.debug(f" reading repetition time from JSON file: {bold_js}")                                                              
+            tr = None                                                                                                                       
+            with open(bold_js, "r") as jf: 
+                tr = float(json.load(jf)["RepetitionTime"])
+
+            # read in the confounds file 
+            confound_df = pd.read_csv(f, sep="\t")
+            n_frames = len(confound_df["framewise_displacement"])
+            x_vals = np.arange(0, n_frames*tr, tr)
+            mean_fd = np.mean(confound_df["framewise_displacement"])
+            func_thresh = 0.9
+            rest_thresh = 0.2
+
+            # plot the framewise displacement
+            fig, ax = plt.subplots(1,1, figsize=(15,5))
+            # ax.set_ylabel("Displacement (mm)")
+            ax.set_xlabel("Time (sec)")
+            ax.plot(x_vals, confound_df["framewise_displacement"], label="FD Trace")                    
+            ax.plot(x_vals, [func_thresh]*n_frames, label=f"Threshold: {func_thresh}")
+            ax.plot(x_vals, [rest_thresh]*n_frames, label=f"Threshold: {rest_thresh}")
+            ax.plot(x_vals, [mean_fd]*n_frames, label=f"Mean: {round(mean_fd,2)}")         
+            ax.set_xlim(0, (n_frames*tr))                                                                              
+            ax.set_ylim(0, 1.5)
+            ax.legend(loc="upper left")
+            plot_path = figures_path / f"sub-{subject}_ses-{session}_task-{task}_run-{run}_desc-fd-trace.svg"
+            fig.savefig(plot_path, bbox_inches="tight", format="svg", pad_inches=0.2)
+            logger.debug(f" saved the fd plot figure for run-{run} to path: {plot_path}")
+
+            # find the location in the report where the new figure will go
+            confounds_plot_div = soup.find(id=lambda x: (f"desc-carpetplot_run-{run}" in x) if x else False)
+
+            # Copy a div element from the report and add the new figure into it 
+            fd_plot_div = copy.copy(confounds_plot_div)
+            del fd_plot_div["id"]
+            fd_plot_div.p.extract()
+            fd_plot_div.h3.string = "Scaled FD Plot"
+            rel_path = os.path.relpath(plot_path, derivs_path)
+            fd_plot_div.img["src"] = "./" + rel_path
+
+            # find the reference div for the copied div element and make a copy of this as well
+            confounds_plot_reference_div = confounds_plot_div.find_next_sibling("div", class_="elem-filename")
+
+            fd_plot_reference_div = copy.copy(confounds_plot_reference_div)
+            fd_plot_reference_div.a["href"] = "./" + rel_path
+            fd_plot_reference_div.a.string = rel_path
+
+            # Add the new elements into the file
+            logger.debug(f" inserting the new html elements into the fMRIPrep report")
+            confounds_plot_reference_div.insert_after(fd_plot_div)
+            fd_plot_div.insert_after(fd_plot_reference_div)
+        except Exception as e:
+            logger.warning(f"Error generating the scaled FD plot for confound file: {f}")
+
+    logger.info("writing the edited html to the report file")
+    with open(report_path, "w") as f:
+        f.write(soup.prettify())
+
+
+@debug_logging
+def process_data(subject:str,
+                 session:str,
+                 bids_path:Path,
+                 derivs_path:Path,
+                 remove_work_folder:Path=None,
+                 **kwargs):
+    """
+    Faciliates the running of fmriprep and any additions to the output report.
+
+    :param subject: Name of subject (ex. if path contains 'sub-5000', subject='5000')
+    :type subject: str
+    :param session: Session name (ex. 'ses-01', session would be '01')
+    :type session: str
+    :param bids_path: Path to BIDS-compliant raw data folder.
+    :type bids_path: pathlib.Path
+    :param derivs_path: Path to BIDS-compliant derivatives folder.
+    :type derivs_path: pathlib.Path
+    :param remove_work_folder: Path to the working directory that will be deleted upon completion or error (default None)
+    :type remove_work_folder: str
+    :param **kwargs: any arguments to be passed to the fmriprep subprocess
+    """
+
+    fmriprep_option_chain = " ".join([make_option(v, key=k, delimeter="=", convert_underscore=True) for k,v in kwargs.items()])
+    
+    run_fmri_prep(subject=subject,
+                  bids_path=bids_path,
+                  derivs_path=derivs_path,
+                  option_chain=fmriprep_option_chain,
+                  remove_work_folder=remove_work_folder)
+    
+    add_fd_plot_to_report(subject=subject,
+                          session=session,
+                          derivs_path=derivs_path)
+    
+

oceanproc/group_series.py

@@ -0,0 +1,228 @@
+#!/usr/bin/env python3
+
+import glob
+import json
+import os
+from datetime import datetime
+from collections import defaultdict
+import argparse
+import re
+from pathlib import Path
+import xml.etree.ElementTree as et
+from .utils import exit_program_early, debug_logging, log_linebreak
+import logging
+
+logger = logging.getLogger(__name__)
+
+@debug_logging
+def get_locals_from_xml(xml_path: Path) -> set:
+    """
+    Read in the xml file to find the localizers.
+
+    :param xml_path: Path to XML generated by XNAT
+    :type xml_path: pathlib.Path
+    :return: Set containing all localizer IDs
+    :rtype: set
+    """
+    tree = et.parse(xml_path)
+    prefix = "{" + str(tree.getroot()).split("{")[-1].split("}")[0] + "}"
+    scan_element_list = list(tree.iter(f"{prefix}scans"))
+    
+    if len(scan_element_list) != 1:
+        exit_program_early(f"Error parsing the xml file provided. Found none or more than one scan groups")
+    
+    scans = scan_element_list[0]
+    
+    localizers = set()
+    for s in scans:
+        if re.match(r"Localizer.*", s.get("type")) and s.find(f'{prefix}quality').text == "usable":
+            localizers.add(int(s.get("ID")))
+    return sorted(localizers)
+
+
+@debug_logging
+def get_func_from_bids(bids_path: Path,
+                       localizers: set[int],
+                       json_dict: defaultdict[list],
+                       groupings: list[dict[str:set]]):
+    """
+    Read in the JSON associated with task-based runs from the bids dir, and pair with a localizer run.
+
+    :param bids_path: path to BIDS-compliant .nii/.json files
+    :type bids_path: pathlib.Path
+    :param localizers: set of localizer IDs
+    :type localizers: set[int]
+    :param json_dict: dict with each key being a series number, each value being an object representation of it's JSON file with added 'bidsname' and 'filename' attributes
+    :type json_dict: defaultdict[list]
+    :param groupings: list of dictionaries containing mappings of localizers to series number
+    :type groupings: list[dict[str:set]]
+    """
+    bids_func_json = sorted(list(bids_path.glob("func/*bold.json")))
+    # assert len(bids_func_json) > 0, "---[ERROR]: Could not find any JSON files for bold runs in the functional directory of the bids data"
+    if len(bids_func_json) == 0:
+        exit_program_early("Could not find any JSON files for bold runs in the functional directory of the bids data.")
+    for jf in bids_func_json:
+        jd = None
+        with open(jf, "r") as j:
+            jd = json.load(j)
+        series_num = int(jd["SeriesNumber"])
+        jd["bidsname"] = f"{bids_path.name}/func/{jf.name.split('/')[-1][:-4]}nii.gz"
+        jd["filename"] = str(jf)
+        json_dict[series_num].append(jd)
+        for i, l in enumerate(localizers):
+            if i < len(localizers)-1:
+                if series_num > l and series_num < localizers[i+1]:
+                    groupings[i]["task"].add(series_num)
+                    break
+            else:
+                groupings[i]["task"].add(series_num)
+
+
+# Read in the json for the field maps from the bids dir
+@debug_logging
+def get_fmap_from_bids(bids_path: Path,
+                       localizers: set[int],
+                       json_dict: defaultdict[list],
+                       groupings: list[dict[str:set]]):
+    """
+    Read in all fmap JSON from the bids dir, and pair to a localizer.
+
+    :param bids_path: path to BIDS-compliant .nii/.json files
+    :type bids_path: pathlib.Path
+    :param localizers: set of localizer IDs
+    :type localizers: set[int]
+    :param json_dict: dict with each key being a series number, each value being an object representation of it's JSON file with added 'bidsname' and 'filename' attributes
+    :type json_dict: defaultdict[list]
+    :param groupings: list of dictionaries containing mappings of localizers to series number
+    :type groupings: list[dict[str:set]]
+    """
+    bids_fmap_json = sorted(list(bids_path.glob("fmap/*.json")))
+    # assert len(bids_fmap_json) > 0, "---[ERROR]: Could not find any JSON files from the fieldmap directory of the bids data"
+    if len(bids_fmap_json) == 0:
+        exit_program_early("Could not find any JSON files from the fieldmap directory of the bids data.")
+    for jf in bids_fmap_json:
+        jd = None
+        with open(jf, "r") as j:
+            jd = json.load(j)
+        series_num = int(jd["SeriesNumber"])
+        jd["filename"] = jf.name.split("/")[-1]
+        json_dict[series_num].append(jd)
+        direction = "fmapAP" if jd["PhaseEncodingDirection"] == "j-" else "fmapPA"
+        for i, l in enumerate(localizers):
+            if i < len(localizers)-1:
+                if series_num > l and series_num < localizers[i+1]:
+                    groupings[i][direction].add(series_num)
+                    break
+            else:
+                groupings[i][direction].add(series_num)
+
+
+@debug_logging
+def map_fmap_to_func(xml_path: Path,
+                     bids_dir_path: Path):
+    """
+    Group field maps to BOLD task runs.
+
+    :param xml_path: path to XML generated by XNAT
+    :type xml_path: pathlib.Path
+    :param bids_dir_path: path to BIDS-compliant session directory
+    :type bids_dir_path: pathlib.Path
+    """
+    log_linebreak()
+    logger.info("####### Pairing field maps to functional runs #######\n")
+
+    if not xml_path.is_file():
+        exit_program_early(f"Session xml file {xml_path} does not exist.")
+    if not bids_dir_path.is_dir():
+        exit_program_early(f"Session bids dicrectory {bids_dir_path} does not exist.")
+    series_json = defaultdict(list)
+
+    locals_series = get_locals_from_xml(xml_path=xml_path)
+    logger.info(f"Localizers: {locals_series}")
+
+    groups = [{"task":set(), "fmapAP": set(), "fmapPA": set()} for _ in locals_series]
+    get_func_from_bids(bids_path=bids_dir_path, 
+                       localizers=locals_series, 
+                       json_dict=series_json, 
+                       groupings=groups)
+    get_fmap_from_bids(bids_path=bids_dir_path, 
+                       localizers=locals_series, 
+                       json_dict=series_json, 
+                       groupings=groups)
+    logger.info(f"Localizer groups: {groups}") 
+
+    for group in groups:
+        # assert len(group["fmapAP"]) == len(group["fmapPA"]), "Unequal number of AP and PA field maps!"
+        if len(group["fmapAP"]) != len(group["fmapPA"]):
+            exit_program_early("Unequal number of AP and PA field maps.")
+        fmap_pairs = tuple(zip(sorted(group["fmapAP"]), sorted(group["fmapPA"])))
+        fmap_times = []
+
+        # get times for field maps
+        for i,p in enumerate(fmap_pairs):
+            times = sorted((datetime.strptime(series_json[p[0]][0]["AcquisitionTime"], "%H:%M:%S.%f"),
+                            datetime.strptime(series_json[p[1]][0]["AcquisitionTime"], "%H:%M:%S.%f")))
+            fmap_times.append(times[0] + (abs(times[1] - times[0])/2))
+        
+        # pair task runs with field maps based on closest Acquisition Time
+        map_pairings = {s:[] for s in fmap_pairs}
+        for t in group["task"]:
+            aqt = datetime.strptime(series_json[t][0]["AcquisitionTime"], "%H:%M:%S.%f")
+            diff = list(map(lambda x: abs(x-aqt), fmap_times))
+            pairing = fmap_pairs[diff.index(min(diff))]
+            map_pairings[pairing].append(t)
+        logger.info(f"Field map pairings: {map_pairings}")
+
+        # add the list of task run files that are paired with each field map in their json files
+        for k,v in map_pairings.items():
+            for s in k:
+                jd = series_json[s][0]
+                file = jd.pop("filename")
+                jd["IntendedFor"] = []
+                for t in v:
+                    for echo in series_json[t]:
+                        jd["IntendedFor"].append(echo["bidsname"])
+                fmap_file = bids_dir_path/f"fmap/{file}"
+                with open(fmap_file, "w") as out_file:
+                    logger.debug(f"writing field map pairing information to file: {fmap_file}")
+                    out_file.write(json.dumps(jd, indent=4))
+
+def map_fmap_to_func_with_pairing_file(bids_dir_path: Path,
+                                       pairing_json: Path):
+    log_linebreak()
+    for json_path in bids_dir_path.glob("fmap/*json"): # reset IntendedFor field in all fmap json
+        with open(json_path) as f:
+            json_obj = json.load(f)
+        json_obj["IntendedFor"] = []
+        with open(json_path, "w") as f:
+            json.dump(json_obj, f, indent=4)
+    logger.info("####### Pairing field maps to functional runs using pairing file #######\n")
+    with pairing_json.open() as f:
+        pairing_dict = json.load(f)
+    pairings_list = pairing_dict["pairings"]
+    for pairing in pairings_list:
+        fmap_jsons = bids_dir_path.glob(f"fmap/*{pairing['fmap']}*json")
+        func_paths = []
+        for func in pairing["func"]:
+            func_paths.extend(
+                [str(p) for p in bids_dir_path.parent.glob(f"*/func/*{func}*nii.gz")]
+            )
+        for fmap_json in fmap_jsons:
+            with fmap_json.open() as f:
+                fmap_dict = json.load(f)
+            fmap_dict["IntendedFor"] = func_paths
+            with fmap_json.open('w') as f:
+                json.dump(fmap_dict, f, indent=4)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        prog="group_series.py", 
+        description="Grouping field maps to BOLD task runs"
+    )
+    parser.add_argument("xml_ses_file", type=Path, help="The path to the xml file for this session")
+    parser.add_argument("bids_ses_dir", type=Path, help="The path to the bids directory for this session")
+    args = parser.parse_args()
+
+    map_fmap_to_func(xml_path=args.xml_ses_file, 
+                     bids_dir_path=args.bids_ses_dir)