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

siibra/locations/point.py

@@ -25,26 +25,25 @@ import numpy as np
 import json
 import numbers
 import hashlib
-from typing import Union
+from typing import Union, Tuple
 
 
 class Point(location.Location):
     """A single 3D point in reference space."""
 
     @staticmethod
-    def parse(spec, unit="mm"):
+    def parse(spec, unit="mm") -> Tuple[float, float, float]:
         """Converts a 3D coordinate specification into a 3D tuple of floats.
 
         Parameters
         ----------
-        spec : Any of str, tuple(float,float,float)
+        spec: Any of str, tuple(float,float,float)
             For string specifications, comma separation with decimal points are expected.
-        unit : str
+        unit: str
             specification of the unit (only 'mm' supported so far)
-
         Returns
         -------
-        tuple(float,float,float)
+        tuple(float, float, float)
         """
         if unit != "mm":
             raise NotImplementedError(
@@ -77,13 +76,16 @@ class Point(location.Location):
 
         Parameters
         ----------
-        coordinate : 3-tuple of int/float, or string specification
+        coordinatespec: 3-tuple of int/float, or string specification
             Coordinate in mm of the given space
-        space : reference space specification (id, object, or name)
-            The reference space
-        sigma_mm : float
-            Optional location uncertainy of the point
-            (will be interpreted as the isotropic standard deviation of location)
+        space: Space or str
+            The reference space (id, object, or name)
+        sigma_mm : float, optional
+            Location uncertainty of the point
+
+            Note
+            ----
+                Interpreted as the isotropic standard deviation of location.
         """
         location.Location.__init__(self, space)
         self.coordinate = Point.parse(coordinatespec)
@@ -247,12 +249,14 @@ class Point(location.Location):
 
         Parameters
         ----------
-        affine : numpy 4x4 ndarray
+        affine: numpy 4x4 ndarray
             affine matrix
-        space : reference space, (str, Space, or None))
-            Target reference space which is reached after
-            applying the transform. Note that the consistency
-            of this cannot be checked and is up to the user.
+        space: str, Space, or None
+            Target reference space which is reached after applying the transform
+
+            Note
+            ----
+            The consistency of this cannot be checked and is up to the user.
         """
         from ..core.space import Space
         spaceobj = Space.get_instance(space)

siibra/locations/pointset.py

@@ -74,8 +74,8 @@ class PointSet(location.Location):
                 sigma_mm=[p.sigma for p in inside],
             )
 
-    def intersects(self, mask: Nifti1Image):
-        return len(self.intersection(mask)) > 0
+    def intersects(self, other: Union[location.Location, Nifti1Image]):
+        return len(self.intersection(other)) > 0
 
     @property
     def sigma(self):

siibra/retrieval/__init__.py

@@ -21,6 +21,6 @@ from .repositories import (
     LocalFileRepository,
     ZipfileConnector
 )
-from .requests import HttpRequest, ZipfileRequest, EbrainsRequest, EbrainsKgQuery, SiibraHttpRequestError
+from .requests import HttpRequest, ZipfileRequest, EbrainsRequest, SiibraHttpRequestError
 from .cache import CACHE
 from .exceptions import NoSiibraConfigMirrorsAvailableException, TagNotFoundException

siibra/retrieval/cache.py

@@ -93,8 +93,14 @@ class Cache:
         if index > 0:
             logger.debug(f"Removing the {index+1} oldest files to keep cache size below {targetsize:.2f} GiB.")
             for fn, st in sfiles[:index + 1]:
-                size_gib -= st.st_size / 1024**3
-                os.remove(fn)
+                if os.path.isdir(fn):
+                    import shutil
+                    size = sum(os.path.getsize(f) for f in os.listdir(fn) if os.path.isfile(f))
+                    shutil.rmtree(fn)
+                else:
+                    size = st.st_size
+                    os.remove(fn)
+                size_gib -= size / 1024**3
 
     @property
     def size(self):

siibra/retrieval/datasets.py

@@ -14,10 +14,11 @@
 # limitations under the License.
 
 
-from .requests import EbrainsKgQuery, MultiSourcedRequest, GitlabProxy, GitlabProxyEnum
+from .requests import MultiSourcedRequest, GitlabProxy, GitlabProxyEnum
 
 import re
 from typing import Union, List
+from abc import ABC, abstractproperty
 
 try:
     from typing import TypedDict
@@ -44,15 +45,69 @@ EbrainsDatasetEmbargoStatus = TypedDict('EbrainsDatasetEmbargoStatus', {
     'identifier': List[str]
 })
 
+class EbrainsBaseDataset(ABC):
+    
+    @abstractproperty
+    def id(self) -> str:
+        raise NotImplementedError
+    
+    @abstractproperty
+    def name(self) -> str:
+        raise NotImplementedError
+    
+    @abstractproperty
+    def urls(self) -> List[EbrainsDatasetUrl]:
+        raise NotImplementedError
+
+    @abstractproperty
+    def description(self) -> str:
+        raise NotImplementedError
+
+    @abstractproperty
+    def contributors(self) -> List[EbrainsDatasetPerson]:
+        raise NotImplementedError
+
+    @abstractproperty
+    def ebrains_page(self) -> str:
+        raise NotImplementedError
+
+    @abstractproperty
+    def custodians(self) -> List[EbrainsDatasetPerson]:
+        raise NotImplementedError
+    
+    def __hash__(self):
+        return hash(self.id)
+    
+    def __eq__(self, o: object) -> bool:
+        return hasattr(o, "id") and self.id == o.id
+    
+    def match(self, spec: Union[str, 'EbrainsBaseDataset']) -> bool:
+        """
+        Checks if the given specification describes this dataset.
+
+        Parameters
+        ----------
+        spec (str, EbrainsBaseDataset)
+            specification to be matched.
+        Returns
+        -------
+        bool
+        """
+        if spec is self:
+            return True
+        if isinstance(spec, str):
+            return self.id == spec
+        raise RuntimeError(f"Cannot match {spec.__class__}, must be either str or EbrainsBaseDataset")
 
-class EbrainsDataset:
+class EbrainsDataset(EbrainsBaseDataset):
 
     def __init__(self, id, name=None, embargo_status: List[EbrainsDatasetEmbargoStatus] = None, *, cached_data=None):
+        super().__init__()
 
         self._id = id
+        self._name = name
         self._cached_data = cached_data
         self.embargo_status = embargo_status
-        self._name_cached = name
 
         if id is None:
             raise TypeError("Dataset id is required")
@@ -78,20 +133,15 @@ class EbrainsDataset:
                         GitlabProxyEnum.DATASET_V1,
                         instance_id=instance_id,
                     ),
-                    EbrainsKgQuery(
-                        query_id="interactiveViewerKgQuery-v1_0",
-                        instance_id=instance_id,
-                        params={"vocab": "https://schema.hbp.eu/myQuery/"},
-                    )
                 ]
             ).data
         return self._cached_data
 
     @property
     def name(self) -> str:
-        if self._name_cached is None:
-            self._name_cached = self.detail.get("name")
-        return self._name_cached
+        if self._name is None:
+            self._name = self.detail.get("name")
+        return self._name
 
     @property
     def urls(self) -> List[EbrainsDatasetUrl]:
@@ -118,26 +168,96 @@ class EbrainsDataset:
     def custodians(self) -> EbrainsDatasetPerson:
         return self.detail.get("custodians")
 
+class EbrainsV3DatasetVersion(EbrainsBaseDataset):
+
+    @staticmethod
+    def parse_person(d: dict) -> EbrainsDatasetPerson:
+        assert "https://openminds.ebrains.eu/core/Person" in d.get("type"), f"Cannot convert a non person to a person dict!"
+        _id = d.get('id')
+        name = f"{d.get('givenName')} {d.get('familyName')}"
+        return {
+            '@id': _id,
+            'schema.org/shortName': name,
+            'identifier': _id,
+            "shortName": name,
+            "name": name
+        }
+
+    def __init__(self, id, *, cached_data=None) -> None:
+        super().__init__()
+
+        self._id = id
+        self._cached_data = cached_data
+    
+    @property
+    def detail(self):
+        if not self._cached_data:
+            match = re.search(r"([a-f0-9-]+)$", self._id)
+            instance_id = match.group(1)
+            self._cached_data = MultiSourcedRequest(
+                requests=[
+                    GitlabProxy(
+                        GitlabProxyEnum.DATASETVERSION_V3,
+                        instance_id=instance_id,
+                    ),
+                ]
+            ).data
+        return self._cached_data
+    
+    @property
+    def id(self) -> str :
+        return self._id
+
+    @property
+    def name(self) -> str :
+        fullname = self.detail.get("fullName")
+        version_id = self.detail.get("versionIdentifier")
+        return f"{fullname} ({version_id})"
+        
     @property
-    def key(self):
-        return self.id
+    def urls(self) -> List[EbrainsDatasetUrl] :
+        return [{
+            "url": doi.get("identifier", None)
+        } for doi in self.detail.get("doi", []) ]
+    
+    @property
+    def description(self) -> str :
+        return self.detail.get("description", "")
 
-    def __hash__(self):
-        return hash(self.id)
+    @property
+    def contributors(self) -> List[EbrainsDatasetPerson] :
+        return [EbrainsV3DatasetVersion.parse_person(d) for d in self.detail.get("author", [])]
 
-    def __eq__(self, o: object) -> bool:
-        if type(o) is not EbrainsDataset and not issubclass(type(o), EbrainsDataset):
-            return False
-        return self.id == o.id
+    @property
+    def ebrains_page(self) -> str :
+        if len(self.urls) > 0:
+            return self.urls[0].get("url")
+        return None
+    
+    @property
+    def custodians(self) -> EbrainsDatasetPerson:
+        return [EbrainsV3DatasetVersion.parse_person(d) for d in self.detail.get("custodian", [])]
 
-    def match(self, spec: Union[str, 'EbrainsDataset']) -> bool:
-        """Checks of a given spec (of type str or EbrainsDataset) describes this dataset.
+class EbrainsV3Dataset(EbrainsBaseDataset):
+    # TODO finish implementing me
+    # some fields are currently missing, e.g. desc, contributors etc.
+    def __init__(self, id, *, cached_data=None) -> None:
+        super().__init__()
 
-        Args:
-            spec (str, EbrainsDataset): spec to be checked
-        """
-        if spec is self:
-            return True
-        if isinstance(spec, str):
-            return self.id == spec
-        raise RuntimeError(f"Cannot match {spec.__class__}, must be either str or EbrainsDataset")
+        self._id = id
+        self._cached_data = cached_data
+    
+    @property
+    def detail(self):
+        if not self._cached_data:
+            match = re.search(r"([a-f0-9-]+)$", self._id)
+            instance_id = match.group(1)
+            self._cached_data = MultiSourcedRequest(
+                requests=[
+                    GitlabProxy(
+                        GitlabProxyEnum.DATASET_V3,
+                        instance_id=instance_id,
+                    ),
+                ]
+            ).data
+        return self._cached_data

siibra/retrieval/repositories.py

@@ -16,11 +16,10 @@
 from .requests import DECODERS, HttpRequest, EbrainsRequest, SiibraHttpRequestError
 from .cache import CACHE
 
-from .. import logger
+from ..commons import logger, siibra_tqdm
 
 from abc import ABC, abstractmethod
 from urllib.parse import quote
-from tqdm import tqdm
 import os
 from zipfile import ZipFile
 from typing import List
@@ -84,9 +83,7 @@ class RepositoryConnector(ABC):
         if progress is None or all_cached:
             return result
         else:
-            return list(tqdm(
-                result, total=len(fnames), desc=progress, disable=logger.level > 20
-            ))
+            return list(siibra_tqdm(result, total=len(fnames), desc=progress))
 
     @classmethod
     def _from_url(cls, url: str):
@@ -101,6 +98,9 @@ class RepositoryConnector(ABC):
                 f"connector from url '{url}'."
             )
 
+    def __eq__(self, other):
+        return self.base_url == other.base_url
+
 
 class LocalFileRepository(RepositoryConnector):
 
@@ -159,6 +159,9 @@ class LocalFileRepository(RepositoryConnector):
     def __str__(self):
         return f"{self.__class__.__name__} at {self._folder}"
 
+    def __eq__(self, other):
+        return self._folder == other._folder
+
 
 class GitlabConnector(RepositoryConnector):
 
@@ -270,6 +273,12 @@ class GitlabConnector(RepositoryConnector):
         with open(f"{archive_directory}/{folder}/{filename}", "rb") as fp:
             return decoder(fp.read())
 
+    def __eq__(self, other):
+        return all([
+            self.base_url == other.base_url,
+            self.reftag == other.reftag
+        ])
+
 
 class ZipfileConnector(RepositoryConnector):
 
@@ -307,6 +316,9 @@ class ZipfileConnector(RepositoryConnector):
                 result.append(fname)
         return result
 
+    def __eq__(self, other):
+        return self.url == other.url
+
     class FileLoader:
         """
         Loads a file from the zip archive, but mimics the behaviour
@@ -610,9 +622,9 @@ class EbrainsPublicDatasetConnectorMinds(RepositoryConnector):
             EBRAINS dataset id of a public dataset in KG v3.
         title: str
             Part of dataset title as an alternative dataset specification (will ignore dataset_id then)
-        in_progress: bool (default:False)
+        in_progress: bool, default: False
             If true, will request datasets that are still under curation.
-            Will only work when autenticated with an appropriately privileged
+            Will only work when authenticated with an appropriately privileged
             user account.
         """
         stage = "IN_PROGRESS" if in_progress else "RELEASED"
@@ -625,7 +637,6 @@ class EbrainsPublicDatasetConnectorMinds(RepositoryConnector):
             logger.info(f"Using title '{title}' for EBRAINS dataset search, ignoring id '{dataset_id}'")
             url = f"{self.base_url}/{self.QUERY_ID}/instances?databaseScope={stage}&title={title}"
         req = EbrainsRequest(url, DECODERS[".json"])
-        print(req.cachefile)
         response = req.get()
         self._files = {}
         results = response.get('results', [])