ppop 0.1.0__tar.gz

ppop-0.1.0/LICENSE

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

ppop-0.1.0/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: ppop
+Version: 0.1.0
+Summary: An interactive PPU process viewer and resource monitor, inspired by nvitop.
+Author-email: Zhongwang Lun <lunandcnn@gmail.com>
+License-Expression: MIT
+Keywords: ppu,monitor,process-viewer,tui
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console :: Curses
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psutil>=5.6.6
+Dynamic: license-file
+
+# ppop
+
+An interactive PPU process viewer and resource monitor for the terminal, inspired by [nvitop](https://github.com/XuehaiPan/nvitop).
+
+## Features
+
+- Real-time PPU device monitoring (utilization, memory, temperature, power)
+- Host CPU and memory usage display
+- Per-process PPU memory tracking
+- Interactive curses-based TUI with color-coded utilization bars
+- Non-interactive one-shot mode for scripts and logging
+
+## Demo
+
+```
++-------------------------------------------------------------------------------+
+| ppop - PPU Monitor                               Driver Version: 1.5.5-7a3ae6 |
++-----------------------------------+----------------------+-------------------+
+|              PPU  Name             |      Memory-Usage     |      PPU-Util      |
++===================================+======================+===================+
+| 0  PPU-ZW810E  32C  71W / 400W     |      2MiB / 98304MiB |       0%  Default |
+| 1  PPU-ZW810E  32C  75W / 400W     |      2MiB / 98304MiB |       0%  Default |
++-----------------------------------+----------------------+-------------------+
+
++-------------------------------------------------------------------------------+
+| Host:                                                                          |
+| CPU [||||                ]  21.3% (32 cores)    MEM [||||||              ] 32.1GiB/64.0GiB (50.2%)
++-------------------------------------------------------------------------------+
+
++-------------------------------------------------------------------------------+
+| Processes:                                                                     |
+| PPU       PID  USER         PPU-MEM   CPU%   MEM%       TIME  Command         |
++===============================================================================+
+|   0    12345  user           8192MiB   3.2%  12.6%      1:23  python train.py |
++-------------------------------------------------------------------------------+
+```
+
+## Requirements
+
+- Python 3.8+
+- PPU device with `ppu-smi` installed (default path: `/usr/local/PPU_SDK/ppu-smi/bin/ppu-smi`)
+
+## Installation
+
+### From source
+
+```bash
+git clone https://github.com/your-username/ppop.git
+cd ppop
+pip install .
+```
+
+### From PyPI (coming soon)
+
+```bash
+pip install ppop
+```
+
+## Usage
+
+```bash
+# Interactive mode (real-time monitoring)
+ppop
+
+# One-shot mode (print once and exit)
+ppop --once
+
+# Custom refresh interval (default: 2s)
+ppop -i 5
+```
+
+### Keyboard Shortcuts (interactive mode)
+
+| Key | Action |
+|-----|--------|
+| `q` | Quit |
+| `↑` / `k` | Scroll up |
+| `↓` / `j` | Scroll down |
+| `PgUp` / `PgDn` | Scroll by page |
+| `r` | Force refresh |
+
+## Configuration
+
+If `ppu-smi` is not at the default path, set the environment variable:
+
+```bash
+export PPU_SMI_PATH=/path/to/ppu-smi
+```
+
+## License
+
+[MIT](LICENSE)

ppop-0.1.0/README.md

@@ -0,0 +1,92 @@
+# ppop
+
+An interactive PPU process viewer and resource monitor for the terminal, inspired by [nvitop](https://github.com/XuehaiPan/nvitop).
+
+## Features
+
+- Real-time PPU device monitoring (utilization, memory, temperature, power)
+- Host CPU and memory usage display
+- Per-process PPU memory tracking
+- Interactive curses-based TUI with color-coded utilization bars
+- Non-interactive one-shot mode for scripts and logging
+
+## Demo
+
+```
++-------------------------------------------------------------------------------+
+| ppop - PPU Monitor                               Driver Version: 1.5.5-7a3ae6 |
++-----------------------------------+----------------------+-------------------+
+|              PPU  Name             |      Memory-Usage     |      PPU-Util      |
++===================================+======================+===================+
+| 0  PPU-ZW810E  32C  71W / 400W     |      2MiB / 98304MiB |       0%  Default |
+| 1  PPU-ZW810E  32C  75W / 400W     |      2MiB / 98304MiB |       0%  Default |
++-----------------------------------+----------------------+-------------------+
+
++-------------------------------------------------------------------------------+
+| Host:                                                                          |
+| CPU [||||                ]  21.3% (32 cores)    MEM [||||||              ] 32.1GiB/64.0GiB (50.2%)
++-------------------------------------------------------------------------------+
+
++-------------------------------------------------------------------------------+
+| Processes:                                                                     |
+| PPU       PID  USER         PPU-MEM   CPU%   MEM%       TIME  Command         |
++===============================================================================+
+|   0    12345  user           8192MiB   3.2%  12.6%      1:23  python train.py |
++-------------------------------------------------------------------------------+
+```
+
+## Requirements
+
+- Python 3.8+
+- PPU device with `ppu-smi` installed (default path: `/usr/local/PPU_SDK/ppu-smi/bin/ppu-smi`)
+
+## Installation
+
+### From source
+
+```bash
+git clone https://github.com/your-username/ppop.git
+cd ppop
+pip install .
+```
+
+### From PyPI (coming soon)
+
+```bash
+pip install ppop
+```
+
+## Usage
+
+```bash
+# Interactive mode (real-time monitoring)
+ppop
+
+# One-shot mode (print once and exit)
+ppop --once
+
+# Custom refresh interval (default: 2s)
+ppop -i 5
+```
+
+### Keyboard Shortcuts (interactive mode)
+
+| Key | Action |
+|-----|--------|
+| `q` | Quit |
+| `↑` / `k` | Scroll up |
+| `↓` / `j` | Scroll down |
+| `PgUp` / `PgDn` | Scroll by page |
+| `r` | Force refresh |
+
+## Configuration
+
+If `ppu-smi` is not at the default path, set the environment variable:
+
+```bash
+export PPU_SMI_PATH=/path/to/ppu-smi
+```
+
+## License
+
+[MIT](LICENSE)

ppop-0.1.0/popup/__init__.py

@@ -0,0 +1,3 @@
+"""popup - An interactive PPU process viewer and resource monitor."""
+
+__version__ = "0.1.0"

ppop-0.1.0/popup/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as python -m popup."""
+
+from popup.cli import main
+
+main()

ppop-0.1.0/popup/cli.py

@@ -0,0 +1,46 @@
+"""CLI entry point for popup."""
+
+from __future__ import annotations
+
+import argparse
+import curses
+import sys
+
+
+def parse_arguments() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        prog="ppop",
+        description="An interactive PPU process viewer and resource monitor.",
+    )
+    parser.add_argument(
+        "-1", "--once",
+        action="store_true",
+        help="Report device info once and exit (non-interactive).",
+    )
+    parser.add_argument(
+        "-i", "--interval",
+        type=float,
+        default=2.0,
+        help="Update interval in seconds (default: 2).",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_arguments()
+
+    from popup.tui import TUI, print_once
+
+    if args.once or not sys.stdout.isatty():
+        print_once()
+        return
+
+    tui = TUI(interval=args.interval)
+    try:
+        curses.wrapper(tui.run)
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()

ppop-0.1.0/popup/device.py

@@ -0,0 +1,225 @@
+"""PPU device and process data collection via ppu-smi."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+PPU_SMI = os.environ.get("PPU_SMI_PATH", "/usr/local/PPU_SDK/ppu-smi/bin/ppu-smi")
+
+DEVICE_QUERY_FIELDS = (
+    "index,name,uuid,pci.bus_id,memory.total,memory.used,memory.free,"
+    "utilization.ppu,utilization.memory,temperature.ppu,"
+    "power.draw,power.limit,fan.speed,clocks.current.sm,clocks.current.memory,"
+    "persistence_mode,pstate,compute_mode,ecc.errors.corrected.volatile.total"
+)
+
+PROCESS_QUERY_FIELDS = "pid,process_name,used_ppu_memory,ppu_bus_id"
+
+
+def _parse_value(raw: str) -> str:
+    """Strip units and whitespace from a ppu-smi CSV value."""
+    raw = raw.strip()
+    for suffix in (" MiB", " W", " C", " %", " MHz", " KB/s"):
+        if raw.endswith(suffix):
+            return raw[: -len(suffix)].strip()
+    return raw
+
+
+def _parse_int(raw: str, default: int = 0) -> int:
+    v = _parse_value(raw)
+    if v in ("[N/A]", "N/A", "[Not Supported]", ""):
+        return default
+    try:
+        return int(v)
+    except ValueError:
+        return default
+
+
+def _parse_float(raw: str, default: float = 0.0) -> float:
+    v = _parse_value(raw)
+    if v in ("[N/A]", "N/A", "[Not Supported]", ""):
+        return default
+    try:
+        return float(v)
+    except ValueError:
+        return default
+
+
+def _parse_str(raw: str) -> str:
+    v = raw.strip()
+    if v in ("[N/A]", "[Not Supported]"):
+        return "N/A"
+    return v
+
+
+@dataclass
+class PPUDevice:
+    index: int = 0
+    name: str = ""
+    uuid: str = ""
+    bus_id: str = ""
+    memory_total: int = 0  # MiB
+    memory_used: int = 0   # MiB
+    memory_free: int = 0   # MiB
+    ppu_utilization: int = 0  # %
+    memory_utilization: int = 0  # %
+    temperature: int = 0  # C
+    power_draw: float = 0.0  # W
+    power_limit: float = 0.0  # W
+    fan_speed: str = "N/A"
+    sm_clock: int = 0  # MHz
+    memory_clock: int = 0  # MHz
+    persistence_mode: str = "N/A"
+    pstate: str = "N/A"
+    compute_mode: str = "Default"
+    ecc_errors: int = 0
+    processes: List[PPUProcess] = field(default_factory=list)
+
+    @property
+    def memory_percent(self) -> float:
+        if self.memory_total == 0:
+            return 0.0
+        return 100.0 * self.memory_used / self.memory_total
+
+    @property
+    def power_status(self) -> str:
+        return f"{self.power_draw:.0f}W / {self.power_limit:.0f}W"
+
+    @property
+    def memory_usage(self) -> str:
+        return f"{self.memory_used}MiB / {self.memory_total}MiB"
+
+
+@dataclass
+class PPUProcess:
+    pid: int = 0
+    name: str = ""
+    ppu_memory: int = 0  # MiB
+    bus_id: str = ""
+    device_index: int = -1
+    username: str = ""
+    command: str = ""
+    cpu_percent: float = 0.0
+    host_memory: float = 0.0  # %
+    running_time: str = ""
+
+
+def _run_ppu_smi(*args: str) -> str:
+    try:
+        result = subprocess.run(
+            [PPU_SMI, *args],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        return result.stdout
+    except (FileNotFoundError, subprocess.TimeoutExpired, OSError):
+        return ""
+
+
+def _enrich_process(proc: PPUProcess) -> None:
+    """Add host-level info (username, cmdline, cpu%, mem%) via psutil."""
+    try:
+        import psutil
+
+        p = psutil.Process(proc.pid)
+        proc.username = p.username()
+        try:
+            cmdline = p.cmdline()
+            proc.command = " ".join(cmdline) if cmdline else proc.name
+        except (psutil.AccessDenied, psutil.ZombieProcess):
+            proc.command = proc.name
+        proc.cpu_percent = p.cpu_percent(interval=0)
+        proc.host_memory = p.memory_percent()
+        try:
+            import time
+            elapsed = time.time() - p.create_time()
+            hours, rem = divmod(int(elapsed), 3600)
+            minutes, seconds = divmod(rem, 60)
+            if hours > 0:
+                proc.running_time = f"{hours}:{minutes:02d}:{seconds:02d}"
+            else:
+                proc.running_time = f"{minutes}:{seconds:02d}"
+        except (psutil.AccessDenied, psutil.ZombieProcess):
+            proc.running_time = "N/A"
+    except Exception:
+        pass
+
+
+def query_devices() -> List[PPUDevice]:
+    """Query all PPU devices and their processes."""
+    # Query devices
+    output = _run_ppu_smi(f"--query-ppu={DEVICE_QUERY_FIELDS}", "--format=csv")
+    if not output.strip():
+        return []
+
+    lines = output.strip().splitlines()
+    if len(lines) < 2:
+        return []
+
+    devices: List[PPUDevice] = []
+    bus_id_to_device: dict[str, PPUDevice] = {}
+
+    for line in lines[1:]:
+        cols = line.split(",")
+        if len(cols) < 19:
+            continue
+        dev = PPUDevice(
+            index=_parse_int(cols[0]),
+            name=_parse_str(cols[1]),
+            uuid=_parse_str(cols[2]),
+            bus_id=_parse_str(cols[3]),
+            memory_total=_parse_int(cols[4]),
+            memory_used=_parse_int(cols[5]),
+            memory_free=_parse_int(cols[6]),
+            ppu_utilization=_parse_int(cols[7]),
+            memory_utilization=_parse_int(cols[8]),
+            temperature=_parse_int(cols[9]),
+            power_draw=_parse_float(cols[10]),
+            power_limit=_parse_float(cols[11]),
+            fan_speed=_parse_str(cols[12]),
+            sm_clock=_parse_int(cols[13]),
+            memory_clock=_parse_int(cols[14]),
+            persistence_mode=_parse_str(cols[15]),
+            pstate=_parse_str(cols[16]),
+            compute_mode=_parse_str(cols[17]),
+            ecc_errors=_parse_int(cols[18]),
+        )
+        devices.append(dev)
+        bus_id_to_device[dev.bus_id] = dev
+
+    # Query processes
+    proc_output = _run_ppu_smi(
+        f"--query-compute-apps={PROCESS_QUERY_FIELDS}", "--format=csv"
+    )
+    if proc_output.strip():
+        proc_lines = proc_output.strip().splitlines()
+        for pline in proc_lines[1:]:
+            pcols = pline.split(",")
+            if len(pcols) < 4:
+                continue
+            bus_id = _parse_str(pcols[3])
+            proc = PPUProcess(
+                pid=_parse_int(pcols[0]),
+                name=_parse_str(pcols[1]),
+                ppu_memory=_parse_int(pcols[2]),
+                bus_id=bus_id,
+            )
+            _enrich_process(proc)
+            dev = bus_id_to_device.get(bus_id)
+            if dev is not None:
+                proc.device_index = dev.index
+                dev.processes.append(proc)
+
+    return devices
+
+
+def get_driver_version() -> str:
+    output = _run_ppu_smi("--query-ppu=driver_version", "--format=csv")
+    lines = output.strip().splitlines()
+    if len(lines) >= 2:
+        return lines[1].strip()
+    return "N/A"

ppop-0.1.0/popup/tui.py

@@ -0,0 +1,513 @@
+"""Curses-based TUI for monitoring PPU devices."""
+
+from __future__ import annotations
+
+import curses
+import signal
+import time
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+import psutil
+
+from popup.device import PPUDevice, PPUProcess, get_driver_version, query_devices
+
+
+@dataclass
+class HostInfo:
+    cpu_percent: float = 0.0
+    cpu_count: int = 0
+    cpu_percents: List[float] = field(default_factory=list)
+    mem_total: int = 0    # bytes
+    mem_used: int = 0     # bytes
+    mem_percent: float = 0.0
+    swap_total: int = 0
+    swap_used: int = 0
+    swap_percent: float = 0.0
+    load_avg: tuple = (0.0, 0.0, 0.0)
+
+
+def query_host() -> HostInfo:
+    info = HostInfo()
+    info.cpu_count = psutil.cpu_count() or 1
+    info.cpu_percents = psutil.cpu_percent(percpu=True) or []
+    info.cpu_percent = psutil.cpu_percent()
+    mem = psutil.virtual_memory()
+    info.mem_total = mem.total
+    info.mem_used = mem.used
+    info.mem_percent = mem.percent
+    swap = psutil.swap_memory()
+    info.swap_total = swap.total
+    info.swap_used = swap.used
+    info.swap_percent = swap.percent
+    try:
+        info.load_avg = psutil.getloadavg()
+    except (AttributeError, OSError):
+        pass
+    return info
+
+
+def _fmt_bytes(n: int) -> str:
+    if n >= 1 << 30:
+        return f"{n / (1 << 30):.1f}GiB"
+    elif n >= 1 << 20:
+        return f"{n / (1 << 20):.0f}MiB"
+    else:
+        return f"{n / (1 << 10):.0f}KiB"
+
+
+# Color pair IDs
+PAIR_NORMAL = 0
+PAIR_HEADER = 1
+PAIR_GOOD = 2
+PAIR_WARN = 3
+PAIR_CRIT = 4
+PAIR_BAR_LOW = 5
+PAIR_BAR_MED = 6
+PAIR_BAR_HIGH = 7
+PAIR_TITLE = 8
+PAIR_PROCESS = 9
+PAIR_BORDER = 10
+PAIR_HIGHLIGHT = 11
+
+
+def _init_colors() -> None:
+    curses.start_color()
+    curses.use_default_colors()
+    curses.init_pair(PAIR_HEADER, curses.COLOR_WHITE, curses.COLOR_BLUE)
+    curses.init_pair(PAIR_GOOD, curses.COLOR_GREEN, -1)
+    curses.init_pair(PAIR_WARN, curses.COLOR_YELLOW, -1)
+    curses.init_pair(PAIR_CRIT, curses.COLOR_RED, -1)
+    curses.init_pair(PAIR_BAR_LOW, curses.COLOR_GREEN, -1)
+    curses.init_pair(PAIR_BAR_MED, curses.COLOR_YELLOW, -1)
+    curses.init_pair(PAIR_BAR_HIGH, curses.COLOR_RED, -1)
+    curses.init_pair(PAIR_TITLE, curses.COLOR_CYAN, -1)
+    curses.init_pair(PAIR_PROCESS, curses.COLOR_WHITE, -1)
+    curses.init_pair(PAIR_BORDER, curses.COLOR_WHITE, -1)
+    curses.init_pair(PAIR_HIGHLIGHT, curses.COLOR_BLACK, curses.COLOR_CYAN)
+
+
+def _util_color(percent: float) -> int:
+    if percent < 50:
+        return curses.color_pair(PAIR_BAR_LOW) | curses.A_BOLD
+    elif percent < 80:
+        return curses.color_pair(PAIR_BAR_MED) | curses.A_BOLD
+    else:
+        return curses.color_pair(PAIR_BAR_HIGH) | curses.A_BOLD
+
+
+def _temp_color(temp: int) -> int:
+    if temp < 50:
+        return curses.color_pair(PAIR_GOOD)
+    elif temp < 75:
+        return curses.color_pair(PAIR_WARN)
+    else:
+        return curses.color_pair(PAIR_CRIT)
+
+
+def _draw_bar(win, y: int, x: int, width: int, percent: float, label: str = "") -> None:
+    """Draw a utilization bar [||||      ] with color."""
+    if width < 4:
+        return
+    bar_inner = width - 2  # excluding [ and ]
+    filled = int(bar_inner * percent / 100.0)
+    filled = min(filled, bar_inner)
+
+    attr = _util_color(percent)
+    try:
+        win.addstr(y, x, "[", curses.color_pair(PAIR_BORDER))
+        win.addstr(y, x + 1, "|" * filled, attr)
+        win.addstr(y, x + 1 + filled, " " * (bar_inner - filled))
+        win.addstr(y, x + width - 1, "]", curses.color_pair(PAIR_BORDER))
+        if label:
+            lx = x + width + 1
+            win.addstr(y, lx, label, attr)
+    except curses.error:
+        pass
+
+
+def _safe_addstr(win, y: int, x: int, text: str, attr: int = 0) -> None:
+    max_y, max_x = win.getmaxyx()
+    if y < 0 or y >= max_y or x >= max_x:
+        return
+    available = max_x - x - 1
+    if available <= 0:
+        return
+    try:
+        win.addstr(y, x, text[:available], attr)
+    except curses.error:
+        pass
+
+
+def _draw_header(win, y: int, width: int, driver_version: str) -> int:
+    """Draw the top header. Returns next y."""
+    timestamp = time.strftime("%a %b %d %H:%M:%S %Y")
+    title = f" ppop - PPU Monitor"
+    ver = f"Driver: {driver_version}"
+
+    _safe_addstr(win, y, 0, " " * width, curses.color_pair(PAIR_HEADER))
+    _safe_addstr(win, y, 1, title, curses.color_pair(PAIR_HEADER) | curses.A_BOLD)
+    _safe_addstr(win, y, width - len(ver) - 2, ver, curses.color_pair(PAIR_HEADER))
+    y += 1
+    _safe_addstr(win, y, 0, " " * width, curses.color_pair(PAIR_HEADER))
+    _safe_addstr(win, y, 1, f" {timestamp}", curses.color_pair(PAIR_HEADER))
+    help_text = "q:Quit  ↑↓:Scroll"
+    _safe_addstr(win, y, width - len(help_text) - 2, help_text, curses.color_pair(PAIR_HEADER))
+    return y + 1
+
+
+def _draw_device_panel(win, y: int, width: int, devices: List[PPUDevice]) -> int:
+    """Draw device info panel. Returns next y."""
+    if not devices:
+        _safe_addstr(win, y, 1, "No PPU devices found.", curses.color_pair(PAIR_CRIT) | curses.A_BOLD)
+        return y + 2
+
+    # Table header
+    border = "+" + "-" * (width - 2) + "+"
+    _safe_addstr(win, y, 0, border, curses.color_pair(PAIR_BORDER))
+    y += 1
+
+    col_header = (
+        "| PPU  Name             Temp   Power         |"
+        "  Memory-Usage          |  PPU-Util  |"
+    )
+    # Simplified header that fits
+    hdr1 = f"| {'PPU':>3}  {'Name':<16} {'Temp':>5}  {'Pwr:Usage/Cap':>15} | {'Memory-Usage':^22} | {'PPU-Util':^9} |"
+    _safe_addstr(win, y, 0, hdr1[:width], curses.color_pair(PAIR_TITLE) | curses.A_BOLD)
+    y += 1
+
+    sep = "|" + "-" * (width - 2) + "|"
+    _safe_addstr(win, y, 0, sep, curses.color_pair(PAIR_BORDER))
+    y += 1
+
+    for dev in devices:
+        # Row 1: index, name, temp, power, memory usage, ppu util
+        mem_usage = f"{dev.memory_used:>5}MiB / {dev.memory_total}MiB"
+        ppu_util = f"{dev.ppu_utilization}%"
+
+        line = f"| {dev.index:>3}  {dev.name:<16} "
+        _safe_addstr(win, y, 0, line, curses.color_pair(PAIR_PROCESS))
+
+        # Temperature with color
+        temp_str = f"{dev.temperature:>3}C"
+        tx = len(line)
+        _safe_addstr(win, y, tx, temp_str, _temp_color(dev.temperature))
+        tx += len(temp_str)
+
+        # Power
+        pwr_str = f"  {dev.power_draw:>6.0f}W / {dev.power_limit:.0f}W"
+        _safe_addstr(win, y, tx, pwr_str, curses.color_pair(PAIR_PROCESS))
+        tx += len(pwr_str)
+
+        _safe_addstr(win, y, tx, " | ", curses.color_pair(PAIR_BORDER))
+        tx += 3
+
+        # Memory usage with bar
+        mem_pct = dev.memory_percent
+        bar_width = 12
+        _draw_bar(win, y, tx, bar_width, mem_pct)
+        tx += bar_width + 1
+        mem_str = f"{dev.memory_used:>5}/{dev.memory_total}M"
+        _safe_addstr(win, y, tx, mem_str, _util_color(mem_pct))
+        tx += len(mem_str)
+
+        _safe_addstr(win, y, tx, " | ", curses.color_pair(PAIR_BORDER))
+        tx += 3
+
+        # PPU utilization with bar
+        _draw_bar(win, y, tx, bar_width, dev.ppu_utilization)
+        tx += bar_width + 1
+        util_str = f"{dev.ppu_utilization:>3}%"
+        _safe_addstr(win, y, tx, util_str, _util_color(dev.ppu_utilization))
+        tx += len(util_str)
+
+        _safe_addstr(win, y, tx, " |", curses.color_pair(PAIR_BORDER))
+        y += 1
+
+    _safe_addstr(win, y, 0, border, curses.color_pair(PAIR_BORDER))
+    return y + 1
+
+
+def _draw_host_panel(win, y: int, width: int, host: HostInfo) -> int:
+    """Draw CPU and memory usage panel. Returns next y."""
+    border = "+" + "-" * (width - 2) + "+"
+    _safe_addstr(win, y, 0, border, curses.color_pair(PAIR_BORDER))
+    y += 1
+
+    _safe_addstr(
+        win, y, 0,
+        "| Host:" + " " * (width - 8) + "|",
+        curses.color_pair(PAIR_TITLE) | curses.A_BOLD,
+    )
+    y += 1
+
+    # CPU row: overall bar + per-core mini bars
+    bar_width = 20
+    cpu_label = f"CPU  {host.cpu_percent:>5.1f}%  ({host.cpu_count} cores)"
+    load_str = f"Load: {host.load_avg[0]:.2f} {host.load_avg[1]:.2f} {host.load_avg[2]:.2f}"
+
+    _safe_addstr(win, y, 1, "| ", curses.color_pair(PAIR_BORDER))
+    _safe_addstr(win, y, 3, "CPU ", curses.color_pair(PAIR_TITLE) | curses.A_BOLD)
+    _draw_bar(win, y, 7, bar_width, host.cpu_percent)
+    pct_str = f" {host.cpu_percent:>5.1f}%  ({host.cpu_count} cores)"
+    _safe_addstr(win, y, 7 + bar_width + 1, pct_str, _util_color(host.cpu_percent))
+
+    # Memory on the same row, right-aligned area
+    mem_x = max(7 + bar_width + 1 + len(pct_str) + 3, width // 2)
+    _safe_addstr(win, y, mem_x, "MEM ", curses.color_pair(PAIR_TITLE) | curses.A_BOLD)
+    _draw_bar(win, y, mem_x + 4, bar_width, host.mem_percent)
+    mem_str = f" {_fmt_bytes(host.mem_used)}/{_fmt_bytes(host.mem_total)} ({host.mem_percent:.1f}%)"
+    _safe_addstr(win, y, mem_x + 4 + bar_width + 1, mem_str, _util_color(host.mem_percent))
+    _safe_addstr(win, y, width - 1, "|", curses.color_pair(PAIR_BORDER))
+    y += 1
+
+    # Second row: per-core CPU mini view + swap
+    _safe_addstr(win, y, 1, "| ", curses.color_pair(PAIR_BORDER))
+    _safe_addstr(win, y, 3, "Per-core: ", curses.color_pair(PAIR_PROCESS))
+    cx = 13
+    cores_per_row = (width - 16) // 5  # each core ~5 chars "XX% "
+    for i, cpct in enumerate(host.cpu_percents):
+        if cx + 5 >= mem_x - 1:
+            break
+        core_str = f"{cpct:>3.0f}%"
+        _safe_addstr(win, y, cx, core_str, _util_color(cpct))
+        cx += 5
+
+    # Swap on the right
+    _safe_addstr(win, y, mem_x, "SWP ", curses.color_pair(PAIR_TITLE) | curses.A_BOLD)
+    _draw_bar(win, y, mem_x + 4, bar_width, host.swap_percent)
+    swap_str = f" {_fmt_bytes(host.swap_used)}/{_fmt_bytes(host.swap_total)} ({host.swap_percent:.1f}%)"
+    _safe_addstr(win, y, mem_x + 4 + bar_width + 1, swap_str, _util_color(host.swap_percent))
+
+    _safe_addstr(win, y, width - 1, "|", curses.color_pair(PAIR_BORDER))
+    y += 1
+
+    # Third row: load average
+    _safe_addstr(win, y, 1, "| ", curses.color_pair(PAIR_BORDER))
+    _safe_addstr(win, y, 3, f"Load Avg: {host.load_avg[0]:.2f}  {host.load_avg[1]:.2f}  {host.load_avg[2]:.2f}  (1/5/15 min)", curses.color_pair(PAIR_PROCESS))
+    _safe_addstr(win, y, width - 1, "|", curses.color_pair(PAIR_BORDER))
+    y += 1
+
+    _safe_addstr(win, y, 0, border, curses.color_pair(PAIR_BORDER))
+    return y + 1
+
+
+def _draw_process_panel(
+    win, y: int, width: int, devices: List[PPUDevice], scroll_offset: int
+) -> int:
+    """Draw processes table. Returns next y."""
+    border = "+" + "-" * (width - 2) + "+"
+    _safe_addstr(win, y, 0, border, curses.color_pair(PAIR_BORDER))
+    y += 1
+
+    _safe_addstr(
+        win, y, 0,
+        "| Processes:" + " " * (width - 13) + "|",
+        curses.color_pair(PAIR_TITLE) | curses.A_BOLD,
+    )
+    y += 1
+
+    # Column header
+    hdr = (
+        f"| {'PPU':>3}  {'PID':>8}  {'USER':<10}  "
+        f"{'PPU-MEM':>8}  {'PPU%':>5}  {'MEM%':>5}  "
+        f"{'CPU%':>5}  {'TIME':>9}  {'Command':<20} |"
+    )
+    _safe_addstr(win, y, 0, hdr[:width], curses.color_pair(PAIR_TITLE) | curses.A_BOLD)
+    y += 1
+
+    sep = "|" + "-" * (width - 2) + "|"
+    _safe_addstr(win, y, 0, sep, curses.color_pair(PAIR_BORDER))
+    y += 1
+
+    # Collect all processes
+    all_procs: list[PPUProcess] = []
+    for dev in devices:
+        all_procs.extend(dev.processes)
+
+    max_y, _ = win.getmaxyx()
+    available_rows = max_y - y - 2  # leave room for bottom border + status
+
+    if not all_procs:
+        _safe_addstr(win, y, 0, f"| {'No running processes':^{width-4}} |", curses.color_pair(PAIR_PROCESS))
+        y += 1
+    else:
+        visible = all_procs[scroll_offset : scroll_offset + max(available_rows, 1)]
+        for proc in visible:
+            if y >= max_y - 2:
+                break
+            user = (proc.username[:10] if proc.username else "N/A")
+            cmd = proc.command if proc.command else proc.name
+            # Truncate command to fit
+            cmd_width = max(width - 68, 10)
+            if len(cmd) > cmd_width:
+                cmd = cmd[:cmd_width - 3] + "..."
+
+            line = (
+                f"| {proc.device_index:>3}  {proc.pid:>8}  {user:<10}  "
+                f"{proc.ppu_memory:>6}MiB  {'-':>5}  {proc.host_memory:>4.1f}%  "
+                f"{proc.cpu_percent:>4.1f}%  {proc.running_time:>9}  {cmd:<{cmd_width}} |"
+            )
+            _safe_addstr(win, y, 0, line[:width], curses.color_pair(PAIR_PROCESS))
+            y += 1
+
+    _safe_addstr(win, y, 0, border, curses.color_pair(PAIR_BORDER))
+    y += 1
+
+    # Show scroll info
+    total = len(all_procs)
+    if total > available_rows:
+        info = f" [{scroll_offset+1}-{min(scroll_offset+available_rows, total)}/{total}] "
+        _safe_addstr(win, y, 1, info, curses.color_pair(PAIR_TITLE))
+
+    return y
+
+
+class TUI:
+    def __init__(self, interval: float = 2.0):
+        self.interval = interval
+        self.devices: List[PPUDevice] = []
+        self.host: HostInfo = HostInfo()
+        self.driver_version = "N/A"
+        self.scroll_offset = 0
+        self.running = True
+
+    def _refresh_data(self) -> None:
+        self.devices = query_devices()
+        self.host = query_host()
+        if self.driver_version == "N/A":
+            self.driver_version = get_driver_version()
+
+    def _total_processes(self) -> int:
+        return sum(len(d.processes) for d in self.devices)
+
+    def run(self, stdscr) -> None:
+        _init_colors()
+        curses.curs_set(0)
+        stdscr.timeout(200)  # 200ms for responsive input
+        curses.halfdelay(1)
+
+        self._refresh_data()
+        last_refresh = time.time()
+
+        while self.running:
+            now = time.time()
+            if now - last_refresh >= self.interval:
+                self._refresh_data()
+                last_refresh = now
+
+            stdscr.erase()
+            height, width = stdscr.getmaxyx()
+            if width < 40 or height < 10:
+                _safe_addstr(stdscr, 0, 0, "Terminal too small!", curses.A_BOLD)
+                stdscr.refresh()
+                key = stdscr.getch()
+                if key == ord("q") or key == ord("Q"):
+                    break
+                continue
+
+            y = 0
+            y = _draw_header(stdscr, y, width, self.driver_version)
+            y += 1
+            y = _draw_device_panel(stdscr, y, width, self.devices)
+            y += 1
+            y = _draw_host_panel(stdscr, y, width, self.host)
+            y += 1
+            y = _draw_process_panel(stdscr, y, width, self.devices, self.scroll_offset)
+
+            stdscr.refresh()
+
+            # Handle input
+            key = stdscr.getch()
+            if key == ord("q") or key == ord("Q"):
+                break
+            elif key == curses.KEY_DOWN or key == ord("j"):
+                total = self._total_processes()
+                if self.scroll_offset < total - 1:
+                    self.scroll_offset += 1
+            elif key == curses.KEY_UP or key == ord("k"):
+                if self.scroll_offset > 0:
+                    self.scroll_offset -= 1
+            elif key == curses.KEY_PPAGE:
+                self.scroll_offset = max(0, self.scroll_offset - 10)
+            elif key == curses.KEY_NPAGE:
+                total = self._total_processes()
+                self.scroll_offset = min(total - 1, self.scroll_offset + 10)
+            elif key == ord("r") or key == ord("R"):
+                self._refresh_data()
+                last_refresh = time.time()
+
+
+def print_once() -> None:
+    """Print a one-shot snapshot to stdout (non-interactive mode)."""
+    devices = query_devices()
+    driver_version = get_driver_version()
+
+    timestamp = time.strftime("%a %b %d %H:%M:%S %Y")
+    print(timestamp)
+    print("+" + "-" * 79 + "+")
+    print(f"| {'ppop - PPU Monitor':<49} Driver Version: {driver_version:<12} |")
+    print("+" + "-" * 35 + "+" + "-" * 22 + "+" + "-" * 19 + "+")
+    print(
+        f"| {'PPU  Name':^35}| {'Memory-Usage':^22}| {'PPU-Util':^19}|"
+    )
+    print("+" + "=" * 35 + "+" + "=" * 22 + "+" + "=" * 19 + "+")
+
+    for dev in devices:
+        name_part = f"{dev.index}  {dev.name}  {dev.temperature}C  {dev.power_status}"
+        mem_part = f"{dev.memory_used}MiB / {dev.memory_total}MiB"
+        util_part = f"{dev.ppu_utilization}%  {dev.compute_mode}"
+        print(f"| {name_part:<35}| {mem_part:>20} | {util_part:>17} |")
+
+    print("+" + "-" * 35 + "+" + "-" * 22 + "+" + "-" * 19 + "+")
+    print()
+
+    # Host info
+    host = query_host()
+    print("+" + "-" * 79 + "+")
+    print(f"| {'Host:':<79}|")
+    cpu_bar_filled = int(20 * host.cpu_percent / 100)
+    cpu_bar = "|" * cpu_bar_filled + " " * (20 - cpu_bar_filled)
+    mem_bar_filled = int(20 * host.mem_percent / 100)
+    mem_bar = "|" * mem_bar_filled + " " * (20 - mem_bar_filled)
+    print(
+        f"| CPU [{cpu_bar}] {host.cpu_percent:>5.1f}% ({host.cpu_count} cores)"
+        f"    MEM [{mem_bar}] {_fmt_bytes(host.mem_used)}/{_fmt_bytes(host.mem_total)} ({host.mem_percent:.1f}%)"
+    )
+    swap_bar_filled = int(20 * host.swap_percent / 100)
+    swap_bar = "|" * swap_bar_filled + " " * (20 - swap_bar_filled)
+    print(
+        f"| Load: {host.load_avg[0]:.2f} {host.load_avg[1]:.2f} {host.load_avg[2]:.2f} (1/5/15 min)"
+        f"       SWP [{swap_bar}] {_fmt_bytes(host.swap_used)}/{_fmt_bytes(host.swap_total)} ({host.swap_percent:.1f}%)"
+    )
+    print("+" + "-" * 79 + "+")
+    print()
+
+    # Processes
+    print("+" + "-" * 79 + "+")
+    print(f"| {'Processes:':<79}|")
+    print(
+        f"| {'PPU':>3}  {'PID':>8}  {'USER':<10}  "
+        f"{'PPU-MEM':>8}  {'CPU%':>5}  {'MEM%':>5}  "
+        f"{'TIME':>9}  {'Command':<15} |"
+    )
+    print("+" + "=" * 79 + "+")
+
+    has_proc = False
+    for dev in devices:
+        for proc in dev.processes:
+            has_proc = True
+            user = (proc.username[:10] if proc.username else "N/A")
+            cmd = proc.command if proc.command else proc.name
+            if len(cmd) > 15:
+                cmd = cmd[:12] + "..."
+            print(
+                f"| {proc.device_index:>3}  {proc.pid:>8}  {user:<10}  "
+                f"{proc.ppu_memory:>6}MiB  {proc.cpu_percent:>4.1f}%  "
+                f"{proc.host_memory:>4.1f}%  {proc.running_time:>9}  {cmd:<15} |"
+            )
+
+    if not has_proc:
+        print(f"| {'No running processes':^79}|")
+
+    print("+" + "-" * 79 + "+")

ppop-0.1.0/ppop.egg-info/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: ppop
+Version: 0.1.0
+Summary: An interactive PPU process viewer and resource monitor, inspired by nvitop.
+Author-email: Zhongwang Lun <lunandcnn@gmail.com>
+License-Expression: MIT
+Keywords: ppu,monitor,process-viewer,tui
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console :: Curses
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psutil>=5.6.6
+Dynamic: license-file
+
+# ppop
+
+An interactive PPU process viewer and resource monitor for the terminal, inspired by [nvitop](https://github.com/XuehaiPan/nvitop).
+
+## Features
+
+- Real-time PPU device monitoring (utilization, memory, temperature, power)
+- Host CPU and memory usage display
+- Per-process PPU memory tracking
+- Interactive curses-based TUI with color-coded utilization bars
+- Non-interactive one-shot mode for scripts and logging
+
+## Demo
+
+```
++-------------------------------------------------------------------------------+
+| ppop - PPU Monitor                               Driver Version: 1.5.5-7a3ae6 |
++-----------------------------------+----------------------+-------------------+
+|              PPU  Name             |      Memory-Usage     |      PPU-Util      |
++===================================+======================+===================+
+| 0  PPU-ZW810E  32C  71W / 400W     |      2MiB / 98304MiB |       0%  Default |
+| 1  PPU-ZW810E  32C  75W / 400W     |      2MiB / 98304MiB |       0%  Default |
++-----------------------------------+----------------------+-------------------+
+
++-------------------------------------------------------------------------------+
+| Host:                                                                          |
+| CPU [||||                ]  21.3% (32 cores)    MEM [||||||              ] 32.1GiB/64.0GiB (50.2%)
++-------------------------------------------------------------------------------+
+
++-------------------------------------------------------------------------------+
+| Processes:                                                                     |
+| PPU       PID  USER         PPU-MEM   CPU%   MEM%       TIME  Command         |
++===============================================================================+
+|   0    12345  user           8192MiB   3.2%  12.6%      1:23  python train.py |
++-------------------------------------------------------------------------------+
+```
+
+## Requirements
+
+- Python 3.8+
+- PPU device with `ppu-smi` installed (default path: `/usr/local/PPU_SDK/ppu-smi/bin/ppu-smi`)
+
+## Installation
+
+### From source
+
+```bash
+git clone https://github.com/your-username/ppop.git
+cd ppop
+pip install .
+```
+
+### From PyPI (coming soon)
+
+```bash
+pip install ppop
+```
+
+## Usage
+
+```bash
+# Interactive mode (real-time monitoring)
+ppop
+
+# One-shot mode (print once and exit)
+ppop --once
+
+# Custom refresh interval (default: 2s)
+ppop -i 5
+```
+
+### Keyboard Shortcuts (interactive mode)
+
+| Key | Action |
+|-----|--------|
+| `q` | Quit |
+| `↑` / `k` | Scroll up |
+| `↓` / `j` | Scroll down |
+| `PgUp` / `PgDn` | Scroll by page |
+| `r` | Force refresh |
+
+## Configuration
+
+If `ppu-smi` is not at the default path, set the environment variable:
+
+```bash
+export PPU_SMI_PATH=/path/to/ppu-smi
+```
+
+## License
+
+[MIT](LICENSE)

ppop-0.1.0/ppop.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+popup/__init__.py
+popup/__main__.py
+popup/cli.py
+popup/device.py
+popup/tui.py
+ppop.egg-info/PKG-INFO
+ppop.egg-info/SOURCES.txt
+ppop.egg-info/dependency_links.txt
+ppop.egg-info/entry_points.txt
+ppop.egg-info/requires.txt
+ppop.egg-info/top_level.txt

ppop-0.1.0/ppop.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ppop-0.1.0/ppop.egg-info/entry_points.txt

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

ppop-0.1.0/ppop.egg-info/requires.txt

@@ -0,0 +1 @@
+psutil>=5.6.6

ppop-0.1.0/ppop.egg-info/top_level.txt

@@ -0,0 +1 @@
+popup

ppop-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ppop"
+version = "0.1.0"
+description = "An interactive PPU process viewer and resource monitor, inspired by nvitop."
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+authors = [
+    { name = "Zhongwang Lun", email = "lunandcnn@gmail.com" },
+]
+keywords = ["ppu", "monitor", "process-viewer", "tui"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console :: Curses",
+    "Intended Audience :: Developers",
+    "Intended Audience :: System Administrators",
+    "Programming Language :: Python :: 3",
+    "Topic :: System :: Monitoring",
+]
+dependencies = [
+    "psutil>=5.6.6",
+]
+
+[project.scripts]
+ppop = "popup.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["popup*"]

ppop-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+