nimare 0.4.2rc4__py3-none-any.whl

nimare/tests/test_generate.py

@@ -0,0 +1,247 @@
+"""Tests for the nimare.generate module."""
+
+from contextlib import ExitStack as does_not_raise
+
+import pytest
+from numpy.random import RandomState
+
+from nimare.dataset import Dataset
+from nimare.generate import (
+    _array_like,
+    _create_foci,
+    _create_source,
+    create_coordinate_dataset,
+    create_neurovault_dataset,
+)
+
+
+@pytest.mark.parametrize(
+    "kwargs,expectation",
+    [
+        pytest.param(
+            {
+                "foci": [(0, 0, 0)],
+                "foci_percentage": "60%",
+                "fwhm": 10.0,
+                "n_studies": 5,
+                "n_noise_foci": 2,
+                "rng": RandomState(seed=42),
+                "space": "MNI",
+            },
+            does_not_raise(),
+            id="specify_foci_coord",
+        ),
+        pytest.param(
+            {
+                "foci": 1,
+                "foci_percentage": "60%",
+                "fwhm": 10.0,
+                "n_studies": 5,
+                "n_noise_foci": 2,
+                "rng": RandomState(seed=42),
+                "space": "MNI",
+            },
+            does_not_raise(),
+            id="integer_foci",
+        ),
+        pytest.param(
+            {
+                "foci": 0,
+                "foci_percentage": "60%",
+                "fwhm": 10.0,
+                "n_studies": 5,
+                "n_noise_foci": 0,
+                "rng": RandomState(seed=42),
+                "space": "MNI",
+            },
+            does_not_raise(),
+            id="no_foci",
+        ),
+    ],
+)
+def test_create_foci(kwargs, expectation):
+    """Smoke test for _create_foci."""
+    with expectation:
+        ground_truth_foci, foci_dict = _create_foci(**kwargs)
+    if isinstance(expectation, does_not_raise):
+        assert all(isinstance(key, int) for key in foci_dict)
+        assert all(isinstance(coord, tuple) for coord in ground_truth_foci)
+
+
+def test_create_source():
+    """Smoke test for _create_source."""
+    source_dict = _create_source(foci={0: [(0, 0, 0)]}, sample_sizes=[25])
+    assert source_dict["study-0"]["contrasts"]["1"]["metadata"]["sample_sizes"] == [25]
+
+
+@pytest.mark.parametrize(
+    "kwargs,expectation",
+    [
+        pytest.param(
+            {
+                "foci": 2,
+                "foci_percentage": 1.0,
+                "fwhm": 10.0,
+                "sample_size": (10, 20),
+                "n_studies": 5,
+                "n_noise_foci": 0,
+                "seed": 42,
+                "space": "MNI",
+            },
+            does_not_raise(),
+            id="random_sample_size",
+        ),
+        pytest.param(
+            {
+                "foci": [(0, 0, 0), (0, 10, 10)],
+                "foci_percentage": "100%",
+                "fwhm": 10.0,
+                "sample_size": [30] * 5,
+                "n_studies": 5,
+                "n_noise_foci": 0,
+                "seed": 42,
+                "space": "MNI",
+            },
+            does_not_raise(),
+            id="specified_sample_size",
+        ),
+        pytest.param(
+            {
+                "foci": 2,
+                "fwhm": 10.0,
+                "sample_size": [30] * 4,
+                "n_studies": 5,
+                "n_noise_foci": 0,
+                "seed": 42,
+                "space": "MNI",
+            },
+            pytest.raises(ValueError),
+            id="incorrect_sample_size_list",
+        ),
+        pytest.param(
+            {
+                "foci": 0,
+                "foci_percentage": 1.0,
+                "fwhm": 10.0,
+                "sample_size": (10, 20),
+                "n_studies": 5,
+                "n_noise_foci": 0,
+                "seed": 42,
+                "space": "MNI",
+            },
+            does_not_raise(),
+            id="no_foci",
+        ),
+        pytest.param(
+            {
+                "foci": 0,
+                "foci_percentage": "50%",
+                "fwhm": 10.0,
+                "sample_size": (10, 20),
+                "n_studies": 5,
+                "n_noise_foci": 10,
+                "seed": 42,
+                "space": "MNI",
+            },
+            does_not_raise(),
+            id="only_noise_foci",
+        ),
+        pytest.param(
+            {
+                "foci": 1,
+                "foci_percentage": "50%",
+                "fwhm": 10.0,
+                "sample_size": (10, 20),
+                "n_studies": 5,
+                "n_noise_foci": 0,
+                "seed": 42,
+                "space": "MNI",
+            },
+            does_not_raise(),
+            id="insufficient_foci",
+        ),
+        pytest.param(
+            {
+                "foci": "INVALID_FOCI",
+                "foci_percentage": "50%",
+                "fwhm": 10.0,
+                "sample_size": (10, 20),
+                "n_studies": 5,
+                "n_noise_foci": 0,
+                "seed": 42,
+                "space": "MNI",
+            },
+            pytest.raises(ValueError),
+            id="invalid_foci",
+        ),
+        pytest.param(
+            {
+                "foci": 1,
+                "foci_percentage": "INVALID_PERCENT",
+                "fwhm": 10.0,
+                "sample_size": (10, 20),
+                "n_studies": 5,
+                "n_noise_foci": 0,
+                "seed": 42,
+                "space": "MNI",
+            },
+            pytest.raises(ValueError),
+            id="invalid_percent",
+        ),
+        pytest.param(
+            {
+                "foci": 1,
+                "foci_percentage": "60%",
+                "fwhm": 10.0,
+                "sample_size": "INVALID_SAMPLE_SIZE",
+                "n_studies": 5,
+                "n_noise_foci": 0,
+                "seed": 42,
+                "space": "MNI",
+            },
+            pytest.raises(ValueError),
+            id="invalid_sample_size",
+        ),
+        pytest.param(
+            {
+                "foci": 1,
+                "foci_percentage": "60%",
+                "fwhm": 10.0,
+                "sample_size": 30,
+                "n_studies": 5,
+                "n_noise_foci": 0,
+                "seed": 42,
+                "space": "INVALID_SPACE",
+            },
+            pytest.raises(NotImplementedError),
+            id="invalid_space",
+        ),
+    ],
+)
+def test_create_coordinate_dataset(kwargs, expectation):
+    """Create a coordinate Dataset according to parameters."""
+    with expectation:
+        ground_truth_foci, dataset = create_coordinate_dataset(**kwargs)
+    if isinstance(expectation, does_not_raise):
+        assert isinstance(dataset, Dataset)
+        assert len(dataset.ids) == kwargs["n_studies"]
+        # test if the number of observed coordinates in the dataset is correct
+        if _array_like(kwargs["foci"]):
+            n_foci = len(kwargs["foci"])
+        else:
+            n_foci = kwargs["foci"]
+        expected_coordinate_number = max(
+            kwargs["n_studies"],
+            (kwargs["n_studies"] * n_foci) + (kwargs["n_studies"] * kwargs["n_noise_foci"]),
+        )
+        assert len(dataset.coordinates) == expected_coordinate_number
+
+
+def test_create_neurovault_dataset():
+    """Test creating a neurovault dataset."""
+    dset = create_neurovault_dataset(
+        collection_ids=(8836,),
+        contrasts={"animal": "as-Animal"},
+    )
+    expected_columns = {"beta", "t", "varcope", "z"}
+    assert expected_columns.issubset(dset.images.columns)

nimare/tests/test_io.py

@@ -0,0 +1,240 @@
+"""Test nimare.io (Dataset IO/transformations)."""
+
+import os
+
+import pytest
+
+import nimare
+from nimare import io
+from nimare.nimads import Studyset
+from nimare.tests.utils import get_test_data_path
+from nimare.utils import get_template
+
+
+def test_convert_nimads_to_dataset(example_nimads_studyset, example_nimads_annotation):
+    """Conversion of nimads JSON to nimare dataset."""
+    studyset = Studyset(example_nimads_studyset)
+    dset1 = io.convert_nimads_to_dataset(studyset)
+    studyset.annotations = example_nimads_annotation
+    dset2 = io.convert_nimads_to_dataset(studyset)
+
+    assert isinstance(dset1, nimare.dataset.Dataset)
+    assert isinstance(dset2, nimare.dataset.Dataset)
+
+
+def test_convert_sleuth_to_dataset_smoke():
+    """Smoke test for Sleuth text file conversion."""
+    sleuth_file = os.path.join(get_test_data_path(), "test_sleuth_file.txt")
+    sleuth_file2 = os.path.join(get_test_data_path(), "test_sleuth_file2.txt")
+    sleuth_file3 = os.path.join(get_test_data_path(), "test_sleuth_file3.txt")
+    sleuth_file4 = os.path.join(get_test_data_path(), "test_sleuth_file4.txt")
+    sleuth_file5 = os.path.join(get_test_data_path(), "test_sleuth_file5.txt")
+    # Use one input file
+    dset = io.convert_sleuth_to_dataset(sleuth_file)
+    assert isinstance(dset, nimare.dataset.Dataset)
+    assert dset.coordinates.shape[0] == 7
+    assert len(dset.ids) == 3
+    # Use two input files
+    dset2 = io.convert_sleuth_to_dataset([sleuth_file, sleuth_file2])
+    assert isinstance(dset2, nimare.dataset.Dataset)
+    assert dset2.coordinates.shape[0] == 11
+    assert len(dset2.ids) == 5
+    # Use invalid input
+    with pytest.raises(ValueError):
+        io.convert_sleuth_to_dataset(5)
+    # Use invalid input (one coordinate is a str instead of a number)
+    with pytest.raises(ValueError):
+        io.convert_sleuth_to_dataset(sleuth_file3)
+    # Use invalid input (one has x & y, but not z)
+    with pytest.raises(ValueError):
+        io.convert_sleuth_to_dataset(sleuth_file4)
+    # Use invalid input (bad space)
+    with pytest.raises(ValueError):
+        io.convert_sleuth_to_dataset(sleuth_file5)
+
+
+def test_convert_sleuth_to_json_smoke():
+    """Smoke test for Sleuth text file conversion."""
+    out_file = os.path.abspath("temp.json")
+    sleuth_file = os.path.join(get_test_data_path(), "test_sleuth_file.txt")
+    sleuth_file2 = os.path.join(get_test_data_path(), "test_sleuth_file2.txt")
+    sleuth_file3 = os.path.join(get_test_data_path(), "test_sleuth_file3.txt")
+    sleuth_file4 = os.path.join(get_test_data_path(), "test_sleuth_file4.txt")
+    sleuth_file5 = os.path.join(get_test_data_path(), "test_sleuth_file5.txt")
+    # Use one input file
+    io.convert_sleuth_to_json(sleuth_file, out_file)
+    dset = nimare.dataset.Dataset(out_file)
+    assert os.path.isfile(out_file)
+    assert isinstance(dset, nimare.dataset.Dataset)
+    assert dset.coordinates.shape[0] == 7
+    assert len(dset.ids) == 3
+    os.remove(out_file)
+    # Use two input files
+    io.convert_sleuth_to_json([sleuth_file, sleuth_file2], out_file)
+    dset2 = nimare.dataset.Dataset(out_file)
+    assert isinstance(dset2, nimare.dataset.Dataset)
+    assert dset2.coordinates.shape[0] == 11
+    assert len(dset2.ids) == 5
+    # Use invalid input (number instead of file)
+    with pytest.raises(ValueError):
+        io.convert_sleuth_to_json(5, out_file)
+    # Use invalid input (one coordinate is a str instead of a number)
+    with pytest.raises(ValueError):
+        io.convert_sleuth_to_json(sleuth_file3, out_file)
+    # Use invalid input (one has x & y, but not z)
+    with pytest.raises(ValueError):
+        io.convert_sleuth_to_json(sleuth_file4, out_file)
+    # Use invalid input (bad space)
+    with pytest.raises(ValueError):
+        io.convert_sleuth_to_json(sleuth_file5, out_file)
+
+
+def test_convert_neurosynth_to_dataset_smoke():
+    """Smoke test for Neurosynth file conversion."""
+    coordinates_file = os.path.join(
+        get_test_data_path(),
+        "data-neurosynth_version-7_coordinates.tsv.gz",
+    )
+    metadata_file = os.path.join(
+        get_test_data_path(),
+        "data-neurosynth_version-7_metadata.tsv.gz",
+    )
+    features = {
+        "features": os.path.join(
+            get_test_data_path(),
+            "data-neurosynth_version-7_vocab-terms_source-abstract_type-tfidf_features.npz",
+        ),
+        "vocabulary": os.path.join(
+            get_test_data_path(), "data-neurosynth_version-7_vocab-terms_vocabulary.txt"
+        ),
+    }
+    dset = io.convert_neurosynth_to_dataset(
+        coordinates_file,
+        metadata_file,
+        annotations_files=features,
+    )
+    assert isinstance(dset, nimare.dataset.Dataset)
+    assert "terms_abstract_tfidf__abilities" in dset.annotations.columns
+
+
+def test_convert_neurosynth_to_json_smoke():
+    """Smoke test for Neurosynth file conversion."""
+    out_file = os.path.abspath("temp.json")
+    coordinates_file = os.path.join(
+        get_test_data_path(),
+        "data-neurosynth_version-7_coordinates.tsv.gz",
+    )
+    metadata_file = os.path.join(
+        get_test_data_path(),
+        "data-neurosynth_version-7_metadata.tsv.gz",
+    )
+    features = {
+        "features": os.path.join(
+            get_test_data_path(),
+            "data-neurosynth_version-7_vocab-terms_source-abstract_type-tfidf_features.npz",
+        ),
+        "vocabulary": os.path.join(
+            get_test_data_path(), "data-neurosynth_version-7_vocab-terms_vocabulary.txt"
+        ),
+    }
+    io.convert_neurosynth_to_json(
+        coordinates_file,
+        metadata_file,
+        out_file,
+        annotations_files=features,
+    )
+    dset = nimare.dataset.Dataset(out_file)
+    assert os.path.isfile(out_file)
+    assert isinstance(dset, nimare.dataset.Dataset)
+    os.remove(out_file)
+
+
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        (
+            {
+                "collection_ids": (8836,),
+                "contrasts": {"animal": "as-Animal"},
+            }
+        ),
+        (
+            {
+                "collection_ids": {"informative_name": 8836},
+                "contrasts": {"animal": "as-Animal"},
+                "map_type_conversion": {"T map": "t"},
+                "target": "mni152_2mm",
+                "mask": get_template("mni152_2mm", mask="brain"),
+            }
+        ),
+        (
+            {
+                "collection_ids": (6348, 6419),
+                "contrasts": {"action": "action"},
+                "map_type_conversion": {"univariate-beta map": "beta"},
+            }
+        ),
+        (
+            {
+                "collection_ids": (778,),  # collection not found
+                "contrasts": {"action": "action"},
+                "map_type_conversion": {"univariate-beta map": "beta"},
+            }
+        ),
+        (
+            {
+                "collection_ids": (11303,),
+                "contrasts": {"rms": "rms"},
+                "map_type_conversion": {"univariate-beta map": "beta"},
+            }
+        ),
+        (
+            {
+                "collection_ids": (8836,),
+                "contrasts": {"crab_people": "cannot hurt you because they do not exist"},
+            }
+        ),
+    ],
+)
+def test_convert_neurovault_to_dataset(kwargs):
+    """Test conversion of neurovault collection to a dataset."""
+    if 778 in kwargs["collection_ids"]:
+        with pytest.raises(ValueError) as excinfo:
+            dset = io.convert_neurovault_to_dataset(**kwargs)
+        assert "Collection 778 not found." in str(excinfo.value)
+        return
+    elif "crab_people" in kwargs["contrasts"].keys():
+        with pytest.raises(ValueError) as excinfo:
+            dset = io.convert_neurovault_to_dataset(**kwargs)
+        assert "No images were found for contrast crab_people" in str(excinfo.value)
+        return
+    else:
+        dset = io.convert_neurovault_to_dataset(**kwargs)
+
+    # check if names are propagated into Dataset
+    if isinstance(kwargs.get("collection_ids"), dict):
+        study_ids = set(kwargs["collection_ids"].keys())
+    else:
+        study_ids = set(map(str, kwargs["collection_ids"]))
+    dset_ids = {id_.split("-")[1] for id_ in dset.ids}
+
+    assert study_ids == dset_ids
+
+    # check if images were downloaded and are unique
+    if kwargs.get("map_type_conversion"):
+        for img_type in kwargs.get("map_type_conversion").values():
+            assert not dset.images[img_type].empty
+            assert len(set(dset.images[img_type])) == len(dset.images[img_type])
+
+
+@pytest.mark.parametrize(
+    "sample_sizes,expected_sample_size",
+    [
+        ([1, 2, 1], 1),
+        ([None, None, 1], 1),
+        ([1, 1, 2, 2], 1),
+    ],
+)
+def test_resolve_sample_sizes(sample_sizes, expected_sample_size):
+    """Test modal sample size heuristic."""
+    assert io._resolve_sample_size(sample_sizes) == expected_sample_size