brainstat 0.4.2__tar.gz → 0.6.0__tar.gz

{brainstat-0.4.2/brainstat.egg-info → brainstat-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: brainstat
-Version: 0.4.2
+Version: 0.6.0
 Summary: A toolbox for statistical analysis of neuroimaging data
 Home-page: https://github.com/MICA-LAB/BrainStat
 Author: MNI-MICA Lab and MPI-CNG Lab
@@ -13,13 +13,44 @@ Classifier: Intended Audience :: Science/Research
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Build Tools
 Classifier: Topic :: Scientific/Engineering
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Requires-Python: >=3.7.*
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
-Provides-Extra: dev
 License-File: LICENSE
+Requires-Dist: abagen>=0.1
+Requires-Dist: brainspace>=0.1.2
+Requires-Dist: h5py
+Requires-Dist: matplotlib>=3.4
+Requires-Dist: netneurotools<0.3.0
+Requires-Dist: neurosynth
+Requires-Dist: nibabel
+Requires-Dist: nilearn>=0.7.0
+Requires-Dist: nimare
+Requires-Dist: numpy<2,>=1.21
+Requires-Dist: pandas<2.1,>=1.3
+Requires-Dist: scikit_learn>=1.0
+Requires-Dist: scipy>=1.7
+Requires-Dist: templateflow
+Requires-Dist: trimesh
+Provides-Extra: dev
+Requires-Dist: gitpython; extra == "dev"
+Requires-Dist: hcp-utils; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: plotly; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 BrainStat : A toolbox for statistical analysis of neuroimaging data
 ===================================================================

{brainstat-0.4.2 → brainstat-0.6.0}/brainstat/__init__.py

@@ -1,2 +1,2 @@
 """Neuroimaging statistics toolbox."""
-__version__ = "0.4.2"
+__version__ = "0.6.0"

{brainstat-0.4.2 → brainstat-0.6.0}/brainstat/_utils.py

@@ -150,7 +150,7 @@ def deprecated(message: str) -> Callable:
 def _download_file(
     url: str, output_file: Path, overwrite: bool = False, verbose=True
 ) -> None:
-    """Downloads a file.
+    """Downloads a file with retry logic for network failures.
 
     Parameters
     ----------
@@ -163,14 +163,39 @@ def _download_file(
     verbose : bool
         If true, print a download message, defaults to True.
     """
+    import time
+    from http.client import RemoteDisconnected
+    from urllib.error import URLError
 
     if output_file.exists() and not overwrite:
         return
 
     if verbose:
         logger.info("Downloading " + str(output_file) + " from " + url + ".")
-    with urllib.request.urlopen(url) as response, open(output_file, "wb") as out_file:
-        shutil.copyfileobj(response, out_file)
+    
+    # Retry logic for intermittent network failures
+    max_retries = 3
+    retry_delay = 2  # seconds
+    
+    for attempt in range(max_retries):
+        try:
+            with urllib.request.urlopen(url, timeout=30) as response, open(output_file, "wb") as out_file:
+                shutil.copyfileobj(response, out_file)
+            return  # Success, exit function
+        except (RemoteDisconnected, URLError, TimeoutError) as e:
+            if attempt < max_retries - 1:
+                logger.warning(
+                    f"Download attempt {attempt + 1}/{max_retries} failed: {e}. "
+                    f"Retrying in {retry_delay} seconds..."
+                )
+                time.sleep(retry_delay)
+                retry_delay *= 2  # Exponential backoff
+            else:
+                logger.error(f"Download failed after {max_retries} attempts.")
+                raise  # Re-raise the exception after all retries fail
+
+
+
 
 
 if __name__ == "__main__":

{brainstat-0.4.2 → brainstat-0.6.0}/brainstat/context/genetics.py

@@ -2,13 +2,59 @@
 import tempfile
 from pathlib import Path
 from typing import Optional, Sequence, Union
-
+import os
 import nibabel as nib
 import numpy as np
 import pandas as pd
+
+# Monkeypatch for abagen compatibility with pandas 2.0+
+if not hasattr(pd.DataFrame, 'append'):
+    def _append(self, other, ignore_index=False, verify_integrity=False, sort=False):
+        from pandas import concat
+        if isinstance(other, (list, tuple)):
+            to_concat = [self] + list(other)
+        else:
+            to_concat = [self, other]
+        return concat(to_concat, ignore_index=ignore_index, verify_integrity=verify_integrity, sort=sort)
+    pd.DataFrame.append = _append
+
+# Monkeypatch for abagen compatibility with pandas 2.0+ (set_axis inplace)
+_original_set_axis = pd.DataFrame.set_axis
+def _set_axis_patched(self, labels, *args, **kwargs):
+    if 'inplace' in kwargs:
+        del kwargs['inplace']
+    return _original_set_axis(self, labels, *args, **kwargs)
+pd.DataFrame.set_axis = _set_axis_patched
+
+import abagen.images
+
+def _labeltable_to_df_patched(labels):
+    """
+    Patched version of abagen.utils.labeltable_to_df to handle missing 0 index
+    and use pd.concat instead of append.
+    """
+    info = pd.DataFrame(columns=['id', 'label', 'hemisphere', 'structure'])
+    for table, hemi in zip(labels, ('L', 'R')):
+        if len(table) == 0:
+            continue
+        ids, label = zip(*table.items())
+        new_df = pd.DataFrame(dict(id=ids, label=label, hemisphere=hemi, structure='cortex'))
+        info = pd.concat([info, new_df], ignore_index=True)
+        
+    # Use errors='ignore' to handle missing 0
+    info = info.set_index('id').drop([0], axis=0, errors='ignore').sort_index()
+
+    if len(info) != 0:
+        return info
+
+abagen.images.labeltable_to_df = _labeltable_to_df_patched
+
+
+import collections
 from abagen import check_atlas, get_expression_data
 from brainspace.mesh.mesh_io import read_surface, write_surface
 from sklearn.model_selection import ParameterGrid
+from nibabel.gifti import GiftiImage, GiftiDataArray
 
 from brainstat._utils import data_directories, logger
 from brainstat.datasets.base import (
@@ -23,7 +69,7 @@ def surface_genetic_expression(
     surfaces: Optional[Union[str, Sequence[str]]] = None,
     space: Optional[str] = None,
     *,
-    atlas_info: str = None,
+    atlas_info: Optional[str] = None,
     ibf_threshold: float = 0.5,
     probe_selection: str = "diff_stability",
     donor_probes: str = "aggregate",
@@ -89,52 +135,90 @@ def surface_genetic_expression(
     elif surfaces is None:
         surfaces = []
 
-    surfaces_gii = []
-    for surface in surfaces:
-        if not isinstance(surface, str) and not isinstance(surface, Path):
-            # Rather roundabout deletion of the temporary file for Windows compatibility.
+    temp_files = []
+    try:
+        if isinstance(labels, np.ndarray):
+            # Assuming 'labels' is a 1D NumPy array of length 20484
+            num_vertices = len(labels)  # Should be 20484
+            half_size = num_vertices // 2  # Half of 20484, which is 10242
+
+            # Split the array into two halves
+            labels_left = labels[:half_size]  # First half for the left hemisphere
+            labels_right = labels[half_size:]  # Second half for the right hemisphere
+
+            # Create GiftiDataArrays for each hemisphere
+            data_array_left = GiftiDataArray(data=labels_left)
+            data_array_right = GiftiDataArray(data=labels_right)
+
+            # Create separate GiftiImages for each hemisphere
+            labels_left_gii = GiftiImage(darrays=[data_array_left])
+            labels_right_gii = GiftiImage(darrays=[data_array_right])
+            
+            # Save to temporary files for abagen compatibility
+            labels_files = []
+            for img in [labels_left_gii, labels_right_gii]:
+                f = tempfile.NamedTemporaryFile(suffix=".gii", delete=False)
+                f.close()
+                nib.save(img, f.name)
+                labels_files.append(f.name)
+                temp_files.append(f.name)
+            labels = tuple(labels_files)
+    
+        surfaces_gii = []
+        for surface in surfaces:
+            if not isinstance(surface, str) and not isinstance(surface, Path):
+                # Cast surface data to float32 to comply with GIFTI standard
+                # GIFTI only supports uint8, int32, and float32 datatypes
+                if hasattr(surface, 'Points') and surface.Points.dtype != np.float32:
+                    surface = surface.copy()
+                    surface.Points = surface.Points.astype(np.float32)
+                
+                f = tempfile.NamedTemporaryFile(suffix=".gii", delete=False)
+                f.close()
+                write_surface(surface, f.name, otype="gii")
+                surfaces_gii.append(f.name)
+                temp_files.append(f.name)
+            else:
+                surfaces_gii.append(surface)
+
+        # Use abagen to grab expression data.
+        logger.info(
+            "If you use BrainStat's genetics functionality, please cite abagen (https://abagen.readthedocs.io/en/stable/citing.html)."
+        )
+        atlas = check_atlas(labels, geometry=surfaces_gii, space=space)
+        expression = get_expression_data(
+            atlas,
+            atlas_info=atlas_info,
+            ibf_threshold=ibf_threshold,
+            probe_selection=probe_selection,
+            donor_probes=donor_probes,
+            lr_mirror=lr_mirror,
+            missing=missing,
+            tolerance=tolerance,
+            sample_norm=sample_norm,
+            gene_norm=gene_norm,
+            norm_matched=norm_matched,
+            norm_structures=norm_structures,
+            region_agg=region_agg,
+            agg_metric=agg_metric,
+            corrected_mni=corrected_mni,
+            reannotated=reannotated,
+            return_counts=return_counts,
+            return_donors=return_donors,
+            return_report=return_report,
+            donors=donors,
+            data_dir=data_dir,
+            verbose=verbose,
+            n_proc=n_proc,
+        )
+
+        return expression
+    finally:
+        for f in temp_files:
             try:
-                with tempfile.NamedTemporaryFile(suffix=".gii", delete=False) as f:
-                    name = f.name
-                    write_surface(surface, name, otype="gii")
-                surfaces_gii.append(nib.load(name))
-            finally:
-                Path(name).unlink()
-        else:
-            surfaces_gii.append(nib.load(surface))
-
-    # Use abagen to grab expression data.
-    logger.info(
-        "If you use BrainStat's genetics functionality, please cite abagen (https://abagen.readthedocs.io/en/stable/citing.html)."
-    )
-    atlas = check_atlas(labels, geometry=surfaces_gii, space=space)
-    expression = get_expression_data(
-        atlas,
-        atlas_info=atlas_info,
-        ibf_threshold=ibf_threshold,
-        probe_selection=probe_selection,
-        donor_probes=donor_probes,
-        lr_mirror=lr_mirror,
-        missing=missing,
-        tolerance=tolerance,
-        sample_norm=sample_norm,
-        gene_norm=gene_norm,
-        norm_matched=norm_matched,
-        norm_structures=norm_structures,
-        region_agg=region_agg,
-        agg_metric=agg_metric,
-        corrected_mni=corrected_mni,
-        reannotated=reannotated,
-        return_counts=return_counts,
-        return_donors=return_donors,
-        return_report=return_report,
-        donors=donors,
-        data_dir=data_dir,
-        verbose=verbose,
-        n_proc=n_proc,
-    )
-
-    return expression
+                Path(f).unlink()
+            except FileNotFoundError:
+                pass
 
 
 def __create_precomputed(

{brainstat-0.4.2 → brainstat-0.6.0}/brainstat/context/histology.py

@@ -114,6 +114,7 @@ def read_histology_profile(
     data_dir: Optional[Union[str, Path]] = None,
     template: str = "fsaverage",
     overwrite: bool = False,
+    invert: bool = True,
 ) -> np.ndarray:
     """Reads BigBrain histology profiles.
 
@@ -127,6 +128,15 @@ def read_histology_profile(
         default 'fsaverage'.
     overwrite : bool, optional
         If true, existing data will be overwrriten, by default False.
+    invert : bool, optional
+        If True (default), invert the 8-bit intensity values so that higher
+        numbers correspond to darker, more cell-dense regions, matching the
+        convention used in Paquola et al. 2021 (eLife) and most downstream
+        BigBrain analyses. The raw BigBrainWarp data uses the opposite
+        convention (0 = black). Set to False to return the raw values. MPC
+        and gradient computations (correlation-based) are invariant to this
+        flip; only direct inspection of profile intensities is affected.
+        See https://github.com/MICA-MNI/BrainStat/issues/274 for context.
 
     Returns
     -------
@@ -156,13 +166,32 @@ def read_histology_profile(
         )
 
     with h5py.File(histology_file, "r") as h5_file:
-        profiles = h5_file.get(template)[...]
-        if civet_template:
-            fsaverage_surface = fetch_template_surface("fsaverage")
-            civet_surface = fetch_template_surface(civet_template)
-            return _surf2surf(fsaverage_surface, civet_surface, profiles.T).T
+        if template == "fslr32k":
+            # Known issue #369: The fslr32k data file on the server actually contains
+            # fs_LR_64k resolution data (64984 vertices) instead of fs_LR_32k (32492 vertices).
+            # This is a data hosting issue. Users expecting 32k resolution data should be aware
+            # that they will receive 64k resolution data until this is fixed on the server.
+            logger.warning(
+                "Known issue: The fslr32k histology profile data currently contains "
+                "fs_LR_64k resolution (64984 vertices) instead of fs_LR_32k (32492 vertices). "
+                "See https://github.com/MICA-MNI/BrainStat/issues/369 for details."
+            )
+            profiles = h5_file.get("fs_LR_64k")[...]
         else:
-            return profiles
+            profiles = h5_file.get(template)[...]
+
+    if invert:
+        # Map from BigBrainWarp convention (low = dark/dense) to the
+        # literature convention (high = dark/dense). The data is unsigned
+        # 8-bit, so the inversion is `255 - x`.
+        max_value = np.iinfo(profiles.dtype).max if np.issubdtype(profiles.dtype, np.integer) else 255
+        profiles = max_value - profiles
+
+    if civet_template:
+        fsaverage_surface = fetch_template_surface("fsaverage")
+        civet_surface = fetch_template_surface(civet_template)
+        return _surf2surf(fsaverage_surface, civet_surface, profiles.T).T
+    return profiles
 
 
 def download_histology_profiles(
@@ -191,7 +220,16 @@ def download_histology_profiles(
 
     data_dir = Path(data_dir) if data_dir else data_directories["BIGBRAIN_DATA_DIR"]
     data_dir.mkdir(parents=True, exist_ok=True)
-    output_file = data_dir / ("histology_" + template + ".h5")
+    if template == "fslr32k":
+        output_file = data_dir / "histology_fslr32k.h5"
+        # Known issue #369: warn users about data resolution mismatch
+        logger.warning(
+            "Note: The fslr32k histology profile data currently contains "
+            "fs_LR_64k resolution (64984 vertices) instead of fs_LR_32k. "
+            "See https://github.com/MICA-MNI/BrainStat/issues/369 for details."
+        )
+    else:
+        output_file = data_dir / ("histology_" + template + ".h5")
 
     url = read_data_fetcher_json()["bigbrain_profiles"][template]["url"]
 

{brainstat-0.4.2 → brainstat-0.6.0}/brainstat/datasets/base.py

@@ -1,6 +1,8 @@
 """ Load external datasets. """
+import json
 import tempfile
 import zipfile
+from collections import namedtuple
 from pathlib import Path
 from typing import List, Optional, Tuple, Union
 
@@ -11,9 +13,19 @@ from brainspace.mesh.mesh_io import read_surface
 from brainspace.mesh.mesh_operations import combine_surfaces
 from brainspace.vtk_interface.wrappers.data_object import BSPolyData
 from netneurotools import datasets as nnt_datasets
-from netneurotools.civet import read_civet
 from nibabel import load as nib_load
 from nibabel.freesurfer.io import read_annot, read_geometry
+from sklearn.utils import Bunch
+
+try:
+    from netneurotools.datasets.utils import _get_data_dir, _get_dataset_info
+except ImportError:
+    from netneurotools.datasets.datasets_utils import _get_data_dir, _get_dataset_info
+
+try:
+    from nilearn.datasets._utils import fetch_files as _fetch_files
+except ImportError:
+    from nilearn.datasets.utils import fetch_files as _fetch_files
 
 from brainstat._utils import (
     _download_file,
@@ -24,6 +36,65 @@ from brainstat._utils import (
 from brainstat.mesh.interpolate import _surf2surf
 
 
+def read_civet(fname: Union[str, Path]) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Reads a CIVET surface file (MNI OBJ format).
+
+    Parameters
+    ----------
+    fname : str or Path
+        Path to the CIVET surface file.
+
+    Returns
+    -------
+    vertices : numpy.ndarray
+        (N, 3) array of vertex coordinates.
+    faces : numpy.ndarray
+        (M, 3) array of face indices.
+    """
+    fname = str(fname)
+    with open(fname, "rb") as f:
+        first_char = f.read(1)
+
+    if first_char == b"P":
+        with open(fname, "r") as f:
+            content = f.read().split()
+
+        n_vertices = int(content[6])
+
+        idx = 7
+        # Vertices
+        vertices = np.array(content[idx : idx + n_vertices * 3], dtype=float).reshape(
+            -1, 3
+        )
+        idx += n_vertices * 3
+
+        # Normals
+        idx += n_vertices * 3
+
+        n_triangles = int(content[idx])
+        idx += 1
+
+        color_flag = int(content[idx])
+        idx += 1
+
+        if color_flag == 0:
+            idx += 4
+        else:
+            idx += n_vertices * 4
+
+        # Check remaining items to decide if we need to skip
+        remaining = len(content) - idx
+        if remaining == n_triangles * 3 + n_triangles:
+            idx += n_triangles
+
+        triangles = np.array(content[idx:], dtype=int).reshape(-1, 3)
+
+        return vertices, triangles
+    else:
+        raise NotImplementedError("Binary CIVET files are not supported yet.")
+
+
 def fetch_parcellation(
     template: str,
     atlas: str,
@@ -40,12 +111,15 @@ def fetch_parcellation(
         The surface template. Valid values are "fsaverage", "fsaverage5",
         "fsaverage6", "fslr32k", "civet41k", "civet164k", by default "fsaverage5".
     atlas : str
-        Name of the atlas. Valid names are "cammoun", "glasser", "schaefer", "yeo".
+        Name of the atlas. Valid names are "cammoun", "destrieux", "glasser",
+        "schaefer", "yeo".
     n_regions : int
         Number of regions of the requested atlas. Valid values for the cammoun
         atlas are 33, 60, 125, 250, 500. Valid values for the glasser atlas are
         360. Valid values for the "schaefer" atlas are 100, 200, 300, 400, 500,
-        600, 800, 1000. Valid values for "yeo" are 7 and 17.
+        600, 800, 1000. Valid values for "yeo" are 7 and 17. The
+        "destrieux" atlas (a2009s, FreeSurfer's 75 cortical labels per
+        hemisphere) ignores ``n_regions``.
     join : bool, optional
         If true, returns parcellation as a single array, if false, returns an
         array per hemisphere, by default True.
@@ -83,6 +157,8 @@ def fetch_parcellation(
         parcellations = _fetch_glasser_parcellation(template, data_dir)
     elif atlas == "yeo":
         parcellations = _fetch_yeo_parcellation(template, n_regions, data_dir)
+    elif atlas == "destrieux":
+        parcellations = _fetch_destrieux_parcellation(template, data_dir)
     else:
         raise ValueError(f"Invalid atlas: {atlas}")
 
@@ -147,7 +223,7 @@ def fetch_template_surface(
         surfaces_fs = [read_geometry(file) for file in surface_files]
         surfaces = [build_polydata(surface[0], surface[1]) for surface in surfaces_fs]
     elif template == "fslr32k":
-        surfaces = [read_surface(file) for file in surface_files]
+        surfaces = [read_surface(str(file)) for file in surface_files]
     else:
         surfaces_obj = [read_civet(file) for file in surface_files]
         surfaces = [build_polydata(surface[0], surface[1]) for surface in surfaces_obj]
@@ -384,7 +460,7 @@ def _fetch_template_surface_files(
 
     if template == "fslr32k":
         layer = layer if layer else "midthickness"
-        bunch = nnt_datasets.fetch_conte69(data_dir=str(data_dir))
+        bunch = _fetch_conte69_fixed(data_dir=str(data_dir))
     elif template == "civet41k" or template == "civet164k":
         layer = layer if layer else "mid"
         if layer == "sphere":
@@ -466,6 +542,48 @@ def _fetch_glasser_parcellation(template: str, data_dir: Path) -> List[np.ndarra
     return parcellations
 
 
+def _fetch_destrieux_parcellation(
+    template: str, data_dir: Path
+) -> List[np.ndarray]:
+    """Fetches the Destrieux 2009 (FreeSurfer ``aparc.a2009s``) parcellation.
+
+    Uses :func:`nilearn.datasets.fetch_atlas_surf_destrieux`, which provides
+    the parcellation on the ``fsaverage5`` surface. For other ``fsaverage*``
+    templates we resample with nearest-neighbour interpolation; ``fslr32k``
+    is not supported because the destrieux atlas is FreeSurfer-specific.
+    """
+    from nilearn.datasets import fetch_atlas_surf_destrieux
+
+    if template == "fslr32k":
+        raise ValueError(
+            "The destrieux atlas is FreeSurfer-specific; fslr32k is not "
+            "supported. Use a fsaverage* template instead."
+        )
+
+    bunch = fetch_atlas_surf_destrieux(data_dir=str(data_dir))
+    # nilearn returns int32 arrays for fsaverage5 (10242 vertices/hemi).
+    parcellations = [np.asarray(bunch["map_left"]), np.asarray(bunch["map_right"])]
+
+    if template != "fsaverage5":
+        # Nearest-neighbour resample fsaverage5 -> requested fsaverage*.
+        from brainstat.mesh.interpolate import _surf2surf
+
+        src_left, src_right = fetch_template_surface(
+            "fsaverage5", layer="white", join=False
+        )
+        dst_left, dst_right = fetch_template_surface(
+            template, layer="white", join=False
+        )
+        parcellations[0] = _surf2surf(
+            src_left, dst_left, parcellations[0], interpolation="nearest"
+        ).astype(parcellations[0].dtype)
+        parcellations[1] = _surf2surf(
+            src_right, dst_right, parcellations[1], interpolation="nearest"
+        ).astype(parcellations[1].dtype)
+
+    return parcellations
+
+
 def _fetch_yeo_parcellation(
     template: str, n_regions: int, data_dir: Path
 ) -> List[np.ndarray]:
@@ -515,3 +633,43 @@ def _fetch_civet_spheres(template: str, data_dir: Path) -> Tuple[str, str]:
 
     # Return two filenames to conform to other left/right hemisphere functions.
     return (str(filename), str(filename))
+
+
+SURFACE = namedtuple('Surface', ('lh', 'rh'))
+
+
+def _fetch_conte69_fixed(data_dir=None, url=None, resume=True, verbose=1):
+    """
+    Download files for Van Essen et al., 2012 Conte69 template.
+    Fixed version to handle encoding on Windows.
+    """
+    dataset_name = 'tpl-conte69'
+    keys = ['midthickness', 'inflated', 'vinflated']
+
+    data_dir = _get_data_dir(data_dir=data_dir)
+    info = _get_dataset_info(dataset_name)
+    if url is None:
+        url = info['url']
+
+    opts = {
+        'uncompress': True,
+        'md5sum': info['md5'],
+        'move': '{}.tar.gz'.format(dataset_name)
+    }
+
+    filenames = [
+        'tpl-conte69/tpl-conte69_space-MNI305_variant-fsLR32k_{}.{}.surf.gii'
+        .format(res, hemi) for res in keys for hemi in ['L', 'R']
+    ] + ['tpl-conte69/template_description.json']
+
+    data = _fetch_files(data_dir, files=[(f, url, opts) for f in filenames],
+                        resume=resume, verbose=verbose)
+
+    # Fix: Specify encoding='utf-8'
+    with open(data[-1], 'r', encoding='utf-8') as src:
+        data[-1] = json.load(src)
+
+    # bundle hemispheres together
+    data = [SURFACE(*data[:-1][i:i + 2]) for i in range(0, 6, 2)] + [data[-1]]
+
+    return Bunch(**dict(zip(keys + ['info'], data)))

{brainstat-0.4.2 → brainstat-0.6.0}/brainstat/mesh/interpolate.py

@@ -13,7 +13,7 @@ from brainspace.mesh.mesh_elements import get_cells, get_points
 from brainspace.mesh.mesh_io import read_surface
 from brainspace.vtk_interface.wrappers.data_object import BSPolyData
 from nilearn.datasets import load_mni152_brain_mask
-from scipy.interpolate.ndgriddata import LinearNDInterpolator, NearestNDInterpolator
+from scipy.interpolate import LinearNDInterpolator, NearestNDInterpolator
 from scipy.spatial import cKDTree
 
 from brainstat._typing import ArrayLike