seroverse 0.0.1__py3-none-any.whl

seroverse/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.0.1'
+__version_tuple__ = version_tuple = (0, 0, 1)
+
+__commit_id__ = commit_id = None

seroverse/client/base.py

@@ -0,0 +1,287 @@
+"""Unified asynchronous HTTP client and msgspec serialization helpers for SeroVerse."""
+
+import asyncio
+import hashlib
+import os
+import time
+from collections.abc import AsyncIterator, Coroutine
+from concurrent.futures import ThreadPoolExecutor
+from io import BytesIO
+from pathlib import Path
+from types import TracebackType
+from typing import Any, Self
+
+import aiohttp
+import msgspec
+
+from seroverse.progress import current_progress
+
+
+class Client:
+    """High-performance asynchronous HTTP client powered by `aiohttp` and `msgspec`.
+
+    Args:
+        base_url: Base endpoint URL.
+        api_key_header: Optional HTTP header key for API authorization.
+        api_key: Optional API key string.
+        user_agent: User-Agent header value.
+        timeout: Total request timeout in seconds.
+        max_concurrency: Maximum concurrent in-flight requests per event loop.
+        polite_delay: Optional minimum delay (in seconds) after live network requests.
+        recorder: Optional `cassetter` recorder instance.
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        api_key_header: str | None = None,
+        api_key: str | None = None,
+        user_agent: str = "seroverse-client/0.1",
+        timeout: float = 30.0,
+        *,
+        max_concurrency: int = 5,
+        polite_delay: float = 0.0,
+        recorder: Any | None = None,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.api_key_header = api_key_header
+        self._api_key: str | None = api_key
+        self.user_agent = user_agent
+        self.timeout = aiohttp.ClientTimeout(total=timeout)
+        self.max_concurrency = max(1, int(max_concurrency))
+        self.polite_delay = float(polite_delay)
+        self.recorder = recorder
+        self._session: aiohttp.ClientSession | None = None
+        self._sem: asyncio.Semaphore | None = None
+        self._sem_loop: asyncio.AbstractEventLoop | None = None
+
+    @property
+    def api_key(self) -> str | None:
+        """Return the configured API key string, or `None`."""
+        return self._api_key
+
+    @staticmethod
+    def encode_msgpack(obj: Any) -> bytes:
+        """Serialize an object or dataclass tree into compact MessagePack bytes."""
+        return msgspec.msgpack.encode(obj)
+
+    @staticmethod
+    def decode_msgpack[T](data: bytes, type_: type[T]) -> T:
+        """Deserialize MessagePack bytes directly into a typed `@dataclass(frozen=True, slots=True)` structure."""
+        return msgspec.msgpack.decode(data, type=type_)
+
+    @staticmethod
+    def save_msgpack(path: Path, obj: Any) -> None:
+        """Atomically persist `obj` to `path` as binary MessagePack."""
+        path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = path.with_name(f"{path.name}.{os.getpid()}.tmp")
+        tmp.write_bytes(msgspec.msgpack.encode(obj))
+        os.replace(tmp, path)
+
+    @staticmethod
+    def load_msgpack[T](path: Path, type_: type[T]) -> T:
+        """Load and decode a binary MessagePack file into `type_`."""
+        return msgspec.msgpack.decode(path.read_bytes(), type=type_)
+
+    def __repr__(self) -> str:
+        key_repr = "'**********'" if self._api_key else "None"
+        return f"{self.__class__.__name__}(base_url='{self.base_url}', api_key={key_repr})"
+
+    def __cache_fingerprint__(self) -> tuple[str, str, str]:
+        """Returns a deterministic, credential-safe fingerprint tuple for content-addressable caches."""
+        key_digest = hashlib.sha256((self._api_key or "").encode("utf-8")).hexdigest()[:16] if self._api_key else ""
+        return (type(self).__qualname__, self.base_url, key_digest)
+
+    def _headers(self) -> dict[str, str]:
+        headers = {"User-Agent": self.user_agent, "Accept": "application/json"}
+        if self.api_key_header and self._api_key:
+            headers[self.api_key_header] = self._api_key
+        return headers
+
+    def _get_semaphore(self) -> asyncio.Semaphore:
+        loop = asyncio.get_running_loop()
+        if self._sem is None or self._sem_loop is not loop:
+            self._sem = asyncio.Semaphore(self.max_concurrency)
+            self._sem_loop = loop
+        return self._sem
+
+    async def polite_sleep(self, t_req: float, delay: float | None = None) -> None:
+        """Sleep politely after a live network request, skipping sleep on fast cassette replays."""
+        wait_s = self.polite_delay if delay is None else delay
+        if wait_s <= 0.0:
+            return
+        elapsed = time.perf_counter() - t_req
+        if not (self.recorder is not None and elapsed < 0.25) and elapsed > 0.02:
+            await asyncio.sleep(wait_s)
+
+    async def get_session(self) -> aiohttp.ClientSession:
+        """Retrieve or instantiate the underlying `aiohttp.ClientSession` for the active event loop."""
+        current_loop = asyncio.get_running_loop()
+        if (
+            self._session is None
+            or self._session.closed
+            or getattr(self._session, "_loop", None) is not current_loop
+            or getattr(self._session, "_loop", current_loop).is_closed()
+        ):
+            self._session = aiohttp.ClientSession(
+                headers=self._headers(),
+                timeout=self.timeout,
+            )
+        return self._session
+
+    async def __aenter__(self) -> Self:
+        await self.get_session()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        await self.close()
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        self.close_sync()
+
+    async def close(self) -> None:
+        """Close the underlying `aiohttp.ClientSession` if open."""
+        if self._session is not None:
+            if not self._session.closed:
+                loop = getattr(self._session, "_loop", None)
+                if loop is None or not loop.is_closed():
+                    await self._session.close()
+            self._session = None
+
+    def close_sync(self) -> None:
+        """Close the underlying `aiohttp.ClientSession` synchronously."""
+        if self._session is not None and not self._session.closed:
+            loop = getattr(self._session, "_loop", None)
+            if loop is not None and not loop.is_closed():
+                self.run_sync(self.close())
+            else:
+                self._session = None
+
+    def _url(self, endpoint: str) -> str:
+        if endpoint.startswith(("http://", "https://")):
+            return endpoint
+        return f"{self.base_url}/{endpoint.lstrip('/')}" if endpoint else self.base_url
+
+    async def request(self, method: str, endpoint: str, **kwargs: Any) -> Any:
+        """Send an async HTTP request and return decoded JSON (via `msgspec`) or text."""
+        session = await self.get_session()
+        url = self._url(endpoint)
+        async with self._get_semaphore():
+            t_req = time.perf_counter()
+            try:
+                async with session.request(method, url, **kwargs) as resp:
+                    raw = await resp.read()
+                    if resp.status >= 400:
+                        body = raw.decode("utf-8", errors="replace").strip()
+                        reason = resp.reason or "HTTP Error"
+                        detail = f"{reason}: {body[:300]}" if body else reason
+                        raise aiohttp.ClientResponseError(
+                            resp.request_info,
+                            resp.history,
+                            status=resp.status,
+                            message=detail,
+                            headers=resp.headers,
+                        )
+                    ctype = (resp.content_type or "").lower()
+                    if "json" in ctype:
+                        return msgspec.json.decode(raw)
+                    return raw.decode("utf-8", errors="replace")
+            finally:
+                await self.polite_sleep(t_req)
+
+    async def get(self, endpoint: str, **kwargs: Any) -> Any:
+        """Perform an async HTTP GET request."""
+        return await self.request("GET", endpoint, **kwargs)
+
+    async def post(self, endpoint: str, **kwargs: Any) -> Any:
+        """Perform an async HTTP POST request."""
+        return await self.request("POST", endpoint, **kwargs)
+
+    async def delete(self, endpoint: str, **kwargs: Any) -> Any:
+        """Perform an async HTTP DELETE request."""
+        return await self.request("DELETE", endpoint, **kwargs)
+
+    async def stream_bytes(self, method: str, endpoint: str, **kwargs: Any) -> bytes:
+        """Send an async HTTP request and read raw response bytes."""
+        session = await self.get_session()
+        url = self._url(endpoint)
+        async with self._get_semaphore():
+            t_req = time.perf_counter()
+            try:
+                async with session.request(method, url, **kwargs) as resp:
+                    resp.raise_for_status()
+                    return await resp.read()
+            finally:
+                await self.polite_sleep(t_req)
+
+    async def get_json[T](self, endpoint: str, *, type_: type[T], **kwargs: Any) -> T:
+        """Fetch `endpoint` via GET and decode JSON directly into `type_` using `msgspec`."""
+        raw = await self.stream_bytes("GET", endpoint, **kwargs)
+        return msgspec.json.decode(raw, type=type_)
+
+    async def post_json[T](self, endpoint: str, *, type_: type[T], **kwargs: Any) -> T:
+        """Fetch `endpoint` via POST and decode JSON directly into `type_` using `msgspec`."""
+        raw = await self.stream_bytes("POST", endpoint, **kwargs)
+        return msgspec.json.decode(raw, type=type_)
+
+    async def stream_buffer(self, method: str, endpoint: str, **kwargs: Any) -> BytesIO:
+        """Send an async HTTP request and return an in-memory `BytesIO` stream."""
+        b = await self.stream_bytes(method, endpoint, **kwargs)
+        return BytesIO(b)
+
+    async def stream_chunks(
+        self,
+        method: str,
+        endpoint: str,
+        chunk_size: int = 65536,
+        **kwargs: Any,
+    ) -> AsyncIterator[bytes]:
+        """Stream response bytes in chunks as an async generator, emitting progress when `Content-Length` is known."""
+        session = await self.get_session()
+        url = self._url(endpoint)
+        prog = current_progress()
+        async with session.request(method, url, **kwargs) as resp:
+            resp.raise_for_status()
+            total_bytes = resp.content_length if resp.content_length and resp.content_length > 0 else None
+            received = 0
+            async for chunk in resp.content.iter_chunked(chunk_size):
+                received += len(chunk)
+                if total_bytes is not None and prog.is_active:
+                    prog.report(
+                        min(1.0, received / total_bytes),
+                        detail=f"Streaming {endpoint} ({received:,} / {total_bytes:,} B)",
+                    )
+                yield chunk
+
+    def run_sync[T](self, coro: Coroutine[Any, Any, T]) -> T:
+        """Execute a coroutine synchronously and close any session bound to the temporary event loop."""
+
+        async def _runner() -> T:
+            try:
+                return await coro
+            finally:
+                await self.close()
+
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = None
+
+        if loop and loop.is_running():
+            with ThreadPoolExecutor(max_workers=1) as pool:
+                future = pool.submit(lambda: asyncio.run(_runner()))
+                return future.result()
+        return asyncio.run(_runner())

seroverse/client/dsmz.py

@@ -0,0 +1,234 @@
+"""DSMZ StrainInfo v2 and BacDive v2 REST API clients and culture-collection models."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import urllib.parse
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import Any
+
+import msgspec
+
+from seroverse.client.base import Client
+from seroverse.progress import current_progress
+
+STRAININFO_V2_URL = "https://api.straininfo.dsmz.de/v2"
+BACDIVE_V2_URL = "https://api.bacdive.dsmz.de/v2"
+
+
+@dataclass(frozen=True, slots=True)
+class StrainLiterature:
+    """Immutable bibliographic entry linked to a StrainInfo culture deposit."""
+
+    id: int = 0
+    pubmed: int = 0
+    doi: str = ""
+    title: str = ""
+    year: int = 0
+
+
+@dataclass(frozen=True, slots=True)
+class StrainPassport:
+    """Consolidated DSMZ StrainInfo v2 passport with culture-collection synonyms, PMIDs, and INSDC accessions."""
+
+    si_id: int
+    taxon_name: str = ""
+    ncbi_taxid: int = 0
+    bacdive_id: int = 0
+    type_strain: bool = False
+    designations: tuple[str, ...] = ()
+    pmids: tuple[int, ...] = ()
+    dois: tuple[str, ...] = ()
+    sequence_accessions: tuple[str, ...] = ()
+    genome_accessions: tuple[str, ...] = ()
+
+    @classmethod
+    def from_raw_dict(cls, raw: dict[str, Any]) -> StrainPassport | None:
+        """Parse a raw StrainInfo `/v2/data/strain/max/` JSON object into a `StrainPassport`."""
+        si_obj = raw.get("strain") if isinstance(raw.get("strain"), dict) else raw
+        if not isinstance(si_obj, dict):
+            return None
+        raw_id = si_obj.get("siID") if si_obj.get("siID") is not None else si_obj.get("id")
+        si_id = int(raw_id or 0) if str(raw_id or "").isdigit() else 0
+        if si_id <= 0:
+            return None
+
+        taxon = si_obj.get("taxon") or {}
+        taxon_name = str(taxon.get("name") or "").strip() if isinstance(taxon, dict) else ""
+        ncbi_taxid = (
+            int(taxon.get("ncbi") or 0) if isinstance(taxon, dict) and str(taxon.get("ncbi") or "").isdigit() else 0
+        )
+        raw_bd = si_obj.get("bdID") if si_obj.get("bdID") is not None else si_obj.get("bacdive")
+        bacdive_id = int(raw_bd or 0) if str(raw_bd or "").isdigit() else 0
+        type_strain = bool(si_obj.get("typeStrain") if "typeStrain" in si_obj else si_obj.get("type_strain"))
+
+        des_list: list[str] = []
+        rel = si_obj.get("relation") or {}
+        if isinstance(rel, dict):
+            for c_item in (rel.get("deposit") or ()) or (rel.get("culture") or ()):
+                if isinstance(c_item, dict):
+                    sn = str(c_item.get("designation") or c_item.get("strain_number") or "").strip()
+                    if sn and sn not in des_list:
+                        des_list.append(sn)
+            for d_item in rel.get("designation") or ():
+                sn_d = str(d_item.get("designation") if isinstance(d_item, dict) else d_item or "").strip()
+                if sn_d and sn_d not in des_list:
+                    des_list.append(sn_d)
+        for dep_item in raw.get("deposits") or ():
+            if isinstance(dep_item, dict) and (sn_dep := str(dep_item.get("designation") or "").strip()):
+                if sn_dep not in des_list:
+                    des_list.append(sn_dep)
+
+        pmids: list[int] = []
+        dois: list[str] = []
+        for lit in si_obj.get("literature") or ():
+            if isinstance(lit, dict):
+                pm_raw = str(lit.get("pubmed") or "").strip()
+                if pm_raw.isdigit() and (pm_int := int(pm_raw)) > 0 and pm_int not in pmids:
+                    pmids.append(pm_int)
+                doi_raw = str(lit.get("doi") or "").strip()
+                if doi_raw and doi_raw not in dois:
+                    dois.append(doi_raw)
+
+        seq_accs: list[str] = []
+        gen_accs: list[str] = []
+        for seq in (si_obj.get("sequence") or ()) or (si_obj.get("sequences") or ()):
+            if isinstance(seq, dict) and (acc := str(seq.get("accessionNumber") or seq.get("accession") or "").strip()):
+                s_type = str(seq.get("type") or "").lower()
+                if "genome" in s_type or acc.startswith(("GCA_", "GCF_")):
+                    if acc not in gen_accs:
+                        gen_accs.append(acc)
+                elif s_type != "rrnaop" and acc not in seq_accs:
+                    seq_accs.append(acc)
+
+        return cls(
+            si_id=si_id,
+            taxon_name=taxon_name,
+            ncbi_taxid=ncbi_taxid,
+            bacdive_id=bacdive_id,
+            type_strain=type_strain,
+            designations=tuple(des_list),
+            pmids=tuple(pmids),
+            dois=tuple(dois),
+            sequence_accessions=tuple(seq_accs),
+            genome_accessions=tuple(gen_accs),
+        )
+
+
+class StrainInfoClient(Client):
+    """Asynchronous client for the public DSMZ StrainInfo v2 REST API."""
+
+    def __init__(
+        self,
+        *,
+        timeout: float = 30.0,
+        max_concurrency: int = 5,
+        polite_delay: float = 0.05,
+        recorder: Any | None = None,
+    ) -> None:
+        super().__init__(
+            base_url=STRAININFO_V2_URL,
+            user_agent="seroverse-straininfo-client/0.1",
+            timeout=timeout,
+            max_concurrency=max_concurrency,
+            polite_delay=polite_delay,
+            recorder=recorder,
+        )
+
+    async def _search_ids(self, path: str) -> list[int]:
+        try:
+            raw_ids = await self.get_json(path, type_=list[int])
+            return [int(x) for x in raw_ids if int(x) > 0]
+        except Exception:
+            return []
+
+    async def search_by_taxon(self, taxon_name: str) -> list[int]:
+        """Return all StrainInfo IDs (`SI-ID`s) for a species or genus name."""
+        return await self._search_ids(f"search/strain/tax_name/{urllib.parse.quote(taxon_name.strip())}")
+
+    async def search_by_cc_no(self, cc_no: str) -> list[int]:
+        """Return matching `SI-ID`s for a culture collection number (e.g. `ATCC 25238`, `NCTC 9001`)."""
+        return await self._search_ids(f"search/strain/cc_no/{urllib.parse.quote(cc_no.strip())}")
+
+    async def search_by_designation(self, designation: str) -> list[int]:
+        """Return matching `SI-ID`s for an arbitrary strain designation (e.g. `Prague 1550/57`)."""
+        return await self._search_ids(f"search/strain/des/{urllib.parse.quote(designation.strip())}")
+
+    async def search_by_collection(self, collection_code: str) -> list[int]:
+        """Return all `SI-ID`s deposited in a culture collection (e.g. `CNCTC`, `NCTC`, `ATCC`)."""
+        return await self._search_ids(f"search/strain/cc/{urllib.parse.quote(collection_code.strip())}")
+
+    async def fetch_passports(self, si_ids: Sequence[int], batch_size: int = 50) -> list[StrainPassport]:
+        """Batch-fetch `StrainPassport` records for `si_ids` via `/v2/data/strain/max/{ids}`."""
+        unique_ids = list(dict.fromkeys(int(x) for x in si_ids if int(x) > 0))
+        if not unique_ids:
+            return []
+        passports: list[StrainPassport] = []
+        chunks = [unique_ids[i : i + batch_size] for i in range(0, len(unique_ids), batch_size)]
+        prog = current_progress()
+        completed = 0
+        total = len(chunks)
+
+        async def _fetch_chunk(chunk: Sequence[int]) -> list[StrainPassport]:
+            nonlocal completed
+            joined = ",".join(str(x) for x in chunk)
+            try:
+                raw = await self.stream_bytes("GET", f"data/strain/max/{joined}")
+                items = msgspec.json.decode(raw)
+                if isinstance(items, list):
+                    return [
+                        p
+                        for item in items
+                        if isinstance(item, dict) and (p := StrainPassport.from_raw_dict(item)) is not None
+                    ]
+            except Exception:
+                pass
+            finally:
+                completed += 1
+                if prog.is_active:
+                    prog.report(completed / total, detail=f"StrainInfo passports: batch {completed}/{total}")
+            return []
+
+        for res in await asyncio.gather(*[_fetch_chunk(c) for c in chunks]):
+            passports.extend(res)
+        return passports
+
+    async def fetch_taxon_passports(self, taxon_name: str, batch_size: int = 50) -> list[StrainPassport]:
+        """Search all strains for `taxon_name` and batch-fetch their complete `StrainPassport` records."""
+        si_ids = await self.search_by_taxon(taxon_name)
+        return await self.fetch_passports(si_ids, batch_size=batch_size)
+
+
+class BacDiveClient(Client):
+    """Asynchronous client for the DSMZ BacDive v2 REST API."""
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        *,
+        timeout: float = 30.0,
+        max_concurrency: int = 4,
+        polite_delay: float = 0.05,
+        recorder: Any | None = None,
+    ) -> None:
+        token = api_key if api_key is not None else os.environ.get("BACDIVE_API_KEY", "")
+        super().__init__(
+            base_url=BACDIVE_V2_URL,
+            api_key_header="Authorization" if token else None,
+            api_key=f"Bearer {token}" if token and not token.startswith("Bearer ") else (token or None),
+            user_agent="seroverse-bacdive-client/0.1",
+            timeout=timeout,
+            max_concurrency=max_concurrency,
+            polite_delay=polite_delay,
+            recorder=recorder,
+        )
+
+    async def fetch_strain(self, bacdive_id: int) -> dict[str, Any]:
+        """Fetch a BacDive strain record by its integer `bacdive_id`."""
+        try:
+            res = await self.get(f"fetch/{int(bacdive_id)}")
+            return res if isinstance(res, dict) else {}
+        except Exception:
+            return {}

seroverse/client/ena.py

@@ -0,0 +1,93 @@
+"""Asynchronous client for the EMBL-EBI ENA Portal REST API."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import Any
+
+from seroverse.client.base import Client
+
+ENA_PORTAL_URL = "https://www.ebi.ac.uk/ena/portal/api"
+
+
+@dataclass(frozen=True, slots=True)
+class ENASampleRecord:
+    """Immutable ENA Portal `sample` record decoded via `msgspec`."""
+
+    sample_accession: str = ""
+    scientific_name: str = ""
+    strain: str = ""
+    serotype: str = ""
+    serovar: str = ""
+    tax_id: str = ""
+
+
+@dataclass(frozen=True, slots=True)
+class ENAAssemblyRecord:
+    """Immutable ENA Portal `assembly` record decoded via `msgspec`."""
+
+    accession: str = ""
+    sample_accession: str = ""
+    scientific_name: str = ""
+    strain: str = ""
+    tax_id: str = ""
+
+
+class ENAClient(Client):
+    """Asynchronous client for the EMBL-EBI ENA Portal API."""
+
+    def __init__(
+        self,
+        *,
+        timeout: float = 40.0,
+        max_concurrency: int = 4,
+        polite_delay: float = 0.05,
+        recorder: Any | None = None,
+    ) -> None:
+        super().__init__(
+            base_url=ENA_PORTAL_URL,
+            user_agent="seroverse-ena-client/0.1",
+            timeout=timeout,
+            max_concurrency=max_concurrency,
+            polite_delay=polite_delay,
+            recorder=recorder,
+        )
+
+    async def search_samples(
+        self,
+        query: str,
+        fields: Sequence[str] = ("sample_accession", "scientific_name", "strain", "serotype", "serovar", "tax_id"),
+        limit: int = 0,
+    ) -> list[ENASampleRecord]:
+        """Query `search?result=sample` and decode directly into `list[ENASampleRecord]`."""
+        params = {
+            "result": "sample",
+            "query": query,
+            "fields": ",".join(fields),
+            "limit": str(limit),
+            "format": "json",
+        }
+        try:
+            return await self.get_json("search", type_=list[ENASampleRecord], params=params)
+        except Exception:
+            return []
+
+    async def search_assemblies(
+        self,
+        query: str,
+        fields: Sequence[str] = ("accession", "sample_accession", "scientific_name", "strain", "tax_id"),
+        limit: int = 0,
+    ) -> list[ENAAssemblyRecord]:
+        """Query `search?result=assembly` and decode directly into `list[ENAAssemblyRecord]`."""
+        params = {
+            "result": "assembly",
+            "query": query,
+            "fields": ",".join(fields),
+            "limit": str(limit),
+            "format": "json",
+        }
+        try:
+            return await self.get_json("search", type_=list[ENAAssemblyRecord], params=params)
+        except Exception:
+            return []