siibra 0.5a2__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

siibra/livequeries/allen.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2021
+# Copyright 2018-2024
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,16 +16,15 @@
 
 from .query import LiveQuery
 
-from ..core import space as _space
+from ..core import space as _space, structure
 from ..features import anchor as _anchor
 from ..features.tabular.gene_expression import GeneExpressions
-from ..commons import logger, Species, MapType
-from ..locations import Point, PointSet
-from ..core.region import Region
+from ..commons import logger, Species
+from ..locations import point, pointcloud
 from ..retrieval import HttpRequest
 from ..vocabularies import GENE_NAMES
 
-from typing import Iterable, List
+from typing import List
 from xml.etree import ElementTree
 import numpy as np
 import json
@@ -33,6 +32,24 @@ import json
 
 BASE_URL = "http://api.brain-map.org/api/v2/data"
 
+LOCATION_PRECISION_MM = 2.  # the assumed spatial precision of the probe locations in MNI space
+
+
+def is_allen_api_microarray_service_available():
+    import requests
+
+    # see https://community.brain-map.org/t/human-brain-atlas-api/2876
+    microarray_test_url = "http://api.brain-map.org/api/v2/data/query.json?criteria= service::human_microarray_expression[probes$eq1023146,1023147][donors$eq15496][structures$eq9148]"
+    try:
+        response = requests.get(microarray_test_url).json()
+    except requests.RequestException:
+        return False
+    return response["success"]
+
+
+class InvalidAllenAPIResponseException(Exception):
+    pass
+
 
 class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions):
     """
@@ -61,7 +78,7 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
         "probe": BASE_URL
         + "/query.xml?criteria=model::Probe,rma::criteria,[probe_type$eq'DNA'],products[abbreviation$eq'HumanMA'],gene[acronym$eq'{gene}'],rma::options[only$eq'probes.id']",
         "multiple_gene_probe": BASE_URL
-        + "/query.xml?criteria=model::Probe,rma::criteria,[probe_type$eq'DNA'],products[abbreviation$eq'HumanMA'],gene[acronym$in{genes}],rma::options[only$eq'probes.id']",
+        + "/query.xml?criteria=model::Probe,rma::criteria,[probe_type$eq'DNA'],products[abbreviation$eq'HumanMA'],gene[acronym$in{genes}],rma::options[only$eq'probes.id']&start_row={start_row}&num_rows={num_rows}",
         "specimen": BASE_URL
         + "/Specimen/query.json?criteria=[name$eq'{specimen_id}']&include=alignment3d",
         "microarray": BASE_URL
@@ -69,7 +86,7 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
         "gene": BASE_URL
         + "/Gene/query.json?criteria=products[abbreviation$eq'HumanMA']&num_rows=all",
         "factors": BASE_URL
-        + "/query.json?criteria=model::Donor,rma::criteria,products[id$eq2],rma::include,age,rma::options[only$eq%27donors.id,dono  rs.name,donors.race_only,donors.sex%27]",
+        + "/query.json?criteria=model::Donor,rma::criteria,products[id$eq2],rma::include,age,rma::options[only$eq%27donors.id,dono  rs.name,donors.race_only,donors.sex%27]&start_row={start_row}&num_rows={num_rows}",
     }
 
     # there is a 1:1 mapping between donors and specimen for the 6 adult human brains
@@ -102,10 +119,6 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
         """
         LiveQuery.__init__(self, **kwargs)
         gene = kwargs.get('gene')
-        self.maptype = kwargs.get("maptype", MapType.LABELLED)
-        if isinstance(self.maptype, str):
-            self.maptype = MapType[self.maptype.upper()]
-        self.threshold_statistical = kwargs.get("threshold_statistical", 0)
 
         def parse_gene(spec):
             if isinstance(spec, str):
@@ -122,48 +135,62 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
 
         self.genes = parse_gene(gene)
 
-    def query(self, region: Region) -> List[GeneExpressions]:
-        assert isinstance(region, Region)
-        space = _space.Space.registry().get('mni152')
-        mask = region.fetch_regional_map(space, maptype=self.maptype, threshold=self.threshold_statistical)
+    def query(self, concept: structure.BrainStructure) -> List[GeneExpressions]:
+        if not is_allen_api_microarray_service_available():
+            raise InvalidAllenAPIResponseException(
+                'The service "web API of the Allen Brain Atlas for the human microarray expression" '
+                'is not available at the moment, therefore siibra is not able to fetch '
+                'gene expression features. This is a known issue which we are investigating: '
+                'https://github.com/FZJ-INM1-BDA/siibra-python/issues/636.'
+            )
+
+        mnispace = _space.Space.registry().get('mni152')
+
+        # Match the microarray probes to the query mask.
+        # Record matched instances and their locations.
+        measurements = []
+        coordinates = []
+        for measurement in self:
+            pt = point.Point(measurement['mni_xyz'], space=mnispace, sigma_mm=LOCATION_PRECISION_MM)
+            if pt in concept:
+                measurements.append(measurement)
+                coordinates.append(pt)
+
+        if len(coordinates) == 0:
+            logger.info(f"No probes found that lie within {concept}")
+            return []
+
+        # Build the anatomical anchor and assignment to the query concept.
+        # It will be attached to the returned feature, with the set of matched
+        # MNI coordinates as anchor's location.
         anchor = _anchor.AnatomicalAnchor(
-            species=self.species, region=region.name
-        )
-        ass = _anchor.AnatomicalAssignment(
-            query_structure=region,
-            assigned_structure=region,
-            qualification=_anchor.AssignmentQualification.CONTAINED,
-            explanation=(f"MNI coordinates of tissue samples were compared with mask of '{region.name}' in {space}.")
+            location=pointcloud.from_points(coordinates),
+            species=self.species
         )
-        anchor._assignments[region] = [ass]
-        anchor._last_matched_concept = region
-        anchor._location_cached = PointSet(coordinates=[], space=space)
-
-        measures = []
-        contained = {}
-        for measure in self:
-            location = Point(measure['mni_xyz'], space=space)
-            if location not in contained:  # cache redundant intersection tests
-                contained[location] = location.intersects(mask)
-            if contained[location]:
-                measures.append(measure)
-                anchor._location_cached.points.append(location)
-
-        yield GeneExpressions(
+        explanation = f"MNI coordinates of tissue samples were filtered using {concept}"
+        anchor._assignments[concept] = [_anchor.AnatomicalAssignment(
+            query_structure=concept,
+            assigned_structure=concept,
+            qualification=_anchor.Qualification.CONTAINED,
+            explanation=explanation
+        )]
+        anchor._last_matched_concept = concept
+
+        return [GeneExpressions(
             anchor=anchor,
-            genes=[m['gene'] for m in measures],
-            levels=[m['expression_level'] for m in measures],
-            z_scores=[m['z_score'] for m in measures],
+            genes=[m['gene'] for m in measurements],
+            levels=[m['expression_level'] for m in measurements],
+            z_scores=[m['z_score'] for m in measurements],
             additional_columns={
-                "race": [m['race'] for m in measures],
-                "gender": [m['gender'] for m in measures],
-                "age": [m['age'] for m in measures],
-                "mni_xyz": [tuple(m['mni_xyz']) for m in measures],
-                "sample": [m['sample_index'] for m in measures],
-                "probe_id": [m['probe_id'] for m in measures],
-                "donor_name": [m['donor_name'] for m in measures],
+                "race": [m['race'] for m in measurements],
+                "gender": [m['gender'] for m in measurements],
+                "age": [m['age'] for m in measurements],
+                "mni_xyz": [tuple(m['mni_xyz']) for m in measurements],
+                "sample": [m['sample_index'] for m in measurements],
+                "probe_id": [m['probe_id'] for m in measurements],
+                "donor_name": [m['donor_name'] for m in measurements],
             }
-        )
+        )]
 
     def __iter__(self):
 
@@ -178,21 +205,7 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
             print(GeneExpressions.ALLEN_ATLAS_NOTIFICATION)
             self.__class__._notification_shown = True
 
-        assert isinstance(self.genes, list)
-        if len(self.genes) == 1:
-            logger.info(f"Retrieving probe ids for gene {self.genes[0]['symbol']}")
-        else:
-            logger.info(f"Retrieving probe ids for genes {', '.join(g['symbol'] for g in self.genes)}")
-        url = self._QUERY["multiple_gene_probe"].format(genes=','.join([f"'{g['symbol']}'" for g in self.genes]))
-        response = HttpRequest(url).get()
-        if "site unavailable" in response.decode().lower():
-            # When the Allen site is not available, they still send a status code 200.
-            raise RuntimeError(
-                "Allen institute site unavailable - please try again later."
-            )
-        root = ElementTree.fromstring(response)
-        num_probes = int(root.attrib["total_rows"])
-        probe_ids = [int(root[0][i][0].text) for i in range(num_probes)]
+        probe_ids = self._retrieve_probe_ids(self.genes)
 
         # get specimen information
         if AllenBrainAtlasQuery._specimen is None:
@@ -201,15 +214,7 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
             }
 
         if AllenBrainAtlasQuery.factors is None:
-            response = HttpRequest(self._QUERY["factors"]).get()
-            AllenBrainAtlasQuery.factors = {
-                item["id"]: {
-                    "race": item["race_only"],
-                    "gender": item["sex"],
-                    "age": int(item["age"]["days"] / 365),
-                }
-                for item in response["msg"]
-            }
+            self._retrieve_factors()
 
         # get expression levels and z_scores for the gene
         if len(probe_ids) > 0:
@@ -217,6 +222,60 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
                 for item in self._retrieve_microarray(donor_id, probe_ids):
                     yield item
 
+    @staticmethod
+    def _retrieve_probe_ids(genes: list):
+        assert isinstance(genes, list)
+        if len(genes) == 1:
+            logger.debug(f"Retrieving probe ids for gene {genes[0]['symbol']}")
+        else:
+            logger.debug(f"Retrieving probe ids for genes {', '.join(g['symbol'] for g in genes)}")
+        start_row = 0
+        num_rows = 50
+        probe_ids = []
+        while True:
+            url = AllenBrainAtlasQuery._QUERY["multiple_gene_probe"].format(
+                start_row=start_row, num_rows=num_rows, genes=','.join([f"'{g['symbol']}'" for g in genes])
+            )
+            response = HttpRequest(url).get()
+            if "site unavailable" in response.decode().lower():
+                # When the Allen site is not available, they still send a status code 200.
+                raise RuntimeError(
+                    "Allen institute site unavailable - please try again later."
+                )
+            root = ElementTree.fromstring(response)
+            num_probes = int(root.attrib["num_rows"])
+            total_probes = int(root.attrib["total_rows"])
+            assert len(root) == 1
+            probe_ids.extend([int(root[0][i][0].text) for i in range(num_probes)])
+            if (start_row + num_rows) >= total_probes:
+                break
+            # retrieve another page
+            start_row += num_rows
+        return probe_ids
+
+    @staticmethod
+    def _retrieve_factors():
+        start_row = 0
+        num_rows = 50
+        if AllenBrainAtlasQuery.factors is None or len(AllenBrainAtlasQuery.factors) == 0:
+            AllenBrainAtlasQuery.factors = {}
+            while True:
+                factors_url = AllenBrainAtlasQuery._QUERY["factors"].format(start_row=start_row, num_rows=num_rows)
+                response = HttpRequest(factors_url).get()
+                AllenBrainAtlasQuery.factors.update({
+                    item["id"]: {
+                        "race": item["race_only"],
+                        "gender": item["sex"],
+                        "age": int(item["age"]["days"] / 365),
+                    }
+                    for item in response["msg"]
+                })
+                total_factors = int(response["total_rows"])
+                if (start_row + num_rows) >= total_factors:
+                    break
+                # retrieve another page
+                start_row += num_rows
+
     @staticmethod
     def _retrieve_specimen(specimen_id: str):
         """
@@ -225,7 +284,7 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
         url = AllenBrainAtlasQuery._QUERY["specimen"].format(specimen_id=specimen_id)
         response = HttpRequest(url).get()
         if not response["success"]:
-            raise Exception(
+            raise InvalidAllenAPIResponseException(
                 "Invalid response when retrieving specimen information: {}".format(url)
             )
         # we ask for 1 specimen, so list should have length 1
@@ -242,7 +301,7 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
         return specimen
 
     @classmethod
-    def _retrieve_microarray(cls, donor_id: str, probe_ids: str) -> Iterable[GeneExpressions]:
+    def _retrieve_microarray(cls, donor_id: str, probe_ids: str):
         """
         Retrieve microarray data for several probes of a given donor, and
         compute the MRI position of the corresponding tissue block in the ICBM
@@ -256,9 +315,12 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
         url = AllenBrainAtlasQuery._QUERY["microarray"].format(
             probe_ids=",".join([str(id) for id in probe_ids]), donor_id=donor_id
         )
-        response = HttpRequest(url, json.loads).get()
+        try:
+            response = HttpRequest(url, json.loads).get()
+        except json.JSONDecodeError as e:
+            raise RuntimeError(f"Allen institute site produced an empty response - please try again later.\n{e}")
         if not response["success"]:
-            raise Exception(
+            raise InvalidAllenAPIResponseException(
                 "Invalid response when retrieving microarray data: {}".format(url)
             )
 

siibra/livequeries/bigbrain.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2021
+# Copyright 2018-2024
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,10 +17,12 @@
 from . import query
 
 from ..features.tabular import bigbrain_intensity_profile, layerwise_bigbrain_intensities
+from ..features import anchor as _anchor
 from ..commons import logger
-from ..locations import point, pointset
-from ..core import region
+from ..locations import point, pointcloud
+from ..core import structure
 from ..retrieval import requests, cache
+from ..retrieval.datasets import GenericDataset
 
 import numpy as np
 from typing import List
@@ -36,6 +38,37 @@ class WagstylProfileLoader:
     _profiles = None
     _vertices = None
     _boundary_depths = None
+    DATASET = GenericDataset(
+        name="HIBALL workshop on cortical layers",
+        contributors=[
+            'Konrad Wagstyl',
+            'Stéphanie Larocque',
+            'Guillem Cucurull',
+            'Claude Lepage',
+            'Joseph Paul Cohen',
+            'Sebastian Bludau',
+            'Nicola Palomero-Gallagher',
+            'Lindsay B. Lewis',
+            'Thomas Funck',
+            'Hannah Spitzer',
+            'Timo Dickscheid',
+            'Paul C. Fletcher',
+            'Adriana Romero',
+            'Karl Zilles',
+            'Katrin Amunts',
+            'Yoshua Bengio',
+            'Alan C. Evans'
+        ],
+        url="https://github.com/kwagstyl/cortical_layers_tutorial/",
+        description="Cortical profiles of BigBrain staining intensities computed by Konrad Wagstyl, "
+        "as described in the publication 'Wagstyl, K., et al (2020). BigBrain 3D atlas of "
+        "cortical layers: Cortical and laminar thickness gradients diverge in sensory and "
+        "motor cortices. PLoS Biology, 18(4), e3000678. "
+        "http://dx.doi.org/10.1371/journal.pbio.3000678."
+        "The data is taken from the tutorial at "
+        "https://github.com/kwagstyl/cortical_layers_tutorial. Each vertex is "
+        "assigned to the regional map when queried."
+    )
 
     def __init__(self):
         if self._profiles is None:
@@ -72,78 +105,11 @@ class WagstylProfileLoader:
         logger.debug(f"{cls._profiles.shape[0]} BigBrain intensity profiles.")
         assert cls._vertices.shape[0] == cls._profiles.shape[0]
 
-    @staticmethod
-    def _choose_space(regionobj: region.Region):
-        """
-        Helper function to obtain a suitable space to fetch a regional mask.
-        BigBrain space has priorty.
-
-        Parameters
-        ----------
-        regionobj : region.Region
-
-        Returns
-        -------
-        Space
-
-        Raises
-        ------
-        RuntimeError
-            When there is no supported space that provides image for `regionobj`.
-        """
-        if regionobj.mapped_in_space('bigbrain'):
-            return 'bigbrain'
-        supported_spaces = [s for s in regionobj.supported_spaces if s.provides_image]
-        if len(supported_spaces) == 0:
-            raise RuntimeError(f"Could not find a supported space for {regionobj}")
-        return supported_spaces[0]
-
     def __len__(self):
         return self._vertices.shape[0]
 
-    def match(self, regionobj: region.Region, space: str = None):
-        """
-        Retrieve BigBrainIntesityProfiles .
-
-        Parameters
-        ----------
-        regionobj : region.Region
-            Region or parcellation
-        space : str, optional
-            The space in which the region masks will be calculated. By default,
-            siibra tries to fetch in BigBrain first and then the other spaces.
-
-        Returns
-        -------
-        tuple
-            tuple of profiles, boundary depths, and vertices
-        """
-        assert isinstance(regionobj, region.Region)
-        logger.debug(f"Matching locations of {len(self)} BigBrain profiles to {regionobj}")
-
-        if space is None:
-            space = self._choose_space(regionobj)
-
-        mask = regionobj.fetch_regional_map(space=space, maptype="labelled")
-        logger.info(f"Assigning {len(self)} profile locations to {regionobj} in {space}...")
-        voxels = (
-            pointset.PointSet(self._vertices, space="bigbrain")
-            .warp(space)
-            .transform(np.linalg.inv(mask.affine), space=None)
-        )
-        arr = mask.get_fdata()
-        XYZ = np.array(voxels.as_list()).astype('int')
-        X, Y, Z = np.split(
-            XYZ[np.all((XYZ < arr.shape) & (XYZ > 0), axis=1), :],
-            3, axis=1
-        )
-        inside = np.where(arr[X, Y, Z] > 0)[0]
 
-        return (
-            self._profiles[inside, :],
-            self._boundary_depths[inside, :],
-            self._vertices[inside, :]
-        )
+cache.Warmup.register_warmup_fn()(lambda: WagstylProfileLoader._load())
 
 
 class BigBrainProfileQuery(query.LiveQuery, args=[], FeatureType=bigbrain_intensity_profile.BigBrainIntensityProfile):
@@ -151,32 +117,38 @@ class BigBrainProfileQuery(query.LiveQuery, args=[], FeatureType=bigbrain_intens
     def __init__(self):
         query.LiveQuery.__init__(self)
 
-    def query(self, regionobj: region.Region, **kwargs) -> List[bigbrain_intensity_profile.BigBrainIntensityProfile]:
-        assert isinstance(regionobj, region.Region)
+    def query(self, concept: structure.BrainStructure, **kwargs) -> List[bigbrain_intensity_profile.BigBrainIntensityProfile]:
         loader = WagstylProfileLoader()
+        mesh_vertices = pointcloud.PointCloud(loader._vertices, space='bigbrain')
+        matched = concept.intersection(mesh_vertices)  # returns a reduced PointCloud with og indices as labels
+        if matched is None:
+            return []
+        assert isinstance(matched, pointcloud.PointCloud)
+        indices = matched.labels
+        assert indices is not None
+        features = []
+        for i in matched.labels:
+            anchor = _anchor.AnatomicalAnchor(
+                location=point.Point(loader._vertices[i], space='bigbrain'),
+                region=str(concept),
+                species='Homo sapiens'
+            )
+            prof = bigbrain_intensity_profile.BigBrainIntensityProfile(
+                anchor=anchor,
+                depths=loader.profile_labels,
+                values=loader._profiles[i],
+                boundaries=loader._boundary_depths[i]
+            )
+            prof.anchor._assignments[concept] = _anchor.AnatomicalAssignment(
+                query_structure=concept,
+                assigned_structure=concept,
+                qualification=_anchor.Qualification.CONTAINED,
+                explanation=f"Surface vertex of BigBrain cortical profile was filtered using {concept}"
+            )
+            prof.datasets = [WagstylProfileLoader.DATASET]
+            features.append(prof)
 
-        space = WagstylProfileLoader._choose_space(regionobj)
-        if not regionobj.is_leaf:
-            leaves_defined_on_space = [
-                r for r in regionobj.leaves if r.mapped_in_space(space)
-            ]
-        else:
-            leaves_defined_on_space = [regionobj]
-
-        result = []
-        for subregion in leaves_defined_on_space:
-            matched_profiles, boundary_depths, coords = loader.match(subregion, space)
-            for i, profile in enumerate(matched_profiles):
-                prof = bigbrain_intensity_profile.BigBrainIntensityProfile(
-                    regionname=subregion.name,
-                    depths=loader.profile_labels,
-                    values=profile,
-                    boundaries=boundary_depths[i, :],
-                    location=point.Point(coords[i, :], 'bigbrain')  # points are warped into BigBrain
-                )
-                result.append(prof)
-
-        return result
+        return features
 
 
 class LayerwiseBigBrainIntensityQuery(query.LiveQuery, args=[], FeatureType=layerwise_bigbrain_intensities.LayerwiseBigBrainIntensities):
@@ -184,38 +156,42 @@ class LayerwiseBigBrainIntensityQuery(query.LiveQuery, args=[], FeatureType=laye
     def __init__(self):
         query.LiveQuery.__init__(self)
 
-    def query(self, regionobj: region.Region, **kwargs) -> List[layerwise_bigbrain_intensities.LayerwiseBigBrainIntensities]:
-        assert isinstance(regionobj, region.Region)
-        loader = WagstylProfileLoader()
+    def query(self, concept: structure.BrainStructure, **kwargs) -> List[layerwise_bigbrain_intensities.LayerwiseBigBrainIntensities]:
 
-        space = WagstylProfileLoader._choose_space(regionobj)
-        if not regionobj.is_leaf:
-            leaves_defined_on_space = [
-                r for r in regionobj.leaves if r.mapped_in_space(space)
-            ]
-        else:
-            leaves_defined_on_space = [regionobj]
-
-        result = []
-        for subregion in leaves_defined_on_space:
-            matched_profiles, boundary_depths, coords = loader.match(subregion, space)
-            if matched_profiles.shape[0] == 0:
-                continue
-
-            # compute array of layer labels for all coefficients in profiles_left
-            N = matched_profiles.shape[1]
-            prange = np.arange(N)
-            layer_labels = 7 - np.array([
-                [np.array([[(prange < T) * 1] for i, T in enumerate((b * N).astype('int'))]).squeeze().sum(0)]
-                for b in boundary_depths
-            ]).reshape((-1, 200))
-
-            fp = layerwise_bigbrain_intensities.LayerwiseBigBrainIntensities(
-                regionname=subregion.name,
-                means=[matched_profiles[layer_labels == layer].mean() for layer in range(1, 7)],
-                stds=[matched_profiles[layer_labels == layer].std() for layer in range(1, 7)],
-            )
-            assert fp.matches(subregion)  # to create an assignment result
-            result.append(fp)
+        loader = WagstylProfileLoader()
+        mesh_vertices = pointcloud.PointCloud(loader._vertices, space='bigbrain')
+        matched = concept.intersection(mesh_vertices)  # returns a reduced PointCloud with og indices as labels
+        if matched is None:
+            return []
+        assert isinstance(matched, pointcloud.PointCloud)
+        indices = matched.labels
+        assert indices is not None
+        matched_profiles = loader._profiles[indices, :]
+        boundary_depths = loader._boundary_depths[indices, :]
+        # compute array of layer labels for all coefficients in profiles_left
+        N = matched_profiles.shape[1]
+        prange = np.arange(N)
+        layer_labels = 7 - np.array([
+            [np.array([[(prange < T) * 1] for i, T in enumerate((b * N).astype('int'))]).squeeze().sum(0)]
+            for b in boundary_depths
+        ]).reshape((-1, 200))
+
+        anchor = _anchor.AnatomicalAnchor(
+            location=pointcloud.PointCloud(loader._vertices[indices, :], space='bigbrain'),
+            region=str(concept),
+            species='Homo sapiens'
+        )
+        result = layerwise_bigbrain_intensities.LayerwiseBigBrainIntensities(
+            anchor=anchor,
+            means=[matched_profiles[layer_labels == layer].mean() for layer in range(1, 7)],
+            stds=[matched_profiles[layer_labels == layer].std() for layer in range(1, 7)],
+        )
+        result.anchor._assignments[concept] = _anchor.AnatomicalAssignment(
+            query_structure=concept,
+            assigned_structure=concept,
+            qualification=_anchor.Qualification.CONTAINED,
+            explanation=f"Surface vertices of BigBrain cortical profiles were filtered using {concept}"
+        )
+        result.datasets = [WagstylProfileLoader.DATASET]
 
-        return result
+        return [result]

siibra/livequeries/ebrains.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2021
+# Copyright 2018-2024
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -19,12 +19,12 @@ from . import query
 
 from ..commons import logger, siibra_tqdm
 from ..features import anchor as _anchor
-from ..retrieval import requests, datasets
+from ..retrieval import requests, datasets, cache
 from ..core import parcellation, region
 
 from collections import defaultdict
 import re
-from distutils.version import LooseVersion
+from packaging.version import Version
 from tempfile import NamedTemporaryFile
 
 
@@ -121,7 +121,7 @@ class EbrainsFeatureQuery(query.LiveQuery, args=[], FeatureType=_ebrains.Ebrains
         # the newest one with older ones linked as a version history.
         for name, dsets in versioned_datasets.items():
             try:  # if possible, sort by version tag
-                sorted_versions = sorted(dsets.keys(), key=LooseVersion)
+                sorted_versions = sorted(dsets.keys(), key=Version)
             except TypeError:  # else sort lexicographically
                 sorted_versions = sorted(dsets.keys())
 
@@ -140,3 +140,6 @@ class EbrainsFeatureQuery(query.LiveQuery, args=[], FeatureType=_ebrains.Ebrains
                 f"Its version history is: {curr.version_history}"
             )
             yield curr
+
+
+cache.Warmup.register_warmup_fn(cache.WarmupLevel.DATA)(lambda: EbrainsFeatureQuery.loader.data)

siibra/livequeries/query.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2021
+# Copyright 2018-2024
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -47,4 +47,3 @@ class LiveQuery(ABC):
     @abstractmethod
     def query(self, concept: AtlasConcept, **kwargs) -> List[Feature]:
         raise NotImplementedError(f"Dervied class {self.__class__} needs to implement query()")
-        pass