siibra 0.4a33__py3-none-any.whl → 0.4a46__py3-none-any.whl

siibra/volumes/sparsemap.py

@@ -15,16 +15,15 @@
 """Represents lists of probabilistic brain region maps."""
 from . import parcellationmap, volume as _volume
 
-from ..commons import MapIndex, logger
+from ..commons import MapIndex, logger, iterate_connected_components, siibra_tqdm
 from ..locations import boundingbox
 from ..retrieval import cache
 
 from os import path
 import gzip
-from typing import Dict, Union, TYPE_CHECKING
+from typing import Dict, Union, TYPE_CHECKING, List
 from nilearn import image
 from nibabel import Nifti1Image, load
-from tqdm import tqdm
 import numpy as np
 
 if TYPE_CHECKING:
@@ -111,8 +110,10 @@ class SparseIndex:
         return x, y, z, v
 
     def to_cache(self, prefix: str):
-        """ Serialize this index to the cache,
-        using the given prefix for the cache filenames. """
+        """
+        Serialize this index to the cache, using the given prefix for the cache
+        filenames.
+        """
         probsfile = cache.CACHE.build_filename(f"{prefix}", suffix="probs.txt.gz")
         bboxfile = cache.CACHE.build_filename(f"{prefix}", suffix="bboxes.txt.gz")
         voxelfile = cache.CACHE.build_filename(f"{prefix}", suffix="voxels.nii.gz")
@@ -132,9 +133,18 @@ class SparseIndex:
     @classmethod
     def from_cache(cls, prefix: str):
         """
-        Attemts to build a sparse index from the siibra cache,
-        looking for suitable cache files with the specified prefix.
-        Returns None if cached files are not found or suitable.
+        Attempts to build a sparse index from the siibra cache, looking for
+        suitable cache files with the specified prefix.
+
+        Parameters
+        ----------
+        prefix: str
+            Prefix of the filenames.
+
+        Returns
+        -------
+        SparseIndex
+            None if cached files are not found or suitable.
         """
 
         probsfile = cache.CACHE.build_filename(f"{prefix}", suffix="probs.txt.gz")
@@ -152,12 +162,11 @@ class SparseIndex:
 
         with gzip.open(probsfile, "rt") as f:
             lines = f.readlines()
-            for line in tqdm(
+            for line in siibra_tqdm(
                 lines,
                 total=len(lines),
                 desc="Loading sparse index",
-                unit="voxels",
-                disable=logger.level > 20,
+                unit="voxels"
             ):
                 fields = line.strip().split(" ")
                 mapindices = list(map(int, fields[0::2]))
@@ -179,21 +188,22 @@ class SparseIndex:
 
 
 class SparseMap(parcellationmap.Map):
-    """A sparse representation of list of statistical (e.g. probabilistic) brain region maps.
+    """
+    A sparse representation of list of statistical (e.g. probabilistic) brain
+    region maps.
 
     It represents the 3D statistical maps of N brain regions by two data structures:
-        1) 'spatial_index', a 3D volume where non-negative values represent unique
-            indices into a list of region assignments
-        2) 'probs', a list of region assignments where each entry is a dict
 
-    More precisely, given
-        i = sparse_index.voxels[x, y, z]
-    we define that
-        - if i<0, no brain region is assigned at this location
-        - if i>=0, probs[i] defines the probabilities of brain regions.
+    1) 'spatial_index', a 3D volume where non-negative values represent unique indices into a list of region assignments
+    2) 'probs', a list of region assignments where each entry is a dict
+
+    More precisely, given ``i = sparse_index.voxels[x, y, z]`` we define that
+
+    - if `i<0`, no brain region is assigned at this location
+    - if `i>=0`, ``probs[i]`` defines the probabilities of brain regions.
 
     Each entry in probs is a dictionary that represents the region assignments for
-    the unique voxel where spatial_index==i. The assignment maps from a "mapindex"
+    the unique voxel where ``spatial_index == i``. The assignment maps from a MapIndex
     to the actual (probability) value.
     """
 
@@ -235,15 +245,14 @@ class SparseMap(parcellationmap.Map):
     @property
     def sparse_index(self):
         if self._sparse_index_cached is None:
-            prefix = f"{self.parcellation.id}_{self.space.id}_{self.maptype}_index"
+            prefix = f"{self.parcellation.id}_{self.space.id}_{self.maptype}_{self.name}_index"
             spind = SparseIndex.from_cache(prefix)
-            with _volume.SubvolumeProvider.UseCaching():
-                if spind is None:
+            if spind is None:
+                with _volume.SubvolumeProvider.UseCaching():
                     spind = SparseIndex()
-                    for vol in tqdm(
+                    for vol in siibra_tqdm(
                         range(len(self)), total=len(self), unit="maps",
-                        desc=f"Fetching {len(self)} volumetric maps",
-                        disable=logger.level > 20,
+                        desc=f"Fetching {len(self)} volumetric maps"
                     ):
                         img = super().fetch(
                             index=MapIndex(volume=vol, label=None)
@@ -253,8 +262,8 @@ class SparseMap(parcellationmap.Map):
                             logger.error(f"Cannot retrieve volume #{vol} for {region.name}, it will not be included in the sparse map.")
                             continue
                         spind.add_img(img)
-                spind.to_cache(prefix)
-                self._sparse_index_cached = spind
+                    spind.to_cache(prefix)
+            self._sparse_index_cached = spind
         assert self._sparse_index_cached.max() == len(self._sparse_index_cached.probs) - 1
         return self._sparse_index_cached
 
@@ -278,15 +287,19 @@ class SparseMap(parcellationmap.Map):
         Recreate a particular volumetric map from the sparse
         representation.
 
-        Arguments
-        ---------
-        region_or_index: Union[str, Region, MapIndex]
+        Parameters
+        ----------
+        region_or_index: str, Region, MapIndex
             Lazy match the specification.
         index : MapIndex
             The index to be fetched.
-        region: Union[str, Region]
-            Region name specification. If given, will be used to
-            decode the map index of a particular region.
+        region: str, Region
+            Region name specification. If given, will be used to decode the map
+            index of a particular region.
+
+        Returns
+        -------
+        An image or mesh
         """
         if kwargs.get('format') in ['mesh'] + _volume.Volume.MESH_FORMATS:
             # a mesh is requested, this is not handled by the sparse map
@@ -349,7 +362,7 @@ class SparseMap(parcellationmap.Map):
                 for volume, value in spind.probs[voxel].items()
             )
 
-    def _assign_image(self, queryimg: Nifti1Image, minsize_voxel: int, lower_threshold: float):
+    def _assign_image(self, queryimg: Nifti1Image, minsize_voxel: int, lower_threshold: float) -> List[parcellationmap.AssignImageResult]:
         """
         Assign an image volume to this parcellation map.
 
@@ -383,7 +396,7 @@ class SparseMap(parcellationmap.Map):
 
         querydata = np.asanyarray(queryimg.dataobj).squeeze()
 
-        for mode, modeimg in parcellationmap.Map.iterate_connected_components(queryimg):
+        for mode, modeimg in iterate_connected_components(queryimg):
 
             # determine bounding box of the mode
             modemask = np.asanyarray(modeimg.dataobj)
@@ -400,12 +413,11 @@ class SparseMap(parcellationmap.Map):
 
             spind = self.sparse_index
 
-            for volume in tqdm(
+            for volume in siibra_tqdm(
                 range(len(self)),
                 desc=f"Assigning structure #{mode} to {len(self)} sparse maps",
                 total=len(self),
-                unit=" map",
-                disable=logger.level > 20,
+                unit=" map"
             ):
                 bbox1 = boundingbox.BoundingBox(
                     self.sparse_index.bboxes[volume]["minpoint"],
@@ -447,8 +459,6 @@ class SparseMap(parcellationmap.Map):
                 iou = intersection / np.sum(
                     (v1 > 0) | (v2 > 0)
                 )  # np.maximum(v1, v2).sum()
-                contains = intersection / (v1 > 0).sum()
-                contained = intersection / (v2 > 0).sum()
 
                 v1d = v1 - v1.mean()
                 v2d = v2 - v2.mean()
@@ -460,16 +470,20 @@ class SparseMap(parcellationmap.Map):
 
                 maxval = v1.max()
 
-                assignments.append([
-                    mode,
-                    tuple(position.round(2)),
-                    volume,
-                    None,
-                    maxval,
-                    iou,
-                    contained,
-                    contains,
-                    rho
-                ])
+                assignments.append(
+                    parcellationmap.AssignImageResult(
+                        input_structure=mode,
+                        centroid=tuple(position.round(2)),
+                        volume=volume,
+                        fragment=None,
+                        map_value=maxval,
+                        intersection_over_union=iou,
+                        intersection_over_first=intersection / (v1 > 0).sum(),
+                        intersection_over_second=intersection / (v2 > 0).sum(),
+                        correlation=rho,
+                        weighted_mean_of_first=np.sum(v1 * v2) / np.sum(v2),
+                        weighted_mean_of_second=np.sum(v1 * v2) / np.sum(v1)
+                    )
+                )
 
         return assignments

siibra/volumes/volume.py

@@ -20,9 +20,12 @@ from ..core import space
 
 import nibabel as nib
 from abc import ABC, abstractmethod
-from typing import List, Dict, Union, Set
+from typing import List, Dict, Union, Set, TYPE_CHECKING
 import json
 
+if TYPE_CHECKING:
+    from ..retrieval.datasets import EbrainsDataset
+    TypeDataset = EbrainsDataset
 
 class ColorVolumeNotSupported(NotImplementedError):
     pass
@@ -55,11 +58,13 @@ class Volume:
         providers: List['VolumeProvider'],
         name: str = "",
         variant: str = None,
+        datasets: List['TypeDataset'] = [],
     ):
         self._name_cached = name  # see lazy implementation below
         self._space_spec = space_spec
         self.variant = variant
         self._providers: Dict[str, 'VolumeProvider'] = {}
+        self.datasets = datasets
         for provider in providers:
             srctype = provider.srctype
             assert srctype not in self._providers
@@ -69,13 +74,20 @@ class Volume:
 
     @property
     def name(self):
-        """ allows derived classes to implemente a lazy name specification."""
+        """
+        Allows derived classes to implement a lazy name specification.
+        """
         return self._name_cached
 
     @property
     def providers(self):
+        def concat(url: Union[str, Dict[str, str]], concat: str):
+            if isinstance(url, str):
+                return url + concat
+            return {key: url[key] + concat for key in url}
         return {
-            srctype: prov._url for srctype, prov in self._providers.items()
+            srctype: concat(prov._url, f" {prov.label}" if hasattr(prov, "label") else "")
+            for srctype, prov in self._providers.items()
         }
 
     @property
@@ -149,16 +161,16 @@ class Volume:
         ----------
         format: str
             Requested format. Per default, several formats are tried,
-            starting with volumetric formats. You may explicitly specify:
-            - 'surface' or 'mesh' to fetch a surface format
-            - 'volumetric' or 'voxel' to fetch a volumetric format
-            - supported format types, see :data:`Volume.SUPPORTED_FORMATS`. This includes:
-                :class:`'nii'<siibra.volumes.nifti.NiftiProvider()>`,
-                :class:`'zip/nii'<siibra.volumes.nifti.ZipContainedNiftiProvider()>`,
-                :class:`'neuroglancer/precomputed'<siibra.volumes.neuroglancer.NeuroglancerProvider()>`,
-                :class:`'gii-mesh'<siibra.volumes.gifti.GiftiMesh()>`,
-                :class:`'neuroglancer/precompmesh'<siibra.volumes.neuroglancer.NeuroglancerMesh()>`,
-                :class:`'gii-label'<siibra.volumes.gifti.GiftiSurfaceLabeling()>`
+            starting with volumetric formats. It can be explicitly specified as:
+                - 'surface' or 'mesh' to fetch a surface format
+                - 'volumetric' or 'voxel' to fetch a volumetric format
+                - supported format types, see SUPPORTED_FORMATS. This includes
+                'nii', 'zip/nii', 'neuroglancer/precomputed', 'gii-mesh',
+                'neuroglancer/precompmesh', 'gii-label'
+
+        Returns
+        -------
+        An image or mesh
         """
 
         if format is None:

{siibra-0.4a33.dist-info → siibra-0.4a46.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: siibra
-Version: 0.4a33
+Version: 0.4a46
 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)
@@ -22,6 +22,7 @@ Requires-Dist: scikit-image
 Requires-Dist: requests
 Requires-Dist: neuroglancer-scripts
 Requires-Dist: nilearn
+Requires-Dist: filelock
 Requires-Dist: typing-extensions ; python_version < "3.8"
 
 |License| |PyPI version| |Python versions| |Documentation Status|
@@ -39,7 +40,7 @@ Medicine (INM-1), Forschungszentrum Jülich GmbH*
 ``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. 
 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.*
+    **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. 
@@ -48,7 +49,7 @@ The datasets anchored to brain regions address features of molecular, cellular a
 ``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>`__. 
-Its functionalities include common actions known from the interactive viewer ``siibra explorer`` `hosted at EBRAINS <https://atlases.ebrains.eu/viewer>`__. 
+Its functionalities include common actions known from the interactive viewer ``siibra-explorer`` `hosted at EBRAINS <https://atlases.ebrains.eu/viewer>`__. 
 In fact, the viewer is a good resource for exploring ``siibra``\ ’s core functionalities interactively: Selecting different parcellations, browsing and searching brain region hierarchies, downloading maps, identifying brain regions, and accessing multimodal features and connectivity information associated with brain regions. 
 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-0.4a46.dist-info/RECORD

@@ -0,0 +1,69 @@
+siibra/VERSION,sha256=L13hDahuVhINiq4SVkPO6tDOa7WbXfZmeuvUoNN_ovw,7
+siibra/__init__.py,sha256=VWA9EoVSVpkgwn3fmPw-nv4_kN63iWfyAwbU5W0_phY,3812
+siibra/commons.py,sha256=dNANERrRyaRt_DYi24i-uyOb3ajt7zTfy-BS-gGg3_Q,24325
+siibra/configuration/__init__.py,sha256=gXtcw2wbHCJ1o6jnd_HBudpaptHWBke71gcBd3ze7zE,688
+siibra/configuration/configuration.py,sha256=YB02grlZbCHC5CfD0FX8bc4eEAQiLmZUzBRVT9lhXQ8,6886
+siibra/configuration/factory.py,sha256=nonPGcDCBLavUQZQJBrPupBdUrOj8Te-Q_ghUBnPuvg,19405
+siibra/core/__init__.py,sha256=YQkeqGqpOT3aH-PPHeGb1kxSyMbgR3ZHqDCy2I0Zlsk,735
+siibra/core/atlas.py,sha256=FDtzpW1d492hFekttMz9aX-ggDwQrSwXlw1fWWF2tfE,7947
+siibra/core/concept.py,sha256=zP76RKGOrityiJZQjKcYmsL1Z92IC4MPZUDl3qwz01k,8091
+siibra/core/parcellation.py,sha256=eRX9FXEEPV-f6CsIUzh7hgSx100M48rLtnxZd7rBrSg,13405
+siibra/core/region.py,sha256=cBcc5Jp5fgxxR_I-k3mDEbcxP0h2bDmF3f4XRUpCaGg,24613
+siibra/core/space.py,sha256=iweTByicSWqSk-dJEscBceAGBUJ6k9pDFEUc8j29qXc,5959
+siibra/features/__init__.py,sha256=da1Eyti0i6gMeZlwCQkf7SgZJpePc9CoUP7I53-DC6c,1315
+siibra/features/anchor.py,sha256=Zz_0ovU_k5W_WM3z7sv7IjG2kGjt9jhku8RRw4jcByM,16131
+siibra/features/feature.py,sha256=s_fixmcxRTR30r2WSOdKAlirD8rxQCEEXoq76vB5abA,15497
+siibra/features/connectivity/__init__.py,sha256=c5ITfy6p6n-vze1jcgSguMq0Wk6QXVibmRvC-d92AbU,805
+siibra/features/connectivity/functional_connectivity.py,sha256=9YYaeTSSDOv6Ha7gE0zJFgRP1bTL-0c7knukZtw2nqE,1407
+siibra/features/connectivity/regional_connectivity.py,sha256=oUT_xvS2ngPVoxNG4UmkAGfJXKB8HvqipKsHvxnbpiQ,12083
+siibra/features/connectivity/streamline_counts.py,sha256=ngl7xCiCUOyflyBvjZYa3ShOmtf21E5e0A_BeWfFtSQ,1064
+siibra/features/connectivity/streamline_lengths.py,sha256=0a09Dag-eRvs1KgHSU47I3xQwbgHICsDozhZyuNzQME,1067
+siibra/features/dataset/__init__.py,sha256=FB7PGXFyl0CEuVuzEU5VHPkxf7AwQK6Oyej3waClBKM,687
+siibra/features/dataset/ebrains.py,sha256=vLWZvJAdTxtREf8-dlniIPiN4_itNujcvLhfic830V8,2699
+siibra/features/image/__init__.py,sha256=514GkYVuxEwYpNZkRptHnygnYtoUaEgyUUNthXPxBKU,833
+siibra/features/image/image.py,sha256=_P0V3WiF6TB_OF4F2Fo9Lobwm1esP8gNNve5-aqY5Dw,2819
+siibra/features/image/sections.py,sha256=3Xllns8VBXdqrQHfIHJWt88tMN8uo8RHCEgvTZ3NQ7g,915
+siibra/features/image/volume_of_interest.py,sha256=c4L5FMvfF0SWhD9m-_cpou64f6JwFWiO--oKA7W4DcI,2138
+siibra/features/tabular/__init__.py,sha256=EuROA0DhSsMgw0FTLbIXGmPyOEG8UJ-ZQtl9wNQmbEU,1196
+siibra/features/tabular/bigbrain_intensity_profile.py,sha256=JWG4KC9DlmsXazSn9tLdWkx7F8AlCtpwrBQcYZ0tRw0,2215
+siibra/features/tabular/cell_density_profile.py,sha256=hPGE-lW36QCJrfLWHk9W4DmAow6HxSJG18onBcOicK8,9096
+siibra/features/tabular/cortical_profile.py,sha256=-0xbLndu5_IYZYw-ElyMtBcLWkXhGuGefj3FVomDfJI,7911
+siibra/features/tabular/gene_expression.py,sha256=gR2neifFbo_baPKEsXbnrn52CAg5kF5IovOxd6GvGKA,4798
+siibra/features/tabular/layerwise_bigbrain_intensities.py,sha256=qbuOcV2EBuUFJDVrHBzDVLY3emV_xFslgESniOxl6cg,2138
+siibra/features/tabular/layerwise_cell_density.py,sha256=hKwykSmzh7Z9zKgQXk_YQ3UUfULPnOHE85cIPQDkaCk,4266
+siibra/features/tabular/receptor_density_fingerprint.py,sha256=xHt7woUKHRVz08i8dON7HTnzTR1R2jcAxyWL60mEeFE,6010
+siibra/features/tabular/receptor_density_profile.py,sha256=6JO14y9WB40PbDDcxu8KvC_0HGi3l3rnUiGJWjgsk4w,3577
+siibra/features/tabular/regional_timeseries_activity.py,sha256=C-QCBKraXH3qw1qHCRM8M4pyR_30eDyQwZ1UBakMHME,7247
+siibra/features/tabular/tabular.py,sha256=r9CJ0UCEZImfjPkhWvzgITDJ9q37Cz_AKmupUhE2xMs,3201
+siibra/livequeries/__init__.py,sha256=b5qKiJt_SrgSzy4abRYqvnbLSo01vUHrK8-K2zbnKIo,804
+siibra/livequeries/allen.py,sha256=-XHS1zA4tMQCEX3x4tMhuADuvjCUK5RpafyfrTeK5mc,12179
+siibra/livequeries/bigbrain.py,sha256=Rtfp2hwpX4pR45j0ZtFlEZx0AdHkpSEQgW_V59A5GRY,6834
+siibra/livequeries/ebrains.py,sha256=tdDwiaVhIrlzwT68aNV3Ds8JLjbgJ0nOx6GGAPmBCbA,5789
+siibra/livequeries/query.py,sha256=GYD_nidlKmC9N7M8Jo54iolSrcvg4P2ixjurbWMk0dk,1786
+siibra/locations/__init__.py,sha256=ItA2BnaaqP9wdXUH78mMhPFR0dSDxnz66o-y9vJH2Ag,773
+siibra/locations/boundingbox.py,sha256=Oh2FxRFcDIh3a59ko1wbp5LQBVgLPhJx8Tkn4R3z_MQ,16824
+siibra/locations/location.py,sha256=s1HEafa8jGi2C47ohwgG9XgVKAotK1HtS7Ez5gMsf_U,4577
+siibra/locations/point.py,sha256=1ea3X9cGKltNPZnnQyBoKoVhCE0U0hGtzWljf-xZw6I,12586
+siibra/locations/pointset.py,sha256=GaWnHDN7NRuKvl4hSU6YREcydFX1yWygbEOJBKTW2Ws,7110
+siibra/retrieval/__init__.py,sha256=VaR81n9ldwwbpPgIHmoUPmn8QHlZ0_R633yDqQrx6JA,1028
+siibra/retrieval/cache.py,sha256=NfieYe-3stgjpWQXVGTJSVSLJQOoat-eswj5eWEEaB8,4889
+siibra/retrieval/datasets.py,sha256=-MB8A-r3bmqPMOelSWZkaHq41Vu0YHjQEVHeq36qfW0,7660
+siibra/retrieval/repositories.py,sha256=i_eDQcLmpIbImdVWkIWLSkshCPYQ9fWJe4gmvUMM790,26309
+siibra/retrieval/requests.py,sha256=UYeo38hpbxWxmKOofiTIFcHabbwvIHWIcw0J9_xJsT0,20940
+siibra/retrieval/exceptions/__init__.py,sha256=STIPOyunBN2f7d26NTElLTL3xM1KoB3U7jLhNBivguA,173
+siibra/vocabularies/__init__.py,sha256=I_tTB-3xYAdVzRGP0CCVGgd3dP6QiltoJqEZFTr-lkI,1261
+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=RFxH36D3JS-T6lGlATthcNbPkKINjiqZxFoeb7OTtJY,8449
+siibra/volumes/__init__.py,sha256=b6O5aWKfFU0JGT8PMTUF6OewCti7aRyOno_kjJ4es_U,830
+siibra/volumes/gifti.py,sha256=idULD08pB_wxqzSFHlC_JkhFr-KuHP7FZnqp62QLXGo,5504
+siibra/volumes/neuroglancer.py,sha256=QX7rYsgLPowQsGbOYCUsFj-r3z16c1c7VFTDDL9dkNk,24056
+siibra/volumes/nifti.py,sha256=3psZ8cdOVRe9nsf82sUivb7VwfhD5MtYqAOs9IzW8Is,8948
+siibra/volumes/parcellationmap.py,sha256=lldGnmqp2_VZNv9cr5e7tvA_pgzXFapjzJ9WmhNPg74,42172
+siibra/volumes/sparsemap.py,sha256=rRl8xZFIpI8WxMjDF_WQYqxtKoH6fCQWBfBvCf_mPJs,18071
+siibra/volumes/volume.py,sha256=2YZdjcHScmYhdJI0gH-wzyE8ZjQcKrlhtEk9udtcyeE,9915
+siibra-0.4a46.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+siibra-0.4a46.dist-info/METADATA,sha256=_us0IIlXJHZ25hgSeQc3b5S1JAdnweu5cXe7r5P5o6s,9248
+siibra-0.4a46.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+siibra-0.4a46.dist-info/top_level.txt,sha256=NF0OSGLL0li2qyC7MaU0iBB5Y9S09_euPpvisD0-8Hg,7
+siibra-0.4a46.dist-info/RECORD,,

{siibra-0.4a33.dist-info → siibra-0.4a46.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.38.4)
+Generator: bdist_wheel (0.40.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

siibra/features/basetypes/feature.py

@@ -1,248 +0,0 @@
-# Copyright 2018-2021
-# Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
-
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-
-#     http://www.apache.org/licenses/LICENSE-2.0
-
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from .. import anchor as _anchor
-
-from ...commons import logger
-from ...core import concept
-from ...core import space, region, parcellation
-
-from typing import Union, TYPE_CHECKING, List, Dict, Type
-from tqdm import tqdm
-from hashlib import md5
-from collections import defaultdict
-
-if TYPE_CHECKING:
-    from ...retrieval.datasets import EbrainsDataset
-    TypeDataset = EbrainsDataset
-
-
-class Feature:
-    """
-    Base class for anatomically anchored data features.
-    """
-
-    SUBCLASSES: Dict[Type['Feature'], List[Type['Feature']]] = defaultdict(list)
-
-    def __init__(
-        self,
-        modality: str,
-        description: str,
-        anchor: _anchor.AnatomicalAnchor,
-        datasets: List['TypeDataset'] = []
-    ):
-        """
-        Parameters
-        ----------
-        modality: str
-            A textual description of the type of measured information
-        description: str
-            A textual description of the feature.
-        anchor: AnatomicalAnchor
-        datasets : list
-            list of datasets corresponding to this feature
-        """
-        self._modality_cached = modality
-        self._description = description
-        self._anchor_cached = anchor
-        self.datasets = datasets
-
-    @property
-    def modality(self):
-        # allows subclasses to implement lazy loading of an anchor
-        return self._modality_cached
-
-    @property
-    def anchor(self):
-        # allows subclasses to implement lazy loading of an anchor
-        return self._anchor_cached
-
-    def __init_subclass__(cls, configuration_folder=None):
-        # extend the subclass lists
-
-        # Iterate over all mro, not just immediate base classes
-        for BaseCls in cls.__mro__:
-            # some base classes may not be sub class of feature, ignore these
-            if not issubclass(BaseCls, Feature):
-                continue
-            cls.SUBCLASSES[BaseCls].append(cls)
-
-        cls._live_queries = []
-        cls._preconfigured_instances = None
-        cls._configuration_folder = configuration_folder
-        return super().__init_subclass__()
-
-    @classmethod
-    def _get_subclasses(cls):
-        return {Cls.__name__: Cls for Cls in cls.SUBCLASSES}
-
-    @property
-    def description(self):
-        """ Allowssubclasses to overwrite the description with a function call. """
-        return self._description
-
-    @property
-    def name(self):
-        """Returns a short human-readable name of this feature."""
-        return f"{self.__class__.__name__} ({self.modality}) anchored at {self.anchor}"
-
-    @classmethod
-    def get_instances(cls, **kwargs) -> List['Feature']:
-        """
-        Retrieve objects of a particular feature subclass.
-        Objects can be preconfigured in the configuration,
-        or delivered by Live queries.
-        """
-        result = []
-
-        if hasattr(cls, "_preconfigured_instances"):
-            if cls._preconfigured_instances is None:
-                if cls._configuration_folder is None:
-                    cls._preconfigured_instances = []
-                else:
-                    from ...configuration.configuration import Configuration
-                    conf = Configuration()
-                    Configuration.register_cleanup(cls.clean_instances)
-                    assert cls._configuration_folder in conf.folders
-                    cls._preconfigured_instances = [
-                        o for o in conf.build_objects(cls._configuration_folder)
-                        if isinstance(o, cls)
-                    ]
-                    logger.debug(
-                        f"Built {len(cls._preconfigured_instances)} preconfigured {cls.__name__} "
-                        f"objects from {cls._configuration_folder}."
-                    )
-            result.extend(cls._preconfigured_instances)
-
-        return result
-
-    @classmethod
-    def clean_instances(cls):
-        """ Removes all instantiated object instances"""
-        cls._preconfigured_instances = None
-
-    def matches(self, concept: concept.AtlasConcept) -> bool:
-        if self.anchor and self.anchor.matches(concept):
-            self.anchor._last_matched_concept = concept
-            return True
-        self.anchor._last_matched_concept = None
-        return False
-
-    @property
-    def last_match_result(self):
-        return None if self.anchor is None \
-            else self.anchor.last_match_result
-
-    @property
-    def last_match_description(self):
-        return "" if self.anchor is None \
-            else self.anchor.last_match_description
-
-    @property
-    def id(self):
-        prefix = ''
-        id_set = {ds.id for ds in self.datasets if hasattr(ds, 'id')}
-        if len(id_set) == 1:
-            prefix = list(id_set)[0] + '--'
-        return prefix + md5(self.name.encode("utf-8")).hexdigest()
-
-    @classmethod
-    def match(cls, concept: Union[region.Region, parcellation.Parcellation, space.Space], feature_type: Union[str, Type['Feature'], list], **kwargs) -> List['Feature']:
-        """
-        Retrieve data features of the desired modality.
-
-        Parameters
-        ----------
-        concept: AtlasConcept
-            An anatomical concept, typically a brain region or parcellation.
-        modality: subclass of Feature
-            specififies the type of features ("modality")
-        """
-        if isinstance(feature_type, list):
-            # a list of feature types is given, collect match results on those
-            assert all((isinstance(t, str) or issubclass(t, cls)) for t in feature_type)
-            return sum((cls.match(concept, t, **kwargs) for t in feature_type), [])
-
-        if isinstance(feature_type, str):
-            # feature type given as a string. Decode the corresponding class.
-            # Some string inputs, such as connectivity, may hit multiple matches
-            # In this case
-            candidates = [
-                feattype
-                for FeatCls, feattypes in cls.SUBCLASSES.items()
-                if all(w.lower() in FeatCls.__name__.lower() for w in feature_type.split())
-                for feattype in feattypes
-            ]
-            if len(candidates) == 0:
-                raise ValueError(f"feature_type {str(feature_type)} did not match with any features. Available features are: {', '.join(cls.SUBCLASSES.keys())}")
-
-            return [feat for c in candidates for feat in cls.match(concept, c, **kwargs)]
-
-        assert issubclass(feature_type, Feature)
-
-        if not isinstance(concept, (region.Region, parcellation.Parcellation, space.Space)):
-            raise ValueError(
-                "Feature.match / siibra.features.get only accepts Region, "
-                "Space and Parcellation objects as concept."
-            )
-
-        msg = f"Matching {feature_type.__name__} to {concept}"
-        instances = [
-            instance
-            for f_type in cls.SUBCLASSES[feature_type]
-            for instance in f_type.get_instances()
-        ]
-
-        if logger.getEffectiveLevel() > 20:
-            preconfigured_instances = [f for f in instances if f.matches(concept)]
-        else:
-            preconfigured_instances = [f for f in tqdm(instances, desc=msg, total=len(instances)) if f.matches(concept)]
-
-        live_instances = []
-        if hasattr(feature_type, "_live_queries"):
-            for QueryType in feature_type._live_queries:
-                argstr = f" ({', '.join('='.join(map(str,_)) for _ in kwargs.items())})" \
-                    if len(kwargs) > 0 else ""
-                logger.info(
-                    f"Running live query for {QueryType.feature_type.__name__} "
-                    f"objects linked to {str(concept)}{argstr}"
-                )
-                q = QueryType(**kwargs)
-                live_instances.extend(q.query(concept))
-
-        return preconfigured_instances + live_instances
-
-    @classmethod
-    def get_ascii_tree(cls):
-        # build an Ascii representation of class hierarchy
-        # under this feature class
-        from anytree.importer import DictImporter
-        from anytree import RenderTree
-
-        def create_treenode(feature_type):
-            return {
-                'name': feature_type.__name__,
-                'children': [
-                    create_treenode(c) 
-                    for c in feature_type.__subclasses__()
-                ]
-            }
-        D = create_treenode(cls)
-        importer = DictImporter()
-        tree = importer.import_(D)
-        return "\n".join(
-            "%s%s" % (pre, node.name)
-            for pre, _, node in RenderTree(tree)
-        )