ifpretty 0.1.0__py3-none-any.whl

ifpretty/__init__.py

@@ -0,0 +1,6 @@
+"""ifpretty — prettify and enrich `ifconfig` output."""
+
+from .cli import main
+
+__version__ = "0.1.0"
+__all__ = ["main", "__version__"]

ifpretty/__main__.py

@@ -0,0 +1,8 @@
+"""Enable `python -m ifpretty`."""
+
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

ifpretty/cli.py

@@ -0,0 +1,1215 @@
+"""ifpretty — render `ifconfig` output as aligned tables (using rich).
+
+Usage:
+    ifconfig | ifpretty            # boxed table per interface (default), borders aligned
+    ifconfig | ifpretty --records  # compact label/value record layout
+    ifconfig | ifpretty --table    # single wide table, all fields as columns (<=240)
+    ifconfig | ifpretty --live      # +route, traffic, friendly names, DNS, DHCP (macOS)
+    ifconfig | ifpretty --check     # +ping the default gateway for latency (macOS)
+    ifconfig | ifpretty --explain   # append a legend explaining the flags/options seen
+    ifconfig en0 | ifpretty
+
+Architecture (thin layers, one file):
+    MODEL    dataclasses Inet / Inet6 / Interface
+    PARSE    parse(text) -> list[Interface]
+    ENRICH   Tier 1 (pure derivation: role, IP scope, MAC kind+vendor, net info,
+             EUI-64, shared MACs, MTU/media notes) and Tier 2 (--live / --check:
+             route/netstat/networksetup/scutil/ipconfig/ping cross-reference)
+    FORMAT   value formatters — the single source of truth for how a value looks;
+             interface_fields() gives the canonical (label, value) ordering
+    RENDER   render_boxed / render_records / render_table  (selected via RENDERERS)
+
+Every field ifpretty understands is preserved; unmodeled lines (e.g. a bridge's
+config block) are kept verbatim and shown under the "bridge" label.
+"""
+
+from __future__ import annotations
+
+import argparse
+import gzip
+import importlib.resources
+import ipaddress
+import os
+import re
+import shutil
+import subprocess
+import sys
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Callable
+
+try:
+    from rich import box
+    from rich.console import Console
+    from rich.table import Table
+    from rich.text import Text
+except ImportError:
+    sys.exit(
+        "ifpretty: the 'rich' library is required.\n"
+        "  install it with:  python3 -m pip install rich"
+    )
+
+
+# ── MODEL ─────────────────────────────────────────────────────────────────────
+@dataclass(frozen=True)
+class Inet:
+    addr: str
+    netmask: str = ""  # already CIDR form, e.g. "255.255.255.0/24"
+    broadcast: str = ""
+
+
+@dataclass(frozen=True)
+class Inet6:
+    addr: str
+    prefixlen: str = ""
+    attrs: tuple[str, ...] = ()
+
+
+@dataclass
+class Interface:
+    name: str
+    mtu: str = ""
+    flags: list[str] = field(default_factory=list)
+    options: list[str] = field(default_factory=list)
+    ether: str = ""
+    inet: list[Inet] = field(default_factory=list)
+    inet6: list[Inet6] = field(default_factory=list)
+    nd6: list[str] = field(default_factory=list)
+    media: str = ""
+    status: str = ""
+    other: list[str] = field(default_factory=list)  # unmodeled lines, verbatim
+
+    # Tier-2 live enrichment (populated only with --live; -1 / "" mean "unknown")
+    hw_port: str = ""  # friendly name from networksetup, e.g. "Wi-Fi"
+    gateway: str = ""  # set on the default-route interface
+    is_default: bool = False
+    rx_bytes: int = -1
+    tx_bytes: int = -1
+    rx_pkts: int = -1
+    tx_pkts: int = -1
+    rx_errs: int = 0
+    tx_errs: int = 0
+    collisions: int = 0
+    dns: list[str] = field(default_factory=list)
+    search_domains: list[str] = field(default_factory=list)
+    dhcp_server: str = ""
+    dhcp_lease: int = -1  # seconds
+    gw_latency_ms: float = -1.0  # set by --check
+    gw_loss: bool = False
+    shares_mac_with: list[str] = field(default_factory=list)  # Tier-1 derivation
+    rx_hist: list[float] = field(default_factory=list)  # bytes/s, from --record history
+    tx_hist: list[float] = field(default_factory=list)
+
+    @property
+    def is_up(self) -> bool:
+        return "UP" in self.flags
+
+    @property
+    def role(self) -> str:
+        return interface_role(self.name)
+
+
+# ── PARSE ─────────────────────────────────────────────────────────────────────
+def hexmask_to_cidr(mask: str) -> str:
+    """Convert an ifconfig netmask (0xffffff00) to '255.255.255.0/24'."""
+    try:
+        value = int(mask, 16)
+    except ValueError:
+        return mask
+    octets = [(value >> shift) & 0xFF for shift in (24, 16, 8, 0)]
+    bits = bin(value).count("1")
+    return f"{'.'.join(map(str, octets))}/{bits}"
+
+
+# words that are values even though they're alphabetic (no digit/colon to give them away)
+_VALUE_WORDS = {
+    "stp",
+    "rstp",
+    "disabled",
+    "enabled",
+    "up",
+    "down",
+    "active",
+    "inactive",
+    "none",
+    "auto",
+}
+
+
+def _is_value(tok: str) -> bool:
+    if "=" in tok or tok.endswith(":"):
+        return False
+    if any(ch.isdigit() for ch in tok):
+        return True
+    if ":" in tok:  # mac / ipv6 fragment
+        return True
+    return tok.lower() in _VALUE_WORDS
+
+
+def kv_pairs(s: str) -> list[tuple[str, str]]:
+    """Split a multi-field line into (key, value) pairs.
+
+    Handles `key value` runs (multi-word keys allowed), `label:` headers, and
+    `name=hex<FLAG,FLAG>` blobs. Returns ('', value) for a bare value and
+    (label, '') for a header so the renderer can style each kind.
+    """
+    pairs: list[tuple[str, str]] = []
+    key_parts: list[str] = []
+
+    def flush_label() -> None:
+        if key_parts:
+            pairs.append((" ".join(key_parts), ""))
+            key_parts.clear()
+
+    for tok in s.split():
+        if "=" in tok:  # name=hex<FLAGS>  or  name=value
+            flush_label()
+            name, _, val = tok.partition("=")
+            fm = re.search(r"<([^>]*)>", val)
+            if fm:
+                val = "  ".join(f for f in fm.group(1).split(",") if f)
+            pairs.append((name, val))
+        elif tok.endswith(":"):  # completes a label phrase ("Address cache:")
+            key_parts.append(tok[:-1])
+        elif _is_value(tok):
+            pairs.append((" ".join(key_parts), tok))
+            key_parts.clear()
+        else:
+            key_parts.append(tok)
+    flush_label()
+    return pairs
+
+
+def _parse_inet(parts: list[str]) -> Inet:
+    addr = parts[1] if len(parts) > 1 else ""
+    netmask = broadcast = ""
+    i = 2
+    while i < len(parts) - 1:
+        if parts[i] == "netmask":
+            netmask = hexmask_to_cidr(parts[i + 1])
+        elif parts[i] == "broadcast":
+            broadcast = parts[i + 1]
+        i += 2
+    return Inet(addr, netmask, broadcast)
+
+
+def _parse_inet6(parts: list[str]) -> Inet6:
+    addr = parts[1] if len(parts) > 1 else ""
+    prefixlen = ""
+    attrs: list[str] = []
+    i = 2
+    while i < len(parts):
+        if parts[i] in ("prefixlen", "scopeid") and i + 1 < len(parts):
+            if parts[i] == "prefixlen":
+                prefixlen = parts[i + 1]
+            i += 2
+        else:
+            attrs.append(parts[i])
+            i += 1
+    return Inet6(addr, prefixlen, tuple(attrs))
+
+
+def _flags_in(rest: str) -> list[str]:
+    m = re.search(r"flags=\w+<([^>]*)>", rest)
+    return [f for f in m.group(1).split(",") if f] if m else []
+
+
+def parse(text: str) -> list[Interface]:
+    """Parse ifconfig text into a list of Interface records."""
+    interfaces: list[Interface] = []
+    cur: Interface | None = None
+
+    for raw in text.splitlines():
+        if not raw.strip():
+            continue
+
+        if not raw[0].isspace():  # interface header at column 0
+            m = re.match(r"^(\S+?):\s+(.*)$", raw)
+            name, rest = m.groups() if m else (raw.rstrip(":"), "")
+            mtu = re.search(r"mtu (\d+)", rest)
+            cur = Interface(
+                name=name, flags=_flags_in(rest), mtu=mtu.group(1) if mtu else ""
+            )
+            interfaces.append(cur)
+            continue
+
+        if cur is None:  # detail before any header — shouldn't happen
+            continue
+
+        s = raw.strip()
+        if s.startswith("inet "):
+            cur.inet.append(_parse_inet(s.split()))
+        elif s.startswith("inet6 "):
+            cur.inet6.append(_parse_inet6(s.split()))
+        elif s.startswith("ether "):
+            cur.ether = s.split(None, 1)[1]
+        elif s.startswith("status:"):
+            cur.status = s.split(":", 1)[1].strip()
+        elif s.startswith("media:"):
+            cur.media = s.split(":", 1)[1].strip()
+        elif m := re.match(r"^options=\w+<([^>]*)>$", s):
+            cur.options = [f for f in m.group(1).split(",") if f]
+        elif m := re.match(r"^nd6 options=\w+<([^>]*)>$", s):
+            cur.nd6 = [f for f in m.group(1).split(",") if f]
+        else:
+            cur.other.append(s)
+
+    return interfaces
+
+
+# ── ENRICH (Tier 1: pure derivation, offline, deterministic) ──────────────────
+_ROLES = {
+    "lo": "loopback",
+    "gif": "tunnel",
+    "stf": "6to4 tunnel",
+    "awdl": "Apple Wireless Direct",
+    "llw": "low-latency WLAN",
+    "utun": "VPN/tunnel",
+    "bridge": "bridge",
+    "ap": "access point",
+    "en": "Ethernet/Wi-Fi",
+    "anpi": "Apple private",
+}
+
+_ULA = ipaddress.ip_network("fc00::/7")
+
+
+def interface_role(name: str) -> str:
+    m = re.match(r"^([a-z]+)", name)
+    return _ROLES.get(m.group(1), "") if m else ""
+
+
+def mac_kind(ether: str) -> str:
+    """'universal' (burned-in) vs 'locally administered' (randomized/virtual)."""
+    if not ether:
+        return ""
+    try:
+        first = int(ether.split(":")[0], 16)
+    except ValueError:
+        return ""
+    if first & 0x01:
+        return "multicast"
+    return "locally administered" if first & 0x02 else "universal"
+
+
+# OUI vendor lookup, lazily loaded from the bundled IEEE registry (offline).
+_OUI: dict[str, str] | None = None
+
+
+def _load_oui() -> dict[str, str]:
+    global _OUI
+    if _OUI is None:
+        _OUI = {}
+        try:
+            res = importlib.resources.files("ifpretty").joinpath("data/oui.tsv.gz")
+            text = gzip.decompress(res.read_bytes()).decode("utf-8")
+            for line in text.splitlines():
+                prefix, _, org = line.partition("\t")
+                if org:
+                    _OUI[prefix] = org
+        except (OSError, FileNotFoundError, ModuleNotFoundError):
+            pass  # no bundled DB → vendor lookup silently disabled
+    return _OUI
+
+
+def mac_vendor(ether: str) -> str:
+    """IEEE-registered vendor for a universal MAC; '' for local/multicast/unknown."""
+    if mac_kind(ether) != "universal":
+        return ""
+    key = ether.replace(":", "").upper()[:6]
+    return _load_oui().get(key, "")
+
+
+def is_eui64(addr: str) -> bool:
+    """True if an IPv6 interface ID is derived from a MAC (modified EUI-64: ff:fe)."""
+    try:
+        ip = ipaddress.ip_address(addr.split("%")[0])
+    except ValueError:
+        return False
+    if ip.version != 6:
+        return False
+    iid = int(ip) & ((1 << 64) - 1)  # low 64 bits
+    return (iid >> 24) & 0xFFFF == 0xFFFE  # bytes 3-4 of the interface identifier
+
+
+def mtu_note(mtu: str) -> str:
+    if not mtu.isdigit():
+        return ""
+    n = int(mtu)
+    if n >= 9000:
+        return "   [dim]· jumbo frames[/]"
+    if n < 1280:
+        return "   [yellow]· below IPv6 minimum[/]"
+    return ""
+
+
+def derive_shared_macs(interfaces: list[Interface]) -> None:
+    """Tier 1: note interfaces that share an Ethernet address (e.g. bridge members)."""
+    seen: dict[str, list[str]] = {}
+    for i in interfaces:
+        if i.ether:
+            seen.setdefault(i.ether, []).append(i.name)
+    for i in interfaces:
+        peers = [n for n in seen.get(i.ether, []) if n != i.name]
+        i.shares_mac_with = peers
+
+
+def ip_scope(addr: str) -> str:
+    """Classify an address: loopback / link-local / ULA / private / global."""
+    try:
+        ip = ipaddress.ip_address(addr.split("%")[0])
+    except ValueError:
+        return ""
+    if ip.is_loopback:
+        return "loopback"
+    if ip.is_link_local:
+        return "link-local"
+    if ip.version == 6 and ip in _ULA:
+        return "ULA"
+    if ip.is_private:
+        return "private"
+    if ip.is_global:
+        return "global"
+    return "reserved"
+
+
+def ipv4_net_info(x: Inet) -> str:
+    """'net 192.168.1.0/24 · 254 hosts' from an IPv4 address + netmask."""
+    if "/" not in x.netmask:
+        return ""
+    try:
+        net = ipaddress.ip_network(f"{x.addr}/{x.netmask.split('/')[-1]}", strict=False)
+    except ValueError:
+        return ""
+    usable = net.num_addresses - 2 if net.prefixlen <= 30 else net.num_addresses
+    return f"net {net.with_prefixlen} · {usable} hosts"
+
+
+def humanize_bytes(n: int) -> str:
+    if n < 0:
+        return ""
+    size = float(n)
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if size < 1024 or unit == "TB":
+            return f"{size:.0f} {unit}" if unit == "B" else f"{size:.1f} {unit}"
+        size /= 1024
+    return f"{size:.1f} PB"
+
+
+def humanize_count(n: int) -> str:
+    if n < 0:
+        return ""
+    size = float(n)
+    for unit in ("", "k", "M", "G"):
+        if size < 1000 or unit == "G":
+            return f"{size:.0f}{unit}" if unit == "" else f"{size:.1f}{unit}"
+        size /= 1000
+    return f"{size:.1f}G"
+
+
+def humanize_secs(s: int) -> str:
+    if s < 0:
+        return ""
+    for limit, unit in ((86400, "d"), (3600, "h"), (60, "m")):
+        if s >= limit:
+            return f"{s // limit}{unit}"
+    return f"{s}s"
+
+
+def humanize_rate(bytes_per_s: float) -> str:
+    bits = bytes_per_s * 8
+    for unit in ("bps", "Kbps", "Mbps", "Gbps"):
+        if bits < 1000 or unit == "Gbps":
+            return f"{bits:.0f} {unit}" if unit == "bps" else f"{bits:.1f} {unit}"
+        bits /= 1000
+    return f"{bits:.1f} Gbps"
+
+
+_SPARK = "▁▂▃▄▅▆▇█"
+
+
+def sparkline(values: list[float]) -> str:
+    """Unicode block sparkline scaled 0..peak (single-width chars, alignment-safe)."""
+    if not values:
+        return ""
+    peak = max(values) or 1.0
+    return "".join(_SPARK[min(7, int(v / peak * 7.999))] for v in values)
+
+
+def bar(frac: float, width: int = 10) -> str:
+    """Horizontal gauge from full/light blocks (single-width, alignment-safe)."""
+    n = round(max(0.0, min(1.0, frac)) * width)
+    return "█" * n + "░" * (width - n)
+
+
+def link_mbps(media: str) -> int:
+    m = re.search(r"(\d+)(G?)[Bb]ase", media or "")
+    if not m:
+        return 0
+    return int(m.group(1)) * 1000 if m.group(2) == "G" else int(m.group(1))
+
+
+def media_note(media: str) -> str:
+    """Derive 'speed full-duplex' from a media string; warn on half-duplex."""
+    if not media:
+        return ""
+    parts = []
+    m = re.search(r"(\d+)(G?)[Bb]ase", media)
+    if m:
+        n = int(m.group(1))
+        if m.group(2) == "G":
+            parts.append(f"{n} Gbps")
+        elif n >= 1000 and n % 1000 == 0:
+            parts.append(f"{n // 1000} Gbps")
+        else:
+            parts.append(f"{n} Mbps")
+    if "full-duplex" in media:
+        parts.append("full-duplex")
+    out = f"   [dim]· {' '.join(parts)}[/]" if parts else ""
+    if "half-duplex" in media:
+        out += "   [yellow]⚠ half-duplex[/]"
+    return out
+
+
+def traffic_value(iface: Interface) -> str:
+    if iface.rx_bytes < 0:
+        return ""
+    rp = f" ({humanize_count(iface.rx_pkts)} pkts)" if iface.rx_pkts >= 0 else ""
+    tp = f" ({humanize_count(iface.tx_pkts)} pkts)" if iface.tx_pkts >= 0 else ""
+    return (
+        f"↓ {humanize_bytes(iface.rx_bytes)}{rp}"
+        f"   ↑ {humanize_bytes(iface.tx_bytes)}{tp}"
+    )
+
+
+def errors_value(iface: Interface) -> str:
+    """Non-empty only when traffic was collected (--live) and something is nonzero."""
+    if iface.rx_bytes < 0 or (iface.rx_errs == iface.tx_errs == iface.collisions == 0):
+        return ""
+    return f"in {iface.rx_errs}  out {iface.tx_errs}  coll {iface.collisions}"
+
+
+# ── ENRICH (Tier 2: local system cross-reference, opt-in via --live) ──────────
+def _run(cmd: list[str], timeout: float = 3.0) -> str | None:
+    """Run a helper command; return stdout, or None (with a stderr note) on failure."""
+    try:
+        r = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout)
+    except (OSError, subprocess.SubprocessError) as e:
+        print(f"ifpretty: --live: {cmd[0]} failed ({e})", file=sys.stderr)
+        return None
+    return r.stdout or None  # route(8) returns nonzero with no default route — tolerate
+
+
+def _apply_default_route(by_name: dict[str, Interface]) -> None:
+    out = _run(["route", "-n", "get", "default"])
+    if not out:
+        return
+    gateway = iface = ""
+    for line in out.splitlines():
+        line = line.strip()
+        if line.startswith("gateway:"):
+            gateway = line.split(":", 1)[1].strip()
+        elif line.startswith("interface:"):
+            iface = line.split(":", 1)[1].strip()
+    if iface in by_name:
+        by_name[iface].is_default = True
+        by_name[iface].gateway = gateway
+
+
+def _read_link_counters() -> dict[str, tuple[int, ...]]:
+    """{ifname: (rx_pkts, rx_errs, rx_bytes, tx_pkts, tx_errs, tx_bytes, coll)}."""
+    out: dict[str, tuple[int, ...]] = {}
+    text = _run(["netstat", "-ib"])
+    if not text:
+        return out
+    for line in text.splitlines()[1:]:
+        f = line.split()
+        if len(f) < 6 or not f[2].startswith("<Link"):
+            continue
+        nums = f[3:]
+        if nums and ":" in nums[0]:  # drop the MAC column when present
+            nums = nums[1:]
+        try:  # nums = [Ipkts, Ierrs, Ibytes, Opkts, Oerrs, Obytes, Coll]
+            vals = tuple(int(nums[i]) for i in range(6))
+        except (ValueError, IndexError):
+            continue
+        coll = int(nums[6]) if len(nums) > 6 and nums[6].isdigit() else 0
+        out[f[0]] = vals + (coll,)
+    return out
+
+
+def _apply_traffic(by_name: dict[str, Interface]) -> None:
+    for name, v in _read_link_counters().items():
+        if name in by_name:
+            i = by_name[name]
+            (
+                i.rx_pkts,
+                i.rx_errs,
+                i.rx_bytes,
+                i.tx_pkts,
+                i.tx_errs,
+                i.tx_bytes,
+                i.collisions,
+            ) = v
+
+
+def _apply_hw_ports(by_name: dict[str, Interface]) -> None:
+    out = _run(["networksetup", "-listallhardwareports"])
+    if not out:
+        return
+    port = ""
+    for line in out.splitlines():
+        line = line.strip()
+        if line.startswith("Hardware Port:"):
+            port = line.split(":", 1)[1].strip()
+        elif line.startswith("Device:"):
+            dev = line.split(":", 1)[1].strip()
+            if dev in by_name:
+                by_name[dev].hw_port = port
+
+
+def _apply_dns(by_name: dict[str, Interface]) -> None:
+    out = _run(["scutil", "--dns"])
+    if not out:
+        return
+    for block in re.split(r"resolver #\d+", out):
+        m = re.search(r"if_index\s*:\s*\d+\s*\(([^)]+)\)", block)
+        if not m or m.group(1) not in by_name:
+            continue
+        iface = by_name[m.group(1)]
+        for ns in re.findall(r"nameserver\[\d+\]\s*:\s*(\S+)", block):
+            if ns not in iface.dns:
+                iface.dns.append(ns)
+        for sd in re.findall(r"search domain\[\d+\]\s*:\s*(\S+)", block):
+            if sd not in iface.search_domains:
+                iface.search_domains.append(sd)
+
+
+def _apply_dhcp(by_name: dict[str, Interface]) -> None:
+    for name, iface in by_name.items():
+        if not iface.inet:  # only DHCP-capable (IPv4-configured) interfaces
+            continue
+        server = _run(["ipconfig", "getoption", name, "server_identifier"])
+        if server and server.strip():
+            iface.dhcp_server = server.strip()
+        lease = _run(["ipconfig", "getoption", name, "lease_time"])
+        if lease and lease.strip().isdigit():
+            iface.dhcp_lease = int(lease.strip())
+
+
+def enrich_live(interfaces: list[Interface]) -> None:
+    """Augment interfaces with route, traffic, names, DNS and DHCP lease."""
+    if sys.platform != "darwin":
+        print("ifpretty: --live enrichment is macOS-only; skipping", file=sys.stderr)
+        return
+    by_name = {i.name: i for i in interfaces}
+    _apply_default_route(by_name)
+    _apply_traffic(by_name)
+    _apply_hw_ports(by_name)
+    _apply_dns(by_name)
+    _apply_dhcp(by_name)
+
+
+def _apply_gateway_ping(interfaces: list[Interface]) -> None:
+    for iface in interfaces:
+        if not (iface.is_default and iface.gateway):
+            continue
+        out = _run(["ping", "-c", "2", "-t", "2", iface.gateway], timeout=5.0)
+        m = re.search(r"=\s*[\d.]+/([\d.]+)/", out) if out else None
+        if m:
+            iface.gw_latency_ms = float(m.group(1))
+        else:
+            iface.gw_loss = True
+
+
+def enrich_check(interfaces: list[Interface]) -> None:
+    """Active health probe (--check): ping the default gateway."""
+    if sys.platform != "darwin":
+        print("ifpretty: --check is macOS-only; skipping", file=sys.stderr)
+        return
+    by_name = {i.name: i for i in interfaces}
+    if not any(i.is_default for i in interfaces):
+        _apply_default_route(by_name)  # need the gateway if --live wasn't used
+    _apply_gateway_ping(interfaces)
+
+
+# ── ENRICH (bandwidth history: --record samples counters; rendered as a 1h graph)
+_HISTORY_WINDOW = 3600  # seconds of history kept / graphed
+_HISTORY_PATH = Path(
+    os.environ.get("IFPRETTY_HISTORY")
+    or Path.home() / ".cache" / "ifpretty" / "samples.csv"
+)
+
+
+def _load_samples() -> list[tuple[int, str, int, int]]:
+    """Each row: (epoch, ifname, rx_bytes, tx_bytes)."""
+    rows: list[tuple[int, str, int, int]] = []
+    try:
+        text = _HISTORY_PATH.read_text()
+    except OSError:
+        return rows
+    for line in text.splitlines():
+        parts = line.split(",")
+        if len(parts) != 4:
+            continue
+        try:
+            rows.append((int(parts[0]), parts[1], int(parts[2]), int(parts[3])))
+        except ValueError:
+            continue
+    return rows
+
+
+def record_sample() -> int:
+    """Append current per-interface byte counters to the history file (for --record)."""
+    if sys.platform != "darwin":
+        print("ifpretty: --record is macOS-only", file=sys.stderr)
+        return 1
+    counters = _read_link_counters()
+    if not counters:
+        print("ifpretty: --record: could not read counters", file=sys.stderr)
+        return 1
+    now = int(time.time())
+    cutoff = now - 2 * _HISTORY_WINDOW
+    rows = [r for r in _load_samples() if r[0] >= cutoff]
+    rows += [(now, name, v[2], v[5]) for name, v in counters.items()]
+    _HISTORY_PATH.parent.mkdir(parents=True, exist_ok=True)
+    _HISTORY_PATH.write_text("".join(f"{t},{n},{rx},{tx}\n" for t, n, rx, tx in rows))
+    return 0
+
+
+def _rates(points: list[tuple[int, int, int]]) -> tuple[list[float], list[float]]:
+    """Consecutive (ts, rx, tx) samples -> (rx_bytes/s, tx_bytes/s), resets clamped."""
+    rx_rates, tx_rates = [], []
+    for (t0, rx0, tx0), (t1, rx1, tx1) in zip(points, points[1:]):
+        dt = t1 - t0
+        if dt <= 0:
+            continue
+        rx_rates.append(max(0, rx1 - rx0) / dt)
+        tx_rates.append(max(0, tx1 - tx0) / dt)
+    return rx_rates, tx_rates
+
+
+def enrich_history(interfaces: list[Interface]) -> None:
+    """Attach the last hour of throughput rates from the --record datastore."""
+    samples = _load_samples()
+    if not samples:
+        return
+    now = max(ts for ts, _, _, _ in samples)
+    by_iface: dict[str, list[tuple[int, int, int]]] = {}
+    for ts, name, rx, tx in samples:
+        if now - ts <= _HISTORY_WINDOW:
+            by_iface.setdefault(name, []).append((ts, rx, tx))
+    for iface in interfaces:
+        pts = sorted(by_iface.get(iface.name, []))[-61:]  # ~1h at 1/min
+        iface.rx_hist, iface.tx_hist = _rates(pts)
+
+
+# ── FORMAT — single source of truth for how each value looks ───────────────────
+DASH = "[grey50]—[/]"
+
+
+def status_badge(iface: Interface) -> str:
+    if iface.status == "active":
+        return "[green]● active[/]"
+    if iface.status == "inactive":
+        return "[red]● inactive[/]"
+    return "[green]● up[/]" if iface.is_up else "[grey50]● down[/]"
+
+
+def _color_kv_line(line: str, sep: str = "  ") -> str:
+    """Color a verbatim multi-field line (bridge config) into key/value chunks."""
+    chunks = []
+    for k, v in kv_pairs(line):
+        if k and v:
+            chunks.append(f"[cyan]{k}[/] {v}")
+        elif k:
+            chunks.append(f"[bold]{k}[/]")
+        else:
+            chunks.append(v)
+    return sep.join(chunks) or f"[dim]{line}[/]"
+
+
+def inet_detail(x: Inet) -> str:
+    val = f"[bold green]{x.addr}[/]"
+    if x.netmask:
+        val += f"   netmask {x.netmask}"
+    if x.broadcast:
+        val += f"   broadcast {x.broadcast}"
+    ann = [a for a in (ip_scope(x.addr), ipv4_net_info(x)) if a]
+    if ann:
+        val += "   [dim]· " + " · ".join(ann) + "[/]"
+    return val
+
+
+# IPv6 attributes map to fixed display columns so they line up vertically.
+_V6_SLOTS = ("state", "config", "source")
+_V6_ATTR_SLOT = {
+    "deprecated": "state",
+    "detached": "state",
+    "tentative": "state",
+    "duplicated": "state",
+    "optimistic": "state",
+    "autoconf": "config",
+    "secured": "source",
+    "temporary": "source",
+    "dynamic": "source",
+}
+
+
+@dataclass
+class V6Layout:
+    """Column widths for aligning a single interface's IPv6 rows."""
+
+    addr_w: int = 0
+    slot_w: dict[str, int] = field(default_factory=lambda: {s: 0 for s in _V6_SLOTS})
+    extra_w: int = 0
+
+
+def _v6_slotted(attrs: tuple[str, ...]) -> tuple[dict[str, str], list[str]]:
+    slots: dict[str, list[str]] = {s: [] for s in _V6_SLOTS}
+    extra: list[str] = []
+    for a in attrs:
+        slot = _V6_ATTR_SLOT.get(a)
+        (slots[slot] if slot else extra).append(a)
+    return {s: " ".join(v) for s, v in slots.items()}, extra
+
+
+def plan_inet6(items: list[Inet6]) -> V6Layout:
+    layout = V6Layout()
+    for x in items:
+        addr = f"{x.addr}/{x.prefixlen}" if x.prefixlen else x.addr
+        layout.addr_w = max(layout.addr_w, len(addr))
+        slots, extra = _v6_slotted(x.attrs)
+        for s in _V6_SLOTS:
+            layout.slot_w[s] = max(layout.slot_w[s], len(slots[s]))
+        layout.extra_w = max(layout.extra_w, len(" ".join(extra)))
+    return layout
+
+
+def _pad(markup: str, visible: int, width: int) -> str:
+    """Right-pad `markup` to `width` columns, counting only `visible` chars."""
+    return markup + " " * max(0, width - visible)
+
+
+def fmt_inet6_aligned(x: Inet6, layout: V6Layout) -> str:
+    addr = f"{x.addr}/{x.prefixlen}" if x.prefixlen else x.addr
+    parts = [_pad(f"[bold magenta]{addr}[/]", len(addr), layout.addr_w)]
+    slots, extra = _v6_slotted(x.attrs)
+    for s in _V6_SLOTS:
+        if layout.slot_w[s]:
+            v = slots[s]
+            parts.append(_pad(f"[yellow]{v}[/]" if v else "", len(v), layout.slot_w[s]))
+    if layout.extra_w:
+        ex = " ".join(extra)
+        parts.append(_pad(f"[yellow]{ex}[/]" if ex else "", len(ex), layout.extra_w))
+    line = "   ".join(parts)
+    tail = [t for t in (ip_scope(x.addr), "EUI-64" if is_eui64(x.addr) else "") if t]
+    if tail:
+        line += "   [dim]· " + " · ".join(tail) + "[/]"
+    return line
+
+
+def ether_value(iface: Interface) -> str:
+    """MAC + (kind · vendor) + shared-with note."""
+    if not iface.ether:
+        return ""
+    out = f"[yellow]{iface.ether}[/]"
+    tags = [t for t in (mac_kind(iface.ether), mac_vendor(iface.ether)) if t]
+    if tags:
+        out += "   [dim](" + " · ".join(tags) + ")[/]"
+    if iface.shares_mac_with:
+        out += "   [dim]· shared with " + " ".join(iface.shares_mac_with) + "[/]"
+    return out
+
+
+def gateway_value(iface: Interface) -> str:
+    if not iface.gateway:
+        return ""
+    out = iface.gateway
+    if iface.gw_latency_ms >= 0:
+        out += f"   [dim]· {iface.gw_latency_ms:.1f} ms[/]"
+    elif iface.gw_loss:
+        out += "   [red]· unreachable[/]"
+    return out
+
+
+def dhcp_value(iface: Interface) -> str:
+    if not iface.dhcp_server:
+        return ""
+    lease = humanize_secs(iface.dhcp_lease)
+    return iface.dhcp_server + (f"   [dim]· lease {lease}[/]" if lease else "")
+
+
+def bandwidth_rows(iface: Interface) -> list[tuple[str, str]]:
+    """1h throughput sparklines + link-utilization gauge (only with --record data)."""
+    rows: list[tuple[str, str]] = []
+    if iface.rx_hist:
+        rows.append(
+            (
+                "1h in",
+                sparkline(iface.rx_hist)
+                + f"   [dim]peak {humanize_rate(max(iface.rx_hist))}[/]",
+            )
+        )
+    if iface.tx_hist:
+        rows.append(
+            (
+                "1h out",
+                sparkline(iface.tx_hist)
+                + f"   [dim]peak {humanize_rate(max(iface.tx_hist))}[/]",
+            )
+        )
+    spd = link_mbps(iface.media)
+    if iface.rx_hist and iface.tx_hist and spd:
+        frac = max(iface.rx_hist[-1], iface.tx_hist[-1]) * 8 / (spd * 1e6)
+        rows.append(
+            ("link use", f"{bar(frac)}   [dim]{frac * 100:.0f}% of {spd} Mbps[/]")
+        )
+    return rows
+
+
+def interface_fields(iface: Interface) -> list[tuple[str, str]]:
+    """Canonical ordered (label, styled-value) rows for the row-based layouts."""
+    rows: list[tuple[str, str]] = []
+
+    def add(label: str, value: str) -> None:
+        if value:
+            rows.append((label, value))
+
+    add("mtu", iface.mtu + mtu_note(iface.mtu) if iface.mtu else "")
+    add("flags", "  ".join(iface.flags))
+    add("options", "  ".join(iface.options))
+    add("ether", ether_value(iface))
+    for v4 in iface.inet:
+        add("inet", inet_detail(v4))
+    v6plan = plan_inet6(iface.inet6)
+    for v6 in iface.inet6:
+        add("inet6", fmt_inet6_aligned(v6, v6plan))
+    add("nd6 options", "  ".join(iface.nd6))
+    add("media", iface.media + media_note(iface.media) if iface.media else "")
+    add("dns", " ".join(iface.dns))  # Tier 2 (--live)
+    add("search", " ".join(iface.search_domains))
+    add("dhcp", dhcp_value(iface))
+    add("gateway", gateway_value(iface))
+    add("traffic", traffic_value(iface))
+    errs = errors_value(iface)
+    add("errors", f"[red]{errs}[/]" if errs else "")
+    for label, value in bandwidth_rows(iface):
+        add(label, value)
+    for i, line in enumerate(iface.other):
+        add("bridge" if i == 0 else "", _color_kv_line(line, sep="    "))
+    return rows
+
+
+# compact formatters for the column-oriented table layout
+def inet_compact(x: Inet) -> str:
+    bits = x.netmask.split("/")[-1] if "/" in x.netmask else ""
+    s = f"{x.addr}/{bits}" if bits else x.addr
+    if x.broadcast:
+        s += f" [dim]bcast {x.broadcast}[/]"
+    return s
+
+
+def inet6_compact(x: Inet6) -> str:
+    s = f"{x.addr}/{x.prefixlen}" if x.prefixlen else x.addr
+    if x.attrs:
+        s += " [yellow]" + " ".join(x.attrs) + "[/]"
+    return s
+
+
+def details_cell(iface: Interface) -> str:
+    """flags / options / nd6 / media / bridge-config as labeled lines (table view)."""
+    lines = []
+    if iface.flags:
+        lines.append("[dim cyan]flags[/] [green]" + " ".join(iface.flags) + "[/]")
+    if iface.options:
+        lines.append("[dim cyan]opts [/] " + " ".join(iface.options))
+    if iface.nd6:
+        lines.append("[dim cyan]nd6  [/] " + " ".join(iface.nd6))
+    if iface.media:
+        lines.append("[dim cyan]media[/] " + iface.media + media_note(iface.media))
+    if iface.dns:
+        lines.append("[dim cyan]dns  [/] " + " ".join(iface.dns))
+    if iface.search_domains:
+        lines.append("[dim cyan]srch [/] " + " ".join(iface.search_domains))
+    if dhcp_value(iface):
+        lines.append("[dim cyan]dhcp [/] " + dhcp_value(iface))
+    if gateway_value(iface):
+        lines.append("[dim cyan]gw   [/] " + gateway_value(iface))
+    if traffic_value(iface):
+        lines.append("[dim cyan]traf [/] " + traffic_value(iface))
+    if errors_value(iface):
+        lines.append("[dim cyan]err  [/] [red]" + errors_value(iface) + "[/]")
+    for label, value in bandwidth_rows(iface):
+        lines.append(f"[dim cyan]{label:<5}[/] {value}")
+    lines += [_color_kv_line(line) for line in iface.other]
+    return "\n".join(lines) or DASH
+
+
+def caption_suffix(iface: Interface) -> str:
+    """Role / friendly-name / default-route badge appended to an interface header."""
+    parts = []
+    label = iface.hw_port or iface.role
+    if label:
+        parts.append(f"[cyan]{label}[/]")
+    if iface.is_default:
+        parts.append("[green]default ↑[/]")
+    return ("  ·  " + "  ·  ".join(parts)) if parts else ""
+
+
+# ── RENDER — strategies over the same model/formatters ─────────────────────────
+def _console(non_tty_width: int) -> Console:
+    return Console(width=None if sys.stdout.isatty() else non_tty_width)
+
+
+def render_boxed(interfaces: list[Interface]) -> None:
+    """Boxed table per interface; every box shares one width so borders align."""
+    console = _console(200)
+    all_rows = [interface_fields(iface) for iface in interfaces]
+    label_w = max(
+        (len(lbl) for rows in all_rows for lbl, _ in rows), default=len("nd6 options")
+    )
+    value_w = max(
+        (Text.from_markup(val).cell_len for rows in all_rows for _, val in rows),
+        default=1,
+    )
+
+    for iface, rows in zip(interfaces, all_rows):
+        table = Table(
+            box=box.ROUNDED,
+            show_header=False,
+            title=f"[bold blue]{iface.name}[/]  {status_badge(iface)}"
+            f"{caption_suffix(iface)}",
+            title_justify="left",
+        )
+        table.add_column(
+            "Field", style="cyan", justify="right", width=label_w, no_wrap=True
+        )
+        table.add_column("Value", width=value_w, no_wrap=True)
+        for label, value in rows:
+            table.add_row(label, value)
+        console.print(table)
+
+
+def render_records(interfaces: list[Interface]) -> None:
+    """Compact label/value blocks — width bounded by the longest line."""
+    console = _console(100)
+    all_rows = [interface_fields(iface) for iface in interfaces]
+    label_w = max((len(lbl) for rows in all_rows for lbl, _ in rows), default=1)
+
+    for i, (iface, rows) in enumerate(zip(interfaces, all_rows)):
+        if i:
+            console.print()
+        mtu = f"  ·  [dim]mtu {iface.mtu}[/]" if iface.mtu else ""
+        console.print(
+            f"[bold blue]{iface.name}[/]  {status_badge(iface)}"
+            f"{caption_suffix(iface)}{mtu}"
+        )
+        for label, value in rows:
+            if label == "mtu":  # already shown in the header
+                continue
+            console.print(f"  [cyan]{label:<{label_w}}[/] {value}")
+
+
+def render_table(interfaces: list[Interface]) -> None:
+    """All interfaces and all fields in one wide table; cap width at 240."""
+    cap = 240
+    term = shutil.get_terminal_size((cap, 24)).columns if sys.stdout.isatty() else cap
+    console = Console(width=min(term, cap))
+
+    table = Table(
+        box=box.ROUNDED, header_style="bold cyan", title="ifconfig", show_lines=True
+    )
+    table.add_column("Interface", no_wrap=True)
+    table.add_column("Status", no_wrap=True)
+    table.add_column("MTU", justify="right", style="dim", no_wrap=True)
+    table.add_column("MAC", style="yellow", no_wrap=True)
+    table.add_column("IPv4", style="green", no_wrap=True)
+    table.add_column("IPv6", style="magenta", no_wrap=True)
+    table.add_column("Details")
+
+    for iface in interfaces:
+        name_cell = f"[bold blue]{iface.name}[/]"
+        sub = iface.hw_port or iface.role
+        if sub:
+            name_cell += f"\n[dim]{sub}[/]"
+        if iface.is_default:
+            name_cell += "\n[green]default ↑[/]"
+        table.add_row(
+            name_cell,
+            status_badge(iface),
+            iface.mtu or DASH,
+            iface.ether or DASH,
+            "\n".join(inet_compact(x) for x in iface.inet) or DASH,
+            "\n".join(inet6_compact(x) for x in iface.inet6) or DASH,
+            details_cell(iface),
+        )
+    console.print(table)
+
+
+def render_overview(interfaces: list[Interface]) -> None:
+    """One-line summary above the layout (shown only when >1 interface)."""
+    console = _console(120)
+    up = sum(1 for i in interfaces if i.is_up)
+    parts = [f"[bold]{len(interfaces)}[/] interfaces", f"[green]{up} up[/]"]
+    default = next((i for i in interfaces if i.is_default), None)
+    if default:
+        gw = f" ({default.gateway})" if default.gateway else ""
+        parts.append(f"default via [bold blue]{default.name}[/]{gw}")
+    live = [i for i in interfaces if i.rx_bytes >= 0]
+    if live:
+        rx = sum(i.rx_bytes for i in live)
+        tx = sum(i.tx_bytes for i in live)
+        parts.append(f"↓ {humanize_bytes(rx)}  ↑ {humanize_bytes(tx)}")
+    console.print("  ·  ".join(parts))
+    console.print()
+
+
+Renderer = Callable[[list[Interface]], None]
+RENDERERS: dict[str, Renderer] = {
+    "boxed": render_boxed,
+    "records": render_records,
+    "table": render_table,
+}
+
+
+# ── EXPLAIN — flag/option glossary (--explain) ────────────────────────────────
+_GLOSSARY = {
+    # flags
+    "UP": "interface is up",
+    "DOWN": "interface is down",
+    "BROADCAST": "supports broadcast",
+    "MULTICAST": "supports multicast",
+    "LOOPBACK": "loopback interface",
+    "POINTOPOINT": "point-to-point link",
+    "RUNNING": "resources allocated",
+    "SIMPLEX": "can't hear its own transmissions",
+    "SMART": "managed by the system",
+    "PROMISC": "promiscuous (sees all traffic)",
+    "NOARP": "ARP disabled",
+    # options (hardware offloads etc.)
+    "RXCSUM": "hardware RX checksum offload",
+    "TXCSUM": "hardware TX checksum offload",
+    "TSO4": "TCP segmentation offload (IPv4)",
+    "TSO6": "TCP segmentation offload (IPv6)",
+    "LRO": "large receive offload",
+    "VLAN_MTU": "VLAN-sized MTU support",
+    "CHANNEL_IO": "multi-queue channel I/O",
+    "PARTIAL_CSUM": "partial checksum offload",
+    "ZEROINVERT_CSUM": "zero-invert checksum offload",
+    "TXSTATUS": "TX completion status",
+    "SW_TIMESTAMP": "software packet timestamping",
+    # nd6
+    "PERFORMNUD": "neighbor unreachability detection",
+    "DAD": "duplicate address detection",
+    "IFDISABLED": "IPv6 disabled on this interface",
+}
+
+
+def render_legend(interfaces: list[Interface]) -> None:
+    console = Console(width=None if sys.stdout.isatty() else 100)
+    sections = [
+        ("flags", sorted({t for i in interfaces for t in i.flags})),
+        ("options", sorted({t for i in interfaces for t in i.options})),
+        ("nd6", sorted({t for i in interfaces for t in i.nd6})),
+    ]
+    console.print("\n[bold]Legend[/]")
+    for title, tokens in sections:
+        if not tokens:
+            continue
+        console.print(f"[dim cyan]{title}[/]")
+        for tok in tokens:
+            desc = _GLOSSARY.get(tok, "[dim](no description)[/]")
+            console.print(f"  [green]{tok:<16}[/] {desc}")
+
+
+# ── CLI ───────────────────────────────────────────────────────────────────────
+def _cli() -> int:
+    p = argparse.ArgumentParser(
+        prog="ifpretty",
+        description="Prettify `ifconfig` output. Pipe ifconfig into me.",
+        epilog="bandwidth graph: schedule `* * * * * %s --record` (cron/launchd) to "
+        "sample counters; the 1h sparkline then appears automatically."
+        % (shutil.which("ifpretty") or "ifpretty"),
+    )
+    g = p.add_mutually_exclusive_group()
+    g.add_argument(
+        "-r",
+        "--records",
+        dest="layout",
+        action="store_const",
+        const="records",
+        help="compact label/value record layout",
+    )
+    g.add_argument(
+        "-t",
+        "--table",
+        dest="layout",
+        action="store_const",
+        const="table",
+        help="single wide table, all fields as columns",
+    )
+    p.add_argument(
+        "-l",
+        "--live",
+        action="store_true",
+        help="enrich with live system data (macOS: route, traffic, "
+        "friendly names, DNS, DHCP lease)",
+    )
+    p.add_argument(
+        "-c",
+        "--check",
+        action="store_true",
+        help="ping the default gateway and report latency (macOS)",
+    )
+    p.add_argument(
+        "--record",
+        action="store_true",
+        help="sample byte counters into the history file and exit "
+        "(run periodically via cron to feed the 1h graph)",
+    )
+    p.add_argument(
+        "-x",
+        "--explain",
+        action="store_true",
+        help="append a legend explaining the flags/options seen",
+    )
+    p.set_defaults(layout="boxed")
+    args = p.parse_args()
+
+    if args.record:  # no stdin needed; samples counters and exits
+        return record_sample()
+
+    data = sys.stdin.read()
+    if not data.strip():
+        print("ifpretty: no input (pipe `ifconfig` into me)", file=sys.stderr)
+        return 1
+
+    interfaces = parse(data)
+    if args.live:
+        enrich_live(interfaces)
+    if args.check:
+        enrich_check(interfaces)
+    derive_shared_macs(interfaces)  # Tier 1: always-on, deterministic
+    enrich_history(interfaces)  # 1h bandwidth from the --record datastore
+    if len(interfaces) > 1:
+        render_overview(interfaces)
+    RENDERERS[args.layout](interfaces)
+    if args.explain:
+        render_legend(interfaces)
+    return 0
+
+
+def main() -> int:
+    """Console-script entry point: run and translate signals to exit codes."""
+    try:
+        return _cli()
+    except BrokenPipeError:
+        return 0
+    except KeyboardInterrupt:
+        return 130
+
+
+if __name__ == "__main__":
+    sys.exit(main())

ifpretty-0.1.0.dist-info/METADATA

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: ifpretty
+Version: 0.1.0
+Summary: Prettify and enrich ifconfig output: aligned tables, IP/MAC/scope annotations, OUI vendor lookup, live DNS/DHCP/route, and a 1h bandwidth graph.
+Author-email: iklo <tiktachack@gmail.com>
+License: MIT
+Keywords: ifconfig,network,networking,cli,terminal,rich,macos
+Classifier: Environment :: Console
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13
+Dynamic: license-file
+
+# ifpretty
+
+Prettify and **enrich** `ifconfig` output — aligned tables, color, decoded flags,
+IP/MAC/scope annotations, OUI vendor lookup, live DNS/DHCP/route, and a 1‑hour
+bandwidth graph. Built on [rich](https://github.com/Textualize/rich); macOS‑focused.
+
+```
+ifconfig | ifpretty
+```
+
+## Install
+
+```sh
+pip install ifpretty
+```
+
+## Usage
+
+```sh
+ifconfig | ifpretty            # boxed table per interface (default), borders aligned
+ifconfig | ifpretty --records  # compact label/value record layout
+ifconfig | ifpretty --table    # single wide table, all fields as columns (<=240)
+ifconfig | ifpretty --live      # + route, traffic, friendly names, DNS, DHCP (macOS)
+ifconfig | ifpretty --check     # + ping the default gateway for latency (macOS)
+ifconfig | ifpretty --explain   # append a legend explaining the flags/options seen
+ifconfig en0 | ifpretty
+```
+
+It reads raw `ifconfig` on **stdin**, so you stay in control of which interfaces
+to show.
+
+## What it adds
+
+**Always on (offline, deterministic):**
+
+- Per‑interface **role** (loopback / Ethernet·Wi‑Fi / VPN·tunnel / bridge / …).
+- **IP scope** for every address — loopback / link‑local / ULA / private / global —
+  plus IPv4 network + usable‑host count.
+- **MAC** kind (universal vs locally‑administered), **OUI vendor** (bundled IEEE
+  registry, no network), shared‑MAC notes (e.g. bridge members), and EUI‑64 detection.
+- **Media** speed/duplex with a half‑duplex ⚠ warning; jumbo / sub‑1280 MTU notes.
+- Decoded flag/option/nd6 bitfields; aligned IPv6 attribute columns.
+
+**`--live` (macOS, cross‑references the system):**
+
+- Default route + gateway, friendly hardware‑port names, per‑interface DNS and
+  search domains, DHCP server + lease, traffic counters (bytes + packets) and
+  error/collision counts.
+
+**`--check`:** pings the default gateway and reports latency.
+
+**1‑hour bandwidth graph:** schedule the recorder, then a Unicode sparkline of
+the last hour appears automatically:
+
+```sh
+# once, e.g. in crontab -e
+* * * * * /usr/local/bin/ifpretty --record
+```
+
+```
+1h in  ▁▁▁▂▄█▅▂▁▁▁▁   peak 10.0 Mbps
+1h out ▁▂▂▄▆█▄▂▂▁▁▁   peak 533.3 Kbps
+```
+
+History is stored at `~/.cache/ifpretty/samples.csv` (override with
+`IFPRETTY_HISTORY`).
+
+## Notes
+
+- Colors auto‑disable when piped; force with `CLICOLOR_FORCE=1`, disable with `NO_COLOR=1`.
+- `--live` / `--check` / `--record` use macOS tools (`route`, `netstat`,
+  `networksetup`, `scutil`, `ipconfig`, `ping`) and no‑op elsewhere.
+
+## License
+
+MIT

ifpretty-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+ifpretty/__init__.py,sha256=PTN2KgYem_jt0VzqfftwuU6ncCRzC-Yv-2zlLpAjMDA,138
+ifpretty/__main__.py,sha256=uZnYIf4DigA8XAM1rpBcnl_kZMNAMlS6Q_rnM4UMXCo,119
+ifpretty/cli.py,sha256=f9LyToh9MPbxKebmeZxFB3KGuzkCuTRFVKTVgEY0_DM,41740
+ifpretty/data/oui.tsv.gz,sha256=SsoMSzpQCkfd5iA2Gu-aGpPMzhY7gpIg0h6o1q0o9b0,383392
+ifpretty-0.1.0.dist-info/licenses/LICENSE,sha256=BmnKRIJzpO5vnb3_d58OfVyK6hLXjgMoRoGcNHkHVsc,1061
+ifpretty-0.1.0.dist-info/METADATA,sha256=V5AEmhmGJM43ZkRiliLYi7AeyYfDktz4O9t1pG3bTr4,3435
+ifpretty-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+ifpretty-0.1.0.dist-info/entry_points.txt,sha256=pXnVylPg1NGTJ3tw5KhEqEuOpoAq9B6Vo2wvfDA6sOU,47
+ifpretty-0.1.0.dist-info/top_level.txt,sha256=DQdGS2WYCG9iSqYevTVLX__L_4hcuEKfAt10Sm6Hm6M,9
+ifpretty-0.1.0.dist-info/RECORD,,

ifpretty-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ifpretty-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ifpretty = ifpretty.cli:main

ifpretty-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 iklo
+
+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.

ifpretty-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ifpretty