def test_dict_to_archive(tmp_path):
subdir = tmp_path / "tmp"
subdir.mkdir()
(subdir / "labels.csv").touch()
(subdir / "img.nii.gz").touch()
archive_spec = {
"empty_data":
subdir,
"empty_data_path.txt":
str(subdir),
Path("data", "labels.csv"):
"a,b,c",
Path("data", "img.nii.gz"):
generate_fake_fmri()[0],
Path("a", "b", "c"): (100).to_bytes(length=1,
byteorder="big",
signed=False),
}
targz = _testing.dict_to_archive(archive_spec)
extract_dir = tmp_path / "extract"
extract_dir.mkdir()
archive_path = tmp_path / "archive"
with archive_path.open("wb") as f:
f.write(targz)
with tarfile.open(str(archive_path)) as tarf:
tarf.extractall(str(extract_dir))
img = image.load_img(str(extract_dir / "data" / "img.nii.gz"))
assert img.shape == (10, 11, 12, 17)
with (extract_dir / "a" / "b" / "c").open("rb") as f:
assert int.from_bytes(f.read(), byteorder="big", signed=False) == 100
with open(str(extract_dir / "empty_data" / "labels.csv")) as f:
assert f.read() == ""
zip_archive = _testing.dict_to_archive(
{
"readme.txt": "hello",
"archive": targz
}, "zip")
with archive_path.open("wb") as f:
f.write(zip_archive)
with zipfile.ZipFile(str(archive_path)) as zipf:
with zipf.open("archive", "r") as f:
assert f.read() == targz
from_list = _testing.list_to_archive(archive_spec.keys())
with archive_path.open("wb") as f:
f.write(from_list)
with tarfile.open(str(archive_path)) as tarf:
assert sorted(map(Path, tarf.getnames())) == sorted(
list(map(Path, archive_spec.keys())) +
[Path("."), Path("a"),
Path("a", "b"),
Path("data")])
def _destrieux_data():
data = {"destrieux2009.rst": "readme"}
for lat in ["_lateralized", ""]:
lat_data = {
"destrieux2009_rois_labels{}.csv".format(lat): "name,index",
"destrieux2009_rois{}.nii.gz".format(lat): "",
}
data.update(lat_data)
return dict_to_archive(data)
def _destrieux_data():
"""Function mocking the download of the destrieux atlas."""
data = {"destrieux2009.rst": "readme"}
atlas = np.random.randint(0, 10, (10, 10, 10))
atlas_img = nibabel.Nifti1Image(atlas, np.eye(4))
labels = "\n".join([f"{idx},label {idx}" for idx in range(10)])
labels = "index,name\n" + labels
for lat in ["_lateralized", ""]:
lat_data = {
"destrieux2009_rois_labels{}.csv".format(lat): labels,
"destrieux2009_rois{}.nii.gz".format(lat): atlas_img,
}
data.update(lat_data)
return dict_to_archive(data)
def _make_oasis_data(dartel=True):
n_subjects = 457
prefix = "mwrc" if dartel else "mwc"
ids = pd.DataFrame({
"ID": list(map("OAS1_{:04}".format, range(n_subjects)))
}).to_csv(index=False, sep="\t")
data = {"oasis_cross-sectional.csv": ids, "data_usage_agreement.txt": ""}
path_pattern = str(
Path(
"OAS1_{subj:04}_MR1",
"{prefix}{kind}OAS1_{subj:04}_MR1_mpr_anon_fslswapdim_bet.nii.gz"))
for i in range(457):
for kind in [1, 2]:
data[path_pattern.format(subj=i, kind=kind, prefix=prefix)] = ""
return dict_to_archive(data)
def test_fetch_atlas_difumo(tmp_path, request_mocker):
resolutions = [2, 3] # Valid resolution values
dimensions = [64, 128, 256, 512, 1024] # Valid dimension values
dimension_urls = ['wjum7', 'n3vba', 'vza2y', 'a23gw', 'jpdum']
url_mapping = {k: v for k, v in zip(dimensions, dimension_urls)}
url_count = 2
for dim in dimensions:
url_count += 1
url = "*osf.io/{0}/*".format(url_mapping[dim])
labels = pd.DataFrame({
"Component": [_ for _ in range(1, dim + 1)],
"Difumo_names": ["" for _ in range(dim)],
"Yeo_networks7": ["" for _ in range(dim)],
"Yeo_networks17": ["" for _ in range(dim)],
"GM": ["" for _ in range(dim)],
"WM": ["" for _ in range(dim)],
"CSF": ["" for _ in range(dim)]
})
root = Path("{0}".format(dim))
archive = {
root / "labels_{0}_dictionary.csv".format(dim):
labels.to_csv(index=False),
root / "maps.nii.gz":
"",
root / "3mm" / "resampled_maps.nii.gz":
""
}
request_mocker.url_mapping[url] = dict_to_archive(archive, "zip")
for res in resolutions:
dataset = atlas.fetch_atlas_difumo(data_dir=str(tmp_path),
dimension=dim,
resolution_mm=res,
verbose=0)
assert len(dataset.keys()) == 3
assert len(dataset.labels) == dim
assert isinstance(dataset.maps, str)
assert request_mocker.url_count == url_count
assert dataset.description != ''
with pytest.raises(ValueError):
atlas.fetch_atlas_difumo(data_dir=str(tmp_path),
dimension=42,
resolution_mm=3)
atlas.fetch_atlas_difumo(data_dir=str(tmp_path),
dimension=128,
resolution_mm=3.14)
def test_fetch_atlas_msdl(tmp_path, request_mocker):
labels = pd.DataFrame(
{"x": [1.5, 1.2], "y": [1.5, 1.3],
"z": [1.5, 1.4], "name": ["Aud", "DMN"], "net_name": ["Aud", "DMN"]})
root = Path("MSDL_rois")
archive = {root / "msdl_rois_labels.csv": labels.to_csv(index=False),
root / "msdl_rois.nii": "",
root / "README.txt": ""}
request_mocker.url_mapping["*MSDL_rois.zip"] = dict_to_archive(
archive, "zip")
dataset = atlas.fetch_atlas_msdl(data_dir=tmp_path, verbose=0)
assert isinstance(dataset.labels, list)
assert isinstance(dataset.region_coords, list)
assert isinstance(dataset.networks, list)
assert isinstance(dataset.maps, str)
assert request_mocker.url_count == 1
assert dataset.description != ''
def _adhd_metadata():
sub1 = [3902469, 7774305, 3699991]
sub2 = [2014113, 4275075, 1019436,
3154996, 3884955, 27034,
4134561, 27018, 6115230,
27037, 8409791, 27011]
sub3 = [3007585, 8697774, 9750701,
10064, 21019, 10042,
10128, 2497695, 4164316,
1552181, 4046678, 23012]
sub4 = [1679142, 1206380, 23008,
4016887, 1418396, 2950754,
3994098, 3520880, 1517058,
9744150, 1562298, 3205761, 3624598]
subs = pd.DataFrame({"Subject": sub1 + sub2 + sub3 + sub4})
return dict_to_archive(
{"ADHD200_40subs_motion_parameters_and_phenotypics.csv":
subs.to_csv(index=False)})
def test_fetch_atlas_aal(tmp_path, request_mocker):
metadata = (b"<?xml version='1.0' encoding='us-ascii'?>"
b"<metadata></metadata>")
archive_root = Path("aal", "atlas")
aal_data = dict_to_archive({
archive_root / "AAL.xml": metadata,
archive_root / "AAL.nii": ""
})
request_mocker.url_mapping["*AAL_files*"] = aal_data
dataset = atlas.fetch_atlas_aal(data_dir=tmp_path, verbose=0)
assert isinstance(dataset.maps, str)
assert isinstance(dataset.labels, list)
assert isinstance(dataset.indices, list)
assert request_mocker.url_count == 1
with pytest.raises(ValueError,
match='The version of AAL requested "FLS33"'):
atlas.fetch_atlas_aal(version="FLS33", data_dir=tmp_path, verbose=0)
assert dataset.description != ''
def make_fake_data():
n_voxels, n_components, n_studies, n_terms = 23, 8, 12, 9
rng = np.random.default_rng(0)
difumo_maps = rng.random((n_components, n_voxels))
difumo_maps[rng.binomial(1, 0.3, size=difumo_maps.shape).astype(int)] = 0
difumo_inverse_covariance = np.linalg.pinv(difumo_maps.dot(difumo_maps.T))
difumo_maps = sparse.csr_matrix(difumo_maps)
projections = rng.random((n_studies, n_components))
term_projections = rng.random((n_terms, n_components))
articles_info = pd.DataFrame({"pmid": np.arange(n_studies) + 100})
articles_info["title"] = [
f"title {pmid}" for pmid in articles_info["pmid"]
]
articles_info["pubmed_url"] = [
f"url {pmid}" for pmid in articles_info["pmid"]
]
mask = np.zeros(4 * 3 * 5, dtype=int)
mask[:n_voxels] = 1
mask = mask.reshape((4, 3, 5))
mask_img = nibabel.Nifti1Image(mask, np.eye(4))
doc_freq = pd.DataFrame({
"term": ["term_{i}" for i in range(n_terms)],
"document_frequency": np.arange(n_terms),
})
with tempfile.TemporaryDirectory() as temp_dir:
temp_dir = Path(temp_dir)
sparse.save_npz(temp_dir / "difumo_maps.npz", difumo_maps)
np.save(
temp_dir / "difumo_inverse_covariance.npy",
difumo_inverse_covariance,
)
np.save(temp_dir / "projections.npy", projections)
np.save(temp_dir / "term_projections.npy", term_projections)
articles_info.to_csv(temp_dir / "articles-info.csv", index=False)
mask_img.to_filename(str(temp_dir / "mask.nii.gz"))
doc_freq.to_csv(str(temp_dir / "document_frequencies.csv"),
index=False)
archive = _testing.dict_to_archive(
{"neuroquery_image_search_data": temp_dir})
return archive
def test_fetch_atlas_aal(version, archive_format, url_key, aal_archive_root,
tmp_path, request_mocker):
metadata = "A\tB\tC\n"
if version == 'SPM12':
metadata = (b"<?xml version='1.0' encoding='us-ascii'?>"
b"<metadata><label><index>1</index>"
b"<name>A</name></label></metadata>")
label_file = "AAL.xml" if version == 'SPM12' else "ROI_MNI_V4.txt"
atlas_file = "AAL.nii" if version == 'SPM12' else "ROI_MNI_V4.nii"
aal_data = dict_to_archive(
{aal_archive_root / label_file: metadata,
aal_archive_root / atlas_file: ""},
archive_format=archive_format
)
request_mocker.url_mapping[f"*{url_key}*"] = aal_data
dataset = atlas.fetch_atlas_aal(
version=version, data_dir=tmp_path, verbose=0
)
assert isinstance(dataset.maps, str)
assert isinstance(dataset.labels, list)
assert isinstance(dataset.indices, list)
assert request_mocker.url_count == 1
assert dataset.description != ''
