PyPI - netpath - Versions diffs - 0.1.0__py3-none-any.whl - Mend

netpath 0.1.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

netpath/__init__.py +1 -0
netpath/__main__.py +3 -0
netpath/asn.py +108 -0
netpath/cli.py +526 -0
netpath/country.py +134 -0
netpath/diagnosis.py +93 -0
netpath/display.py +473 -0
netpath/globe.py +205 -0
netpath/iperf.py +59 -0
netpath/mtr.py +197 -0
netpath/rum.py +55 -0
netpath/servers.py +69 -0
netpath/speedtest.py +112 -0
netpath-0.1.0.dist-info/METADATA +135 -0
netpath-0.1.0.dist-info/RECORD +18 -0
netpath-0.1.0.dist-info/WHEEL +4 -0
netpath-0.1.0.dist-info/entry_points.txt +2 -0
netpath-0.1.0.dist-info/licenses/LICENSE +21 -0

netpath/globe.py ADDED Viewed

@@ -0,0 +1,205 @@
+import ipaddress
+import json
+import tempfile
+import webbrowser
+from pathlib import Path
+import requests
+from rich.panel import Panel
+from netpath.display import LATENCY_GREEN_MS, LATENCY_YELLOW_MS, console
+_BATCH_URL = "http://ip-api.com/batch"
+_BATCH_SIZE = 100
+def _is_private(host: str) -> bool:
+    try:
+        return ipaddress.ip_address(host).is_private
+    except ValueError:
+        return False  # Hostname — let ip-api.com resolve it
+def _geolocate(hosts: list[str]) -> dict[str, dict]:
+    """Batch geolocate hosts/IPs. Returns {host: {lat, lon}} for successful lookups."""
+    results: dict[str, dict] = {}
+    for i in range(0, len(hosts), _BATCH_SIZE):
+        batch = hosts[i : i + _BATCH_SIZE]
+        payload = [{"query": h, "fields": "query,lat,lon,status"} for h in batch]
+        try:
+            resp = requests.post(_BATCH_URL, json=payload, timeout=10)
+        except requests.RequestException as e:
+            raise RuntimeError(f"Geolocation request failed: {e}") from e
+        if resp.status_code == 429:
+            raise RuntimeError("ip-api.com rate limit reached (HTTP 429)")
+        if not resp.ok:
+            raise RuntimeError(f"ip-api.com returned HTTP {resp.status_code}")
+        for item in resp.json():
+            if item.get("status") == "success":
+                results[item["query"]] = {"lat": item["lat"], "lon": item["lon"]}
+    return results
+def _arc_color(delta_ms: float) -> str:
+    if delta_ms < LATENCY_GREEN_MS:
+        return "rgba(0,255,128,0.8)"
+    if delta_ms < LATENCY_YELLOW_MS:
+        return "rgba(255,220,0,0.8)"
+    return "rgba(255,60,60,0.9)"
+def _build_html(points: list[dict], arcs: list[dict]) -> str:
+    pts = json.dumps(points)
+    acs = json.dumps(arcs)
+    return f"""<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>netpath — AS path globe</title>
+  <style>
+    body{{margin:0;background:#0a0a1a;overflow:hidden}}
+    #g{{width:100vw;height:100vh}}
+    #legend{{position:fixed;top:16px;right:16px;background:rgba(0,0,0,.75);
+            color:#ccc;font:13px monospace;padding:12px 16px;
+            border-radius:8px;border:1px solid #333}}
+    .r{{display:flex;align-items:center;gap:8px;margin:3px 0}}
+    .c{{width:12px;height:12px;border-radius:50%;flex-shrink:0}}
+  </style>
+</head>
+<body>
+  <div id="g"></div>
+  <div id="legend">
+    <b>Latency delta per hop</b>
+    <div class="r"><div class="c" style="background:#00ff80"></div>&lt; 20 ms</div>
+    <div class="r"><div class="c" style="background:#ffdc00"></div>20–79 ms</div>
+    <div class="r"><div class="c" style="background:#ff3c3c"></div>≥ 80 ms</div>
+  </div>
+  <script src="https://unpkg.com/globe.gl"></script>
+  <script>
+const G=Globe()
+  .globeImageUrl('https://unpkg.com/three-globe/example/img/earth-dark.jpg')
+  .backgroundImageUrl('https://unpkg.com/three-globe/example/img/night-sky.png')
+  .pointsData({pts})
+  .pointLat(d=>d.lat).pointLng(d=>d.lon)
+  .pointLabel(d=>d.label)
+  .pointColor(()=>'#00cfff').pointRadius(.4).pointAltitude(.01)
+  .arcsData({acs})
+  .arcStartLat(d=>d.sLat).arcStartLng(d=>d.sLon)
+  .arcEndLat(d=>d.eLat).arcEndLng(d=>d.eLon)
+  .arcColor(d=>d.color).arcAltitudeAutoScale(.4)
+  .arcStroke(1.5).arcDashLength(.4).arcDashGap(.2).arcDashAnimateTime(2000)
+  (document.getElementById('g'));
+G.controls().autoRotate=true;
+G.controls().autoRotateSpeed=.5;
+  </script>
+</body>
+</html>"""
+def render(hubs_by_asn: dict[str, list[dict]]) -> None:
+    """Geolocate hops, generate a Globe.gl HTML file, and open it in the browser."""
+    candidates: list[str] = []
+    seen_hosts: set[str] = set()
+    for hubs in hubs_by_asn.values():
+        for hub in hubs:
+            host = hub.get("host") or ""
+            if not host or host == "???":
+                continue
+            if _is_private(host):
+                continue
+            if host not in seen_hosts:
+                seen_hosts.add(host)
+                candidates.append(host)
+    if not candidates:
+        console.print(
+            Panel(
+                "  All hops are unresolvable or private IPs — globe skipped.",
+                title="[bold yellow]Globe[/bold yellow]",
+                border_style="yellow",
+                expand=False,
+            )
+        )
+        return
+    try:
+        geo = _geolocate(candidates)
+    except RuntimeError as e:
+        console.print(
+            Panel(
+                f"  Geolocation failed: {e}\n  Terminal probe results are unaffected.",
+                title="[bold yellow]Globe warning[/bold yellow]",
+                border_style="yellow",
+                expand=False,
+            )
+        )
+        return
+    if not geo:
+        console.print(
+            Panel(
+                "  No hops could be geolocated — globe skipped.",
+                title="[bold yellow]Globe[/bold yellow]",
+                border_style="yellow",
+                expand=False,
+            )
+        )
+        return
+    points: list[dict] = []
+    arcs: list[dict] = []
+    seen_pts: set[tuple[float, float]] = set()
+    for asn_str, hubs in hubs_by_asn.items():
+        geo_hops: list[dict] = []
+        for hub in hubs:
+            host = hub.get("host") or ""
+            if host and geo.get(host):
+                geo_hops.append({
+                    "lat": geo[host]["lat"],
+                    "lon": geo[host]["lon"],
+                    "count": hub.get("count", 0),
+                    "asn": hub.get("ASN") or asn_str,
+                    "avg_ms": float(hub.get("Avg") or 0),
+                })
+        for hop in geo_hops:
+            key = (hop["lat"], hop["lon"])
+            if key not in seen_pts:
+                seen_pts.add(key)
+                points.append({
+                    "lat": hop["lat"],
+                    "lon": hop["lon"],
+                    "label": f"Hop {hop['count']} · {hop['asn']}",
+                })
+        for i in range(1, len(geo_hops)):
+            prev, curr = geo_hops[i - 1], geo_hops[i]
+            delta = curr["avg_ms"] - prev["avg_ms"]
+            arcs.append({
+                "sLat": prev["lat"],
+                "sLon": prev["lon"],
+                "eLat": curr["lat"],
+                "eLon": curr["lon"],
+                "color": _arc_color(delta),
+            })
+    if not points:
+        console.print(
+            Panel(
+                "  No hops could be geolocated — globe skipped.",
+                title="[bold yellow]Globe[/bold yellow]",
+                border_style="yellow",
+                expand=False,
+            )
+        )
+        return
+    html = _build_html(points, arcs)
+    try:
+        out = Path(tempfile.mkdtemp()) / "netpath-globe.html"
+        out.write_text(html, encoding="utf-8")
+        if not webbrowser.open(out.as_uri()):
+            console.print(f"  [dim]Globe saved — open manually: {out}[/dim]")
+    except Exception as e:
+        console.print(f"  [yellow]Globe write failed: {e}[/yellow]")

netpath/iperf.py ADDED Viewed

@@ -0,0 +1,59 @@
+import json
+import shutil
+import subprocess
+def available() -> bool:
+    return shutil.which("iperf3") is not None
+def run_bidirectional(host: str, port: int = 5201, duration: int = 5) -> tuple[dict, dict]:
+    """
+    Run iperf3 upload then download to host:port.
+    Returns (upload_stats, download_stats) in the format display expects.
+    Raises RuntimeError on failure.
+    """
+    ul_raw = _run(host, port, duration, reverse=False)
+    dl_raw = _run(host, port, duration, reverse=True)
+    return _extract(ul_raw, reverse=False), _extract(dl_raw, reverse=True)
+def _run(host: str, port: int, duration: int, reverse: bool) -> dict:
+    cmd = ["iperf3", "-c", host, "-p", str(port), "-t", str(duration), "-J"]
+    if reverse:
+        cmd.append("-R")
+    try:
+        r = subprocess.run(cmd, capture_output=True, text=True, timeout=duration + 30)
+    except subprocess.TimeoutExpired:
+        raise RuntimeError("iperf3 timed out")
+    raw = r.stdout or r.stderr
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError:
+        raise RuntimeError((r.stderr or r.stdout).strip() or "iperf3 failed (no output)")
+    if r.returncode != 0:
+        err = data.get("error", "")
+        raise RuntimeError(err or (r.stderr.strip() or "iperf3 exited non-zero"))
+    return data
+def _extract(data: dict, reverse: bool) -> dict:
+    end = data.get("end", {})
+    if reverse:
+        s = end.get("sum_received", end.get("sum", {}))
+        return {
+            "bps":      s.get("bits_per_second", 0),
+            "recv_bps": s.get("bits_per_second", 0),
+            "bytes":    s.get("bytes", 0),
+        }
+    else:
+        s = end.get("sum_sent", end.get("sum", {}))
+        return {
+            "bps":         s.get("bits_per_second", 0),
+            "bytes":       s.get("bytes", 0),
+            "retransmits": s.get("retransmits"),
+        }

netpath/mtr.py ADDED Viewed

@@ -0,0 +1,197 @@
+import json
+import math
+import re
+import shutil
+import statistics
+import subprocess
+from .asn import cymru_bulk_lookup
+def _percentile(sorted_data: list, p: float) -> float:
+    """Nearest-rank percentile from a pre-sorted list. p is 0–100."""
+    n = len(sorted_data)
+    if n == 0:
+        return 0.0
+    idx = min(math.ceil(p / 100.0 * n) - 1, n - 1)
+    return sorted_data[max(0, idx)]
+def _enrich_percentiles(hub: dict) -> None:
+    """Add p50, p95, p99 to a hub dict using Avg+z*StDev estimation."""
+    if hub.get("Loss%", 0.0) >= 100.0:
+        hub["p50"] = None
+        hub["p95"] = None
+        hub["p99"] = None
+        return
+    avg = hub.get("Avg", 0.0)
+    std = hub.get("StDev", 0.0)
+    hub["p50"] = round(avg, 2)
+    hub["p95"] = round(avg + 1.645 * std, 2)
+    hub["p99"] = round(avg + 2.326 * std, 2)
+def available() -> bool:
+    return shutil.which("mtr") is not None
+_SOCKET_ERR_MARKERS = ("failure to open", "operation not permitted", "permission denied")
+_SUID_REFUSED = "should not run suid"
+class MtrPermissionError(RuntimeError):
+    pass
+def run(host: str, cycles: int = 10) -> list[dict]:
+    """
+    Run mtr in JSON report mode. Raises MtrPermissionError on raw socket
+    denial so the caller can fall back to traceroute.
+    """
+    cmd = ["mtr", "--json", "--report", f"--report-cycles={cycles}", "--aslookup", host]
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=cycles * 4 + 30)
+    except subprocess.TimeoutExpired:
+        raise RuntimeError("mtr timed out")
+    if result.returncode != 0:
+        stderr_lower = result.stderr.strip().lower()
+        if _SUID_REFUSED in stderr_lower or any(m in stderr_lower for m in _SOCKET_ERR_MARKERS):
+            raise MtrPermissionError(result.stderr.strip())
+        raise RuntimeError(result.stderr.strip() or "mtr exited non-zero")
+    try:
+        data = json.loads(result.stdout)
+        hubs = data["report"]["hubs"]
+        for hub in hubs:
+            _enrich_percentiles(hub)
+        return hubs
+    except (json.JSONDecodeError, KeyError) as e:
+        raise RuntimeError(f"Failed to parse mtr output: {e}")
+# ── traceroute fallback ───────────────────────────────────────────────────────
+def _parse_traceroute_output(output: str) -> list[dict]:
+    hubs = []
+    for line in output.splitlines():
+        line = line.strip()
+        if not line or not line[0].isdigit():
+            continue
+        m = re.match(r'^(\d+)\s+(.*)', line)
+        if not m:
+            continue
+        hop_num = int(m.group(1))
+        rest = m.group(2).strip()
+        if re.match(r'^[\*\s]+$', rest):
+            hubs.append({
+                "count": hop_num, "host": "???", "ASN": "AS???",
+                "Loss%": 100.0, "Avg": 0.0, "Best": 0.0, "Wrst": 0.0, "StDev": 0.0,
+                "p50": None, "p95": None, "p99": None,
+            })
+            continue
+        tokens = rest.split()
+        host = tokens[0]
+        rtts = []
+        stars = 0
+        i = 1
+        while i < len(tokens):
+            if tokens[i] == "*":
+                stars += 1
+                i += 1
+            elif i + 1 < len(tokens) and tokens[i + 1] == "ms":
+                try:
+                    rtts.append(float(tokens[i]))
+                except ValueError:
+                    pass
+                i += 2
+            else:
+                i += 1
+        total = len(rtts) + stars
+        loss_pct = (stars / total * 100.0) if total > 0 else 0.0
+        if not rtts:
+            hubs.append({
+                "count": hop_num, "host": host, "ASN": "AS???",
+                "Loss%": 100.0, "Avg": 0.0, "Best": 0.0, "Wrst": 0.0, "StDev": 0.0,
+                "p50": None, "p95": None, "p99": None,
+            })
+            continue
+        avg = sum(rtts) / len(rtts)
+        sorted_rtts = sorted(rtts)
+        hubs.append({
+            "count": hop_num,
+            "host": host,
+            "ASN": "AS???",
+            "Loss%": loss_pct,
+            "Avg": round(avg, 2),
+            "Best": round(min(rtts), 2),
+            "Wrst": round(max(rtts), 2),
+            "StDev": round(statistics.stdev(rtts) if len(rtts) > 1 else 0.0, 2),
+            "p50": round(_percentile(sorted_rtts, 50), 2),
+            "p95": round(_percentile(sorted_rtts, 95), 2),
+            "p99": round(_percentile(sorted_rtts, 99), 2),
+        })
+    return hubs
+def _all_stars(hubs: list[dict]) -> bool:
+    return bool(hubs) and all(h["host"] == "???" for h in hubs)
+def _run_traceroute_cmd(host: str, tcp: bool = False) -> list[dict]:
+    """
+    Run one traceroute pass.
+    Parameters tuned for fast failure: 1s wait, 15 hops, 2 probes → 30s worst case.
+    tcp=True uses TCP SYN to port 443 (requires pcap — may fail on macOS without privs).
+    """
+    cmd = ["/usr/sbin/traceroute", "-n", "-w", "1", "-m", "15", "-q", "2"]
+    if tcp:
+        cmd += ["-P", "tcp", "-p", "443"]
+    cmd.append(host)
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
+    except subprocess.TimeoutExpired:
+        raise RuntimeError("traceroute timed out")
+    if result.returncode != 0:
+        raise RuntimeError(result.stderr.strip() or "traceroute failed")
+    return _parse_traceroute_output(result.stdout)
+def run_traceroute(host: str, probes: int = 5) -> list[dict]:
+    """
+    Fallback when mtr lacks raw socket access.
+    Tries UDP first; if all hops are filtered, retries with TCP SYN (port 443).
+    TCP requires pcap — if that also fails (common on macOS), returns the
+    filtered UDP result rather than raising an error.
+    """
+    hubs = _run_traceroute_cmd(host, tcp=False)
+    if _all_stars(hubs):
+        try:
+            tcp_hubs = _run_traceroute_cmd(host, tcp=True)
+            if not _all_stars(tcp_hubs):
+                hubs = tcp_hubs
+        except RuntimeError:
+            pass  # pcap unavailable or path still filtered — keep UDP result
+    ips = [h["host"] for h in hubs if h["host"] != "???"]
+    if ips:
+        ip_asn = cymru_bulk_lookup(ips)
+        for hub in hubs:
+            if hub["host"] != "???":
+                hub["ASN"] = ip_asn.get(hub["host"], "AS???")
+    return hubs

netpath/rum.py ADDED Viewed

@@ -0,0 +1,55 @@
+import requests
+CF_API_BASE = "https://api.cloudflare.com/client/v4/radar"
+def fetch_asn_quality(asn: str, token: str, date_range: str = "7d") -> dict | None:
+    """
+    Fetch Cloudflare Radar speed + latency summary for an ASN.
+    Token needs the radar:read permission (free Cloudflare account).
+    Returns a flat dict of metrics, or None on failure.
+    """
+    asn_num = asn.lstrip("ASas")
+    headers = {"Authorization": f"Bearer {token}"}
+    params  = {"asn": asn_num, "dateRange": date_range}
+    try:
+        resp = requests.get(
+            f"{CF_API_BASE}/quality/speed/summary",
+            params=params,
+            headers=headers,
+            timeout=10,
+        )
+        if resp.status_code == 401:
+            raise ValueError("Cloudflare token invalid or missing radar:read permission")
+        resp.raise_for_status()
+        data = resp.json()
+    except ValueError:
+        raise
+    except Exception:
+        return None
+    if not data.get("success"):
+        return None
+    # The summary lives under result.summary_0
+    summary = data.get("result", {}).get("summary_0", {})
+    if not summary:
+        return None
+    def _f(key: str) -> float | None:
+        v = summary.get(key)
+        try:
+            return float(v) if v is not None else None
+        except (TypeError, ValueError):
+            return None
+    return {
+        "dl_mbps":       _f("bandwidthDownload"),
+        "ul_mbps":       _f("bandwidthUpload"),
+        "latency_idle":  _f("latencyIdle"),
+        "latency_loaded": _f("latencyLoaded"),
+        "jitter":        _f("jitter"),
+        "packet_loss":   _f("packetLoss"),
+        "date_range":    date_range,
+    }

netpath/servers.py ADDED Viewed

@@ -0,0 +1,69 @@
+import requests
+from .asn import resolve_hosts_parallel, cymru_bulk_lookup, normalize_asn
+SERVERS_URL = "https://export.iperf3serverlist.net/listed_iperf3_servers.json"
+# Module-level cache so the country command doesn't re-fetch + re-resolve for each ASN
+_resolved_cache: list[dict] | None = None
+def parse_port(port_str: str | None) -> int:
+    if not port_str:
+        return 5201
+    try:
+        return int(str(port_str).split("-")[0].split(",")[0].strip())
+    except (ValueError, AttributeError):
+        return 5201
+def _fetch_and_resolve() -> list[dict]:
+    """
+    Fetch the server list, resolve all hostnames, and bulk-lookup ASNs.
+    Result is cached for the lifetime of the process.
+    """
+    global _resolved_cache
+    if _resolved_cache is not None:
+        return _resolved_cache
+    resp = requests.get(SERVERS_URL, timeout=15)
+    resp.raise_for_status()
+    raw = resp.json()
+    if isinstance(raw, dict):
+        for key in ("servers", "data", "results"):
+            if key in raw:
+                raw = raw[key]
+                break
+    seen: set[str] = set()
+    unique: list[dict] = []
+    for s in raw:
+        host = (s.get("IP/HOST") or "").strip()
+        if host and host not in seen:
+            seen.add(host)
+            unique.append({**s, "HOST": host})
+    host_to_ip = resolve_hosts_parallel([s["HOST"] for s in unique])
+    ip_to_asn = cymru_bulk_lookup(list(set(host_to_ip.values())))
+    enriched = []
+    for s in unique:
+        ip = host_to_ip.get(s["HOST"])
+        if not ip:
+            continue
+        enriched.append({
+            **s,
+            "ip": ip,
+            "asn": ip_to_asn.get(ip, "AS???"),
+            "port": parse_port(s.get("PORT")),
+        })
+    _resolved_cache = enriched
+    return enriched
+def find_servers_in_asn(asn: str, max_count: int = 3) -> list[dict]:
+    """Return up to max_count iperf3 servers in the given ASN."""
+    target = normalize_asn(asn)
+    all_servers = _fetch_and_resolve()
+    found = [s for s in all_servers if s["asn"] == target]
+    return found[:max_count] if max_count > 0 else found

netpath/speedtest.py ADDED Viewed

@@ -0,0 +1,112 @@
+"""
+HTTP-based throughput measurement — no dedicated server required.
+Downloads from / uploads to speed.cloudflare.com, which has CDN nodes
+peered inside every major ISP globally. The measured throughput reflects
+the path from this host to the nearest Cloudflare PoP, which is typically
+inside the local ISP's network.
+"""
+import shutil
+import time
+import requests
+CF_DOWN_URL = "https://speed.cloudflare.com/__down"
+CF_UP_URL   = "https://speed.cloudflare.com/__up"
+# Payload sizes: ramp up to saturate the link quickly
+_DOWN_BYTES = 25_000_000   # 25 MB download probe
+_UP_BYTES   = 10_000_000   # 10 MB upload probe
+_TIMEOUT    = 30           # seconds per direction
+def _download(duration: int = 5) -> dict:
+    """Stream a download from Cloudflare and return throughput stats."""
+    start = time.monotonic()
+    total = 0
+    first_byte: float | None = None
+    with requests.get(
+        CF_DOWN_URL,
+        params={"bytes": _DOWN_BYTES},
+        stream=True,
+        timeout=_TIMEOUT,
+    ) as resp:
+        resp.raise_for_status()
+        deadline = start + duration
+        for chunk in resp.iter_content(chunk_size=65_536):
+            if first_byte is None:
+                first_byte = time.monotonic()
+            total += len(chunk)
+            if time.monotonic() >= deadline:
+                break
+    elapsed = time.monotonic() - start
+    ttfb_ms = (first_byte - start) * 1000 if first_byte else None
+    return {
+        "bps":     (total * 8) / elapsed if elapsed > 0 else 0,
+        "bytes":   total,
+        "elapsed": round(elapsed, 2),
+        "ttfb_ms": round(ttfb_ms, 1) if ttfb_ms else None,
+    }
+def _upload(duration: int = 5) -> dict:
+    """POST a zero-filled payload to Cloudflare and return throughput stats."""
+    payload_size = min(_UP_BYTES, duration * 20_000_000)  # ~20 MB/s cap on payload
+    start = time.monotonic()
+    resp = requests.post(
+        CF_UP_URL,
+        data=bytes(payload_size),
+        headers={"Content-Type": "application/octet-stream"},
+        timeout=_TIMEOUT,
+    )
+    resp.raise_for_status()
+    elapsed = time.monotonic() - start
+    return {
+        "bps":     (payload_size * 8) / elapsed if elapsed > 0 else 0,
+        "bytes":   payload_size,
+        "elapsed": round(elapsed, 2),
+    }
+def run(duration: int = 5) -> dict:
+    """
+    Run download + upload speed test against Cloudflare.
+    Returns {"download": {...}, "upload": {...}, "server": "speed.cloudflare.com"}.
+    """
+    try:
+        download = _download(duration)
+    except Exception as e:
+        raise RuntimeError(f"Download test failed: {e}")
+    try:
+        upload = _upload(duration)
+    except Exception as e:
+        raise RuntimeError(f"Upload test failed: {e}")
+    return {
+        "download": download,
+        "upload":   upload,
+        "server":   "speed.cloudflare.com",
+    }
+def extract_stats(result: dict) -> tuple[dict, dict]:
+    """Return (upload_stats, download_stats) in the format display expects."""
+    dl = result["download"]
+    ul = result["upload"]
+    upload_stats = {
+        "bps":         ul["bps"],
+        "bytes":       ul["bytes"],
+        "retransmits": None,
+    }
+    download_stats = {
+        "bps":      dl["bps"],
+        "recv_bps": dl["bps"],
+        "bytes":    dl["bytes"],
+        "ttfb_ms":  dl.get("ttfb_ms"),
+    }
+    return upload_stats, download_stats