nimare 0.4.2rc4__py3-none-any.whl → 0.5.0__py3-none-any.whl

nimare/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-03-10T17:13:59-0500",
+ "date": "2025-04-25T13:22:39-0500",
  "dirty": false,
  "error": null,
- "full-revisionid": "72f0013b0d3d8243aedb7e29fa66a8e4e493eb38",
- "version": "0.4.2rc4"
+ "full-revisionid": "9e3b73cbb6235b31a4fab7a9a118e32c1d2f9932",
+ "version": "0.5.0"
 }
 '''  # END VERSION_JSON
 

nimare/io.py

@@ -62,13 +62,45 @@ def convert_nimads_to_dataset(studyset, annotation=None):
                 "z": [p.z for p in analysis.points] or [None],
             },
         }
-        sample_size = study.metadata.get("sample_size")
-        if sample_size:
-            result["metadata"]["sample_sizes"] = [sample_size]
+
+        sample_sizes = analysis.metadata.get("sample_sizes")
+        sample_size = None
+
+        # Validate sample sizes if present
+        if sample_sizes is not None and not isinstance(sample_sizes, (list, tuple)):
+            raise TypeError(
+                f"Expected sample_sizes to be list or tuple, but got {type(sample_sizes)}"
+            )
+
+        if not sample_sizes:
+            # Try to get single sample size from analysis or study metadata
+            sample_size = analysis.metadata.get("sample_size")
+            if sample_size is None:
+                sample_size = study.metadata.get("sample_size")
+
+            # Validate single sample size if present
+            if sample_size is not None and not isinstance(sample_size, (int, float)):
+                raise TypeError(f"Expected sample_size to be numeric, but got {type(sample_size)}")
+
+        # Add sample size info to result if available
+        if sample_sizes or sample_size is not None:
+            try:
+                result["metadata"]["sample_sizes"] = sample_sizes or [sample_size]
+            except TypeError as e:
+                raise TypeError(f"Error converting sample size data to list: {str(e)}") from e
+
+        # Handle annotations if present
         if analysis.annotations:
             result["labels"] = {}
-            for annotation in analysis.annotations.values():
-                result["labels"].update(annotation)
+            try:
+                for annotation in analysis.annotations.values():
+                    if not isinstance(annotation, dict):
+                        raise TypeError(
+                            f"Expected annotation to be dict, but got {type(annotation)}"
+                        )
+                    result["labels"].update(annotation)
+            except (TypeError, AttributeError) as e:
+                raise ValueError(f"Invalid annotation format: {str(e)}") from e
 
         return result
 

nimare/meta/utils.py

@@ -33,7 +33,7 @@ def _convolve_sphere(kernel, ijks, index, max_shape):
 
     def np_all_axis1(x):
         """Numba compatible version of np.all(x, axis=1)."""
-        out = np.ones(x.shape[0], dtype=np.bool8)
+        out = np.ones(x.shape[0], dtype=np.bool_)
         for i in range(x.shape[1]):
             out = np.logical_and(out, x[:, i])
         return out

nimare/nimads.py

@@ -4,7 +4,11 @@ import json
 import weakref
 from copy import deepcopy
 
+import numpy as np
+from nilearn._utils import load_niimg
+
 from nimare.io import convert_nimads_to_dataset
+from nimare.utils import mm2vox
 
 
 class Studyset:
@@ -84,7 +88,7 @@ class Studyset:
         for study in studyset.studies:
             if len(study.analyses) > 1:
                 source_lst = [analysis.to_dict() for analysis in study.analyses]
-                ids, names, conditions, images, points, weights = [
+                ids, names, conditions, images, points, weights, metadata = [
                     [source[key] for source in source_lst] for key in source_lst[0]
                 ]
 
@@ -95,6 +99,7 @@ class Studyset:
                     "images": [image for i_list in images for image in i_list],
                     "points": [point for p_list in points for point in p_list],
                     "weights": [weight for w_list in weights for weight in w_list],
+                    "metadata": {k: v for m_dict in metadata for k, v in m_dict.items()},
                 }
                 study.analyses = [Analysis(new_source)]
 
@@ -118,12 +123,42 @@ class Studyset:
         return convert_nimads_to_dataset(self)
 
     def load(self, filename):
-        """Load a Studyset from a pickled file."""
-        raise NotImplementedError("Loading from pickled files is not yet supported.")
+        """Load a Studyset from a pickled file.
+
+        Parameters
+        ----------
+        filename : str
+            Path to the pickled file to load from.
+
+        Returns
+        -------
+        Studyset
+            The loaded Studyset object.
+        """
+        import pickle
+
+        with open(filename, "rb") as f:
+            loaded_data = pickle.load(f)
+
+        # Update current instance with loaded data
+        self.id = loaded_data.id
+        self.name = loaded_data.name
+        self.studies = loaded_data.studies
+        self._annotations = loaded_data._annotations
+        return self
 
     def save(self, filename):
-        """Write the Studyset to a pickled file."""
-        raise NotImplementedError("Saving to pickled files is not yet supported.")
+        """Write the Studyset to a pickled file.
+
+        Parameters
+        ----------
+        filename : str
+            Path where the pickled file should be saved.
+        """
+        import pickle
+
+        with open(filename, "wb") as f:
+            pickle.dump(self, f)
 
     def copy(self):
         """Create a copy of the Studyset."""
@@ -141,49 +176,221 @@ class Studyset:
 
         for annot in annotations:
             annot["notes"] = [n for n in annot["notes"] if n["analysis"] in analyses]
-            studyset.annotation = annot
+            studyset.annotations = annot
 
         return studyset
 
     def merge(self, right):
-        """Merge a separate Studyset into the current one."""
-        raise NotImplementedError("Merging Studysets is not yet supported.")
-
-    def update_image_path(self, new_path):
-        """Point to a new location for image files on the local filesystem."""
-        raise NotImplementedError("Updating image paths is not yet supported.")
+        """Merge a separate Studyset into the current one.
+
+        Parameters
+        ----------
+        right : Studyset
+            The other Studyset to merge with this one.
+
+        Returns
+        -------
+        Studyset
+            A new Studyset containing merged studies from both input Studysets.
+            For studies with the same ID, their analyses and metadata are combined,
+            with data from self (left) taking precedence in case of conflicts.
+        """
+        if not isinstance(right, Studyset):
+            raise ValueError("Can only merge with another Studyset")
+
+        # Create new source dictionary starting with left (self) studyset
+        merged_source = self.to_dict()
+        merged_source["id"] = f"{self.id}_{right.id}"
+        merged_source["name"] = f"Merged: {self.name} + {right.name}"
+
+        # Create lookup of existing studies by ID
+        left_studies = {study["id"]: study for study in merged_source["studies"]}
+
+        # Process studies from right studyset
+        right_dict = right.to_dict()
+        for right_study in right_dict["studies"]:
+            study_id = right_study["id"]
+
+            if study_id in left_studies:
+                # Merge study data
+                left_study = left_studies[study_id]
+
+                # Keep metadata from left unless missing
+                left_study["metadata"].update(
+                    {
+                        k: v
+                        for k, v in right_study["metadata"].items()
+                        if k not in left_study["metadata"]
+                    }
+                )
+
+                # Keep basic info from left unless empty
+                for field in ["name", "authors", "publication"]:
+                    if not left_study[field]:
+                        left_study[field] = right_study[field]
+
+                # Combine analyses, avoiding duplicates by ID
+                left_analyses = {a["id"]: a for a in left_study["analyses"]}
+                for right_analysis in right_study["analyses"]:
+                    if right_analysis["id"] not in left_analyses:
+                        left_study["analyses"].append(right_analysis)
+            else:
+                # Add new study
+                merged_source["studies"].append(right_study)
+
+        # Create new merged studyset
+        merged = self.__class__(source=merged_source)
+
+        # Merge annotations, preferring left's annotations for conflicts
+        existing_annot_ids = {a.id for a in self.annotations}
+        for right_annot in right.annotations:
+            if right_annot.id not in existing_annot_ids:
+                merged.annotations = right_annot.to_dict()
+
+        return merged
 
     def get_analyses_by_coordinates(self, xyz, r=None, n=None):
-        """Extract a list of Analyses with at least one Point near the requested coordinates."""
-        raise NotImplementedError("Getting analyses by coordinates is not yet supported.")
+        """Extract a list of Analyses with at least one Point near the requested coordinates.
+
+        Parameters
+        ----------
+        xyz : array_like
+            1 x 3 array of coordinates in mm space to search from
+        r : float, optional
+            Search radius in millimeters.
+            Mutually exclusive with n.
+        n : int, optional
+            Number of closest analyses to return.
+            Mutually exclusive with r.
+
+        Returns
+        -------
+        list[str]
+            A list of Analysis IDs with at least one point within the search criteria.
+
+        Notes
+        -----
+        Either r or n must be provided, but not both.
+        """
+        if (r is None and n is None) or (r is not None and n is not None):
+            raise ValueError("Exactly one of r or n must be provided.")
+
+        xyz = np.asarray(xyz).ravel()
+        if xyz.shape != (3,):
+            raise ValueError("xyz must be a 1 x 3 array-like object.")
+
+        # Extract all points from all analyses
+        all_points = []
+        analysis_ids = []
+        for study in self.studies:
+            for analysis in study.analyses:
+                for point in analysis.points:
+                    if hasattr(point, "x") and hasattr(point, "y") and hasattr(point, "z"):
+                        all_points.append([point.x, point.y, point.z])
+                        analysis_ids.append(analysis.id)
+
+        if not all_points:  # Return empty list if no coordinates found
+            return []
+
+        all_points = np.array(all_points)
+
+        # Calculate Euclidean distances to all points
+        distances = np.sqrt(np.sum((all_points - xyz) ** 2, axis=1))
+
+        if r is not None:
+            # Find analyses with points within radius r
+            within_radius = distances <= r
+            found_analyses = set(np.array(analysis_ids)[within_radius])
+        else:
+            # Find n closest analyses
+            closest_n_idx = np.argsort(distances)[:n]
+            found_analyses = set(np.array(analysis_ids)[closest_n_idx])
+
+        return list(found_analyses)
 
     def get_analyses_by_mask(self, img):
-        """Extract a list of Analyses with at least one Point in the specified mask."""
-        raise NotImplementedError("Getting analyses by mask is not yet supported.")
+        """Extract a list of Analyses with at least one Point in the specified mask.
 
-    def get_analyses_by_annotations(self):
-        """Extract a list of Analyses with a given label/annotation."""
-        raise NotImplementedError("Getting analyses by annotations is not yet supported.")
+        Parameters
+        ----------
+        img : img_like
+            Mask across which to search for coordinates.
 
-    def get_analyses_by_texts(self):
-        """Extract a list of Analyses with a given text."""
-        raise NotImplementedError("Getting analyses by texts is not yet supported.")
+        Returns
+        -------
+        list[str]
+            A list of Analysis IDs with at least one point in the mask.
+        """
+        # Load mask
+        mask = load_niimg(img)
+
+        # Extract all points from all analyses
+        all_points = []
+        analysis_ids = []
+        for study in self.studies:
+            for analysis in study.analyses:
+                for point in analysis.points:
+                    if hasattr(point, "x") and hasattr(point, "y") and hasattr(point, "z"):
+                        all_points.append([point.x, point.y, point.z])
+                        analysis_ids.append(analysis.id)
+
+        if not all_points:  # Return empty list if no coordinates found
+            return []
+
+        # Convert to voxel coordinates
+        all_points = np.array(all_points)
+        ijk = mm2vox(all_points, mask.affine)
+
+        # Get mask coordinates
+        mask_data = mask.get_fdata()
+        mask_coords = np.vstack(np.where(mask_data)).T
 
-    def get_analyses_by_images(self):
-        """Extract a list of Analyses with a given image."""
-        raise NotImplementedError("Getting analyses by images is not yet supported.")
+        # Check for presence of coordinates in mask
+        in_mask = np.any(np.all(ijk[:, None] == mask_coords[None, :], axis=-1), axis=-1)
 
-    def get_analyses_by_metadata(self):
+        # Get unique analysis IDs where points are in mask
+        found_analyses = set(np.array(analysis_ids)[in_mask])
+
+        return list(found_analyses)
+
+    def get_analyses_by_annotations(self, key, value=None):
+        """Extract a list of Analyses with a given label/annotation."""
+        annotations = {}
+        for study in self.studies:
+            for analysis in study.analyses:
+                a_annot = analysis.annotations
+                if key in a_annot and (value is None or a_annot[key] == value):
+                    annotations[analysis.id] = {key: a_annot[key]}
+        return annotations
+
+    def get_analyses_by_metadata(self, key, value=None):
         """Extract a list of Analyses with a metadata field/value."""
-        raise NotImplementedError("Getting analyses by metadata is not yet supported.")
+        metadata = {}
+        for study in self.studies:
+            for analysis in study.analyses:
+                a_metadata = analysis.metadata
+                if key in a_metadata and (value is None or a_metadata[key] == value):
+                    metadata[analysis.id] = {key: a_metadata[key]}
+        return metadata
 
     def get_points(self, analyses):
         """Collect Points associated with specified Analyses."""
-        raise NotImplementedError("Getting points is not yet supported.")
+        points = {}
+        for study in self.studies:
+            for analysis in study.analyses:
+                if analysis.id in analyses:
+                    points[analysis.id] = analysis.points
+        return points
 
     def get_annotations(self, analyses):
         """Collect Annotations associated with specified Analyses."""
-        raise NotImplementedError("Getting annotations is not yet supported.")
+        annotations = {}
+        for study in self.studies:
+            for analysis in study.analyses:
+                if analysis.id in analyses:
+                    annotations[analysis.id] = analysis.annotations
+
+        return annotations
 
     def get_texts(self, analyses):
         """Collect texts associated with specified Analyses."""
@@ -191,11 +398,32 @@ class Studyset:
 
     def get_images(self, analyses):
         """Collect image files associated with specified Analyses."""
-        raise NotImplementedError("Getting images is not yet supported.")
+        images = {}
+        for study in self.studies:
+            for analysis in study.analyses:
+                if analysis.id in analyses:
+                    images[analysis.id] = analysis.images
+        return images
 
     def get_metadata(self, analyses):
-        """Collect metadata associated with specified Analyses."""
-        raise NotImplementedError("Getting metadata is not yet supported.")
+        """Collect metadata associated with specified Analyses.
+
+        Parameters
+        ----------
+        analyses : list of str
+            List of Analysis IDs to get metadata for.
+
+        Returns
+        -------
+        dict[str, dict]
+            Dictionary mapping Analysis IDs to their combined metadata (including study metadata).
+        """
+        metadata = {}
+        for study in self.studies:
+            for analysis in study.analyses:
+                if analysis.id in analyses:
+                    metadata[analysis.id] = analysis.get_metadata()
+        return metadata
 
 
 class Study:
@@ -226,7 +454,7 @@ class Study:
         self.authors = source["authors"] or ""
         self.publication = source["publication"] or ""
         self.metadata = source.get("metadata", {}) or {}
-        self.analyses = [Analysis(a) for a in source["analyses"]]
+        self.analyses = [Analysis(a, study=self) for a in source["analyses"]]
 
     def __repr__(self):
         """My Simple representation."""
@@ -285,7 +513,7 @@ class Analysis:
     Should the images attribute be a list instead, if the Images contain type information?
     """
 
-    def __init__(self, source):
+    def __init__(self, source, study=None):
         self.id = source["id"]
         self.name = source["name"]
         self.conditions = [
@@ -295,6 +523,7 @@ class Analysis:
         self.points = [Point(p) for p in source["points"]]
         self.metadata = source.get("metadata", {}) or {}
         self.annotations = {}
+        self._study = weakref.proxy(study) if study else None
 
     def __repr__(self):
         """My Simple representation."""
@@ -306,6 +535,22 @@ class Analysis:
             " ".join([self.name, f"images: {len(self.images)}", f"points: {len(self.points)}"])
         )
 
+    def get_metadata(self) -> "dict[str, any]":
+        """Get combined metadata from both analysis and parent study.
+
+        Returns
+        -------
+        dict[str, any]
+            Combined metadata dictionary with analysis metadata taking precedence
+            over study metadata for any overlapping keys.
+        """
+        if self._study is None:
+            return self.metadata.copy()
+
+        combined_metadata = self._study.metadata.copy()
+        combined_metadata.update(self.metadata)
+        return combined_metadata
+
     def to_dict(self):
         """Convert the Analysis to a dictionary."""
         return {
@@ -318,6 +563,7 @@ class Analysis:
             "images": [i.to_dict() for i in self.images],
             "points": [p.to_dict() for p in self.points],
             "weights": [c.to_dict()["weight"] for c in self.conditions],
+            "metadata": self.metadata,
         }
 
 

nimare/tests/test_io.py

@@ -22,6 +22,48 @@ def test_convert_nimads_to_dataset(example_nimads_studyset, example_nimads_annot
     assert isinstance(dset2, nimare.dataset.Dataset)
 
 
+def test_convert_nimads_to_dataset_sample_sizes(
+    example_nimads_studyset, example_nimads_annotation
+):
+    """Conversion of nimads JSON to nimare dataset."""
+    studyset = Studyset(example_nimads_studyset)
+    for study in studyset.studies:
+        for analysis in study.analyses:
+            analysis.metadata["sample_sizes"] = [2, 20]
+
+    dset = io.convert_nimads_to_dataset(studyset)
+
+    assert isinstance(dset, nimare.dataset.Dataset)
+    assert "sample_sizes" in dset.metadata.columns
+
+
+def test_convert_nimads_to_dataset_single_sample_size(
+    example_nimads_studyset, example_nimads_annotation
+):
+    """Test conversion of nimads JSON to nimare dataset with a single sample size value."""
+    studyset = Studyset(example_nimads_studyset)
+    for study in studyset.studies:
+        for analysis in study.analyses:
+            analysis.metadata["sample_size"] = 20
+
+    dset = io.convert_nimads_to_dataset(studyset)
+
+    assert isinstance(dset, nimare.dataset.Dataset)
+    assert "sample_sizes" in dset.metadata.columns
+
+
+def test_analysis_to_dict_invalid_sample_sizes_type(example_nimads_studyset):
+    """Test _analysis_to_dict raises ValueError when sample_sizes is not a list/tuple."""
+    studyset = Studyset(example_nimads_studyset)
+    # Set sample_sizes to an int rather than list/tuple
+    for study in studyset.studies:
+        for analysis in study.analyses:
+            analysis.metadata["sample_sizes"] = 5
+    with pytest.raises(TypeError):
+        # Trigger conversion which internally calls _analysis_to_dict
+        io.convert_nimads_to_dataset(studyset)
+
+
 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")

nimare/tests/test_nimads.py

@@ -1,5 +1,11 @@
 """Test NiMADS functionality."""
 
+import json
+import os
+import tempfile
+
+import pytest
+
 from nimare import nimads
 from nimare.dataset import Dataset
 
@@ -19,3 +25,260 @@ def test_load_nimads(example_nimads_studyset, example_nimads_annotation):
     assert isinstance(filtered_studyset, nimads.Studyset)
     dataset = filtered_studyset.to_dataset()
     assert isinstance(dataset, Dataset)
+
+
+def test_slice_preserves_metadata_and_annotations(
+    example_nimads_studyset, example_nimads_annotation
+):
+    """Test that slicing preserves both metadata and annotations.
+
+    This test verifies that both metadata attached to analyses and annotation
+    notes are correctly preserved when slicing a studyset.
+    """
+    studyset = nimads.Studyset(example_nimads_studyset)
+    studyset.annotations = example_nimads_annotation
+
+    # Get analysis IDs from the first annotation
+    annotation = studyset.annotations[0]
+    analysis_ids = [n.analysis.id for n in annotation.notes if n.note["include"]]
+    selected_ids = analysis_ids[:2]  # Take first two analyses
+
+    # Add metadata to the analyses we'll keep
+    metadata_map = {}
+    for study in studyset.studies:
+        for analysis in study.analyses:
+            if analysis.id in selected_ids:
+                analysis.metadata = {
+                    "sample_size": 30,
+                    "contrast_type": "activation",
+                    "significance_threshold": 0.001,
+                }
+                metadata_map[analysis.id] = analysis.metadata
+
+    # Slice studyset
+    sliced_studyset = studyset.slice(analyses=selected_ids)
+
+    # Verify analyses and their metadata are preserved
+    for study in sliced_studyset.studies:
+        for analysis in study.analyses:
+            assert analysis.id in selected_ids
+            assert analysis.metadata == metadata_map[analysis.id]
+
+    # Verify annotations are preserved for remaining analyses
+    sliced_annotation = sliced_studyset.annotations[0]
+    sliced_analysis_ids = [n.analysis.id for n in sliced_annotation.notes]
+    sliced_annotation_notes = {n.analysis.id: n.note for n in sliced_annotation.notes}
+
+    # Check that notes exist only for remaining analyses
+    assert set(sliced_analysis_ids) == set(selected_ids)
+
+    # Check that annotation contents are preserved
+    for analysis_id in selected_ids:
+        original_note = next(n.note for n in annotation.notes if n.analysis.id == analysis_id)
+        assert sliced_annotation_notes[analysis_id] == original_note
+
+
+def test_studyset_init(example_nimads_studyset):
+    """Test Studyset initialization."""
+    # Test initialization with dict
+    studyset1 = nimads.Studyset(example_nimads_studyset)
+    assert studyset1.id == example_nimads_studyset["id"]
+    assert studyset1.name == example_nimads_studyset["name"]
+    assert len(studyset1.studies) == len(example_nimads_studyset["studies"])
+
+    # Test initialization with JSON file
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as tmp:
+        json.dump(example_nimads_studyset, tmp)
+        tmp_path = tmp.name
+
+    try:
+        studyset2 = nimads.Studyset(tmp_path)
+        assert studyset2.id == example_nimads_studyset["id"]
+        assert studyset2.name == example_nimads_studyset["name"]
+        assert len(studyset2.studies) == len(example_nimads_studyset["studies"])
+    finally:
+        os.unlink(tmp_path)
+
+
+def test_studyset_string_methods(example_nimads_studyset):
+    """Test string representation methods."""
+    studyset = nimads.Studyset(example_nimads_studyset)
+
+    # Test __repr__
+    assert repr(studyset) == f"'<Studyset: {studyset.id}>'"
+
+    # Test __str__
+    expected_str = f"Studyset: {studyset.name} :: studies: {len(studyset.studies)}"
+    assert str(studyset) == expected_str
+
+
+def test_studyset_save_load(example_nimads_studyset):
+    """Test saving and loading Studyset."""
+    studyset = nimads.Studyset(example_nimads_studyset)
+
+    with tempfile.NamedTemporaryFile(suffix=".pkl", delete=False) as tmp:
+        tmp_path = tmp.name
+
+    try:
+        # Test save
+        studyset.save(tmp_path)
+        assert os.path.exists(tmp_path)
+
+        # Test load
+        new_studyset = nimads.Studyset({"id": "temp", "name": "", "studies": []})
+        new_studyset.load(tmp_path)
+
+        assert new_studyset.id == studyset.id
+        assert new_studyset.name == studyset.name
+        assert len(new_studyset.studies) == len(studyset.studies)
+    finally:
+        os.unlink(tmp_path)
+
+
+def test_studyset_to_dict(example_nimads_studyset):
+    """Test conversion to dictionary."""
+    studyset = nimads.Studyset(example_nimads_studyset)
+    result = studyset.to_dict()
+
+    assert isinstance(result, dict)
+    assert "id" in result
+    assert "name" in result
+    assert "studies" in result
+    assert len(result["studies"]) == len(studyset.studies)
+
+
+def test_studyset_to_nimads(example_nimads_studyset):
+    """Test saving to NIMADS format."""
+    studyset = nimads.Studyset(example_nimads_studyset)
+
+    with tempfile.NamedTemporaryFile(suffix=".json", delete=False) as tmp:
+        tmp_path = tmp.name
+
+    try:
+        studyset.to_nimads(tmp_path)
+        assert os.path.exists(tmp_path)
+
+        # Verify the saved file can be loaded
+        with open(tmp_path, "r") as f:
+            saved_data = json.load(f)
+
+        assert saved_data["id"] == studyset.id
+        assert saved_data["name"] == studyset.name
+        assert len(saved_data["studies"]) == len(studyset.studies)
+    finally:
+        os.unlink(tmp_path)
+
+
+def test_studyset_copy(example_nimads_studyset):
+    """Test copying of Studyset."""
+    studyset = nimads.Studyset(example_nimads_studyset)
+    copied = studyset.copy()
+
+    assert copied is not studyset
+    assert copied.id == studyset.id
+    assert copied.name == studyset.name
+    assert len(copied.studies) == len(studyset.studies)
+
+
+def test_studyset_merge(example_nimads_studyset):
+    """Test merging of Studysets."""
+    studyset1 = nimads.Studyset(example_nimads_studyset)
+
+    # Create a modified copy for merging
+    modified_data = example_nimads_studyset.copy()
+    modified_data["id"] = "other_id"
+    modified_data["name"] = "Other name"
+    studyset2 = nimads.Studyset(modified_data)
+
+    merged = studyset1.merge(studyset2)
+
+    assert isinstance(merged, nimads.Studyset)
+    assert merged.id == f"{studyset1.id}_{studyset2.id}"
+    assert merged.name == f"Merged: {studyset1.name} + {studyset2.name}"
+
+    # Test invalid merge
+    with pytest.raises(ValueError):
+        studyset1.merge("not a studyset")
+
+
+def test_get_analyses_by_coordinates(example_nimads_studyset):
+    """Test retrieving analyses by coordinates."""
+    studyset = nimads.Studyset(example_nimads_studyset)
+
+    # Test with radius
+    xyz = [0, 0, 0]
+    results_r = studyset.get_analyses_by_coordinates(xyz, r=10)
+    assert isinstance(results_r, list)
+
+    # Test with n nearest
+    results_n = studyset.get_analyses_by_coordinates(xyz, n=5)
+    assert isinstance(results_n, list)
+    assert len(results_n) <= 5
+
+    # Test invalid parameters
+    with pytest.raises(ValueError):
+        studyset.get_analyses_by_coordinates(xyz)  # Neither r nor n
+    with pytest.raises(ValueError):
+        studyset.get_analyses_by_coordinates(xyz, r=10, n=5)  # Both r and n
+    with pytest.raises(ValueError):
+        studyset.get_analyses_by_coordinates([0, 0])  # Invalid coordinates
+
+
+def test_get_analyses_by_mask(example_nimads_studyset, mni_mask):
+    """Test retrieving analyses by mask."""
+    studyset = nimads.Studyset(example_nimads_studyset)
+
+    results = studyset.get_analyses_by_mask(mni_mask)
+    assert isinstance(results, list)
+
+
+def test_get_analyses_by_metadata(example_nimads_studyset):
+    """Test retrieving analyses by metadata."""
+    studyset = nimads.Studyset(example_nimads_studyset)
+
+    # Add some metadata for testing
+    key = "test_key"
+    value = "test_value"
+    for study in studyset.studies:
+        for analysis in study.analyses:
+            analysis.metadata[key] = value
+
+    # Test with key only
+    results1 = studyset.get_analyses_by_metadata(key)
+    assert isinstance(results1, dict)
+
+    # Test with key and value
+    results2 = studyset.get_analyses_by_metadata(key, value)
+    assert isinstance(results2, dict)
+    assert all(list(d.values())[0] == value for d in results2.values())
+
+
+def test_data_retrieval_methods(example_nimads_studyset):
+    """Test methods that retrieve data for specified analyses."""
+    studyset = nimads.Studyset(example_nimads_studyset)
+
+    # Get some analysis IDs to test with
+    analysis_ids = []
+    for study in studyset.studies:
+        for analysis in study.analyses:
+            analysis_ids.append(analysis.id)
+            if len(analysis_ids) >= 2:  # Just test with first two analyses
+                break
+        if len(analysis_ids) >= 2:
+            break
+
+    # Test get_points
+    points = studyset.get_points(analysis_ids)
+    assert isinstance(points, dict)
+
+    # Test get_images
+    images = studyset.get_images(analysis_ids)
+    assert isinstance(images, dict)
+
+    # Test get_metadata
+    metadata = studyset.get_metadata(analysis_ids)
+    assert isinstance(metadata, dict)
+
+    # Test get_annotations
+    annotations = studyset.get_annotations(analysis_ids)
+    assert isinstance(annotations, dict)

nimare/utils.py

@@ -1286,9 +1286,9 @@ def b_spline_bases(masker_voxels, spacing, margin=10):
     x_spline_coords = x_spline.nonzero()
     y_spline_coords = y_spline.nonzero()
     z_spline_coords = z_spline.nonzero()
-    x_spline_sparse = sparse.COO(x_spline_coords, x_spline[x_spline_coords])
-    y_spline_sparse = sparse.COO(y_spline_coords, y_spline[y_spline_coords])
-    z_spline_sparse = sparse.COO(z_spline_coords, z_spline[z_spline_coords])
+    x_spline_sparse = sparse.COO(x_spline_coords, x_spline[x_spline_coords], shape=x_spline.shape)
+    y_spline_sparse = sparse.COO(y_spline_coords, y_spline[y_spline_coords], shape=y_spline.shape)
+    z_spline_sparse = sparse.COO(z_spline_coords, z_spline[z_spline_coords], shape=z_spline.shape)
 
     # create spatial design matrix by tensor product of spline bases in 3 dimesion
     # Row sums of X are all 1=> There is no need to re-normalise X

{nimare-0.4.2rc4.dist-info → nimare-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nimare
-Version: 0.4.2rc4
+Version: 0.5.0
 Summary: NiMARE: Neuroimaging Meta-Analysis Research Environment
 Home-page: https://github.com/neurostuff/NiMARE
 Author: NiMARE developers

{nimare-0.4.2rc4.dist-info → nimare-0.5.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
 benchmarks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 benchmarks/bench_cbma.py,sha256=fg_EER8hohi6kD1Hno_uXsFntKuCLTvseu-6OqkHkoU,1382
 nimare/__init__.py,sha256=HHIq3EimSZSf3zJSDwuTjBig1GbRwHGYfRLSqI3yleE,802
-nimare/_version.py,sha256=-_XjBHi6NWmhzi6JM6lRzA_-9vJ61UHSP66mEa1jicw,500
+nimare/_version.py,sha256=yDyGWuluU_v_cYzPo2r_ijBugg3SveqkOJLRp7q7EJA,497
 nimare/base.py,sha256=9DlcRB2mW759p7XqpKG3wRE-MmPsEPiYTbq6V1Yile4,7826
 nimare/cli.py,sha256=Zvy5jN2KopH_MBke-gm8A0DbBZmIFGvnE1tjhbYib9I,3695
 nimare/correct.py,sha256=2eI0jR6_odND-2CzSlaxRU2um6ccLSapd7ERAYteBnE,17110
@@ -9,12 +9,12 @@ nimare/dataset.py,sha256=LmjDE1GQ3ud33l3plvms_Uv8GB9_Xb-6kPtkIV2eYTw,24650
 nimare/diagnostics.py,sha256=sCatkXUM9rvrY9MMz6Q66njWSiWGifWwSNEMu3ldnVs,20263
 nimare/estimator.py,sha256=DtsSIyPDrKkpi-KNv2m-cZMvJO7CCfHLXHRhCT73sbY,5063
 nimare/generate.py,sha256=L4_c2sLAlF7XDKTm-3q4oOx8pLID2NaxG9YET5KSIZw,12475
-nimare/io.py,sha256=iNejkAclJh6u6_zGa_9sg1u4YBO02fho0quKyycDUTQ,25831
-nimare/nimads.py,sha256=Wxz7b_O0f8DEXb2NNlOuJkEcfGKbH-wGwLkoZhdU8sY,16277
+nimare/io.py,sha256=76T9KLOorquImy-01cLG3pwuJLJm_UD_hAhK3_0qj7g,27299
+nimare/nimads.py,sha256=2s5QnaLvrBt-kMrImGhG_p6r0unysufIIcPczr2bG0c,24342
 nimare/results.py,sha256=7szcyR6PkZAXBqbIGGWrw1nW9j9QCdpdl4MxUK_1Wzc,8190
 nimare/stats.py,sha256=XhXfFj6KHTPVSTXhbEid0qt8HLqJD82Bl5T23qmaf40,10098
 nimare/transforms.py,sha256=_kZO8N3IEHxd6Ir4IcewZtkWHpFknnjEnjsaD9b-1pg,30136
-nimare/utils.py,sha256=BJOOKgQuubamE0RBMJVubggQfaPgIH9wZ9Oou9DKvbU,46936
+nimare/utils.py,sha256=rMuT1mhEYrb3R_2EAsz5A_f5VPWXzqRkH_saQTFybm4,47002
 nimare/annotate/__init__.py,sha256=hTla1yFYTJ8PDjm72ReeHa3qf0Que50Ww0fqz3Z86JI,434
 nimare/annotate/cogat.py,sha256=xzrepAuTkRenbECn4XYwgyul45r0tIMxCDKQV_ZFVb8,7457
 nimare/annotate/gclda.py,sha256=P2OQjuJn3DX0GVPte_VIVZf0LfO-yE_OhLbs6DwMaHQ,42592
@@ -35,7 +35,7 @@ nimare/meta/cbmr.py,sha256=h9CNMHW4KUh-YQYyGDRzqPN7G1tkHYAhrSgxrP8E61s,47769
 nimare/meta/ibma.py,sha256=qVw3ZhOlK6hgTdZZwa7TPDpfrGLf52dN00wH2Gw-Z8c,65442
 nimare/meta/kernel.py,sha256=5wN-6dbLkzqQ0WUSTrC0DJPSbbyGiZCls9M_TAYhNGY,19169
 nimare/meta/models.py,sha256=0QPlQTjWaNTeI8qTX-DHMXVjQSRD72SfJ2RZIYBZnCg,47054
-nimare/meta/utils.py,sha256=fvnFz4ek8APjQHhYBS441WYXE1N9huHaTiOO0Bvui4Q,18083
+nimare/meta/utils.py,sha256=84T4I-wn-HTx7zwMqh0TdvzUbBe_vcpxIU4jA_pfuFU,18083
 nimare/meta/cbma/__init__.py,sha256=bWLrv5tL03U2ITttnnz3yerbg74w44qkZgdy32QMhqQ,219
 nimare/meta/cbma/ale.py,sha256=ZNjXC4MXhfSHvrTRppY04NkGtz_Iri696k5QMuBog7o,39273
 nimare/meta/cbma/base.py,sha256=-gJ4hW6_6T5oto3pre9GbWodHWRmPS2WZ1LJjB0BtMI,38382
@@ -74,13 +74,13 @@ nimare/tests/test_diagnostics.py,sha256=VrfR_8nQKn2VF7dFdnTM7ZQy3Ou5eHdpaLhml5T6
 nimare/tests/test_estimator_performance.py,sha256=tbK2Qr83rB0in-pB6MccnjLg4iHSyfilx-hTNDWQfe4,12749
 nimare/tests/test_extract.py,sha256=XJSxZTdy_hAej1J9CFK9zQk29rAM5KPiZKlopmUVCJ4,1206
 nimare/tests/test_generate.py,sha256=LSh2APJsg87u2s2zydkrre3RVk_ZGpoB4d7uuvIPWYE,7318
-nimare/tests/test_io.py,sha256=KHllr7-GZ4ih2mx4rP-wxJiDZZIK-tNzWnGWEsx8lys,8810
+nimare/tests/test_io.py,sha256=QKr_zRGu8tyrpiLoLAjCV9ektxCTHRlKPWgyJRqQ9T8,10397
 nimare/tests/test_meta_ale.py,sha256=hccXSNzLGUgj6E4tCsiHZpuUFoBxXkP293-vtUS5jdE,11791
 nimare/tests/test_meta_cbmr.py,sha256=cl_pUA1dxXpDD5Ci_tllSVG0uKykuneHDbUxGY4w7Ks,9776
 nimare/tests/test_meta_ibma.py,sha256=Yw4F0_pr3cpVSe7oeMlK0-btg1Uw58cenklOsIw87Pc,7775
 nimare/tests/test_meta_kernel.py,sha256=Edk6lOsnqokg86mp9jAkokA203K61R7pjJEmyEEzV7E,8450
 nimare/tests/test_meta_mkda.py,sha256=9PuzNUKrTBjbCHdSnuOAToXbV7wp1O0TCdD537qGQkA,9206
-nimare/tests/test_nimads.py,sha256=xIp88X2uRumQG04j9pBRP4hoCoQ4U9I5S7zFKn1d4w8,856
+nimare/tests/test_nimads.py,sha256=3yzCO8rmUVfEYAt3HNnJcyAENorJ5BOWdJXY3hjrdP0,9807
 nimare/tests/test_reports.py,sha256=Qdz-PHjQwOneRmSCo0ac2d67BeGypWJIMi4OoiQrNik,3293
 nimare/tests/test_stats.py,sha256=_GhpUC1u4hnFR2SZ-sHQqkJ5MwsyPsvwPEd2GkQmsHY,4030
 nimare/tests/test_transforms.py,sha256=mzEnufefhybs4r_dfRY6zQUAShepPMwKFY7S5amq3cs,10378
@@ -111,9 +111,9 @@ nimare/workflows/cbma.py,sha256=2jYJs9kH7_LzFP6d7-oTHiTTgAFbtmiBNtBXSCSZPjg,7052
 nimare/workflows/ibma.py,sha256=lAkWtqSqnZiUUV460Bh046U9LeGhnry3bl8BFi-tx7s,4289
 nimare/workflows/macm.py,sha256=mVUBeKbTawhU93ApnkunZSUXZWo7qBPrM3dMGWfl0ik,2531
 nimare/workflows/misc.py,sha256=OWgHlSAnRI0-5Seii-bd48piIYsfEAF_aNKGorH1yJQ,1827
-nimare-0.4.2rc4.dist-info/LICENSE,sha256=PWPXnCGWh-FMiBZ61OnQ2BHFjPPlJJ7F0kFx_ryzp-M,1074
-nimare-0.4.2rc4.dist-info/METADATA,sha256=84gE0ZR41UJuqMjIXEpvTaoRAfeGLa_Jb_61s7fMlsk,4698
-nimare-0.4.2rc4.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-nimare-0.4.2rc4.dist-info/entry_points.txt,sha256=3w_hk9N2PWnKZkCaJyDlc0_kdn3rh35aiI21rSdvsuA,44
-nimare-0.4.2rc4.dist-info/top_level.txt,sha256=XnOcEXMs0BxdI8t3_ksTl96T8hykn9L7-bxLLraVrTI,18
-nimare-0.4.2rc4.dist-info/RECORD,,
+nimare-0.5.0.dist-info/LICENSE,sha256=PWPXnCGWh-FMiBZ61OnQ2BHFjPPlJJ7F0kFx_ryzp-M,1074
+nimare-0.5.0.dist-info/METADATA,sha256=6kJAmkMFEOP6_q-95CW66xbYhWrnT-JfYvPSS9yUaDU,4695
+nimare-0.5.0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+nimare-0.5.0.dist-info/entry_points.txt,sha256=3w_hk9N2PWnKZkCaJyDlc0_kdn3rh35aiI21rSdvsuA,44
+nimare-0.5.0.dist-info/top_level.txt,sha256=XnOcEXMs0BxdI8t3_ksTl96T8hykn9L7-bxLLraVrTI,18
+nimare-0.5.0.dist-info/RECORD,,