nimare 0.4.2__tar.gz → 0.5.0__tar.gz

{nimare-0.4.2/nimare.egg-info → nimare-0.5.0}/PKG-INFO

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

{nimare-0.4.2 → nimare-0.5.0}/nimare/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-03-11T16:24:19-0500",
+ "date": "2025-04-25T13:22:39-0500",
  "dirty": false,
  "error": null,
- "full-revisionid": "b838dbbd3afa34668c431ba7cfee568650cee0b4",
- "version": "0.4.2"
+ "full-revisionid": "9e3b73cbb6235b31a4fab7a9a118e32c1d2f9932",
+ "version": "0.5.0"
 }
 '''  # END VERSION_JSON
 

{nimare-0.4.2 → nimare-0.5.0}/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-0.4.2 → nimare-0.5.0}/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-0.4.2 → nimare-0.5.0}/nimare/tests/test_io.py

@@ -64,18 +64,6 @@ def test_analysis_to_dict_invalid_sample_sizes_type(example_nimads_studyset):
         io.convert_nimads_to_dataset(studyset)
 
 
-def test_analysis_to_dict_invalid_annotations_format(example_nimads_studyset):
-    """Test _analysis_to_dict raises ValueError when annotations are in an invalid format."""
-    studyset = Studyset(example_nimads_studyset)
-    # Here we assume that the annotation is expected to be a dict
-    # Set annotation to an invalid format (e.g., a string)
-    for study in studyset.studies:
-        for analysis in study.analyses:
-            analysis.metadata["annotations"] = "invalid_format"
-    with pytest.raises(TypeError):
-        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")