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

siibra/retrieval/cache.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");
@@ -12,14 +12,21 @@
 # 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.
-"""Maintaining and hadnling caching files on disk."""
+"""Maintaining and handling caching files on disk."""
 
 import hashlib
 import os
 from appdirs import user_cache_dir
 import tempfile
+from functools import wraps
+from enum import Enum
+from typing import Callable, List, NamedTuple, Union
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from filelock import FileLock as Lock
 
-from ..commons import logger, SIIBRA_CACHEDIR, SKIP_CACHEINIT_MAINTENANCE
+from ..commons import logger, SIIBRA_CACHEDIR, SKIP_CACHEINIT_MAINTENANCE, siibra_tqdm
+from ..exceptions import WarmupRegException
 
 
 def assert_folder(folder):
@@ -94,7 +101,7 @@ class Cache:
             targetsize -= st.st_size / 1024**3
 
         if index > 0:
-            logger.debug(f"Removing the {index+1} oldest files to keep cache size below {targetsize:.2f} GiB.")
+            logger.debug(f"Removing the {index + 1} oldest files to keep cache size below {targetsize:.2f} GiB.")
             for fn, st in sfiles[:index + 1]:
                 if os.path.isdir(fn):
                     import shutil
@@ -114,15 +121,20 @@ class Cache:
         """ Iterate all element names in the cache directory. """
         return (os.path.join(self.folder, f) for f in os.listdir(self.folder))
 
-    def build_filename(self, str_rep: str, suffix=None):
-        """Generate a filename in the cache.
-
-        Args:
-            str_rep (str): Unique string representation of the item. Will be used to compute a hash.
-            suffix (str, optional): Optional file suffix, in order to allow filetype recognition by the name. Defaults to None.
-
-        Returns:
-            filename
+    def build_filename(self, str_rep: str, suffix=None) -> str:
+        """
+        Generate a filename in the cache.
+
+        Parameters
+        ----------
+        str_rep: str
+            Unique string representation of the item. Will be used to compute a hash.
+        suffix: str. Default: None
+            Optional file suffix, in order to allow filetype recognition by the name.
+
+        Returns
+        -------
+            str
         """
         hashfile = os.path.join(
             self.folder, str(hashlib.sha256(str_rep.encode("ascii")).hexdigest())
@@ -137,3 +149,85 @@ class Cache:
 
 
 CACHE = Cache.instance()
+
+
+class WarmupLevel(int, Enum):
+    TEST = -1000
+    INSTANCE = 1
+    DATA = 5
+
+
+class WarmupParam(NamedTuple):
+    level: Union[int, WarmupLevel]
+    fn: Callable
+    is_factory: bool = False
+
+
+class Warmup:
+
+    _warmup_fns: List[WarmupParam] = []
+
+    @staticmethod
+    def fn_eql(wrapped_fn, original_fn):
+        return wrapped_fn is original_fn or wrapped_fn.__wrapped__ is original_fn
+
+    @classmethod
+    def is_registered(cls, fn):
+        return len([warmup_fn.fn
+                    for warmup_fn in cls._warmup_fns
+                    if cls.fn_eql(warmup_fn.fn, fn)]) > 0
+
+    @classmethod
+    def register_warmup_fn(cls, warmup_level: WarmupLevel = WarmupLevel.INSTANCE, *, is_factory=False):
+        def outer(fn):
+            if cls.is_registered(fn):
+                raise WarmupRegException
+
+            @wraps(fn)
+            def inner(*args, **kwargs):
+                return fn(*args, **kwargs)
+
+            cls._warmup_fns.append(WarmupParam(warmup_level, inner, is_factory))
+            return inner
+        return outer
+
+    @classmethod
+    def deregister_warmup_fn(cls, original_fn):
+        cls._warmup_fns = [
+            warmup_fn for warmup_fn in cls._warmup_fns
+            if not cls.fn_eql(warmup_fn.fn, original_fn)
+        ]
+
+    @classmethod
+    def warmup(cls, warmup_level: WarmupLevel = WarmupLevel.INSTANCE, *, max_workers=4):
+        all_fns = [warmup for warmup in cls._warmup_fns if warmup.level <= warmup_level]
+
+        def call_fn(fn: WarmupParam):
+            return_val = fn.fn()
+            if not fn.is_factory:
+                return
+            for f in return_val:
+                f()
+
+        with Lock(CACHE.build_filename("lockfile", ".warmup")):
+            with ThreadPoolExecutor(max_workers=max_workers) as ex:
+                for _ in siibra_tqdm(
+                    ex.map(
+                        call_fn,
+                        all_fns
+                    ),
+                    desc="Warming cache",
+                    total=len(all_fns),
+                ):
+                    ...
+
+
+try:
+    from joblib import Memory
+    jobmemory_path = Path(CACHE.folder) / "joblib"
+    jobmemory_path.mkdir(parents=True, exist_ok=True)
+    jobmemory = Memory(jobmemory_path, verbose=0)
+    cache_user_fn = jobmemory.cache
+except ImportError:
+    from functools import lru_cache
+    cache_user_fn = lru_cache

siibra/retrieval/datasets.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");
@@ -102,6 +102,13 @@ class EbrainsBaseDataset(ABC):
             f"Cannot match {spec.__class__}, must be either str or EbrainsBaseDataset"
         )
 
+    @property
+    def LICENSE(self) -> str:
+        license_ = self._detail.get("license", [])
+        if len(license_) > 0:
+            return license_ if isinstance(license_, str) else '\n'.join(license_)
+        return None
+
 
 class EbrainsDataset(EbrainsBaseDataset):
     """Ebrains dataset v1 connection"""
@@ -173,10 +180,6 @@ class EbrainsDataset(EbrainsBaseDataset):
     def custodians(self) -> EbrainsDatasetPerson:
         return self._detail.get("custodians")
 
-    @property
-    def LICENSE(self) -> str:
-        return self._detail.get("license", "No license information is found.")
-
 
 class EbrainsV3DatasetVersion(EbrainsBaseDataset):
     @staticmethod
@@ -271,10 +274,6 @@ class EbrainsV3DatasetVersion(EbrainsBaseDataset):
     def version_identifier(self):
         return self._detail.get("versionIdentifier", "")
 
-    @property
-    def LICENSE(self) -> str:
-        return self._detail.get("license", "No license information is found.")
-
 
 class EbrainsV3Dataset(EbrainsBaseDataset):
     def __init__(self, id, *, cached_data=None) -> None:
@@ -342,10 +341,6 @@ class EbrainsV3Dataset(EbrainsBaseDataset):
     def version_ids(self) -> List['str']:
         return [version.get("id") for version in self._detail.get("versions", [])]
 
-    @property
-    def LICENSE(self) -> str:
-        return self._detail.get("license", "No license information is found.")
-
 
 class GenericDataset():
 
@@ -355,7 +350,7 @@ class GenericDataset():
         contributors: List[str] = None,
         url: str = None,
         description: str = None,
-        license: str = "No license information is found."
+        license: str = None
     ):
         self._name = name
         self._contributors = contributors

siibra/retrieval/exceptions/__init__.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");
@@ -14,6 +14,7 @@
 # limitations under the License.
 """Exceptions concerning file retrieval processes."""
 
+
 class NoSiibraConfigMirrorsAvailableException(Exception):
     pass
 

siibra/retrieval/repositories.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,7 +19,8 @@ from .requests import (
     EbrainsRequest,
     SiibraHttpRequestError,
     find_suitiable_decoder,
-    DECODERS
+    DECODERS,
+    FileLoader
 )
 from .cache import CACHE
 
@@ -31,7 +32,6 @@ import pathlib
 import os
 from zipfile import ZipFile
 from typing import List
-import requests
 
 
 class RepositoryConnector(ABC):
@@ -43,7 +43,23 @@ class RepositoryConnector(ABC):
         self.base_url = base_url
 
     @abstractmethod
-    def search_files(folder: str, suffix: str, recursive: bool = False) -> List[str]:
+    def search_files(self, folder: str, suffix: str, recursive: bool = False) -> List[str]:
+        """
+        Get the files within the repository.
+
+        Parameters
+        ----------
+        folder : str
+            folder or folders in the form 'path/to/file'
+        suffix : str
+        recursive : bool, default: False
+            If True, searches files in all subfolders
+
+        Returns
+        -------
+        List[str]
+            List of file names.
+        """
         pass
 
     @abstractmethod
@@ -109,34 +125,16 @@ class LocalFileRepository(RepositoryConnector):
         self._folder = pathlib.Path(folder)
         assert pathlib.Path.is_dir(self._folder)
 
-    def _build_url(self, folder: str, filename: str):
-        return pathlib.Path.joinpath(self._folder, folder, filename)
-
-    class FileLoader:
-        """
-        Just a loads a local file, but mimics the behaviour
-        of cached http requests used in other connectors.
-        """
-        def __init__(self, file_url, decode_func):
-            self.url = file_url
-            self.func = decode_func
-            self.cached = True
-
-        @property
-        def data(self):
-            with open(self.url, 'rb') as f:
-                return self.func(f.read())
+    def _build_url(self, folder: str, filename: str) -> str:
+        return pathlib.Path.joinpath(self._folder, folder, filename).as_posix()
 
     def get_loader(self, filename, folder="", decode_func=None):
         """Get a lazy loader for a file, for loading data
         only once loader.data is accessed."""
-        url = self._build_url(folder, filename)
-        if url is None:
-            raise RuntimeError(f"Cannot build url for ({folder}, {filename})")
-        if decode_func is None:
-            return self.FileLoader(url, lambda b: self._decode_response(b, filename))
-        else:
-            return self.FileLoader(url, decode_func)
+        filepath = self._build_url(folder, filename)
+        if not pathlib.Path(filepath).is_file():
+            raise RuntimeError(f"No file is found in {filepath}")
+        return FileLoader(filepath, decode_func)
 
     def search_files(self, folder="", suffix=None, recursive=False):
         results = []
@@ -150,10 +148,108 @@ class LocalFileRepository(RepositoryConnector):
     def __str__(self):
         return f"{self.__class__.__name__} at {self._folder}"
 
-    def __eq__(self, other):
+    def __eq__(self, other: "LocalFileRepository"):
         return self._folder == other._folder
 
 
+class GithubConnector(RepositoryConnector):
+
+    def __init__(
+        self,
+        owner: str,
+        repo: str,
+        reftag: str,
+        skip_branchtest=False,
+        archive_mode=False
+    ):
+        """
+        Connect to a GitHub repository with a specific ref (branch or tag).
+
+        Parameters
+        ----------
+        owner : str
+        repo : str
+        reftag : str
+            Tag or branch
+        skip_branchtest : bool, default: False
+            Whether to test if the reftag resides in the repository.
+        archive_mode : bool, default: False
+            Archive the repo (for reftag only) to siibra local cache.
+        Raises
+        ------
+        RuntimeError
+            If branch test could not find the reftag in the repo's list of tags
+            and branches.
+        """
+        RepositoryConnector.__init__(
+            self,
+            base_url=f"https://api.github.com/repos/{owner}/{repo}"
+        )
+        assert reftag, "Please supply a branch name or tag for `reftag` to create a `GithubConnector`."
+        if not skip_branchtest:
+            try:
+                tags = HttpRequest(f"{self.base_url}/tags", DECODERS[".json"], refresh=True).data
+                branches = HttpRequest(f"{self.base_url}/branches", DECODERS[".json"], refresh=True).data
+                matched_reftags = list(
+                    filter(lambda b: b["name"] == reftag, tags + branches)
+                )
+                if len(matched_reftags) == 1:
+                    self._want_commit_cached = matched_reftags[0]["commit"]
+                else:
+                    raise RuntimeError(f"Found {len(matched_reftags)} mathces to {reftag}")
+                self._tag_checked = True
+            except Exception:
+                logger.warning("Could not connect to GitHub repository.", exc_info=1)
+        self.reftag = reftag
+        self._raw_baseurl = f"https://raw.githubusercontent.com/{owner}/{repo}/{self.reftag}"
+        self.archive_mode = archive_mode
+        self._archive_conn: LocalFileRepository = None
+        self._recursed_tree = None
+
+    def search_files(self, folder="", suffix="", recursive=False) -> List[str]:
+        if self._recursed_tree is None:
+            self._recursed_tree = HttpRequest(
+                f"{self.base_url}/git/trees/{self.reftag}?recursive=1",
+                DECODERS[".json"]
+            ).data.get("tree", [])
+        folder_depth = len(folder.split('/')) if folder else 0
+        return [
+            f["path"] for f in self._recursed_tree
+            if f["type"] == "blob"
+            and f["path"].startswith(folder)
+            and f["path"].endswith(suffix)
+            and (recursive or len(f["path"].split('/')) == folder_depth + 1)
+        ]
+
+    def _build_url(self, folder: str, filename: str):
+        pathstr = pathlib.Path(folder, filename or "").as_posix()
+        return f'{self._raw_baseurl}/{quote(pathstr, safe="")}'
+
+    def get_loader(self, filename, folder="", decode_func=None):
+        if self.archive_mode:
+            self._archive()
+            return self._archive_conn.get_loader(filename, folder, decode_func)
+        else:
+            return super().get_loader(filename, folder, decode_func)
+
+    def _archive(self):
+        assert self.archive_mode, "To archive the repo, `archive_mode` must be True."
+        archive_directory = CACHE.build_filename(self.base_url + self.reftag)
+        if not os.path.isdir(archive_directory):
+            import tarfile
+
+            tarball_url = f"{self.base_url}/tarball/{self.reftag}"
+            req = HttpRequest(tarball_url, func=lambda b: b)
+            req.get()
+            with tarfile.open(name=req.cachefile, mode="r:gz") as tar:
+                tar.extractall(CACHE.folder)
+                foldername = tar.getnames()[0]
+            os.rename(os.path.join(CACHE.folder, foldername), archive_directory)
+        if self._archive_conn is None:
+            # create LocalFileRepository as an interface to the local files
+            self._archive_conn = LocalFileRepository(archive_directory)
+
+
 class GitlabConnector(RepositoryConnector):
 
     def __init__(self, server: str, project: int, reftag: str, skip_branchtest=False, *, archive_mode=False):
@@ -175,6 +271,7 @@ class GitlabConnector(RepositoryConnector):
         self._tag_checked = True if skip_branchtest else False
         self._want_commit_cached = None
         self.archive_mode = archive_mode
+        self._archive_conn: LocalFileRepository = None
 
     def __str__(self):
         return f"{self.__class__.__name__} {self.base_url} {self.reftag}"
@@ -206,7 +303,7 @@ class GitlabConnector(RepositoryConnector):
     def _build_url(self, folder="", filename=None, recursive=False, page=1):
         ref = self.reftag if self.want_commit is None else self.want_commit["short_id"]
         if filename is None:
-            pathstr = "" if len(folder) == 0 else f"&path={quote(folder,safe='')}"
+            pathstr = "" if len(folder) == 0 else f"&path={quote(folder, safe='')}"
             return f"{self.base_url}/tree?ref={ref}{pathstr}&per_page={self._per_page}&page={page}&recursive={recursive}"
         else:
             pathstr = filename if folder == "" else f"{folder}/{filename}"
@@ -233,33 +330,30 @@ class GitlabConnector(RepositoryConnector):
             if e["type"] == "blob" and e["name"].endswith(end)
         ]
 
-    def get(self, filename, folder="", decode_func=None):
-        if not self.archive_mode:
-            return super().get(filename, folder, decode_func)
+    def get_loader(self, filename, folder="", decode_func=None):
+        if self.archive_mode:
+            self._archive()
+            return self._archive_conn.get_loader(filename, folder, decode_func)
+        else:
+            return super().get_loader(filename, folder, decode_func)
 
+    def _archive(self):
+        assert self.archive_mode, "To archive the repo, `archive_mode` must be True."
         ref = self.reftag if self.want_commit is None else self.want_commit["short_id"]
-        archive_directory = CACHE.build_filename(self.base_url + ref) if self.archive_mode else None
-
+        archive_directory = CACHE.build_filename(self.base_url + ref)
         if not os.path.isdir(archive_directory):
-
-            url = self.base_url + f"/archive.tar.gz?sha={ref}"
-            resp = requests.get(url)
-            tar_filename = f"{archive_directory}.tar.gz"
-
-            resp.raise_for_status()
-            with open(tar_filename, "wb") as fp:
-                fp.write(resp.content)
-
             import tarfile
-            tar = tarfile.open(tar_filename, "r:gz")
-            tar.extractall(archive_directory)
-            for _dir in os.listdir(archive_directory):
-                for file in os.listdir(f"{archive_directory}/{_dir}"):
-                    os.rename(f"{archive_directory}/{_dir}/{file}", f"{archive_directory}/{file}")
-                os.rmdir(f"{archive_directory}/{_dir}")
 
-        with open(f"{archive_directory}/{folder}/{filename}", "rb") as fp:
-            return self._decode_response(fp.read(), filename)
+            tarball_url = self.base_url + f"/archive.tar.gz?sha={ref}"
+            req = HttpRequest(tarball_url, func=lambda b: b)
+            req.get()
+            with tarfile.open(name=req.cachefile, mode="r:gz") as tar:
+                tar.extractall(CACHE.folder)
+                foldername = tar.getnames()[0]
+            os.rename(os.path.join(CACHE.folder, foldername), archive_directory)
+        if self._archive_conn is None:
+            # create LocalFileRepository as an interface to the local files
+            self._archive_conn = LocalFileRepository(archive_directory)
 
     def __eq__(self, other):
         return all([
@@ -353,7 +447,7 @@ class OwncloudConnector(RepositoryConnector):
         )
 
     def _build_url(self, folder, filename):
-        fpath = "" if folder == "" else f"path={quote(folder,safe='')}&"
+        fpath = "" if folder == "" else f"path={quote(folder, safe='')}&"
         fpath += f"files={quote(filename)}"
         url = f"{self.base_url}/download?{fpath}"
         return url

siibra/retrieval/requests.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");
@@ -14,7 +14,7 @@
 # limitations under the License.
 """Request files with decoders, lazy loading, and caching."""
 
-from .cache import CACHE
+from .cache import CACHE, cache_user_fn
 from .exceptions import EbrainsAuthenticationError
 from ..commons import (
     logger,
@@ -30,30 +30,52 @@ import json
 from zipfile import ZipFile
 import requests
 import os
-from nibabel import Nifti1Image, GiftiImage, streamlines
+from nibabel import Nifti1Image, GiftiImage, streamlines, freesurfer
 from skimage import io as skimage_io
 import gzip
 from io import BytesIO
 import urllib.parse
 import pandas as pd
 import numpy as np
-from typing import List, Callable, Any, TYPE_CHECKING
+from typing import List, Callable, TYPE_CHECKING
 from enum import Enum
 from functools import wraps
 from time import sleep
 import sys
-import platform
-
-if platform.system() == "Linux":
-    from filelock import FileLock as Lock
-else:
-    from filelock import SoftFileLock as Lock
-
+from filelock import FileLock as Lock
 if TYPE_CHECKING:
     from .repositories import GitlabConnector
 
 USER_AGENT_HEADER = {"User-Agent": f"siibra-python/{__version__}"}
 
+
+def read_as_bytesio(function: Callable, suffix: str, bytesio: BytesIO):
+    """
+    Helper method to provide BytesIO to methods that only takes file path and
+    cannot handle BytesIO normally (e.g., `nibabel.freesurfer.read_annot()`).
+
+    Writes the bytes to a temporary file on cache and reads with the
+    original function.
+
+    Parameters
+    ----------
+    function : Callable
+    suffix : str
+        Must match the suffix expected by the function provided.
+    bytesio : BytesIO
+
+    Returns
+    -------
+    Return type of the provided function.
+    """
+    tempfile = CACHE.build_filename(f"temp_{suffix}") + suffix
+    with open(tempfile, "wb") as bf:
+        bf.write(bytesio.getbuffer())
+    result = function(tempfile)
+    os.remove(tempfile)
+    return result
+
+
 DECODERS = {
     ".nii": lambda b: Nifti1Image.from_bytes(b),
     ".gii": lambda b: GiftiImage.from_bytes(b),
@@ -65,13 +87,14 @@ DECODERS = {
     ".zip": lambda b: ZipFile(BytesIO(b)),
     ".png": lambda b: skimage_io.imread(BytesIO(b)),
     ".npy": lambda b: np.load(BytesIO(b)),
+    ".annot": lambda b: read_as_bytesio(freesurfer.read_annot, '.annot', BytesIO(b)),
 }
 
 
 def find_suitiable_decoder(url: str) -> Callable:
     """
     By supplying a url or a filename, obtain a suitable decoder function
-    for siibra to digest based on predifined DECODERS. An extra layer of 
+    for siibra to digest based on predifined DECODERS. An extra layer of
     gzip decompresser automatically added for gzipped files.
 
     Parameters
@@ -94,8 +117,7 @@ def find_suitiable_decoder(url: str) -> Callable:
     suitable_decoders = [
         dec for sfx, dec in DECODERS.items() if urlpath.endswith(sfx)
     ]
-    if len(suitable_decoders) > 0:
-        assert len(suitable_decoders) == 1
+    if len(suitable_decoders) == 1:
         return suitable_decoders[0]
     else:
         return None
@@ -247,6 +269,24 @@ class HttpRequest:
         return self.get()
 
 
+class FileLoader(HttpRequest):
+    """
+    Just a loads a local file, but mimics the behaviour
+    of cached http requests used in other connectors.
+    """
+    def __init__(self, filepath, func=None):
+        HttpRequest.__init__(
+            self, filepath, refresh=False,
+            func=func or find_suitiable_decoder(filepath)
+        )
+        self.cachefile = filepath
+
+    def _retrieve(self, **kwargs):
+        if kwargs:
+            logger.info(f"Keywords {list(kwargs.keys())} are supplied but won't be used.")
+        assert os.path.isfile(self.cachefile)
+
+
 class ZipfileRequest(HttpRequest):
     def __init__(self, url, filename, func=None, refresh=False):
         HttpRequest.__init__(
@@ -539,10 +579,11 @@ class GitlabProxyEnum(Enum):
         if SIIBRA_USE_LOCAL_SNAPSPOT:
             logger.info(f"Using localsnapshot at {SIIBRA_USE_LOCAL_SNAPSPOT}")
             return [LocalFileRepository(SIIBRA_USE_LOCAL_SNAPSPOT)]
-        return [
-            GitlabConnector(server[0], server[1], "master", archive_mode=True)
-            for server in servers
-        ]
+        else:
+            return [
+                GitlabConnector(server[0], server[1], "master", archive_mode=True)
+                for server in servers
+            ]
 
     @try_all_connectors()
     def search_files(
@@ -574,27 +615,21 @@ class GitlabProxy(HttpRequest):
         self,
         flavour: GitlabProxyEnum,
         instance_id=None,
-        postprocess: Callable[["GitlabProxy", Any], Any] = (
-            lambda proxy, obj: obj
-            if hasattr(proxy, "instance_id") and proxy.instance_id
-            else {"results": obj}
-        ),
     ):
         if flavour not in GitlabProxyEnum:
             raise RuntimeError("Can only proxy enum members")
 
         self.flavour = flavour
         self.folder = self.folder_dict[flavour]
-        self.postprocess = postprocess
         self.instance_id = instance_id
-        self._cached_files = None
+        self.get = cache_user_fn(self.get)
 
     def get(self):
         if self.instance_id:
-            return self.postprocess(
-                self, self.flavour.get(f"{self.folder}/{self.instance_id}.json")
-            )
-        return self.postprocess(self, self.flavour.get(f"{self.folder}/_all.json"))
+            return self.flavour.get(f"{self.folder}/{self.instance_id}.json")
+        return {
+            "results": self.flavour.get(f"{self.folder}/_all.json")
+        }
 
 
 class MultiSourceRequestException(Exception):