tickerinside 0.1.0__tar.gz

tickerinside-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TickerInside
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tickerinside-0.1.0/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: tickerinside
+Version: 0.1.0
+Summary: Python client for the free TickerInside API: the full holdings of US ETFs, which funds hold a stock, fund overlap and portfolio look-through.
+Project-URL: Homepage, https://tickerinside.com
+Project-URL: Documentation, https://tickerinside.com/api/
+Author-email: TickerInside <contact@tickerinside.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: api,etf,etf holdings,etf overlap,finance,look-through,n-port,portfolio,sec
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Provides-Extra: pandas
+Requires-Dist: pandas>=1.3; extra == 'pandas'
+Description-Content-Type: text/markdown
+
+# tickerinside
+
+A Python client for the free TickerInside API, which serves the full holdings of US ETFs, the funds that hold each stock, and the overlap and look-through computed from them.
+
+## Install
+
+```
+pip install tickerinside
+```
+
+The package uses only the Python standard library and runs on Python 3.9 or later. There is no API key and no account to create. pandas is optional: install it (or `pip install "tickerinside[pandas]"`) and every result also offers a `.df` DataFrame.
+
+## Examples
+
+```python
+import tickerinside as ti
+```
+
+The holdings of VOO as a DataFrame, heaviest first:
+
+```python
+voo = ti.holdings("VOO", names=True)
+voo.holdings_as_of        # '2026-08-31', the date of the issuer's file
+voo.df.head(3)
+#   ticker        name  weight_pct
+# 0   NVDA      Nvidia      8.0927
+# 1   AAPL  Apple Inc.      7.0432
+# 2   MSFT   Microsoft      5.7033
+```
+
+Which ETFs hold NVDA, and at what weight:
+
+```python
+nvda = ti.holders("NVDA")
+nvda.data["counts"]       # {'issuer': 177, 'sec_nport': None}
+nvda.df[["fund", "weight_pct", "holdings_as_of"]].head(3)
+#    fund  weight_pct holdings_as_of
+# 0  GXPT     19.9100     2026-09-24
+# 1   VGT     17.7869     2026-08-31
+# 2  VUSG     16.9500     2026-09-25
+```
+
+Funds covered from their issuers' own files and funds covered from SEC Form N-PORT filings, which are months older, are kept apart in `nvda.data["issuer"]` and `nvda.data["sec_nport"]` (None while the API lists only the first kind). `.df` lists the issuer rows first and the SEC rows after them, without merging the two by weight.
+
+How much VOO and QQQ overlap:
+
+```python
+c = ti.compare("VOO", "QQQ")
+c.data["overlap"]["by_weight"]    # 53.9, the smaller weight of each shared company, summed
+c.data["overlap"]["share_of_b"]   # 93.7, the part of QQQ held in companies VOO also holds
+c.data["correlation_3y"]          # 0.95, from three years of weekly returns
+```
+
+What a small portfolio holds underneath, in percent and in money:
+
+```python
+lt = ti.look_through({"VOO": 6000, "QQQ": 3000, "SCHD": 1000})
+lt.df.head(2)
+#   ticker  weight_pct   value  via_VOO  via_QQQ  via_SCHD
+# 0   NVDA       7.312  731.24   4.8556   2.4568       0.0
+# 1   AAPL       6.449  644.88   4.2259   2.2229       0.0
+```
+
+Citing a figure, with the line every result carries:
+
+```python
+print(c.cite)
+# TickerInside, VOO vs QQQ, holdings files of 2026-08-31 and 2026-09-24, https://tickerinside.com/compare/voo-vs-qqq/, CC BY 4.0
+c.page_url                # the page where a reader can check it
+```
+
+The figures above are from the files of 25 September 2026 and change as issuers publish new ones.
+
+## What each call returns
+
+The functions are `funds()`, `fund(ticker)`, `holdings(ticker)`, `holders(stock_ticker)`, `security(ticker)`, `compare(a, b)`, `overlap_matrix(tickers)`, `look_through(positions)` and `census()`. Each returns a result with these attributes:
+
+- `.data`: the answer as plain dicts and lists.
+- `.df`: the same answer as a pandas DataFrame, when pandas is installed.
+- `.as_of`: the date of the price data, and `.holdings_as_of`: the date of the holdings file, or a dict of dates by fund when the answer uses several funds.
+- `.source`: where the holdings come from, `issuer` for the issuer's own file or `sec_nport` for a fund covered from its latest SEC Form N-PORT filing, which is months older. Like `.holdings_as_of`, it is a dict by fund when the answer uses several funds.
+- `.cite`: a citation line naming the source, its date, a link and the licence.
+- `.url`: the API file the answer was read from, and `.page_url`: the page on tickerinside.com where it can be checked.
+
+Overlap, correlation and look-through are computed on your machine from the fund files, with the same arithmetic as the TickerInside website and MCP server, so the figures agree with theirs. A ticker that is not covered raises `tickerinside.NotCovered` with the API's own message, and a fund given to `holders()` or a stock given to `fund()` gets a message naming the call that fits it. A network failure raises `tickerinside.APIError` with the URL that failed, and so does a 404 that is not the API's own answer, which usually means a wrong base URL. Each file is kept in memory for an hour, so asking twice costs one request. `ti.Client(base_url=..., timeout=..., cache_ttl=...)` gives a session with other settings, and the `TICKERINSIDE_API` environment variable, when it is set, replaces the default base URL `https://tickerinside.com/api/v1` (the TickerInside MCP server reads the same variable). Requests identify themselves with the User-Agent `tickerinside-python/<version>`, and nothing else is sent anywhere.
+
+## Licence and attribution
+
+The code of this package is released under the MIT licence. The data it reads is published by TickerInside under the Creative Commons Attribution 4.0 licence (CC BY 4.0): you may use it, commercially as well, provided you credit TickerInside and link to https://tickerinside.com. The `.cite` line on every result does both. The figures are measurements of what funds hold and how they have behaved, not investment advice.
+
+The API reference, with every field and endpoint, is at https://tickerinside.com/api/.

tickerinside-0.1.0/README.md

@@ -0,0 +1,91 @@
+# tickerinside
+
+A Python client for the free TickerInside API, which serves the full holdings of US ETFs, the funds that hold each stock, and the overlap and look-through computed from them.
+
+## Install
+
+```
+pip install tickerinside
+```
+
+The package uses only the Python standard library and runs on Python 3.9 or later. There is no API key and no account to create. pandas is optional: install it (or `pip install "tickerinside[pandas]"`) and every result also offers a `.df` DataFrame.
+
+## Examples
+
+```python
+import tickerinside as ti
+```
+
+The holdings of VOO as a DataFrame, heaviest first:
+
+```python
+voo = ti.holdings("VOO", names=True)
+voo.holdings_as_of        # '2026-08-31', the date of the issuer's file
+voo.df.head(3)
+#   ticker        name  weight_pct
+# 0   NVDA      Nvidia      8.0927
+# 1   AAPL  Apple Inc.      7.0432
+# 2   MSFT   Microsoft      5.7033
+```
+
+Which ETFs hold NVDA, and at what weight:
+
+```python
+nvda = ti.holders("NVDA")
+nvda.data["counts"]       # {'issuer': 177, 'sec_nport': None}
+nvda.df[["fund", "weight_pct", "holdings_as_of"]].head(3)
+#    fund  weight_pct holdings_as_of
+# 0  GXPT     19.9100     2026-09-24
+# 1   VGT     17.7869     2026-08-31
+# 2  VUSG     16.9500     2026-09-25
+```
+
+Funds covered from their issuers' own files and funds covered from SEC Form N-PORT filings, which are months older, are kept apart in `nvda.data["issuer"]` and `nvda.data["sec_nport"]` (None while the API lists only the first kind). `.df` lists the issuer rows first and the SEC rows after them, without merging the two by weight.
+
+How much VOO and QQQ overlap:
+
+```python
+c = ti.compare("VOO", "QQQ")
+c.data["overlap"]["by_weight"]    # 53.9, the smaller weight of each shared company, summed
+c.data["overlap"]["share_of_b"]   # 93.7, the part of QQQ held in companies VOO also holds
+c.data["correlation_3y"]          # 0.95, from three years of weekly returns
+```
+
+What a small portfolio holds underneath, in percent and in money:
+
+```python
+lt = ti.look_through({"VOO": 6000, "QQQ": 3000, "SCHD": 1000})
+lt.df.head(2)
+#   ticker  weight_pct   value  via_VOO  via_QQQ  via_SCHD
+# 0   NVDA       7.312  731.24   4.8556   2.4568       0.0
+# 1   AAPL       6.449  644.88   4.2259   2.2229       0.0
+```
+
+Citing a figure, with the line every result carries:
+
+```python
+print(c.cite)
+# TickerInside, VOO vs QQQ, holdings files of 2026-08-31 and 2026-09-24, https://tickerinside.com/compare/voo-vs-qqq/, CC BY 4.0
+c.page_url                # the page where a reader can check it
+```
+
+The figures above are from the files of 25 September 2026 and change as issuers publish new ones.
+
+## What each call returns
+
+The functions are `funds()`, `fund(ticker)`, `holdings(ticker)`, `holders(stock_ticker)`, `security(ticker)`, `compare(a, b)`, `overlap_matrix(tickers)`, `look_through(positions)` and `census()`. Each returns a result with these attributes:
+
+- `.data`: the answer as plain dicts and lists.
+- `.df`: the same answer as a pandas DataFrame, when pandas is installed.
+- `.as_of`: the date of the price data, and `.holdings_as_of`: the date of the holdings file, or a dict of dates by fund when the answer uses several funds.
+- `.source`: where the holdings come from, `issuer` for the issuer's own file or `sec_nport` for a fund covered from its latest SEC Form N-PORT filing, which is months older. Like `.holdings_as_of`, it is a dict by fund when the answer uses several funds.
+- `.cite`: a citation line naming the source, its date, a link and the licence.
+- `.url`: the API file the answer was read from, and `.page_url`: the page on tickerinside.com where it can be checked.
+
+Overlap, correlation and look-through are computed on your machine from the fund files, with the same arithmetic as the TickerInside website and MCP server, so the figures agree with theirs. A ticker that is not covered raises `tickerinside.NotCovered` with the API's own message, and a fund given to `holders()` or a stock given to `fund()` gets a message naming the call that fits it. A network failure raises `tickerinside.APIError` with the URL that failed, and so does a 404 that is not the API's own answer, which usually means a wrong base URL. Each file is kept in memory for an hour, so asking twice costs one request. `ti.Client(base_url=..., timeout=..., cache_ttl=...)` gives a session with other settings, and the `TICKERINSIDE_API` environment variable, when it is set, replaces the default base URL `https://tickerinside.com/api/v1` (the TickerInside MCP server reads the same variable). Requests identify themselves with the User-Agent `tickerinside-python/<version>`, and nothing else is sent anywhere.
+
+## Licence and attribution
+
+The code of this package is released under the MIT licence. The data it reads is published by TickerInside under the Creative Commons Attribution 4.0 licence (CC BY 4.0): you may use it, commercially as well, provided you credit TickerInside and link to https://tickerinside.com. The `.cite` line on every result does both. The figures are measurements of what funds hold and how they have behaved, not investment advice.
+
+The API reference, with every field and endpoint, is at https://tickerinside.com/api/.

tickerinside-0.1.0/pyproject.toml

@@ -0,0 +1,53 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "tickerinside"
+dynamic = ["version"]
+description = "Python client for the free TickerInside API: the full holdings of US ETFs, which funds hold a stock, fund overlap and portfolio look-through."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "TickerInside", email = "contact@tickerinside.com" }]
+keywords = ["etf", "etf holdings", "etf overlap", "look-through", "portfolio", "finance", "sec", "n-port", "api"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Financial and Insurance Industry",
+    "Intended Audience :: Science/Research",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Office/Business :: Financial :: Investment",
+    "Typing :: Typed",
+]
+dependencies = []
+
+[project.optional-dependencies]
+pandas = ["pandas>=1.3"]
+
+[project.urls]
+Homepage = "https://tickerinside.com"
+Documentation = "https://tickerinside.com/api/"
+
+[tool.hatch.version]
+path = "tickerinside/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["tickerinside"]
+core-metadata-version = "2.4"
+
+[tool.hatch.build.targets.sdist]
+core-metadata-version = "2.4"
+# The tests stay in the repository: their fixtures are recorded API files,
+# including issuer-layer holdings, which are not redistributed on PyPI.
+include = ["/tickerinside", "/README.md", "/LICENSE", "/pyproject.toml"]
+exclude = ["**/__pycache__", "**/*.pyc"]

tickerinside-0.1.0/tickerinside/__init__.py

@@ -0,0 +1,83 @@
+"""tickerinside: Python client for the free TickerInside API.
+
+The full holdings of US ETFs, which funds hold a stock, the overlap between
+funds and the look-through of a portfolio, read from the static JSON files
+tickerinside.com serves. No key, no account, standard library only; pandas is
+used when it is installed.
+
+    import tickerinside as ti
+
+    ti.holdings("VOO").df            # every position, heaviest first
+    ti.holders("NVDA").df            # the funds that hold NVDA
+    ti.compare("VOO", "QQQ").data    # overlap and correlation
+    ti.look_through({"VOO": 6000, "QQQ": 3000, "SCHD": 1000}).df
+
+Every call returns a Result with .data, .df, .as_of, .holdings_as_of,
+.source, .cite, .url and .page_url. The module functions share one Client;
+create your own Client for another base URL, timeout or cache.
+
+The data is published by TickerInside under CC BY 4.0: credit TickerInside
+and link to https://tickerinside.com when you use it.
+"""
+from __future__ import annotations
+
+import functools
+import inspect
+from typing import Optional, Sequence
+
+from ._http import USER_AGENT
+from ._version import __version__
+from .client import Client, Positions
+from .errors import APIError, NotCovered, TickerInsideError
+from .result import OverlapMatrix, Result
+
+__all__ = [
+    "__version__", "USER_AGENT", "Client", "Result", "OverlapMatrix",
+    "TickerInsideError", "APIError", "NotCovered",
+    "funds", "fund", "holdings", "holders", "security", "compare", "overlap_matrix",
+    "look_through", "census", "configure", "clear_cache",
+]
+
+_default: Optional[Client] = None
+
+
+def _client() -> Client:
+    global _default
+    if _default is None:
+        _default = Client()
+    return _default
+
+
+def configure(base_url: Optional[str] = None, timeout: float = 20.0, cache_ttl: Optional[float] = 3600.0) -> Client:
+    """Replace the client the module functions use, and return it."""
+    global _default
+    _default = Client(base_url=base_url, timeout=timeout, cache_ttl=cache_ttl)
+    return _default
+
+
+def clear_cache() -> None:
+    """Forget every file the module functions have read."""
+    _client().clear_cache()
+
+
+def _bind(name):
+    method = getattr(Client, name)
+
+    @functools.wraps(method)
+    def call(*args, **kwargs):
+        return getattr(_client(), name)(*args, **kwargs)
+    sig = inspect.signature(method)
+    call.__signature__ = sig.replace(parameters=list(sig.parameters.values())[1:])  # type: ignore[attr-defined]
+    del call.__wrapped__
+    return call
+
+
+funds = _bind("funds")
+fund = _bind("fund")
+holdings = _bind("holdings")
+holders = _bind("holders")
+security = _bind("security")
+compare = _bind("compare")
+overlap_matrix = _bind("overlap_matrix")
+look_through = _bind("look_through")
+census = _bind("census")

tickerinside-0.1.0/tickerinside/_http.py

@@ -0,0 +1,177 @@
+"""Reading the API: one GET per file, standard library only.
+
+The API is a set of static files on a CDN, with no key and no quota, so the
+only things worth doing here are naming the program honestly in the
+User-Agent, not fetching the same file twice in a session, retrying once when
+the CDN has a bad moment, and telling a ticker we do not cover apart from a
+network that is down. Nothing else is sent anywhere.
+"""
+from __future__ import annotations
+
+import gzip
+import http.client
+import json
+import socket
+import threading
+import time
+import urllib.error
+import urllib.request
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Dict, List, Optional, Sequence, Tuple
+
+from ._version import __version__
+from .errors import APIError, NotCovered
+
+USER_AGENT = f"tickerinside-python/{__version__} (+https://tickerinside.com/api/)"
+DEFAULT_TIMEOUT = 20.0
+
+
+class Transport:
+    """GETs files under a base URL and keeps each one in memory, by URL,
+    for ``cache_ttl`` seconds (0 turns the cache off, None keeps files for
+    the life of the object)."""
+
+    def __init__(self, base_url: str, timeout: float = DEFAULT_TIMEOUT,
+                 cache_ttl: Optional[float] = 3600.0, retry_wait: float = 1.0, workers: int = 8):
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.cache_ttl = cache_ttl
+        self.retry_wait = retry_wait
+        self.workers = max(1, int(workers))
+        self._cache: Dict[str, Tuple[float, str]] = {}
+        self._lock = threading.Lock()
+
+    # ------------------------------------------------------------ cache
+
+    def clear_cache(self) -> None:
+        with self._lock:
+            self._cache.clear()
+
+    def _cached(self, url: str) -> Optional[str]:
+        if self.cache_ttl == 0:
+            return None
+        with self._lock:
+            hit = self._cache.get(url)
+        if hit is None:
+            return None
+        if self.cache_ttl is not None and time.monotonic() - hit[0] > self.cache_ttl:
+            with self._lock:
+                self._cache.pop(url, None)
+            return None
+        return hit[1]
+
+    def _store(self, url: str, text: str) -> None:
+        if self.cache_ttl == 0:
+            return
+        with self._lock:
+            self._cache[url] = (time.monotonic(), text)
+
+    # ------------------------------------------------------------ reading
+
+    def url(self, path: str) -> str:
+        return self.base_url + path
+
+    def text(self, url: str, ticker: Optional[str] = None, accept: str = "application/json") -> str:
+        """The body of ``url`` as text. A 404 raises NotCovered when the
+        file belongs to a ticker (``ticker`` is given) and the body is the
+        API's own not-covered answer, APIError otherwise."""
+        hit = self._cached(url)
+        if hit is not None:
+            return hit
+        body = self._get(url, ticker, accept)
+        self._store(url, body)
+        return body
+
+    def json(self, path: str, ticker: Optional[str] = None) -> Tuple[Any, str]:
+        """(parsed file, url) for an API path such as "/fund/voo.json"."""
+        url = self.url(path)
+        body = self.text(url, ticker)
+        try:
+            return json.loads(body), url
+        except ValueError:
+            raise APIError(f"{url} did not answer with JSON.", url) from None
+
+    def many(self, items: Sequence[Tuple[str, Optional[str]]]) -> List[Any]:
+        """Several (path, ticker) reads at once. Each result is (file, url) or
+        the NotCovered raised for it; any other error is raised."""
+        def one(item):
+            try:
+                return self.json(item[0], item[1])
+            except NotCovered as e:
+                return e
+        if len(items) <= 1:
+            return [one(i) for i in items]
+        with ThreadPoolExecutor(max_workers=min(self.workers, len(items))) as pool:
+            return list(pool.map(one, items))
+
+    def _get(self, url: str, ticker: Optional[str], accept: str) -> str:
+        req = urllib.request.Request(url, headers={
+            "User-Agent": USER_AGENT,
+            "Accept": accept,
+            "Accept-Encoding": "gzip",
+        })
+        for attempt in (0, 1):
+            try:
+                with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                    return _decode(resp.read(), resp.headers.get("Content-Encoding"), url)
+            except urllib.error.HTTPError as e:
+                status = e.code
+                raw = _read_error_body(e)
+                if 500 <= status < 600 and attempt == 0:
+                    if self.retry_wait:
+                        time.sleep(self.retry_wait)
+                    continue
+                if status == 404:
+                    if ticker is not None:
+                        err = _not_covered(ticker, url, raw, e.headers.get("Content-Encoding") if e.headers else None)
+                        if err is not None:
+                            raise err
+                    raise APIError(f"{url} answered HTTP 404, so there is no file at that address; "
+                                   f"check the base URL.", url, status) from None
+                raise APIError(f"{url} answered HTTP {status}.", url, status) from None
+            except (urllib.error.URLError, socket.timeout, TimeoutError, ConnectionError,
+                    http.client.HTTPException, OSError) as e:
+                reason = getattr(e, "reason", None) or e
+                raise APIError(f"Could not read {url}: {reason}", url) from None
+        raise APIError(f"{url} could not be read.", url)  # pragma: no cover
+
+
+def _read_error_body(e: urllib.error.HTTPError) -> bytes:
+    try:
+        return e.read() or b""
+    except Exception:
+        return b""
+    finally:
+        try:
+            e.close()
+        except Exception:
+            pass
+
+
+def _decode(raw: bytes, encoding: Optional[str], url: str) -> str:
+    if (encoding or "").lower() == "gzip" or raw[:2] == b"\x1f\x8b":
+        try:
+            raw = gzip.decompress(raw)
+        except (OSError, EOFError):
+            raise APIError(f"{url} sent a body that could not be decompressed.", url) from None
+    try:
+        return raw.decode("utf-8")
+    except UnicodeDecodeError:
+        raise APIError(f"{url} sent a body that is not UTF-8.", url) from None
+
+
+def _not_covered(ticker: str, url: str, raw: bytes, encoding: Optional[str]) -> Optional[NotCovered]:
+    """The NotCovered for a 404, or None when the 404 is not the API's own
+    answer about a ticker (a wrong base URL, a proxy's error page), which is
+    then reported as an APIError rather than as a fact about the ticker."""
+    try:
+        body = json.loads(_decode(raw, encoding, url))
+    except (APIError, ValueError):
+        return None
+    if not isinstance(body, dict) or body.get("error") != "not_covered":
+        return None
+    message = body.get("message") if isinstance(body.get("message"), str) else None
+    if not message:
+        message = (f"{ticker} is not covered yet. The funds covered today are listed at "
+                   f"https://tickerinside.com/api/v1/index.json.")
+    return NotCovered({ticker: message}, {ticker: url}, {ticker: body})