proxy-scraper-cli 1.7.1__py3-none-any.whl

proxyscraper/sources.py

@@ -0,0 +1,491 @@
+"""
+Source management for the proxy scraper:
+
+- loads the curated source list (sources.json) and sources found with --discover,
+- resolves meta sources (lists of source URLs maintained by others),
+- finds new proxy lists on GitHub,
+- remembers per source how many of its proxies really work, and
+  skips dead, outdated or unreachable sources.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import json
+import os
+import re
+import subprocess
+import time
+import warnings
+from collections import Counter
+from dataclasses import asdict, dataclass
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Awaitable, Callable, Dict, Iterable, List, Optional, Tuple
+from urllib.parse import quote, urlencode
+
+from .parsing import PROXY_TYPES, TYPE_ALIASES
+from .paths import DATA_DIR, PACKAGE_DIR, atomic_write
+
+SOURCES_FILE = PACKAGE_DIR / "sources.json"
+DISCOVERED_FILE = DATA_DIR / "sources_discovered.json"
+STATS_FILE = DATA_DIR / "source_stats.json"
+
+GH_RAW = "https://raw.githubusercontent.com"
+# "auto" = the list contains type://ip:port lines, the type is given per line
+SOURCE_TYPES = (*PROXY_TYPES, "auto")
+
+# url -> Typ
+SourceMap = Dict[str, str]
+Getter = Callable[..., Awaitable[bytes]]
+
+
+# --------------------------------------------------------------------------- #
+# URLs & source lists
+# --------------------------------------------------------------------------- #
+
+_GH_BLOB_RE = re.compile(r"^https://github\.com/([^/]+)/([^/]+)/(?:raw|blob)/(?:refs/heads/)?(.+)$")
+
+
+def normalize_url(url: str) -> Optional[str]:
+    """Normalizes source URLs so the same file isn't loaded several times.
+
+    github.com/…/raw/… -> raw.githubusercontent.com/…, '/refs/heads/' is dropped,
+    format suffixes like ',,ColonURL' are cut off. Templates with {…} -> None.
+    """
+    url = url.strip().split(",", 1)[0].strip()
+    if not url.startswith(("http://", "https://")) or "{" in url:
+        return None
+    m = _GH_BLOB_RE.match(url)
+    if m:
+        url = f"{GH_RAW}/{m[1]}/{m[2]}/{m[3]}"
+    if url.startswith(GH_RAW):
+        url = url.replace("/refs/heads/", "/", 1)
+    return url
+
+
+def _add(target: SourceMap, url: str, ptype: str) -> None:
+    ptype = TYPE_ALIASES.get(ptype.lower(), "")
+    url = normalize_url(url) if url else None
+    if url and ptype:
+        target.setdefault(url, ptype)
+
+
+def load_source_file(path: Path = SOURCES_FILE) -> Tuple[SourceMap, List[dict]]:
+    """Reads sources.json -> (sources, meta sources)."""
+    data = json.loads(path.read_text(encoding="utf-8"))
+    sources: SourceMap = {}
+    for ptype, urls in data.get("sources", {}).items():
+        for url in urls:
+            _add(sources, url, ptype)
+    return sources, list(data.get("meta", []))
+
+
+def load_discovered(path: Path = DISCOVERED_FILE, now: Optional[datetime] = None) -> SourceMap:
+    """Found sources the search saw in the last DISCOVERED_KEEP_DAYS – also when no search ran since (no token,
+    GitHub down), so old finds expire either way. VPN-config repos from before the filter existed are dropped."""
+    if not path.exists():
+        return {}
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return {}
+    now = now or datetime.now(timezone.utc)
+    seen = data.get("last_seen", {}) if isinstance(data.get("last_seen"), dict) else {}
+    out: SourceMap = {}
+    for url, ptype in data.get("sources", {}).items():
+        if _age_days(seen.get(url) or data.get("generated"), now) > DISCOVERED_KEEP_DAYS or _is_vpn_repo(url):
+            continue
+        _add(out, url, ptype)
+    return out
+
+
+def _age_days(stamp, now: datetime) -> float:
+    try:
+        return (now - datetime.fromisoformat(stamp)).total_seconds() / DAY
+    except (TypeError, ValueError):
+        return float("inf")
+
+
+def _is_vpn_repo(url: str) -> bool:
+    parts = url.split("/")
+    return url.startswith(GH_RAW) and len(parts) > 4 and bool(_REPO_REJECT_RE.search("/".join(parts[3:5])))
+
+
+def discovered_age_days(path: Path = DISCOVERED_FILE) -> Optional[float]:
+    """Age of the last discovery in days, None if there hasn't been one yet."""
+    try:
+        generated = json.loads(path.read_text(encoding="utf-8"))["generated"]
+        return (datetime.now(timezone.utc) - datetime.fromisoformat(generated)).total_seconds() / DAY
+    except (OSError, ValueError, KeyError, TypeError):
+        return None
+
+
+DISCOVERED_KEEP_DAYS = 21  # a found source stays this long after the search last saw it
+
+
+def save_discovered(sources: SourceMap, path: Path = DISCOVERED_FILE, now: Optional[datetime] = None) -> SourceMap:
+    """Adds this run's finds to what earlier runs found – the search only sees repos pushed in the last few days,
+    so a list that was quiet for a day would otherwise drop out. Whatever the search hasn't seen for
+    DISCOVERED_KEEP_DAYS goes; dead sources are skipped by the learning long before that. -> everything kept."""
+    now = now or datetime.now(timezone.utc)
+    stamp = now.isoformat(timespec="seconds")
+    try:
+        old = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        old = {}
+    old_sources = old.get("sources", {}) if isinstance(old, dict) else {}
+    seen = old.get("last_seen", {}) if isinstance(old, dict) else {}
+    kept: SourceMap = {}
+    last_seen: Dict[str, str] = {}
+    for url, ptype in old_sources.items():
+        when = seen.get(url) or old.get("generated")  # files from before last_seen: count from their date
+        if _age_days(when, now) <= DISCOVERED_KEEP_DAYS and isinstance(ptype, str) and not _is_vpn_repo(url):
+            kept[url], last_seen[url] = ptype, when
+    for url, ptype in sources.items():
+        kept[url], last_seen[url] = ptype, stamp
+    payload = {"generated": stamp, "sources": kept, "last_seen": last_seen}
+    atomic_write(path, json.dumps(payload, indent=1, sort_keys=True))
+    return kept
+
+
+# --------------------------------------------------------------------------- #
+# meta sources: lists of source URLs maintained by others
+# --------------------------------------------------------------------------- #
+
+def parse_url_list(data: bytes, ptype: str) -> SourceMap:
+    """One source URL per line (e.g. gfpcom/free-proxy-list/sources/http.txt)."""
+    out: SourceMap = {}
+    for line in data.decode("utf-8", "ignore").splitlines():
+        line = line.strip()
+        if line and not line.startswith("#"):
+            _add(out, line, ptype)
+    return out
+
+
+_TOML_SECTION_RE = re.compile(r"^\s*\[scraping\.(\w+)\]")
+_TOML_URL_RE = re.compile(r'"(https?://[^"]+)"')
+
+
+def parse_monosans_toml(data: bytes) -> SourceMap:
+    """URLs from the [scraping.<type>] sections of monosans/proxy-scraper-checker's config.toml.
+
+    Python 3.9 has no tomllib – a line parser is enough for this flat structure.
+    """
+    out: SourceMap = {}
+    section = None
+    for line in data.decode("utf-8", "ignore").splitlines():
+        m = _TOML_SECTION_RE.match(line)
+        if m:
+            section = m[1]
+            continue
+        if line.lstrip().startswith("["):
+            section = None
+        elif section in PROXY_TYPES and not line.lstrip().startswith("#"):
+            for url in _TOML_URL_RE.findall(line):
+                _add(out, url, section)
+    return out
+
+
+META_PARSERS: Dict[str, Callable[[bytes, dict], SourceMap]] = {
+    "url-list": lambda data, meta: parse_url_list(data, meta.get("type", "auto")),
+    "monosans-toml": lambda data, meta: parse_monosans_toml(data),
+}
+
+
+async def resolve_meta(meta: List[dict], get: Getter) -> Tuple[SourceMap, int]:
+    """Loads every meta source -> (sources found, number of meta sources loaded successfully)."""
+
+    async def one(entry: dict) -> Optional[SourceMap]:
+        parser = META_PARSERS.get(entry.get("format", "url-list"))
+        if not parser:
+            return None
+        try:
+            return parser(await get(entry["url"], timeout=20), entry)
+        except Exception:  # meta source unreachable -> just fewer sources, no abort
+            return None
+
+    found: SourceMap = {}
+    ok = 0
+    for res in await asyncio.gather(*(one(m) for m in meta)):
+        if res is not None:
+            ok += 1
+            for url, ptype in res.items():
+                found.setdefault(url, ptype)
+    return found, ok
+
+
+# --------------------------------------------------------------------------- #
+# GitHub-Discovery
+# --------------------------------------------------------------------------- #
+
+DISCOVERY_QUERIES = (
+    "topic:proxy-list",
+    "topic:free-proxy-list",
+    "topic:proxy-lists",
+    "topic:free-proxy",
+    "topic:free-proxies",
+    "topic:proxylist",
+    "topic:proxies-list",
+    "topic:socks5-proxy",
+    "topic:socks5-proxy-list",
+    "topic:socks4-proxy",
+    "topic:http-proxy-list",
+    "topic:https-proxy",
+    "topic:proxy-scraper",
+    "topic:proxy-checker",
+    "topic:proxy-pool",
+    "proxy list in:name",
+    "proxy-list in:name",
+    "free proxy in:name,description",
+    "proxies in:name",
+    "socks5 in:name",
+    "socks4 in:name",
+    "fresh proxy in:name,description",
+    "proxy updated every in:description",
+)
+SEARCH_PAGES = 3  # GitHub returns 100 per page; most queries end earlier
+RATE_LIMIT_WAIT = 61.0  # the search API allows 30 requests a minute with a token (10 without)
+RATE_LIMIT_RETRIES = 3  # waits per discovery at most
+RATE_LIMIT_ERRORS = {"HTTP 403", "HTTP 429"}  # how netio.http_get reports GitHub's rate limit
+# paths that end in .txt but aren't (complete) proxy lists:
+# VPN configs, splits by country/ASN (subsets only), archives, blocklists …
+_PATH_REJECT_RE = re.compile(
+    r"(v2ray|vmess|vless|trojan|shadowsocks|(^|[/_\-])ssr?([/_\-.]|$)|clash|mtproto|wireguard|hysteria|tuic"
+    r"|readme|license|requirements|block|countr|geo|/asn/|archive|history|backup|old/|test|bench|corpus"
+    r"|subscri|(^|/)subs/|config"
+    r"|(^|/)[a-z]{2}\.txt$)"
+)
+_PATH_TYPE_RE = re.compile(r"(socks5|socks4|https?)")
+_FILE_GENERIC_RE = re.compile(r"(^|[/_\-.])(proxy|proxies|all)[^/]*\.txt$")
+# repos that collect VPN configs: their addresses aren't HTTP/SOCKS proxies, only dead candidates
+_REPO_REJECT_RE = re.compile(r"v2ray|vpn|xray|clash|sing-?box|nekobox|vless|vmess|subscri|config", re.I)
+MAX_FILES_PER_REPO = 12
+MAX_REPOS_PER_OWNER = 3  # against spam accounts with dozens of identical clone repos
+
+
+def classify_path(path: str) -> Optional[str]:
+    """Proxy type of a file from its path, or None if it doesn't look like a proxy list."""
+    p = path.lower()
+    if not p.endswith(".txt") or p.count("/") > 3 or _PATH_REJECT_RE.search(p):
+        return None
+    m = _PATH_TYPE_RE.search(p)
+    if m:
+        return TYPE_ALIASES[m[1]]
+    return "auto" if _FILE_GENERIC_RE.search(p) else None
+
+
+def github_token() -> Optional[str]:
+    """Token from GITHUB_TOKEN/GH_TOKEN or the gh CLI – raises the API limit from 60 to 5000 requests/h."""
+    for key in ("GITHUB_TOKEN", "GH_TOKEN"):
+        if os.environ.get(key):
+            return os.environ[key].strip()
+    try:
+        res = subprocess.run(["gh", "auth", "token"], capture_output=True, text=True, timeout=5)
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if res.returncode != 0:
+        return None
+    return res.stdout.strip() or None
+
+
+async def discover_github(
+    get: Getter,
+    token: Optional[str],
+    max_repos: int,
+    days: int = 3,
+    on_progress: Optional[Callable[[str], None]] = None,
+) -> SourceMap:
+    """Looks for actively maintained proxy list repos and their list files."""
+    headers = {"Accept": "application/vnd.github+json", "X-GitHub-Api-Version": "2022-11-28"}
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    since = (datetime.now(timezone.utc) - timedelta(days=days)).strftime("%Y-%m-%d")
+
+    repos: Dict[str, Tuple[str, int]] = {}
+    waits_left = RATE_LIMIT_RETRIES
+
+    async def search(query: str):
+        nonlocal waits_left
+        while True:
+            try:
+                return json.loads(await get(f"https://api.github.com/search/repositories?{query}", headers=headers))
+            except Exception as e:
+                # only GitHub's rate limit (403/429) is worth waiting for – a bad token or no network won't get better
+                if waits_left <= 0 or str(e) not in RATE_LIMIT_ERRORS:
+                    return None
+                waits_left -= 1
+                if on_progress:
+                    on_progress("rate limit – waiting a minute")
+                await asyncio.sleep(RATE_LIMIT_WAIT)
+
+    for q in DISCOVERY_QUERIES:
+        for page in range(1, SEARCH_PAGES + 1):
+            query = urlencode({"q": f"{q} pushed:>{since}", "sort": "stars", "per_page": 100, "page": page})
+            data = await search(query)
+            if data is None:
+                break
+            items = data.get("items", [])
+            for it in items:
+                repos.setdefault(it["full_name"], (it["default_branch"], it["stargazers_count"]))
+            if on_progress:
+                on_progress(f"{len(repos)} repos found")
+            if len(items) < 100:
+                break
+
+    per_owner: Counter = Counter()
+    chosen: List[Tuple[str, str]] = []
+    for name, (branch, _stars) in sorted(repos.items(), key=lambda kv: -kv[1][1]):
+        if _REPO_REJECT_RE.search(name):
+            continue
+        owner = name.split("/", 1)[0].lower()
+        if per_owner[owner] < MAX_REPOS_PER_OWNER:
+            per_owner[owner] += 1
+            chosen.append((name, branch))
+    chosen = chosen[:max_repos]
+
+    sem = asyncio.Semaphore(8)
+    done = 0
+
+    async def scan(name: str, branch: str) -> SourceMap:
+        nonlocal done
+        url = f"https://api.github.com/repos/{name}/git/trees/{quote(branch, safe='')}?recursive=1"
+        async with sem:
+            try:
+                tree = json.loads(await get(url, headers=headers, timeout=30)).get("tree", [])
+            except Exception:
+                tree = []
+        done += 1
+        if on_progress:
+            on_progress(f"{done}/{len(chosen)} repos searched")
+        files = []
+        for entry in tree:
+            if entry.get("type") == "blob" and entry.get("size", 0) >= 200:
+                ptype = classify_path(entry["path"])
+                if ptype:
+                    files.append((entry["path"].count("/"), entry["path"], ptype))
+        files.sort()  # shallow paths first – those are usually the complete lists
+        return {
+            f"{GH_RAW}/{name}/{branch}/{quote(path)}": ptype
+            for _depth, path, ptype in files[:MAX_FILES_PER_REPO]
+        }
+
+    found: SourceMap = {}
+    for res in await asyncio.gather(*(scan(n, b) for n, b in chosen)):
+        found.update(res)
+    return found
+
+
+# --------------------------------------------------------------------------- #
+# learning the quality of each source
+# --------------------------------------------------------------------------- #
+
+DAY = 86400.0
+DECAY = 0.5                 # older runs count half as much with every run
+PRIOR_HITS, PRIOR_MISSES = 1.0, 30.0   # new sources start at a ~3 % hit rate
+STALE_AFTER = 7 * DAY       # content unchanged for a week -> the list is no longer maintained
+DEAD_MIN_CHECKED = 300      # this many checks without a hit -> the source counts as dead
+UNREACHABLE_STREAK = 3      # failed to load this many times in a row -> pause
+UNREACHABLE_PAUSE = 2 * DAY
+STALE_RECHECK = 3 * DAY     # an outdated list is still looked at this often – it may be maintained again
+
+
+@dataclass
+class SourceRecord:
+    first_seen: float = 0.0
+    last_fetch: float = 0.0
+    fail_streak: int = 0
+    count: int = 0
+    content_hash: str = ""
+    last_change: float = 0.0
+    checked: float = 0.0  # decaying sums over the runs
+    working: float = 0.0
+    runs: int = 0
+
+    @property
+    def score(self) -> float:
+        """Estimated hit rate (Bayesian smoothing, so 1 out of 1 doesn't mean 100 %)."""
+        return (self.working + PRIOR_HITS) / (self.checked + PRIOR_HITS + PRIOR_MISSES)
+
+
+class SourceStats:
+    def __init__(self, path: Path = STATS_FILE):
+        self.path = path
+        self.records: Dict[str, SourceRecord] = {}
+        if path.exists():
+            try:
+                raw = json.loads(path.read_text(encoding="utf-8"))
+                self.records = {url: SourceRecord(**rec) for url, rec in raw.items()}
+            except (OSError, ValueError, TypeError) as e:
+                # broken statistics are no reason to abort – we just learn again
+                warnings.warn(f"{path.name} unreadable ({e}), starting without source statistics", stacklevel=2)
+
+    def get(self, url: str) -> SourceRecord:
+        return self.records.get(url) or SourceRecord()
+
+    def score(self, url: str) -> float:
+        return self.get(url).score
+
+    def skip_reason(self, url: str, now: Optional[float] = None) -> Optional[str]:
+        rec = self.records.get(url)
+        if rec is None:
+            return None
+        now = time.time() if now is None else now
+        if rec.fail_streak >= UNREACHABLE_STREAK and now - rec.last_fetch < UNREACHABLE_PAUSE:
+            return "unreachable"
+        if rec.last_change and now - rec.last_change > STALE_AFTER and now - rec.first_seen > STALE_AFTER:
+            return "outdated"
+        if rec.runs >= 2 and rec.checked >= DEAD_MIN_CHECKED and rec.working < 0.5:
+            return "dead"
+        return None
+
+    def skip_now(self, url: str, now: Optional[float] = None) -> Optional[str]:
+        """Like skip_reason, but an outdated list still gets fetched every STALE_RECHECK – it may be
+        maintained again. skip_reason stays the status for display, so it doesn't flip back and forth."""
+        now = time.time() if now is None else now
+        reason = self.skip_reason(url, now)
+        if reason == "outdated" and now - self.records[url].last_fetch >= STALE_RECHECK:
+            return None
+        return reason
+
+    def record_fetch(self, url: str, data: Optional[bytes], count: int, now: Optional[float] = None,
+                     unchanged: bool = False, parsed: Optional[int] = None) -> None:
+        """unchanged=True: the server answered 304 – reachable, same content as last time.
+        Hash and last_change stay as they are, so the outdated detection keeps working normally.
+
+        count: proxies of the types this run wants; parsed: proxies of any type. A list that has proxies,
+        just none of the requested types (e.g. --types http on a socks5-only list), did answer fine."""
+        now = time.time() if now is None else now
+        rec = self.records.setdefault(url, SourceRecord(first_seen=now))
+        rec.last_fetch = now
+        if unchanged:  # also with 0 matching proxies (e.g. other --types): the source did answer
+            rec.fail_streak = 0
+            rec.count = count
+            return
+        if data is None or (count if parsed is None else parsed) == 0:
+            rec.fail_streak += 1
+            return
+        rec.fail_streak = 0
+        rec.count = count
+        digest = hashlib.sha1(data).hexdigest()
+        if digest != rec.content_hash:
+            rec.content_hash = digest
+            rec.last_change = now
+
+    def record_checks(self, results: Dict[str, Tuple[int, int]]) -> None:
+        """results: url -> (checked, working) in this run."""
+        for url, (checked, working) in results.items():
+            if not checked:
+                continue
+            rec = self.records.setdefault(url, SourceRecord(first_seen=time.time()))
+            rec.checked = rec.checked * DECAY + checked
+            rec.working = rec.working * DECAY + working
+            rec.runs += 1
+
+    def ranking(self, urls: Iterable[str]) -> List[Tuple[str, SourceRecord]]:
+        return sorted(((u, self.get(u)) for u in urls), key=lambda x: -x[1].score)
+
+    def save(self) -> None:
+        payload = {url: asdict(rec) for url, rec in sorted(self.records.items())}
+        atomic_write(self.path, json.dumps(payload, indent=1))

proxyscraper/targets.py

@@ -0,0 +1,76 @@
+"""Target sites for --target: a proxy only counts if it really reaches these sites."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from urllib.parse import urlsplit
+
+
+@dataclass(frozen=True)
+class Target:
+    url: str
+    host: str
+    port: int
+    path: str
+    tls: bool
+
+    @property
+    def host_header(self) -> str:
+        """Host header: with the port if it differs from the default – otherwise you may end up in the wrong vhost."""
+        return self.host if self.port == (443 if self.tls else 80) else f"{self.host}:{self.port}"
+
+    @property
+    def label(self) -> str:
+        """Short name for display: https://www.google.com/ -> google.com"""
+        host = self.host[4:] if self.host.startswith("www.") else self.host
+        default = 443 if self.tls else 80
+        return host if self.port == default else f"{host}:{self.port}"
+
+
+def parse_target(text: str) -> Target:
+    """'google.com' -> https://google.com/ ; raises ValueError for anything unusable."""
+    text = text.strip()
+    if "://" not in text:
+        text = "https://" + text
+    u = urlsplit(text)
+    if u.scheme not in ("http", "https"):
+        raise ValueError(f"only http:// and https:// are possible, not {u.scheme}://")
+    if not u.hostname:
+        raise ValueError(f"no host in {text!r}")
+    tls = u.scheme == "https"
+    try:
+        port = u.port
+    except ValueError as e:  # port outside 0–65535 or similar
+        raise ValueError(f"invalid port in {text!r}") from e
+    if port is None:
+        port = 443 if tls else 80
+    elif port <= 0:  # don't silently replace ":0" with the default port
+        raise ValueError(f"invalid port in {text!r}")
+    path = (u.path or "/") + (f"?{u.query}" if u.query else "")
+    default = 443 if tls else 80
+    netloc = u.hostname if port == default else f"{u.hostname}:{port}"
+    return Target(url=f"{u.scheme}://{netloc}{path}", host=u.hostname, port=port, path=path, tls=tls)
+
+
+def target_label(url: str, others=()) -> str:
+    """Short name; with the scheme when it could be confused (http:// and https:// of the same site)."""
+    try:
+        label = parse_target(url).label
+    except ValueError:
+        return url
+    if any(o != url and target_label(o) == label for o in others):
+        return url.split("/", 3)[0] + "//" + label
+    return label
+
+
+# suggestions for the setup wizard
+SUGGESTIONS = (
+    ("Google", "https://www.google.com/"),
+    ("YouTube", "https://www.youtube.com/"),
+    ("Discord", "https://discord.com/"),
+    ("Instagram", "https://www.instagram.com/"),
+    ("X / Twitter", "https://x.com/"),
+    ("Reddit", "https://www.reddit.com/"),
+    ("TikTok", "https://www.tiktok.com/"),
+    ("Amazon", "https://www.amazon.de/"),
+)

proxyscraper/ui/__init__.py

@@ -0,0 +1,54 @@
+"""Terminal UI: building blocks (widgets), live views (dashboard) and the final report (report).
+
+The console is deliberately not re-exported: whatever prints uses `widgets.console` at runtime,
+so it can be swapped (e.g. for recording screenshots or in tests).
+"""
+
+from . import widgets
+from .dashboard import CheckDashboard, CollectView, LiveStats
+from .report import render_source_ranking, render_summary
+from .widgets import (
+    ACCENT,
+    BAD,
+    BLOCKED_HIT_RATE,
+    BORDER,
+    GOOD,
+    MUTED,
+    WARN,
+    banner,
+    bar,
+    fmt,
+    fmt_duration,
+    info,
+    note,
+    pct,
+    section,
+    section_end,
+    short_url,
+)
+
+__all__ = [
+    "ACCENT",
+    "BAD",
+    "BLOCKED_HIT_RATE",
+    "BORDER",
+    "GOOD",
+    "MUTED",
+    "WARN",
+    "CheckDashboard",
+    "CollectView",
+    "LiveStats",
+    "banner",
+    "bar",
+    "fmt",
+    "fmt_duration",
+    "info",
+    "note",
+    "pct",
+    "render_source_ranking",
+    "render_summary",
+    "section",
+    "section_end",
+    "short_url",
+    "widgets",
+]