systemreports 2.0.0__py3-none-any.whl

systemreports/__init__.py

@@ -0,0 +1,3 @@
+"""Cross-platform system report collection and web dashboard."""
+
+__version__ = "2.0.0"

systemreports/__main__.py

@@ -0,0 +1,4 @@
+from systemreports.cli import main
+
+if __name__ == "__main__":
+    main()

systemreports/app.py

@@ -0,0 +1,34 @@
+"""Flask app serving the system report dashboard."""
+
+from __future__ import annotations
+
+import os
+
+from flask import Flask, jsonify, render_template, request
+
+from systemreports.collector import collect_report
+
+
+def create_app() -> Flask:
+    root = os.path.dirname(os.path.abspath(__file__))
+    app = Flask(
+        __name__,
+        template_folder=os.path.join(root, "templates"),
+        static_folder=os.path.join(root, "static"),
+    )
+
+    @app.route("/")
+    def index():
+        return render_template("index.html")
+
+    @app.route("/api/report")
+    def api_report():
+        ports = request.args.get("ports", "1").lower() not in ("0", "false", "no")
+        return jsonify(collect_report(include_listen_ports=ports))
+
+    return app
+
+
+def run_server(host: str = "127.0.0.1", port: int = 5050, debug: bool = False) -> None:
+    app = create_app()
+    app.run(host=host, port=port, debug=debug, threaded=True)

systemreports/cli.py

@@ -0,0 +1,78 @@
+"""Command-line entry: web dashboard or legacy text report."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import webbrowser
+
+
+def _print_text_report() -> None:
+    """Original-style console output using the new collector."""
+    from systemreports.collector import collect_report
+
+    r = collect_report(include_listen_ports=False)
+    cpu = r["cpu"]
+    mem = r["memory"]
+    sysinfo = r["system"]
+    disk = r["disk"]
+    net = r["network"]
+    up = r["uptime"]
+    load = cpu["load_average"]
+    load_s = (
+        f"({load['1m']}, {load['5m']}, {load['15m']})" if load else "N/A (not available on this OS)"
+    )
+    print("This System Report is Generated on :-", r["generated_at"])
+    print("=========================================================")
+    print("Name of Operating System is      :- ", sysinfo["os"], sysinfo["release"])
+    print("Host Name                        :- ", sysinfo["node"])
+    print("Load Average                     :- ", load_s)
+    print("System Architecture              :- ", sysinfo["machine"])
+    print("Kernel / version detail          :- ", sysinfo["version"][:120])
+    print("CPU model                        :- ", cpu["model"])
+    print("CPU cores (physical / logical)   :- ", cpu["physical_cores"], "/", cpu["logical_cores"])
+    print("CPU usage %                      :- ", cpu["usage_percent"])
+    print("root Disk mount                  :- ", disk["mount"])
+    print("Disk total / used / free (GB)    :- ", disk["total_gb"], "/", disk["used_gb"], "/", disk["free_gb"])
+    print("Memory total / used / free (GB)  :- ", mem["total_gb"], "/", mem["used_gb"], "/", mem["free_gb"])
+    print("Swap used (GB) / %               :- ", mem["swap_used_gb"], "/", mem["swap_percent"])
+    print("Process count                    :- ", r["processes"]["count"])
+    print("Uptime (seconds)                 :- ", up["seconds"])
+    print("Last boot (local)                :- ", up["boot_time_iso"])
+    print("Primary IPv4                     :- ", net["primary_ipv4"])
+    print("DNS google.com                   :- ", net["dns_google_reachable"])
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(description="System report: web dashboard or CLI output.")
+    p.add_argument("--cli", action="store_true", help="Print text report to the console.")
+    p.add_argument("--json", action="store_true", help="Print full JSON report to stdout.")
+    p.add_argument("--host", default="127.0.0.1", help="Bind address for --serve.")
+    p.add_argument("--port", type=int, default=5050, help="Port for --serve.")
+    p.add_argument("--no-browser", action="store_true", help="Do not open a browser with --serve.")
+    p.add_argument("--debug", action="store_true", help="Flask debug mode (dev only).")
+    args = p.parse_args()
+
+    if args.json:
+        from systemreports.collector import collect_report
+
+        print(json.dumps(collect_report(), indent=2))
+        return
+
+    if args.cli:
+        _print_text_report()
+        return
+
+    # Default: web dashboard
+    if not args.no_browser:
+        url = f"http://{args.host}:{args.port}/"
+        if args.host in ("0.0.0.0", "::"):
+            url = f"http://127.0.0.1:{args.port}/"
+        webbrowser.open(url)
+    from systemreports.app import run_server
+
+    run_server(host=args.host, port=args.port, debug=args.debug)
+
+
+if __name__ == "__main__":
+    main()

systemreports/collector.py

@@ -0,0 +1,268 @@
+"""Gather system metrics on Windows, macOS, and Linux."""
+
+from __future__ import annotations
+
+import os
+import platform
+import socket
+import sys
+import time
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+import psutil
+
+
+def _root_fs_path() -> str:
+    if os.name == "nt":
+        drive = os.environ.get("SystemDrive", "C:")
+        return drive + (os.sep if not drive.endswith(("\\", "/")) else "")
+    return "/"
+
+
+def _bytes_to_gb(n: float) -> float:
+    return round(n / (1024**3), 2)
+
+
+def _bytes_to_mb(n: float) -> float:
+    return round(n / (1024**2), 2)
+
+
+def _safe_iso(ts: float) -> str:
+    return datetime.fromtimestamp(ts, tz=timezone.utc).astimezone().strftime("%Y-%m-%d %H:%M:%S %Z")
+
+
+def _cpu_model() -> str:
+    proc = platform.processor() or ""
+    if proc.strip():
+        return proc.strip()
+    if sys.platform == "darwin":
+        try:
+            import subprocess
+
+            out = subprocess.check_output(["sysctl", "-n", "machdep.cpu.brand_string"])
+            return out.decode("utf-8", errors="ignore").strip()
+        except (OSError, subprocess.CalledProcessError):
+            pass
+    if sys.platform.startswith("linux"):
+        try:
+            with open("/proc/cpuinfo", encoding="utf-8", errors="ignore") as f:
+                for line in f:
+                    if line.lower().startswith("model name"):
+                        return line.split(":", 1)[1].strip()
+        except OSError:
+            pass
+    return "Unknown"
+
+
+def _load_average() -> Optional[Dict[str, float]]:
+    try:
+        one, five, fifteen = os.getloadavg()
+        return {"1m": round(one, 2), "5m": round(five, 2), "15m": round(fifteen, 2)}
+    except (AttributeError, OSError):
+        return None
+
+
+def _disk_io() -> Optional[Dict[str, Any]]:
+    try:
+        io = psutil.disk_io_counters(perdisk=False)
+        if io is None:
+            return None
+        return {
+            "read_bytes": io.read_bytes,
+            "write_bytes": io.write_bytes,
+            "read_count": io.read_count,
+            "write_count": io.write_count,
+        }
+    except (RuntimeError, PermissionError):
+        return None
+
+
+def _network_interfaces() -> List[Dict[str, Any]]:
+    out: List[Dict[str, Any]] = []
+    addrs = psutil.net_if_addrs()
+    stats = psutil.net_if_stats()
+    for name, addr_list in addrs.items():
+        entry: Dict[str, Any] = {"name": name, "addresses": [], "is_up": None, "speed_mbps": None}
+        st = stats.get(name)
+        if st:
+            entry["is_up"] = st.isup
+            entry["speed_mbps"] = st.speed if st.speed > 0 else None
+        for a in addr_list:
+            if a.family == socket.AF_INET:
+                entry["addresses"].append({"family": "IPv4", "address": a.address, "netmask": a.netmask})
+            elif a.family == socket.AF_INET6:
+                entry["addresses"].append({"family": "IPv6", "address": a.address, "netmask": a.netmask})
+            elif hasattr(psutil, "AF_LINK") and a.family == psutil.AF_LINK:
+                entry["addresses"].append({"family": "MAC", "address": a.address})
+        out.append(entry)
+    return sorted(out, key=lambda x: x["name"])
+
+
+def _primary_ipv4() -> Optional[str]:
+    try:
+        return socket.gethostbyname(socket.gethostname())
+    except OSError:
+        pass
+    for iface in _network_interfaces():
+        for a in iface["addresses"]:
+            if a.get("family") == "IPv4" and not a["address"].startswith("127."):
+                return a["address"]
+    return None
+
+
+def _listen_ports(limit: int = 80) -> Dict[str, Any]:
+    try:
+        conns = psutil.net_connections(kind="inet")
+        ports = sorted(
+            {c.laddr.port for c in conns if c.status == psutil.CONN_LISTEN and c.laddr}
+        )
+        return {"available": True, "ports": ports[:limit], "truncated": len(ports) > limit}
+    except (psutil.AccessDenied, PermissionError):
+        return {
+            "available": False,
+            "ports": [],
+            "message": "Elevated permissions required to list listening ports on this OS.",
+        }
+
+
+def _top_processes_cpu(n: int = 8) -> List[Dict[str, Any]]:
+    for p in psutil.process_iter(["pid", "name"]):
+        try:
+            p.cpu_percent(interval=None)
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            pass
+    time.sleep(0.15)
+    procs: List[Dict[str, Any]] = []
+    for p in psutil.process_iter(["pid", "name", "cpu_percent", "memory_percent"]):
+        try:
+            cpu = p.cpu_percent(interval=None)
+            mem = p.memory_percent()
+            rss = p.memory_info().rss
+            procs.append(
+                {
+                    "pid": p.pid,
+                    "name": p.info.get("name") or "?",
+                    "cpu_percent": round(cpu or 0.0, 1),
+                    "memory_percent": round(mem or 0.0, 1),
+                    "rss_bytes": rss,
+                    "rss_mb": _bytes_to_mb(rss),
+                }
+            )
+        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+            continue
+    procs.sort(key=lambda x: x["cpu_percent"], reverse=True)
+    return procs[:n]
+
+
+def _top_processes_memory(n: int = 8) -> List[Dict[str, Any]]:
+    procs: List[Dict[str, Any]] = []
+    for p in psutil.process_iter(["pid", "name"]):
+        try:
+            rss = p.memory_info().rss
+            procs.append(
+                {
+                    "pid": p.pid,
+                    "name": p.info.get("name") or "?",
+                    "rss_bytes": rss,
+                    "rss_mb": _bytes_to_mb(rss),
+                    "memory_percent": round(p.memory_percent() or 0.0, 1),
+                }
+            )
+        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+            continue
+    procs.sort(key=lambda x: x["rss_bytes"], reverse=True)
+    return procs[:n]
+
+
+def collect_report(*, include_listen_ports: bool = True) -> Dict[str, Any]:
+    """Return a JSON-serializable system report."""
+    root = _root_fs_path()
+    uname = platform.uname()
+    boot = psutil.boot_time()
+    vm = psutil.virtual_memory()
+    sw = psutil.swap_memory()
+    disk = psutil.disk_usage(root)
+    phys = psutil.cpu_count(logical=False)
+    logical = psutil.cpu_count(logical=True)
+    cpu_pct = psutil.cpu_percent(interval=0.2)
+
+    net_io = psutil.net_io_counters(pernic=False)
+    net_totals = None
+    if net_io:
+        net_totals = {
+            "bytes_sent": net_io.bytes_sent,
+            "bytes_recv": net_io.bytes_recv,
+            "packets_sent": net_io.packets_sent,
+            "packets_recv": net_io.packets_recv,
+        }
+
+    report: Dict[str, Any] = {
+        "generated_at": datetime.now().astimezone().isoformat(),
+        "cpu": {
+            "model": _cpu_model(),
+            "physical_cores": phys,
+            "logical_cores": logical,
+            "usage_percent": round(cpu_pct, 1),
+            "load_average": _load_average(),
+        },
+        "memory": {
+            "total_bytes": vm.total,
+            "total_gb": _bytes_to_gb(vm.total),
+            "used_bytes": vm.used,
+            "used_gb": _bytes_to_gb(vm.used),
+            "free_bytes": vm.available,
+            "free_gb": _bytes_to_gb(vm.available),
+            "percent_used": round(vm.percent, 1),
+            "swap_total_bytes": sw.total,
+            "swap_total_gb": _bytes_to_gb(sw.total) if sw.total else 0,
+            "swap_used_bytes": sw.used,
+            "swap_used_gb": _bytes_to_gb(sw.used) if sw.used else 0,
+            "swap_percent": round(sw.percent, 1) if sw.total else 0,
+        },
+        "system": {
+            "os": uname.system,
+            "node": uname.node,
+            "release": uname.release,
+            "version": uname.version,
+            "machine": uname.machine,
+            "platform": platform.platform(),
+            "python_version": sys.version.split()[0],
+        },
+        "disk": {
+            "mount": root,
+            "total_bytes": disk.total,
+            "total_gb": _bytes_to_gb(disk.total),
+            "used_bytes": disk.used,
+            "used_gb": _bytes_to_gb(disk.used),
+            "free_bytes": disk.free,
+            "free_gb": _bytes_to_gb(disk.free),
+            "percent_used": round(disk.percent, 1),
+            "io": _disk_io(),
+        },
+        "network": {
+            "primary_ipv4": _primary_ipv4(),
+            "interfaces": _network_interfaces(),
+            "totals": net_totals,
+            "dns_google_reachable": None,
+        },
+        "processes": {
+            "count": len(psutil.pids()),
+            "top_cpu": _top_processes_cpu(8),
+            "top_memory": _top_processes_memory(8),
+        },
+        "uptime": {
+            "seconds": int(time.time() - boot),
+            "boot_time_iso": _safe_iso(boot),
+        },
+    }
+
+    try:
+        report["network"]["dns_google_reachable"] = socket.gethostbyname("google.com")
+    except OSError:
+        report["network"]["dns_google_reachable"] = None
+
+    if include_listen_ports:
+        report["network"]["listen_ports"] = _listen_ports()
+
+    return report

systemreports/static/style.css

@@ -0,0 +1,206 @@
+:root {
+  --bg: #0f1419;
+  --surface: #1a2332;
+  --border: #2d3a4d;
+  --text: #e7ecf3;
+  --muted: #8b9cb3;
+  --accent: #3d9cfd;
+  --accent-dim: #2563a8;
+  --ok: #34d399;
+  --warn: #fbbf24;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+body {
+  margin: 0;
+  font-family: "Segoe UI", system-ui, -apple-system, sans-serif;
+  background: var(--bg);
+  color: var(--text);
+  line-height: 1.5;
+  min-height: 100vh;
+}
+
+header {
+  padding: 1.25rem 1.5rem;
+  border-bottom: 1px solid var(--border);
+  background: var(--surface);
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: space-between;
+  gap: 1rem;
+}
+
+header h1 {
+  margin: 0;
+  font-size: 1.25rem;
+  font-weight: 600;
+}
+
+header .meta {
+  color: var(--muted);
+  font-size: 0.875rem;
+}
+
+.toolbar {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+}
+
+.toolbar label {
+  display: flex;
+  align-items: center;
+  gap: 0.35rem;
+  font-size: 0.8rem;
+  color: var(--muted);
+  cursor: pointer;
+}
+
+.toolbar button {
+  background: var(--accent);
+  color: #fff;
+  border: none;
+  padding: 0.45rem 0.9rem;
+  border-radius: 6px;
+  font-size: 0.875rem;
+  cursor: pointer;
+}
+
+.toolbar button:hover {
+  background: var(--accent-dim);
+}
+
+.toolbar button:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+#status {
+  font-size: 0.8rem;
+  color: var(--muted);
+}
+
+main {
+  max-width: 1200px;
+  margin: 0 auto;
+  padding: 1.25rem 1.5rem 2rem;
+}
+
+.grid {
+  display: grid;
+  gap: 1rem;
+  grid-template-columns: repeat(auto-fill, minmax(320px, 1fr));
+}
+
+.card {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 10px;
+  padding: 1rem 1.15rem;
+}
+
+.card h2 {
+  margin: 0 0 0.75rem;
+  font-size: 0.95rem;
+  font-weight: 600;
+  color: var(--accent);
+  display: flex;
+  align-items: center;
+  gap: 0.4rem;
+}
+
+.card.full {
+  grid-column: 1 / -1;
+}
+
+dl {
+  margin: 0;
+  display: grid;
+  grid-template-columns: auto 1fr;
+  gap: 0.35rem 1rem;
+  font-size: 0.875rem;
+}
+
+dt {
+  color: var(--muted);
+  font-weight: 500;
+}
+
+dd {
+  margin: 0;
+  word-break: break-word;
+}
+
+.bar {
+  height: 8px;
+  background: var(--border);
+  border-radius: 4px;
+  overflow: hidden;
+  margin-top: 0.25rem;
+}
+
+.bar > span {
+  display: block;
+  height: 100%;
+  background: linear-gradient(90deg, var(--accent-dim), var(--accent));
+  border-radius: 4px;
+}
+
+table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 0.8rem;
+}
+
+th,
+td {
+  text-align: left;
+  padding: 0.4rem 0.5rem;
+  border-bottom: 1px solid var(--border);
+}
+
+th {
+  color: var(--muted);
+  font-weight: 600;
+}
+
+.iface-name {
+  font-weight: 600;
+  color: var(--text);
+}
+
+.error-banner {
+  background: #3d1f1f;
+  border: 1px solid #7f2d2d;
+  color: #fecaca;
+  padding: 0.75rem 1rem;
+  border-radius: 8px;
+  margin-bottom: 1rem;
+  font-size: 0.875rem;
+}
+
+.hidden {
+  display: none !important;
+}
+
+@media (prefers-color-scheme: light) {
+  :root {
+    --bg: #f0f4f8;
+    --surface: #fff;
+    --border: #d0dbe8;
+    --text: #1a2332;
+    --muted: #5c6b7f;
+    --accent: #0b6bcb;
+    --accent-dim: #084a94;
+  }
+
+  .error-banner {
+    background: #fef2f2;
+    border-color: #fecaca;
+    color: #991b1b;
+  }
+}

systemreports/templates/index.html

@@ -0,0 +1,298 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>System Report</title>
+  <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}" />
+</head>
+<body>
+  <header>
+    <div>
+      <h1>System report</h1>
+      <div class="meta" id="generated">Loading…</div>
+    </div>
+    <div class="toolbar">
+      <label><input type="checkbox" id="auto" checked /> Auto-refresh (15s)</label>
+      <label><input type="checkbox" id="ports" checked /> Include listening ports</label>
+      <button type="button" id="refresh">Refresh now</button>
+    </div>
+    <span id="status"></span>
+  </header>
+  <main>
+    <div id="err" class="error-banner hidden"></div>
+    <div class="grid" id="content"></div>
+  </main>
+  <script>
+    function fmtBytes(n) {
+      if (n == null) return "—";
+      const u = ["B", "KB", "MB", "GB", "TB"];
+      let i = 0;
+      let x = n;
+      while (x >= 1024 && i < u.length - 1) { x /= 1024; i++; }
+      return (i === 0 ? x : x.toFixed(2)) + " " + u[i];
+    }
+
+    function fmtUptime(sec) {
+      const d = Math.floor(sec / 86400);
+      const h = Math.floor((sec % 86400) / 3600);
+      const m = Math.floor((sec % 3600) / 60);
+      const parts = [];
+      if (d) parts.push(d + "d");
+      if (h || d) parts.push(h + "h");
+      parts.push(m + "m");
+      return parts.join(" ");
+    }
+
+    function bar(pct) {
+      const v = Math.min(100, Math.max(0, pct));
+      return '<div class="bar"><span style="width:' + v + '%"></span></div>';
+    }
+
+    function render(r) {
+      const cpu = r.cpu;
+      const mem = r.memory;
+      const sys = r.system;
+      const disk = r.disk;
+      const net = r.network;
+      const proc = r.processes;
+      const up = r.uptime;
+      const load = cpu.load_average;
+      const loadStr = load
+        ? load["1m"] + ", " + load["5m"] + ", " + load["15m"]
+        : "N/A (Windows has no load average)";
+
+      let portsHtml = "";
+      const lp = net.listen_ports;
+      if (lp) {
+        if (lp.available) {
+          const list = lp.ports.length ? lp.ports.join(", ") : "none";
+          portsHtml = "<dt>Listening ports</dt><dd>" + (lp.truncated ? list + " …" : list) + "</dd>";
+        } else {
+          portsHtml = "<dt>Listening ports</dt><dd>" + (lp.message || "Unavailable") + "</dd>";
+        }
+      }
+
+      let diskIo = "<dt>Disk I/O</dt><dd>—</dd>";
+      if (disk.io) {
+        diskIo =
+          "<dt>Disk I/O (read / write)</dt><dd>" +
+          fmtBytes(disk.io.read_bytes) +
+          " / " +
+          fmtBytes(disk.io.write_bytes) +
+          "</dd>";
+      }
+
+      let netTotals = "<dt>Bytes sent / recv (since boot)</dt><dd>—</dd>";
+      if (net.totals) {
+        netTotals =
+          "<dt>Bytes sent / received</dt><dd>" +
+          fmtBytes(net.totals.bytes_sent) +
+          " / " +
+          fmtBytes(net.totals.bytes_recv) +
+          "</dd>";
+      }
+
+      const ifaces = net.interfaces
+        .map(function (iface) {
+          const addrs = iface.addresses
+            .map(function (a) {
+              return a.family + ": " + a.address;
+            })
+            .join("<br/>");
+          const up = iface.is_up == null ? "" : iface.is_up ? "up" : "down";
+          const spd = iface.speed_mbps ? iface.speed_mbps + " Mbps" : "";
+          return (
+            "<tr><td class=\"iface-name\">" +
+            iface.name +
+            "</td><td>" +
+            addrs +
+            "</td><td>" +
+            up +
+            "</td><td>" +
+            spd +
+            "</td></tr>"
+          );
+        })
+        .join("");
+
+      const topCpu = proc.top_cpu
+        .map(function (p) {
+          return (
+            "<tr><td>" +
+            p.pid +
+            "</td><td>" +
+            (p.name || "").replace(/</g, "&lt;") +
+            "</td><td>" +
+            p.cpu_percent +
+            "%</td><td>" +
+            p.rss_mb +
+            " MB</td></tr>"
+          );
+        })
+        .join("");
+
+      const topMem = proc.top_memory
+        .map(function (p) {
+          return (
+            "<tr><td>" +
+            p.pid +
+            "</td><td>" +
+            (p.name || "").replace(/</g, "&lt;") +
+            "</td><td>" +
+            p.rss_mb +
+            " MB</td><td>" +
+            p.memory_percent +
+            "%</td></tr>"
+          );
+        })
+        .join("");
+
+      document.getElementById("generated").textContent = "Generated: " + r.generated_at;
+      document.getElementById("content").innerHTML =
+        '<section class="card"><h2>CPU</h2><dl>' +
+        "<dt>Model</dt><dd>" +
+        (cpu.model || "").replace(/</g, "&lt;") +
+        "</dd>" +
+        "<dt>Cores (physical / logical)</dt><dd>" +
+        (cpu.physical_cores ?? "—") +
+        " / " +
+        (cpu.logical_cores ?? "—") +
+        "</dd>" +
+        "<dt>Usage</dt><dd>" +
+        cpu.usage_percent +
+        "%" +
+        bar(cpu.usage_percent) +
+        "</dd>" +
+        "<dt>Load avg (1m, 5m, 15m)</dt><dd>" +
+        loadStr +
+        "</dd></dl></section>" +
+        '<section class="card"><h2>Memory</h2><dl>' +
+        "<dt>Total RAM</dt><dd>" +
+        mem.total_gb +
+        " GB</dd>" +
+        "<dt>Used / free</dt><dd>" +
+        mem.used_gb +
+        " GB / " +
+        mem.free_gb +
+        " GB (" +
+        mem.percent_used +
+        "%)" +
+        bar(mem.percent_used) +
+        "</dd>" +
+        "<dt>Swap</dt><dd>" +
+        mem.swap_used_gb +
+        " GB used of " +
+        mem.swap_total_gb +
+        " GB (" +
+        mem.swap_percent +
+        "%)</dd></dl></section>" +
+        '<section class="card"><h2>System / OS</h2><dl>' +
+        "<dt>OS</dt><dd>" +
+        sys.os +
+        " " +
+        sys.release +
+        "</dd>" +
+        "<dt>Architecture</dt><dd>" +
+        sys.machine +
+        "</dd>" +
+        "<dt>Kernel / build</dt><dd>" +
+        (sys.version || "").replace(/</g, "&lt;").slice(0, 200) +
+        (sys.version && sys.version.length > 200 ? "…" : "") +
+        "</dd>" +
+        "<dt>Hostname</dt><dd>" +
+        (sys.node || "").replace(/</g, "&lt;") +
+        "</dd>" +
+        "<dt>Python</dt><dd>" +
+        sys.python_version +
+        "</dd></dl></section>" +
+        '<section class="card"><h2>Disk / storage</h2><dl>' +
+        "<dt>Mount</dt><dd>" +
+        (disk.mount || "").replace(/</g, "&lt;") +
+        "</dd>" +
+        "<dt>Total</dt><dd>" +
+        disk.total_gb +
+        " GB</dd>" +
+        "<dt>Used / free</dt><dd>" +
+        disk.used_gb +
+        " GB / " +
+        disk.free_gb +
+        " GB (" +
+        disk.percent_used +
+        "%)" +
+        bar(disk.percent_used) +
+        "</dd>" +
+        diskIo +
+        "</dl></section>" +
+        '<section class="card full"><h2>Network</h2><dl>' +
+        "<dt>Primary IPv4</dt><dd>" +
+        (net.primary_ipv4 || "—") +
+        "</dd>" +
+        netTotals +
+        "<dt>DNS (google.com)</dt><dd>" +
+        (net.dns_google_reachable || "—") +
+        "</dd>" +
+        portsHtml +
+        '</dl><table><thead><tr><th>Interface</th><th>Addresses</th><th>Link</th><th>Speed</th></tr></thead><tbody>' +
+        ifaces +
+        "</tbody></table></section>" +
+        '<section class="card full"><h2>Processes</h2><p style="margin:0 0 0.5rem;font-size:0.875rem;color:var(--muted)">Running: ' +
+        proc.count +
+        '</p><div style="display:grid;grid-template-columns:repeat(auto-fill,minmax(280px,1fr));gap:1rem">' +
+        '<div><strong>Top CPU</strong><table><thead><tr><th>PID</th><th>Name</th><th>CPU</th><th>RSS</th></tr></thead><tbody>' +
+        topCpu +
+        "</tbody></table></div>" +
+        '<div><strong>Top memory</strong><table><thead><tr><th>PID</th><th>Name</th><th>RSS</th><th>%</th></tr></thead><tbody>' +
+        topMem +
+        "</tbody></table></div></div></section>" +
+        '<section class="card"><h2>Uptime</h2><dl>' +
+        "<dt>Uptime</dt><dd>" +
+        fmtUptime(up.seconds) +
+        " (" +
+        up.seconds +
+        " s)</dd>" +
+        "<dt>Last boot (local)</dt><dd>" +
+        up.boot_time_iso +
+        "</dd></dl></section>";
+    }
+
+    let timer = null;
+    async function loadReport() {
+      const btn = document.getElementById("refresh");
+      const st = document.getElementById("status");
+      const err = document.getElementById("err");
+      const ports = document.getElementById("ports").checked ? "1" : "0";
+      btn.disabled = true;
+      st.textContent = "Fetching…";
+      err.classList.add("hidden");
+      try {
+        const res = await fetch("/api/report?ports=" + ports);
+        if (!res.ok) throw new Error(res.statusText);
+        const data = await res.json();
+        render(data);
+        st.textContent = "OK";
+      } catch (e) {
+        err.textContent = "Could not load report: " + e.message;
+        err.classList.remove("hidden");
+        st.textContent = "Error";
+      } finally {
+        btn.disabled = false;
+      }
+    }
+
+    function schedule() {
+      if (timer) clearInterval(timer);
+      timer = null;
+      if (document.getElementById("auto").checked) {
+        timer = setInterval(loadReport, 15000);
+      }
+    }
+
+    document.getElementById("refresh").addEventListener("click", loadReport);
+    document.getElementById("auto").addEventListener("change", schedule);
+    document.getElementById("ports").addEventListener("change", loadReport);
+    loadReport();
+    schedule();
+  </script>
+</body>
+</html>

systemreports-2.0.0.dist-info/METADATA

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: systemreports
+Version: 2.0.0
+Summary: Cross-platform system report with a local web dashboard (Windows, macOS, Linux).
+Home-page: https://github.com/sriramsreedhar/systemreports.git
+Author: Sriram Sreedhar
+Author-email: sriramsreedhar003@gmail.com
+License: Apache-2.0
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: psutil>=5.9.0
+Requires-Dist: flask>=2.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# SystemReports
+
+Cross-platform system metrics with a **local web dashboard** (Windows, macOS, Linux) and optional CLI/JSON output.
+
+- **GitHub:** [github.com/sriramsreedhar/systemreports](https://github.com/sriramsreedhar/systemreports.git)
+- **License:** [Apache-2.0](LICENSE)
+
+## Screenshot
+
+![System report web dashboard](docs/dashboard-screenshot.png)
+
+The UI shows CPU, memory, OS, disk (including I/O), network (interfaces, traffic, optional listening ports), top processes, and uptime. Use **Refresh now** or enable **Auto-refresh** to keep values current.
+
+## Features
+
+- **Web dashboard** — Run `systemreports` and open the URL in your browser (default: `http://127.0.0.1:5050/`).
+- **CLI / JSON** — `systemreports --cli` for a text summary; `systemreports --json` for full JSON.
+- **Legacy** — Original CentOS-oriented script: `legacy_cli.py` (Unix-oriented).
+
+**Requirements:** Python 3.8+, [psutil](https://github.com/giampaolo/psutil), [Flask](https://flask.palletsprojects.com/).
+
+## Install
+
+```bash
+pip install -e .
+# or
+pip install systemreports
+```
+
+## Run the dashboard
+
+```bash
+systemreports
+```
+
+Other useful options:
+
+```bash
+# Do not open a browser automatically
+systemreports --no-browser
+
+# Listen on all interfaces (use only on trusted networks)
+systemreports --host 0.0.0.0 --port 5050
+```
+
+## API
+
+- `GET /api/report` — JSON snapshot (includes listening ports when permitted).
+- `GET /api/report?ports=0` — Skip port enumeration (fewer permission prompts).
+
+You can also run the module directly: `python -m systemreports`.
+
+## Publishing to PyPI
+
+Use a **dedicated virtualenv** for releases if other tools pin an old **packaging** (for example some stacks require `packaging<25`).
+
+```bash
+python -m venv .venv-release
+source .venv-release/bin/activate   # Windows: .venv-release\Scripts\activate
+pip install --upgrade build twine packaging
+python -m build
+python -m twine check dist/*
+python -m twine upload dist/*
+```
+
+If `twine check` / `twine upload` fails with **unrecognized or malformed field `license-file`**, upgrade **`packaging`** (and **twine**). Wheels use metadata 2.4; older `packaging` does not understand the `License-File` field. See [pypa/twine#1216](https://github.com/pypa/twine/issues/1216).
+
+## More detail
+
+See [README.rst](README.rst) for the original project notes and older pip/output examples.

systemreports-2.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+systemreports/__init__.py,sha256=vZmQ6FuBpOySrTiq_mLi-9z8-NvuRLMoAPDkl7W2sFM,88
+systemreports/__main__.py,sha256=X-kTCWBt2C4-ILeNIr9qQQ6uwMt_V7fG69q4u31WvTw,74
+systemreports/app.py,sha256=JdyzahwFsN3sk3tGQadAaIqCGa7nX3PNfT49-qTqP-w,922
+systemreports/cli.py,sha256=mY6Ky_pd3rS3Gurx5kStuGfUD1R2bPlchvKBOUjeyAM,3380
+systemreports/collector.py,sha256=krJ_je9sLyNw_0bc16qamsjXOV3HLGTE-WdU5ZYT1x4,9084
+systemreports/static/style.css,sha256=zswFXDPQKHJfw8-vyArTXdM4eA5fbqBrar6UqlmsyNk,3120
+systemreports/templates/index.html,sha256=p93iGuSFnXyDO7FWK4VNFtRe1TdDHvDbeAOFTaUnsgo,9456
+systemreports-2.0.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+systemreports-2.0.0.dist-info/licenses/NOTICE,sha256=ADPZMK4T1XU1HvzhYoXhCGi9a4BOWMseNtpUTmIRg64,158
+systemreports-2.0.0.dist-info/METADATA,sha256=3EWp4osU2ZdUKEPxQzWj3SbfydWpDI-vg3vqPx1YLs8,3215
+systemreports-2.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+systemreports-2.0.0.dist-info/entry_points.txt,sha256=UrlTdFKbX6peLutehFeWlCsmNnF7iwfWHY6K-HD1rYk,57
+systemreports-2.0.0.dist-info/top_level.txt,sha256=oa__vtIHy4fIEw7qt9XfgEpyWG3RexjJHedysHKuUjg,14
+systemreports-2.0.0.dist-info/RECORD,,

systemreports-2.0.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
+

systemreports-2.0.0.dist-info/entry_points.txt

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

systemreports-2.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

systemreports-2.0.0.dist-info/licenses/NOTICE

@@ -0,0 +1,5 @@
+SystemReports
+Copyright 2026 Sriram Sreedhar
+
+This product is licensed under the Apache License, Version 2.0.
+See the LICENSE file for the full license text.

systemreports-2.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+systemreports