siibra 1.0.1a1__py3-none-any.whl → 1.0.1a5__py3-none-any.whl

siibra/volumes/parcellationmap.py

@@ -14,9 +14,18 @@
 # limitations under the License.
 """Provides spatial representations for parcellations and regions."""
 
+from collections import defaultdict
+from dataclasses import dataclass, asdict
+from typing import Union, Dict, List, TYPE_CHECKING, Iterable, Tuple
+
+import numpy as np
+import pandas as pd
+from scipy.ndimage import distance_transform_edt
+from nilearn import image
+
 from . import volume as _volume
 from .providers import provider
-from .. import logger, QUIET, exceptions
+from .. import exceptions
 from ..commons import (
     MapIndex,
     MapType,
@@ -29,19 +38,13 @@ from ..commons import (
     siibra_tqdm,
     Species,
     CompareMapsResult,
-    generate_uuid
+    generate_uuid,
+    logger,
+    QUIET,
 )
 from ..core import concept, space, parcellation, region as _region
 from ..locations import location, point, pointcloud
 
-import numpy as np
-from typing import Union, Dict, List, TYPE_CHECKING, Iterable, Tuple
-from scipy.ndimage import distance_transform_edt
-from collections import defaultdict
-from nilearn import image
-import pandas as pd
-from dataclasses import dataclass, asdict
-
 if TYPE_CHECKING:
     from ..core.region import Region
 
@@ -690,7 +693,7 @@ class Map(concept.AtlasConcept, configuration_folder="maps"):
             name=f"Custom colorization of {self}"
         )
 
-    def get_colormap(self, region_specs: Iterable = None, *, allow_random_colors: bool = False):
+    def get_colormap(self, region_specs: Iterable = None, *, fill_uncolored: bool = False):
         """
         Generate a matplotlib colormap from known rgb values of label indices.
 
@@ -698,7 +701,8 @@ class Map(concept.AtlasConcept, configuration_folder="maps"):
         ----------
         region_specs: iterable(regions), optional
             Optional parameter to only color the desired regions.
-        allow_random_colors: bool , optional
+        fill_uncolored: bool , optional
+            If a region has no preconfigured color, a color will be randomly (reproducible) created.
 
         Returns
         -------
@@ -711,10 +715,10 @@ class Map(concept.AtlasConcept, configuration_folder="maps"):
                 "matplotlib not available. Please install matplotlib to create a matplotlib colormap."
             )
             raise e
-        if allow_random_colors:
+        if fill_uncolored:
             seed = len(self.regions)
             np.random.seed(seed)
-            logger.info(f"Random colors are allowed for regions without preconfgirued colors. Random seee: {seed}.")
+            logger.info(f"Random colors are allowed for regions without preconfgirued colors. Random seed: {seed}.")
 
         colors = {}
         if region_specs is not None:
@@ -724,6 +728,7 @@ class Map(concept.AtlasConcept, configuration_folder="maps"):
         else:
             include_region_names = None
 
+        no_predefined_color = []
         for regionname, indices in self._indices.items():
             for index in indices:
                 if index.label is None:
@@ -735,22 +740,33 @@ class Map(concept.AtlasConcept, configuration_folder="maps"):
                     region = self.get_region(index=index)
                     if region.rgb is not None:
                         colors[index.label] = region.rgb
-                    elif allow_random_colors:
+                    elif fill_uncolored:
                         random_clr = [np.random.randint(0, 255) for r in range(3)]
                         while random_clr in list(colors.values()):
                             random_clr = [np.random.randint(0, 255) for r in range(3)]
                         colors[index.label] = random_clr
+                    else:
+                        no_predefined_color.append(region.name)
 
         if len(colors) == 0:
             raise exceptions.NoPredifinedColormapException(
                 f"There is no predefined/preconfigured colormap for '{self}'."
-                "Set `allow_random_colors=True` to a colormap with random values"
+                "Set `fill_uncolored=True` to get a reproducible colormap."
             )
 
+        if no_predefined_color:
+            logger.info(
+                f"No preconfigured color found for the following regions."
+                "Use `fill_uncolored=True` to display with a non-background color.\n"
+                f"{no_predefined_color}"
+            )
+
+        max_label_index = max(index[0].label for index in self._indices.values())
+
         palette = np.array(
             [
                 list(colors[i]) + [1] if i in colors else [0, 0, 0, 0]
-                for i in range(max(colors.keys()) + 1)
+                for i in range(max_label_index + 1)
             ]
         ) / [255, 255, 255, 1]
         return ListedColormap(palette)

siibra/volumes/providers/freesurfer.py

@@ -14,12 +14,12 @@
 # limitations under the License.
 """Handles reading and preparing gii files."""
 
-from . import provider as _provider
-
-from ...retrieval.requests import HttpRequest, ZipfileRequest
+from typing import Union, Dict, TYPE_CHECKING
 
 import numpy as np
-from typing import Union, Dict, TYPE_CHECKING
+
+from . import provider as _provider
+from ...retrieval.requests import HttpRequest, ZipfileRequest
 
 if TYPE_CHECKING:
     from ...locations import boundingbox as _boundingbox

siibra/volumes/providers/gifti.py

@@ -14,15 +14,15 @@
 # limitations under the License.
 """Handles reading and preparing gii files."""
 
-from . import provider as _provider
+from typing import Union, Dict
+
+import numpy as np
 
+from . import provider as _provider
 from ...retrieval import requests
 from ...commons import logger, merge_meshes
 from ...locations import boundingbox as _boundingbox
 
-import numpy as np
-from typing import Union, Dict
-
 
 class GiftiMesh(_provider.VolumeProvider, srctype="gii-mesh"):
     """

siibra/volumes/providers/neuroglancer.py

@@ -13,8 +13,20 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from . import provider as _provider
+from io import BytesIO
+import os
+from typing import Union, Dict, Tuple
+import json
+
+import numpy as np
+import nibabel as nib
+from neuroglancer_scripts.precomputed_io import get_IO_for_existing_dataset, PrecomputedIO
+from neuroglancer_scripts.http_accessor import HttpAccessor
+from neuroglancer_scripts.mesh import read_precomputed_mesh, affine_transform_mesh
 
+from . import provider as _provider
+from ...retrieval import requests, cache
+from ...locations import boundingbox as _boundingbox
 from ...commons import (
     logger,
     MapType,
@@ -23,18 +35,6 @@ from ...commons import (
     QUIET,
     resample_img_to_img
 )
-from ...retrieval import requests, cache
-from ...locations import boundingbox as _boundingbox
-
-from neuroglancer_scripts.precomputed_io import get_IO_for_existing_dataset, PrecomputedIO
-from neuroglancer_scripts.http_accessor import HttpAccessor
-from neuroglancer_scripts.mesh import read_precomputed_mesh, affine_transform_mesh
-from io import BytesIO
-import nibabel as nib
-import os
-import numpy as np
-from typing import Union, Dict, Tuple
-import json
 
 
 def shift_ng_transfrom(
@@ -529,14 +529,7 @@ class NeuroglancerScale:
         if voi is None:
             bbox_ = _boundingbox.BoundingBox((0, 0, 0), self.size, space=None)
         else:
-            bbox_ = voi.transform(np.linalg.inv(self.affine))
-
-        for dim in range(3):
-            if bbox_.shape[dim] < 1:
-                logger.warning(
-                    f"Bounding box in voxel space will be enlarged to by {self.res_mm[dim]} along axis {dim}."
-                )
-                bbox_.maxpoint[dim] = bbox_.maxpoint[dim] + self.res_mm[dim]
+            bbox_ = voi.transform(np.linalg.inv(self.affine), space=None)
 
         # extract minimum and maximum the chunk indices to be loaded
         gx0, gy0, gz0 = self._point_to_lower_chunk_idx(tuple(bbox_.minpoint))
@@ -559,8 +552,12 @@ class NeuroglancerScale:
         # exact bounding box requested, to cut off undesired borders
         data_min = np.array([gx0, gy0, gz0]) * self.chunk_sizes
         x0, y0, z0 = (np.array(bbox_.minpoint) - data_min).astype("int")
-        xd, yd, zd = np.ceil((np.array(bbox_.maxpoint))).astype(int) - np.floor((np.array(bbox_.minpoint))).astype(int)
+        xd, yd, zd = np.ceil(bbox_.maxpoint).astype(int) - np.floor(bbox_.minpoint).astype(int)
         offset = tuple(bbox_.minpoint)
+        if voi is not None:
+            logger.debug(
+                f"Input: {voi.minpoint.coordinate}, {voi.maxpoint.coordinate}.\nVoxel space: {bbox_.minpoint.coordinate}, {bbox_.maxpoint.coordinate}"
+            )
 
         # build the nifti image
         trans = np.identity(4)[[2, 1, 0, 3], :]  # zyx -> xyz

siibra/volumes/providers/nifti.py

@@ -13,17 +13,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from . import provider as _provider
+import os
+from typing import Union, Dict, Tuple
+
+import numpy as np
+import nibabel as nib
 
+from . import provider as _provider
 from ...commons import logger, resample_img_to_img
 from ...retrieval import requests
 from ...locations import pointcloud, boundingbox as _boundingbox
 
-from typing import Union, Dict, Tuple
-import nibabel as nib
-import os
-import numpy as np
-
 
 class NiftiProvider(_provider.VolumeProvider, srctype="nii"):
 

siibra/volumes/providers/provider.py

@@ -17,12 +17,13 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Union, Dict, List
-from nibabel import Nifti1Image
 import json
+
+from nibabel import Nifti1Image
+
 if TYPE_CHECKING:
     from ...locations.boundingbox import BoundingBox
 
-# TODO add mesh primitive. Check nibabel implementation? Use trimesh? Do we want to add yet another dependency?
 VolumeData = Union[Nifti1Image, Dict]
 
 

siibra/volumes/sparsemap.py

@@ -13,19 +13,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Represents lists of probabilistic brain region maps."""
-from . import parcellationmap, volume as _volume
 
+from os import path, makedirs
+from typing import Dict, List
+
+import numpy as np
+
+from . import parcellationmap, volume as _volume
 from .providers import provider
-from ..commons import MapIndex, logger, connected_components, siibra_tqdm
+from ..commons import MapIndex, logger, connected_components, siibra_tqdm, resample_img_to_img
 from ..locations import boundingbox
 from ..retrieval.cache import CACHE
 from ..retrieval.requests import HttpRequest, FileLoader
 
-from os import path, makedirs
-from typing import Dict, List
-from nilearn import image
-import numpy as np
-
 
 class SparseIndex:
 
@@ -352,30 +352,23 @@ class SparseMap(parcellationmap.Map):
         split_components: bool, default: True
             Whether to split the query volume into disjoint components.
         """
+        from nibabel import Nifti1Image
+
         queryimg = queryvolume.fetch()
-        imgdata = np.asanyarray(queryimg.dataobj)
-        imgaffine = queryimg.affine
+        assert isinstance(queryimg, Nifti1Image)
         assignments = []
 
-        # resample query image into this image's voxel space, if required
-        if (imgaffine - self.affine).sum() == 0:
-            querydata = imgdata.squeeze()
-        else:
-            if issubclass(imgdata.dtype.type, np.integer):
-                interp = "nearest"
-            else:
-                interp = "linear"
-            from nibabel import Nifti1Image
-            queryimg = image.resample_img(
-                Nifti1Image(imgdata, imgaffine),
-                target_affine=self.affine,
-                target_shape=self.shape,
-                interpolation=interp,
+        # resample query image into this image's voxel space, if required (nilearn checks)
+        queryimg = resample_img_to_img(
+            source_img=queryimg,
+            target_img=Nifti1Image(
+                np.zeros(self.shape), affine=self.affine, dtype=queryimg.dataobj.dtype
             )
-            querydata = np.asanyarray(queryimg.dataobj).squeeze()
+        )
+        self.space.get_template()
+        querydata = np.asanyarray(queryimg.dataobj).squeeze()
 
-        iter_func = connected_components if split_components \
-            else lambda img: [(1, img)]
+        iter_func = connected_components if split_components else lambda img: [(1, img)]
 
         for mode, modemask in iter_func(querydata):
 

siibra/volumes/volume.py

@@ -14,27 +14,26 @@
 # limitations under the License.
 """A specific mesh or 3D array."""
 
-from .providers import provider as _provider
-
-from .. import logger
-from ..retrieval import requests
-from ..core import space as _space, structure
-from ..locations import point, pointcloud, boundingbox
-from ..commons import resample_img_to_img, siibra_tqdm, affine_scaling, connected_components
-from ..exceptions import NoMapAvailableError, SpaceWarpingFailedError, EmptyPointCloudError
-
-from dataclasses import dataclass
-from nibabel import Nifti1Image
-import numpy as np
 from typing import List, Dict, Union, Set, TYPE_CHECKING
+from dataclasses import dataclass
 from time import sleep
 import json
-from skimage import feature as skimage_feature, filters
 from functools import lru_cache
 
+import numpy as np
+from nibabel import Nifti1Image
+from skimage import feature as skimage_feature, filters
+
+from . import providers as _providers
+from ..commons import resample_img_to_img, siibra_tqdm, affine_scaling, connected_components, logger
+from ..exceptions import NoMapAvailableError, SpaceWarpingFailedError, EmptyPointCloudError
+from ..retrieval import requests
+from ..core import space as _space, structure
+from ..core.concept import get_registry
+from ..locations import point, pointcloud, boundingbox
+
 if TYPE_CHECKING:
-    from ..retrieval.datasets import EbrainsDataset
-    TypeDataset = EbrainsDataset
+    from ..retrieval.datasets import EbrainsDataset as TypeDataset
 
 
 @dataclass
@@ -129,7 +128,7 @@ class Volume(structure.BrainStructure):
     def __init__(
         self,
         space_spec: dict,
-        providers: List['_provider.VolumeProvider'],
+        providers: List[_providers.provider.VolumeProvider],
         name: str = "",
         variant: str = None,
         datasets: List['TypeDataset'] = [],
@@ -138,7 +137,7 @@ class Volume(structure.BrainStructure):
         self._name = name
         self._space_spec = space_spec
         self.variant = variant
-        self._providers: Dict[str, _provider.VolumeProvider] = {}
+        self._providers: Dict[str, _providers.provider.VolumeProvider] = {}
         self.datasets = datasets
         self._boundingbox = bbox
         for provider in providers:
@@ -714,7 +713,7 @@ class Subvolume(Volume):
             self,
             space_spec=parent_volume._space_spec,
             providers=[
-                _provider.SubvolumeProvider(p, z=z)
+                _providers.provider.SubvolumeProvider(p, z=z)
                 for p in parent_volume._providers.values()
             ],
             name=parent_volume.name + f" - z: {z}"
@@ -722,25 +721,21 @@ class Subvolume(Volume):
 
 
 def from_file(filename: str, space: str, name: str) -> Volume:
-    """ Builds a nifti volume from a filename. """
-    from ..core.concept import get_registry
-    from .providers.nifti import NiftiProvider
+    """Builds a nifti volume from a filename."""
     spaceobj = get_registry("Space").get(space)
     return Volume(
         space_spec={"@id": spaceobj.id},
-        providers=[NiftiProvider(filename)],
+        providers=[_providers.NiftiProvider(filename)],
         name=filename if name is None else name,
     )
 
 
 def from_nifti(nifti: Nifti1Image, space: str, name: str) -> Volume:
     """Builds a nifti volume from a Nifti image."""
-    from ..core.concept import get_registry
-    from .providers.nifti import NiftiProvider
     spaceobj = get_registry("Space").get(space)
     return Volume(
         space_spec={"@id": spaceobj.id},
-        providers=[NiftiProvider((np.asanyarray(nifti.dataobj), nifti.affine))],
+        providers=[_providers.NiftiProvider((np.asanyarray(nifti.dataobj), nifti.affine))],
         name=name
     )
 
@@ -754,13 +749,11 @@ def from_array(
     """Builds a siibra volume from an array and an affine matrix."""
     if len(name) == 0:
         raise ValueError("Please provide a non-empty string for `name`")
-    from ..core.concept import get_registry
-    from .providers.nifti import NiftiProvider
     spacespec = next(iter(space.values())) if isinstance(space, dict) else space
     spaceobj = get_registry("Space").get(spacespec)
     return Volume(
         space_spec={"@id": spaceobj.id},
-        providers=[NiftiProvider((data, affine))],
+        providers=[_providers.NiftiProvider((data, affine))],
         name=name,
     )
 

{siibra-1.0.1a1.dist-info → siibra-1.0.1a5.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: siibra
-Version: 1.0.1a1
+Version: 1.0.1a5
 Summary: siibra - Software interfaces for interacting with brain atlases
 Home-page: https://github.com/FZJ-INM1-BDA/siibra-python
 Author: Big Data Analytics Group, Forschungszentrum Juelich, Institute of Neuroscience and Medicine (INM-1)
@@ -33,6 +33,7 @@ Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
@@ -43,22 +44,28 @@ Dynamic: summary
 siibra - Software interface for interacting with brain atlases
 ==============================================================
 
-Copyright 2018-2024, Forschungszentrum Jülich GmbH
+Copyright 2018-2025, Forschungszentrum Jülich GmbH
 
 *Authors: Big Data Analytics Group, Institute of Neuroscience and
 Medicine (INM-1), Forschungszentrum Jülich GmbH*
 
 .. intro-start
 
-``siibra`` is a Python client to a brain atlas framework that integrates brain parcellations and reference spaces at different spatial scales, and connects them with a broad range of multimodal regional data features. 
+``siibra-python`` is a Python client to a brain atlas framework that integrates brain parcellations and reference spaces at different spatial scales, and connects them with a broad range of multimodal regional data features. 
 It aims to facilitate programmatic and reproducible incorporation of brain parcellations and brain region features from different sources into neuroscience workflows.
 
-    **Note:** ``siibra-python`` *is still in development. While care is taken that it works reliably, its API is not yet stable and you may still encounter bugs when using it.*
-
 ``siibra`` provides structured access to parcellation schemes in different brain reference spaces, including volumetric reference templates at  macroscopic and microscopic resolutions as well as surface representations. 
 It supports both discretely labelled and statistical (probabilistic) parcellation maps, which can be used to assign brain regions to spatial locations and image signals, to retrieve region-specific neuroscience datasets from multiple online repositories, and to sample information from high-resolution image data. 
 The datasets anchored to brain regions address features of molecular, cellular and architecture as well as connectivity, and are complemented with live queries to external repositories as well as dynamic extraction from "big" image volumes such as the 20 micrometer BigBrain model.
 
+``siibra`` hides much of the complexity that would be required to collect and interact with the individual parcellations, templates and data repositories.
+By encapsulating many aspects of interacting with different maps and reference templates spaces, it also minimizes common errors like misinterpretation of coordinates from different reference spaces, confusing label indices of brain regions, or using inconsistent versions of parcellation maps. 
+It aims to provide a safe way of using maps defined across multiple spatial scales for reproducible analysis.
+
+.. intro-end
+
+.. about-start
+
 ``siibra`` was developed in the frame of the `Human Brain Project <https://humanbrainproject.eu>`__ for accessing the `EBRAINS
 human brain atlas <https://ebrains.eu/service/human-brain-atlas>`__. 
 It stores most of its contents as sustainable and open datasets in the `EBRAINS Knowledge Graph <https://kg.ebrains.eu>`__, and is designed to support the `OpenMINDS metadata standards <https://github.com/HumanBrainProject/openMINDS_SANDS>`__. 
@@ -67,11 +74,7 @@ In fact, the viewer is a good resource for exploring ``siibra``\ ’s core funct
 Feature queries in ``siibra`` are parameterized by data modality and anatomical location, while the latter could be a brain region, brain parcellation, or location in reference space. 
 Beyond the explorative focus of ``siibra-explorer``, the Python library supports a range of data analysis functions suitable for typical neuroscience workflows.
 
-``siibra`` hides much of the complexity that would be required to collect and interact with the individual parcellations, templates and data repositories.
-By encapsulating many aspects of interacting with different maps and reference templates spaces, it also minimizes common errors like misinterpretation of coordinates from different reference spaces, confusing label indices of brain regions, or using inconsistent versions of parcellation maps. 
-It aims to provide a safe way of using maps defined across multiple spatial scales for reproducible analysis.
-
-.. intro-end
+.. about-end
 
 .. getting-started-start
 
@@ -80,10 +83,26 @@ Installation
 
 ``siibra`` is available on pypi. 
 To install the latest released version, simply run ``pip install siibra``. 
+The installation typically takes about 2 minutes on a standard computer where Python is already installed.
 In order to work with the latest version from github, use ``pip install git+https://github.com/FZJ-INM1-BDA/siibra-python.git@main``.
 
-There is also an image based on jupyter:scipy-notebook, which already includes ``siibra``.
-
+``siibra-python`` should be installable on recent versions of Windows, Linux and Mac OS in a recent Python 3 environment.
+We run continuous integration tests for versions 3.7 - 3.12 on recent Ubuntu images. 
+
+The library requires a couple of open source packages, namely:
+```
+anytree >= 2.12.1
+nibabel >= 5.3.2
+appdirs >= 1.4.4
+scikit-image >= 0.25.0
+requests >= 2.32.3
+neuroglancer-scripts >= 1.2.0
+nilearn >= 0.11.0
+filelock >= 3.16.1
+ebrains-drive >= 0.6.0
+```
+
+You can also install a docker image with all dependencies included:
 .. code-block:: sh
 
   docker run -dit \
@@ -93,19 +112,20 @@ There is also an image based on jupyter:scipy-notebook, which already includes `
         docker-registry.ebrains.eu/siibra/siibra-python:latest
 
 
+
 Documentation & Help
 ====================
 
 ``siibra-python``\ ’s documentation is hosted on https://siibra-python.readthedocs.io.
 The documentation includes a catalogue of documented code examples that walk you through the different concepts and functionalities.
+These examples use real data and include both the code and the produced expected outputs.
+They can be accessed at https://siibra-python.readthedocs.io/en/latest/examples.html, and are
+automatically tested and updated whenever a new version of ``siibra-python`` is published.
 As a new user, it is recommended to go through these examples - they are easy and will quickly provide you with the right code snippets that get you started.
-Furthermore, a set of jupyter notebooks demonstrating more extensive example use cases are maintained in the `siibra-tutorials <https://github.com/FZJ-INM1-BDA/siibra-tutorials>`__ repository.
-We are working on a full API documentation of the library. You find the current status on readthedocs, but be aware that it is not yet complete and as up-to-date as the code examples.
+The documentation on readthedocs further includes introductory explanations and an API reference.
 
 If you run into issues, please open a ticket on `EBRAINS support <https://ebrains.eu/support/>`__ or file bugs and
 feature requests on `github <https://github.com/FZJ-INM1-BDA/siibra-python/issues>`__.
-Please keep in mind that ``siibra-python`` is still in development.
-While care is taken to make everything work reliably, the API of the library is not yet stable, and the software is not yet fully tested.
 
 .. getting-started-end
 

siibra-1.0.1a5.dist-info/RECORD

@@ -0,0 +1,80 @@
+siibra/VERSION,sha256=ipm-gM9pHLEb5l5Cx8ZcZ8wKJBYKiaWH87grIEoJ_OM,14
+siibra/__init__.py,sha256=1uWhsE93KG4N9wiWoMdEokUXxfoRcyznXDktjAGhpEI,4496
+siibra/commons.py,sha256=KmbRdX6pfKTgIgbYufxhkE9YiLQ35GObbw6VyFdRm_w,28016
+siibra/exceptions.py,sha256=6MlXOadwXcCsceOE4lmy4fLJyAaBCCVvJF6BZlMYjU8,1371
+siibra/configuration/__init__.py,sha256=ArqQ_B8C_O61KA4Fk3ho8ksckbjLu-COOlPGiXyf8LE,752
+siibra/configuration/configuration.py,sha256=A651Tg632_a_c_yjxs-FJW_douQyzSJBoCDad4expVk,7151
+siibra/configuration/factory.py,sha256=srhxxOAW_qyfe7oIFfuiX6gviou5CRfle5DVKe8FtB0,22798
+siibra/core/__init__.py,sha256=zW887SH2txImUfvU80k83NbxxnlHlbdzBjdryY-3-48,766
+siibra/core/assignment.py,sha256=aSzunUMKVVE0wl_2qEK_NryQIoV8_qMV5t3MBmkdEo8,4310
+siibra/core/atlas.py,sha256=Iwqgcf8sG8_iL4mlw_4Nzi7HWVR-wxYLESqnIS0CFTw,8549
+siibra/core/concept.py,sha256=rLqgJ72Mt1Mc8mlh-bGYOyq65rV7Vc8vCZGs-amJp1w,10891
+siibra/core/parcellation.py,sha256=JzrnoB8G0XupffP8mnwE3oHYmHjo2Mzn4-pXnZ2R6Ow,14480
+siibra/core/region.py,sha256=036Fjck1H6wGSubJomjEHUN1I-XMPSPqx3_78MEYbG8,44108
+siibra/core/space.py,sha256=X7FyKgdhao3ezSWQZ0MAjDxlQh305S-4a4D630RaM-c,4588
+siibra/core/structure.py,sha256=M2li4PPiJf27dOc3b2ycCfHf7Ad1AWxBYc9OpSFazJM,4498
+siibra/explorer/__init__.py,sha256=XBAeYm4W3HlbWsKtt8gOwqE_FinIEY7RdA6Rg4Y275A,781
+siibra/explorer/url.py,sha256=S6Tpg1p2gmu5byHVqsXfkugUStLd1Fu94EqsDzgEU9E,7047
+siibra/explorer/util.py,sha256=ul82TQZAULdupr4tJBACdkjlHm2mt8LJ9UpwNWGHYhE,2083
+siibra/features/__init__.py,sha256=FER6DMnkPhXSV1XMZWibZdyBwVhIgWYSUGYMEYEKb9c,3970
+siibra/features/anchor.py,sha256=cMuaGB8ZCGMpdeb3plzHzNC4ImsxsriQ66janWcjhjk,9101
+siibra/features/feature.py,sha256=uVTp1vvZRnl9DIks49-StrZ88UEfEe-ixshuK5_bvwg,35576
+siibra/features/connectivity/__init__.py,sha256=FkPf0vyrLo3ERxrDbsRHUd7FUgJyajD87NiiXIiXhmY,1161
+siibra/features/connectivity/functional_connectivity.py,sha256=9lQoOXv8lZUnyMduAbWABwDIkQC0QTI8V23yx0NjOBg,2122
+siibra/features/connectivity/regional_connectivity.py,sha256=6oDx-tsvQIh-MG823-6yLpVHvr-rOoS--CKR22GSwxA,18706
+siibra/features/connectivity/streamline_counts.py,sha256=JaAYf6-1S8NYhkE4lhshCSY__EQ5BFcL2i_XXdFfgrM,1064
+siibra/features/connectivity/streamline_lengths.py,sha256=QeuoW_ZDVa9dxCguaemj4Cq9CCPB8ur8_alhATto2-w,1067
+siibra/features/connectivity/tracing_connectivity.py,sha256=rkYgD8mOZzDp0STo5djhDqOaEdz-9j5EuLffXE0F01A,1083
+siibra/features/dataset/__init__.py,sha256=qRV_P0335b4LnSMiONRpSC4elGckp0FXmtJz_QQuVLA,748
+siibra/features/dataset/ebrains.py,sha256=zA_GSIJzeJgClY5KrsfAJgrdjcM5N2Z_mz442UR_1vc,2544
+siibra/features/image/__init__.py,sha256=i_NccD2WJmVAtpLVWeccn8UEnViDMC6Y2CSGARL0Qt8,1049
+siibra/features/image/image.py,sha256=heXBen5Sq3dVEcHSb4W4rs7n9nOXy3Nqp-eO0Vzjz4A,3583
+siibra/features/image/sections.py,sha256=rZPoeZbu_cK8td5J4LVxZxsojjwTodrHe42P2de28_Y,3708
+siibra/features/image/volume_of_interest.py,sha256=fBkTUujUHdcfzF1kPvMTV4x41VJXPUJ5Lbpr_g4GxYM,2649
+siibra/features/tabular/__init__.py,sha256=DdE1GXPEsHSNJ3pyNYZNWu5JxDfuI08DbrDF1iBrXIA,1203
+siibra/features/tabular/bigbrain_intensity_profile.py,sha256=C7rP2QTJPyTz_EnRlgdFWPVaDcwJszTlm1ylHBydJOE,2709
+siibra/features/tabular/cell_density_profile.py,sha256=ScpjD9W-w-lLxdG6q42Zfyqe8LW4JvaorIdnixuPzo4,10818
+siibra/features/tabular/cortical_profile.py,sha256=x0TqZh8FzcVx13EwPtbt8kBYfF1dREWWuf9BhpWzj7o,12542
+siibra/features/tabular/gene_expression.py,sha256=8gJuUrL13oIySOPgiy5j46a5Udae_cJ1_QfrUHA72CI,10309
+siibra/features/tabular/layerwise_bigbrain_intensities.py,sha256=iFCNG641yCSuIXFTY30xgRQqLERDHMqJrAy3SdKkAJ4,2118
+siibra/features/tabular/layerwise_cell_density.py,sha256=MYFiUfDfx6XQj8dezV5-3eKWBg0VOn0T3a1utELE2PM,6513
+siibra/features/tabular/receptor_density_fingerprint.py,sha256=CvFJv940whxzavhEQWnTjueDEq0ZoiuYVpqUpR8t-Ec,8065
+siibra/features/tabular/receptor_density_profile.py,sha256=VW2Ry8ifQLfmiBDKqIdvaN7K1YzMENGU92Lnm4wA8P0,3724
+siibra/features/tabular/regional_timeseries_activity.py,sha256=wuno4oI1I-dyxRr8-tLFj42iaD6dYZiPigCqVMhrG50,10027
+siibra/features/tabular/tabular.py,sha256=37lSZ10cEAzGorA8jxdJvMcAIZvklIR3Vo75YPz7ONA,5783
+siibra/livequeries/__init__.py,sha256=hToUNmyFq1UW5CxScHyBB-mSZ7kUK_w1Cvrk1OkZQf0,875
+siibra/livequeries/allen.py,sha256=l5OqVqq3SZ3x7-pol1PwX6AnvdyufjVUYXtGr3wWBj0,14946
+siibra/livequeries/bigbrain.py,sha256=hT-T6gKRoZQFPWvitm1hv-DoMkkGjz-NfqSx7khfLR0,15762
+siibra/livequeries/ebrains.py,sha256=GBwpm9f_rVjZgF-SyGZ5PGMmL9e9OZzXhHs78uCNhYs,5952
+siibra/livequeries/query.py,sha256=P_uUVFxv4KyOPQXh2WnDQxuaSSBK_dXPKEr8I0-4xSQ,1849
+siibra/locations/__init__.py,sha256=yTJVMdv-pICm_gUYLQ09lDKSkZBfgUihM6LNv07e_yk,3546
+siibra/locations/boundingbox.py,sha256=ACRittMABMZwLPzGnv5Z5E6cIHJfCFWv851s5Bg87WQ,16442
+siibra/locations/experimental.py,sha256=kd9yroLKpnY-N6hoMVgtHK4pVdgeGqhpad4GyxYy6LU,14484
+siibra/locations/location.py,sha256=tb__0td1c7_3BKJFqqEqwspO5m8BZ8ZlyYwvtVBq8SY,4706
+siibra/locations/point.py,sha256=cL2hqbejec24ZoXpbBQQXtHZ-H7KcyxnbITzSBjkXTs,12675
+siibra/locations/pointcloud.py,sha256=AxtR43xG4i1hUXNmal4F_g5WKQo_A1ZtW4l4jsf3p6o,14108
+siibra/retrieval/__init__.py,sha256=E-UA8rDQZFGkHmAcmit6siONo7G2mH_Y0xgLlR1RfvY,1062
+siibra/retrieval/cache.py,sha256=uMWEi93VePSOSXaiU5PZAbUlWBYyO7gbpRxod4jO2Rc,7833
+siibra/retrieval/datasets.py,sha256=JgnSc41TM0oGNAVn8zQjL84HML-feOBVy5bLxxHrEt8,11110
+siibra/retrieval/repositories.py,sha256=mMmSAnLZJjDb-bi86FPKNQXDbIPKpA_kh7IjKlTPkxM,29935
+siibra/retrieval/requests.py,sha256=VhAnD8mTK26YHVv0haWjfYcdnJuHg6uHhZD-TSs8Cfo,23094
+siibra/retrieval/exceptions/__init__.py,sha256=sOuzPHh2xq1p55T0zAcrSW2B1wfwwYEXBOWIuCjGePE,875
+siibra/vocabularies/__init__.py,sha256=aWXsCVmtz0ZtX5J-f_XeyeGSAj9XbuQQjKJz_rvPVtY,1287
+siibra/vocabularies/gene_names.json,sha256=i-gnh753GyZtQfX_dWibNYr_d5ccDPHooOwsdeKUYqE,1647972
+siibra/vocabularies/receptor_symbols.json,sha256=F6DZIArPCBmJV_lWGV-zDpBBH_GOJOZm67LBE4qzMa4,5722
+siibra/vocabularies/region_aliases.json,sha256=T2w1wRlxPNTsPppXn0bzC70tNsb8mOjLsoHuxDSYm2w,8563
+siibra/volumes/__init__.py,sha256=9eiVjgGTqq9BiFJaLVLABtTrhIcE2k3Cn51yC4EKplg,936
+siibra/volumes/parcellationmap.py,sha256=z5wWxK_kcFpS_ROpc9ny4aCbM7P9qc3DRDxrOKGp2Hk,51409
+siibra/volumes/sparsemap.py,sha256=Yv07LIlt5yigw-ubWFq89hHnsivT7dymYCsCTe7Wu9I,17167
+siibra/volumes/volume.py,sha256=wLmtqoXBDoPvE3WBO_Hc8uny3cdE9mB0KgdCq0LOTa0,32408
+siibra/volumes/providers/__init__.py,sha256=AHZCjutCqO4mnHxyykVjqxlz85jDqFWcSjsa4ciwc1A,934
+siibra/volumes/providers/freesurfer.py,sha256=l3zkLlE28EAEmg75tv9yp1YYiaHVkf4Zi8rKn9TUWVs,4893
+siibra/volumes/providers/gifti.py,sha256=JGuixlSJTVjbDU_M5oMDCV8BAwIzuczhnI-qZ7LMQIc,6231
+siibra/volumes/providers/neuroglancer.py,sha256=b3TiJ6yrx_akLFKgHRKZyHculzzRIqbZ7U3TMQHy6-k,28618
+siibra/volumes/providers/nifti.py,sha256=aAzkmeDZaXRZ-dkAeEb2cSywNn9WzIz0z7yFtN6iNpU,10135
+siibra/volumes/providers/provider.py,sha256=Vn02au_LKynO5SIfqLyjqzxCf7JD9Wm4i7yEFcTX0WU,3585
+siibra-1.0.1a5.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+siibra-1.0.1a5.dist-info/METADATA,sha256=CO_Qej2SZ4h9saebuTGGPQLhPZOI4PQE4xSEHKVqKl4,9301
+siibra-1.0.1a5.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+siibra-1.0.1a5.dist-info/top_level.txt,sha256=NF0OSGLL0li2qyC7MaU0iBB5Y9S09_euPpvisD0-8Hg,7
+siibra-1.0.1a5.dist-info/RECORD,,

{siibra-1.0.1a1.dist-info → siibra-1.0.1a5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (80.3.1)
 Root-Is-Purelib: true
 Tag: py3-none-any