siibra 1.0a19__py3-none-any.whl → 1.0.1a1__py3-none-any.whl

siibra/features/tabular/cell_density_profile.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2024
+# Copyright 2018-2025
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,15 +16,77 @@
 from . import cortical_profile
 
 from .. import anchor as _anchor
-from ...commons import PolyLine, logger, create_key
+from ...commons import logger
 from ...retrieval import requests
 
 from skimage.draw import polygon
 from skimage.transform import resize
-from io import BytesIO
 import numpy as np
 import pandas as pd
 
+from io import BytesIO
+from typing import Union, Tuple, Iterable
+
+
+def cell_reader(bytes_buffer: bytes):
+    return pd.read_csv(BytesIO(bytes_buffer[2:]), delimiter=" ", header=0).astype(
+        {"layer": int, "label": int}
+    )
+
+
+def layer_reader(bytes_buffer: bytes):
+    return pd.read_csv(BytesIO(bytes_buffer[2:]), delimiter=" ", header=0, index_col=0)
+
+
+def poly_srt(poly):
+    return poly[poly[:, 0].argsort(), :]
+
+
+def poly_rev(poly):
+    return poly[poly[:, 0].argsort()[::-1], :]
+
+
+class PolyLine:
+    """Simple polyline representation which allows equidistant sampling."""
+
+    def __init__(self, pts):
+        self.pts = pts
+        self.lengths = [
+            np.sqrt(np.sum((pts[i, :] - pts[i - 1, :]) ** 2))
+            for i in range(1, pts.shape[0])
+        ]
+
+    def length(self):
+        return sum(self.lengths)
+
+    def sample(self, d: Union[Iterable[float], np.ndarray, float]):
+        # if d is iterable, we assume a list of sample positions
+        try:
+            iter(d)
+        except TypeError:
+            positions = [d]
+        else:
+            positions = d
+
+        samples = []
+        for s_ in positions:
+            s = min(max(s_, 0), 1)
+            target_distance = s * self.length()
+            current_distance = 0
+            for i, length in enumerate(self.lengths):
+                current_distance += length
+                if current_distance >= target_distance:
+                    p1 = self.pts[i, :]
+                    p2 = self.pts[i + 1, :]
+                    r = (target_distance - current_distance + length) / length
+                    samples.append(p1 + (p2 - p1) * r)
+                    break
+
+        if len(samples) == 1:
+            return samples[0]
+        else:
+            return np.array(samples)
+
 
 class CellDensityProfile(
     cortical_profile.CorticalProfile,
@@ -45,24 +107,6 @@ class CellDensityProfile(
 
     _filter_attrs = cortical_profile.CorticalProfile._filter_attrs + ["location"]
 
-    @classmethod
-    def CELL_READER(cls, b):
-        return pd.read_csv(BytesIO(b[2:]), delimiter=" ", header=0).astype(
-            {"layer": int, "label": int}
-        )
-
-    @classmethod
-    def LAYER_READER(cls, b):
-        return pd.read_csv(BytesIO(b[2:]), delimiter=" ", header=0, index_col=0)
-
-    @staticmethod
-    def poly_srt(poly):
-        return poly[poly[:, 0].argsort(), :]
-
-    @staticmethod
-    def poly_rev(poly):
-        return poly[poly[:, 0].argsort()[::-1], :]
-
     def __init__(
         self,
         section: int,
@@ -89,9 +133,9 @@ class CellDensityProfile(
         )
         self._step = 0.01
         self._url = url
-        self._cell_loader = requests.HttpRequest(url, self.CELL_READER)
+        self._cell_loader = requests.HttpRequest(url, cell_reader)
         self._layer_loader = requests.HttpRequest(
-            url.replace("segments", "layerinfo"), self.LAYER_READER
+            url.replace("segments", "layerinfo"), layer_reader
         )
         self._density_image = None
         self._layer_mask = None
@@ -105,47 +149,49 @@ class CellDensityProfile(
 
     @property
     def shape(self):
-        return tuple(self.cells[["y", "x"]].max().astype("int") + 1)
+        """(y,x)"""
+        return tuple(np.ceil(self.cells[["y", "x"]].max()).astype("int"))
 
-    def boundary_annotation(self, boundary):
+    def boundary_annotation(self, boundary: Tuple[int, int]) -> np.ndarray:
         """Returns the annotation of a specific layer boundary."""
-        y1, x1 = self.shape
+        shape_y, shape_x = self.shape
 
         # start of image patch
         if boundary == (-1, 0):
-            return np.array([[0, 0], [x1, 0]])
+            return np.array([[0, 0], [shape_x, 0]])
 
         # end of image patch
         if boundary == (7, 8):
-            return np.array([[0, y1], [x1, y1]])
+            return np.array([[0, shape_y], [shape_x, shape_y]])
 
         # retrieve polygon
         basename = "{}_{}.json".format(
             *(self.LAYERS[layer] for layer in boundary)
         ).replace("0_I", "0")
-        url = self._url.replace("segments.txt", basename)
-        poly = self.poly_srt(np.array(requests.HttpRequest(url).get()["segments"]))
+        poly_url = self._url.replace("segments.txt", basename)
+        poly = poly_srt(np.array(requests.HttpRequest(poly_url).get()["segments"]))
 
-        # ensure full width
+        # ensure full width and trim to the image shape
         poly[0, 0] = 0
-        poly[-1, 0] = x1
+        poly[poly[:, 0] > shape_x, 0] = shape_x
+        poly[poly[:, 1] > shape_y, 1] = shape_y
 
         return poly
 
-    def layer_annotation(self, layer):
+    def layer_annotation(self, layer: int) -> np.ndarray:
         return np.vstack(
             (
                 self.boundary_annotation((layer - 1, layer)),
-                self.poly_rev(self.boundary_annotation((layer, layer + 1))),
+                poly_rev(self.boundary_annotation((layer, layer + 1))),
                 self.boundary_annotation((layer - 1, layer))[0, :],
             )
         )
 
     @property
-    def layer_mask(self):
+    def layer_mask(self) -> np.ndarray:
         """Generates a layer mask from boundary annotations."""
         if self._layer_mask is None:
-            self._layer_mask = np.zeros(np.array(self.shape).astype("int") + 1)
+            self._layer_mask = np.zeros(np.array(self.shape, dtype=int) + 1, dtype="int")
             for layer in range(1, 8):
                 pl = self.layer_annotation(layer)
                 X, Y = polygon(pl[:, 0], pl[:, 1])
@@ -153,20 +199,20 @@ class CellDensityProfile(
         return self._layer_mask
 
     @property
-    def depth_image(self):
+    def depth_image(self) -> np.ndarray:
         """Cortical depth image from layer boundary polygons by equidistant sampling."""
 
         if self._depth_image is None:
-
+            logger.info("Calculating cell densities from cell and layer data...")
             # compute equidistant cortical depth image from inner and outer contour
             scale = 0.1
-            D = np.zeros((np.array(self.density_image.shape) * scale).astype("int") + 1)
+            depth_arr = np.zeros(np.ceil(np.array(self.shape) * scale).astype("int") + 1)
 
             # determine sufficient stepwidth for profile sampling
             # to match downscaled image resolution
-            vstep, hstep = 1.0 / np.array(D.shape) / 2.0
+            vstep, hstep = 1.0 / np.array(depth_arr.shape) / 2.0
             vsteps = np.arange(0, 1 + vstep, vstep)
-            hsteps = np.arange(0, 1 + vstep, hstep)
+            hsteps = np.arange(0, 1 + hstep, hstep)
 
             # build straight profiles between outer and inner cortical boundary
             s0 = PolyLine(self.boundary_annotation((0, 1)) * scale).sample(hsteps)
@@ -175,16 +221,16 @@ class CellDensityProfile(
 
             # write sample depths to their location in the depth image
             for prof in profiles:
-                XY = prof.sample(vsteps).astype("int")
-                D[XY[:, 1], XY[:, 0]] = vsteps
+                prof_samples_as_index = prof.sample(vsteps).astype("int")
+                depth_arr[prof_samples_as_index[:, 1], prof_samples_as_index[:, 0]] = vsteps
 
             # fix wm region, account for rounding error
             XY = self.layer_annotation(7) * scale
-            D[polygon(XY[:, 1] - 1, XY[:, 0])] = 1
-            D[-1, :] = 1
+            depth_arr[polygon(XY[:, 1] - 1, XY[:, 0])] = 1
+            depth_arr[-1, :] = 1
 
             # rescale depth image to original patch size
-            self._depth_image = resize(D, self.density_image.shape)
+            self._depth_image = resize(depth_arr, self.density_image.shape)
 
         return self._depth_image
 
@@ -200,7 +246,7 @@ class CellDensityProfile(
         return self._boundary_positions
 
     @property
-    def density_image(self):
+    def density_image(self) -> np.ndarray:
         if self._density_image is None:
             logger.debug("Computing density image for", self._url)
             # we integrate cell counts into 2D bins
@@ -209,9 +255,7 @@ class CellDensityProfile(
             counts, xedges, yedges = np.histogram2d(
                 self.cells.y,
                 self.cells.x,
-                bins=(np.array(self.layer_mask.shape) / pixel_size_micron + 0.5).astype(
-                    "int"
-                ),
+                bins=np.round(np.array(self.shape) / pixel_size_micron).astype("int"),
             )
 
             # rescale the counts from count / pixel_size**2  to count / 0.1mm^3,
@@ -229,11 +273,11 @@ class CellDensityProfile(
         return self._density_image
 
     @property
-    def cells(self):
+    def cells(self) -> pd.DataFrame:
         return self._cell_loader.get()
 
     @property
-    def layers(self):
+    def layers(self) -> pd.DataFrame:
         return self._layer_loader.get()
 
     @property
@@ -242,6 +286,7 @@ class CellDensityProfile(
 
     @property
     def _values(self):
+        # TODO: release a dataset update instead of on the fly computation
         densities = []
         delta = self._step / 2.0
         for d in self._depths:
@@ -249,16 +294,5 @@ class CellDensityProfile(
             if np.sum(mask) > 0:
                 densities.append(self.density_image[mask].mean())
             else:
-                densities.append(np.NaN)
+                densities.append(np.nan)
         return np.asanyarray(densities)
-
-    @property
-    def key(self):
-        assert len(self.species) == 1
-        return create_key("{}_{}_{}_{}_{}".format(
-            self.id,
-            self.species[0]['name'],
-            self.regionspec,
-            self.section,
-            self.patch
-        ))

siibra/features/tabular/cortical_profile.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2024
+# Copyright 2018-2025
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -37,7 +37,7 @@ class CorticalProfile(tabular.Tabular, Compoundable):
     Optionally, the depth coordinates of layer boundaries can be specified.
 
     Most attributes are modelled as properties, so dervide classes are able
-    to implement lazy loading instead of direct initialiation.
+    to implement lazy loading instead of direct initialization.
 
     """
 
@@ -151,7 +151,7 @@ class CorticalProfile(tabular.Tabular, Compoundable):
 
     @property
     def _layers(self):
-        """List of layers assigned to each measurments,
+        """List of layers assigned to each measurements,
         if layer boundaries are available for this features.
         """
         if self.boundaries_mapped:

siibra/features/tabular/gene_expression.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2024
+# Copyright 2018-2025
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");

siibra/features/tabular/layerwise_bigbrain_intensities.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2024
+# Copyright 2018-2025
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");

siibra/features/tabular/layerwise_cell_density.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2024
+# Copyright 2018-2025
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,13 +16,13 @@
 from . import cortical_profile
 from .. import anchor as _anchor
 from . import tabular
+from ..tabular.cell_density_profile import cell_reader, layer_reader
 
 from ... import commons
 from ...retrieval import requests
 
 import pandas as pd
 import numpy as np
-from io import BytesIO
 
 
 class LayerwiseCellDensity(
@@ -40,16 +40,6 @@ class LayerwiseCellDensity(
         "The cortical depth is estimated from the measured layer thicknesses."
     )
 
-    @classmethod
-    def CELL_READER(cls, b):
-        return pd.read_csv(BytesIO(b[2:]), delimiter=" ", header=0).astype(
-            {"layer": int, "label": int}
-        )
-
-    @classmethod
-    def LAYER_READER(cls, b):
-        return pd.read_csv(BytesIO(b[2:]), delimiter=" ", header=0, index_col=0)
-
     def __init__(
         self,
         segmentfiles: list,
@@ -77,8 +67,8 @@ class LayerwiseCellDensity(
         density_dict = {}
         for i, (cellfile, layerfile) in enumerate(self._filepairs):
             try:
-                cells = requests.HttpRequest(cellfile, func=self.CELL_READER).data
-                layers = requests.HttpRequest(layerfile, func=self.LAYER_READER).data
+                cells = requests.HttpRequest(cellfile, func=cell_reader).data
+                layers = requests.HttpRequest(layerfile, func=layer_reader).data
             except requests.SiibraHttpRequestError as e:
                 print(str(e))
                 commons.logger.error(f"Skipping to bootstrap a {self.__class__.__name__} feature, cannot access file resource.")
@@ -103,12 +93,3 @@ class LayerwiseCellDensity(
             )
             self._data_cached.index.name = 'layer'
         return self._data_cached
-
-    @property
-    def key(self):
-        assert len(self.species) == 1
-        return commons.create_key("{}_{}_{}".format(
-            self.dataset_id,
-            self.species[0]['name'],
-            self.regionspec
-        ))

siibra/features/tabular/receptor_density_fingerprint.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2024
+# Copyright 2018-2025
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,7 +16,8 @@
 from .. import anchor as _anchor
 from . import tabular
 
-from ... import commons, vocabularies
+from ...commons import logger
+from ...vocabularies import RECEPTOR_SYMBOLS
 from ...retrieval import requests
 
 import pandas as pd
@@ -34,7 +35,7 @@ class ReceptorDensityFingerprint(
     DESCRIPTION = (
         "Fingerprint of densities (in fmol/mg protein) of receptors for classical neurotransmitters "
         "obtained by means of quantitative in vitro autoradiography. The fingerprint provides average "
-        "density measurments for different receptors measured in tissue samples from different subjects "
+        "density measurements for different receptors measured in tissue samples from different subjects "
         "together with the corresponding standard deviations. "
     )
 
@@ -75,9 +76,9 @@ class ReceptorDensityFingerprint(
         # Likely ill-formed tsv's
         return [
             "{} ({})".format(
-                vocabularies.RECEPTOR_SYMBOLS[t]['neurotransmitter']['label'],
-                vocabularies.RECEPTOR_SYMBOLS[t]['neurotransmitter']['name'],
-            ) if t in vocabularies.RECEPTOR_SYMBOLS else
+                RECEPTOR_SYMBOLS[t]['neurotransmitter']['label'],
+                RECEPTOR_SYMBOLS[t]['neurotransmitter']['name'],
+            ) if t in RECEPTOR_SYMBOLS else
             f"{t} (undeciphered)"
             for t in self.receptors
         ]
@@ -107,7 +108,7 @@ class ReceptorDensityFingerprint(
             std = [data[_]["density (sd)"] for _ in labels]
         except KeyError as e:
             print(str(e))
-            commons.logger.error("Could not parse fingerprint from this dictionary")
+            logger.error("Could not parse fingerprint from this dictionary")
         return {
             'unit': next(iter(units)),
             'labels': labels,
@@ -124,9 +125,11 @@ class ReceptorDensityFingerprint(
         if backend == "matplotlib":
             try:
                 import matplotlib.pyplot as plt
-            except ImportError:
-                commons.logger.error("matplotlib not available. Plotting of fingerprints disabled.")
-                return None
+            except ImportError as e:
+                logger.error(
+                    "matplotlib not available. Please install matplotlib or use or another backend such as plotly."
+                )
+                raise e
             from collections import deque
 
             # default args

siibra/features/tabular/receptor_density_profile.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2024
+# Copyright 2018-2025
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");

siibra/features/tabular/regional_timeseries_activity.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2024
+# Copyright 2018-2025
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -19,7 +19,7 @@ from ..feature import Compoundable
 from ...core import region as _region
 from .. import anchor as _anchor
 from ...commons import QUIET, siibra_tqdm
-from ...locations import pointset
+from ...locations import pointcloud
 from ...retrieval.repositories import RepositoryConnector
 from ...retrieval.requests import HttpRequest
 
@@ -203,7 +203,7 @@ class RegionalTimeseriesActivity(tabular.Tabular, Compoundable):
                 found = [r for r in region if r.name in all_centroids]
             assert len(found) > 0
             result.append(
-                tuple(pointset.PointSet(
+                tuple(pointcloud.PointCloud(
                     [all_centroids[r.name] for r in found], space=space
                 ).centroid)
             )
@@ -239,7 +239,7 @@ class RegionalTimeseriesActivity(tabular.Tabular, Compoundable):
         backend="plotly", **kwargs
     ):
         """
-        Create a carpet plot ofthe timeseries data per region.
+        Create a carpet plot of the timeseries data per region.
 
         Parameters
         ----------

siibra/features/tabular/tabular.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2024
+# Copyright 2018-2025
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -19,7 +19,7 @@ from .. import feature
 
 from .. import anchor as _anchor
 
-from ... import commons
+from ...commons import logger
 
 import pandas as pd
 from textwrap import wrap
@@ -91,9 +91,11 @@ class Tabular(feature.Feature):
         if backend == "matplotlib":
             try:
                 import matplotlib.pyplot as plt
-            except ImportError:
-                commons.logger.error("matplotlib not available. Plotting of fingerprints disabled.")
-                return None
+            except ImportError as e:
+                logger.error(
+                    "matplotlib not available. Please install matplotlib or use or another backend such as plotly."
+                )
+                raise e
             # default kwargs
             if kwargs.get("error_y") is None:
                 kwargs["yerr"] = kwargs.get("yerr", 'std' if 'std' in self.data.columns else None)

siibra/livequeries/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2024
+# Copyright 2018-2025
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");

siibra/livequeries/allen.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2024
+# Copyright 2018-2025
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -20,11 +20,11 @@ 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
-from ..locations import point, pointset
+from ..locations import point, pointcloud
 from ..retrieval import HttpRequest
 from ..vocabularies import GENE_NAMES
 
-from typing import Iterable
+from typing import List
 from xml.etree import ElementTree
 import numpy as np
 import json
@@ -32,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):
     """
@@ -48,7 +66,7 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
     - Each sample was subject to multiple (in fact 4) different probes.
     - The probe data structures contain the list of gene expression of a
       particular gene measured in each sample. Therefore the length of the gene
-      expression list in a probe coresponds to the number of samples taken in
+      expression list in a probe corresponds to the number of samples taken in
       the corresponding donor for the given gene.
     """
 
@@ -96,7 +114,7 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
         Each sample is linked to a donor, brain structure, and
         ICBM coordinate.
         When querying with a brain structure, the ICBM coordinates
-        will be tested agains the region mask in ICBM space
+        will be tested against the region mask in ICBM space
         to produce a table of outputs.
         """
         LiveQuery.__init__(self, **kwargs)
@@ -117,7 +135,14 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
 
         self.genes = parse_gene(gene)
 
-    def query(self, concept: structure.BrainStructure) -> Iterable[GeneExpressions]:
+    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')
 
@@ -125,23 +150,21 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
         # Record matched instances and their locations.
         measurements = []
         coordinates = []
-        points_inside = dict()
         for measurement in self:
-            pt = point.Point(measurement['mni_xyz'], space=mnispace)
-            if pt not in points_inside:  # cache redundant intersection tests
-                points_inside[pt] = pt in concept
-            if points_inside[pt]:
+            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(points_inside) == 0:
-            raise StopIteration
+        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(
-            location=pointset.from_points(coordinates),
+            location=pointcloud.from_points(coordinates),
             species=self.species
         )
         explanation = f"MNI coordinates of tissue samples were filtered using {concept}"
@@ -153,7 +176,7 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
         )]
         anchor._last_matched_concept = concept
 
-        yield GeneExpressions(
+        return [GeneExpressions(
             anchor=anchor,
             genes=[m['gene'] for m in measurements],
             levels=[m['expression_level'] for m in measurements],
@@ -167,7 +190,7 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
                 "probe_id": [m['probe_id'] for m in measurements],
                 "donor_name": [m['donor_name'] for m in measurements],
             }
-        )
+        )]
 
     def __iter__(self):
 
@@ -261,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
@@ -278,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
@@ -297,7 +320,7 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
         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)
             )