monitorify 1.0.0__py3-none-any.whl

monitorify/ui/tui/widgets/diskWidget.py

@@ -0,0 +1,207 @@
+# pyrefly: ignore [missing-import]
+from textual.widgets import Static
+# pyrefly: ignore [missing-import]
+from textual.containers import Container, Vertical
+from monitorify.ui.tui.widgets.brailleGraph import BrailleGraph, make_time_grid
+
+
+def format_bps(bps: float) -> str:
+    if bps >= 1024 * 1024 * 1024:
+        return f"{bps / (1024 ** 3):.1f} GB/s"
+    elif bps >= 1024 * 1024:
+        return f"{bps / (1024 * 1024):.1f} MB/s"
+    elif bps >= 1024:
+        return f"{bps / 1024:.1f} KB/s"
+    else:
+        return f"{bps:.0f} B/s"
+
+
+def format_bytes(b: float) -> str:
+    if b >= 1024 ** 4:
+        return f"{b / (1024 ** 4):.1f} TB"
+    elif b >= 1024 ** 3:
+        return f"{b / (1024 ** 3):.1f} GB"
+    elif b >= 1024 ** 2:
+        return f"{b / (1024 ** 2):.1f} MB"
+    elif b >= 1024:
+        return f"{b / 1024:.1f} KB"
+    else:
+        return f"{b:.0f} B"
+
+
+def format_storage_summary(disk_storage: dict | None) -> str:
+    if not disk_storage or not isinstance(disk_storage, dict):
+        return "Storage: –"
+
+    total = sum(d.get("total", 0) for d in disk_storage.values() if isinstance(d, dict))
+    used = sum(d.get("used", 0) for d in disk_storage.values() if isinstance(d, dict))
+    pct = (used / total * 100) if total > 0 else 0
+    return f"{format_bytes(used)}/{format_bytes(total)} ({pct:.0f}%)"
+
+
+class DiskRatePoint:
+    def __init__(self, timestamp: float, read_bps: float, write_bps: float):
+        self.timestamp = timestamp
+        self.read_bps = read_bps
+        self.write_bps = write_bps
+
+
+def compute_disk_rates(snapshots: list) -> list[DiskRatePoint]:
+    points = []
+    prev_ts = None
+    prev_read = None
+    prev_write = None
+
+    for s in snapshots:
+        if s.disk_io is None or not isinstance(s.disk_io, dict):
+            prev_ts = None
+            continue
+
+        curr_read = sum(d.get("read_bytes", 0) for d in s.disk_io.values() if isinstance(d, dict))
+        curr_write = sum(d.get("write_bytes", 0) for d in s.disk_io.values() if isinstance(d, dict))
+
+        if prev_ts is not None:
+            dt = s.timestamp - prev_ts
+            if 0 < dt <= 10.0:
+                r_bps = max(0.0, curr_read - prev_read) / dt
+                w_bps = max(0.0, curr_write - prev_write) / dt
+                points.append(DiskRatePoint(s.timestamp, r_bps, w_bps))
+            else:
+                points.append(DiskRatePoint(s.timestamp, 0.0, 0.0))
+        else:
+            points.append(DiskRatePoint(s.timestamp, 0.0, 0.0))
+
+        prev_ts = s.timestamp
+        prev_read = curr_read
+        prev_write = curr_write
+
+    return points
+
+
+class DiskInfo(Container):
+    def compose(self):
+        self.write_current = Static("▲ 0 B/s", classes="tx_text")
+        self.write_top = Static("▲ Top: 0 B/s", classes="tx_text")
+
+        self.read_current = Static("▼ 0 B/s", classes="rx_text")
+        self.read_top = Static("▼ Top: 0 B/s", classes="rx_text")
+
+        self.storage_label = Static("Storage: –", classes="storage_text")
+
+        yield self.write_current
+        yield self.write_top
+        yield Static("")  # Spacer
+        yield self.read_current
+        yield self.read_top
+        yield Static("")  # Spacer
+        yield self.storage_label
+
+
+class DiskWidget(Container):
+    BORDER_TITLE = "DISK"
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.top_read: float = 0.0
+        self.top_write: float = 0.0
+        self.current_read: float = 0.0
+        self.current_write: float = 0.0
+        self.last_timestamp: float | None = None
+        self.last_read_bytes: float = 0.0
+        self.last_write_bytes: float = 0.0
+
+    def compose(self):
+        self.disk_graph = BrailleGraph(
+            data_lines=2,
+            color1="#c678dd",
+            color2="#61afef",
+            show_scale=True,
+            scale_fmt=format_bps,
+            show_timeline=True,
+            id="disk_graph",
+        )
+        yield self.disk_graph
+
+        with Vertical(id="disk_info_wrapper"):
+            self.disk_info = DiskInfo(id="disk_info")
+            self.disk_info.border_title = "write"
+            self.disk_info.border_subtitle = "read"
+            yield self.disk_info
+
+    def _calculate_rates(self, snapshot) -> tuple[float, float]:
+        if snapshot.disk_io is None or not isinstance(snapshot.disk_io, dict):
+            return 0.0, 0.0
+
+        total_read = sum(d.get("read_bytes", 0) for d in snapshot.disk_io.values() if isinstance(d, dict))
+        total_write = sum(d.get("write_bytes", 0) for d in snapshot.disk_io.values() if isinstance(d, dict))
+
+        if self.last_timestamp is None:
+            self.last_timestamp = snapshot.timestamp
+            self.last_read_bytes = total_read
+            self.last_write_bytes = total_write
+            return 0.0, 0.0
+
+        if snapshot.timestamp <= self.last_timestamp:
+            return self.current_read, self.current_write
+
+        dt = snapshot.timestamp - self.last_timestamp
+        if 0 < dt <= 10.0:
+            read_bps = max(0.0, total_read - self.last_read_bytes) / dt
+            write_bps = max(0.0, total_write - self.last_write_bytes) / dt
+        else:
+            read_bps = 0.0
+            write_bps = 0.0
+
+        self.last_timestamp = snapshot.timestamp
+        self.last_read_bytes = total_read
+        self.last_write_bytes = total_write
+        self.current_read = read_bps
+        self.current_write = write_bps
+
+        return read_bps, write_bps
+
+    def update_disk(self, snapshot) -> None:
+        """Update labels and append one live data point to the graph."""
+        read_bps, write_bps = self._calculate_rates(snapshot)
+        self.top_read = max(self.top_read, read_bps)
+        self.top_write = max(self.top_write, write_bps)
+        self._refresh_labels(read_bps, write_bps, snapshot.disk_storage)
+        self.disk_graph.update_value(write_bps, read_bps)
+
+    def update_labels(self, snapshot) -> None:
+        """Update only the text labels — does not touch the graph."""
+        read_bps, write_bps = self._calculate_rates(snapshot)
+        self.top_read = max(self.top_read, read_bps)
+        self.top_write = max(self.top_write, write_bps)
+        self._refresh_labels(read_bps, write_bps, snapshot.disk_storage)
+
+    def _refresh_labels(self, read_bps: float, write_bps: float, disk_storage: dict | None) -> None:
+        info = self.disk_info
+        info.write_current.update(f"▲ {format_bps(write_bps)}")
+        info.write_top.update(f"▲ Top: {format_bps(self.top_write)}")
+        info.read_current.update(f"▼ {format_bps(read_bps)}")
+        info.read_top.update(f"▼ Top: {format_bps(self.top_read)}")
+        info.storage_label.update(format_storage_summary(disk_storage))
+
+    def load_history(self, snapshots: list, time_span: float = 0.0) -> None:
+        """Bulk-load disk I/O history, time-positioned to show real gaps."""
+        w = self.disk_graph.size.width * 2 or 400
+        rate_points = compute_disk_rates(snapshots)
+        read_vals = make_time_grid(rate_points, lambda p: p.read_bps, time_span, w)
+        write_vals = make_time_grid(rate_points, lambda p: p.write_bps, time_span, w)
+
+        real_read = [v for v in read_vals if v is not None]
+        real_write = [v for v in write_vals if v is not None]
+        if real_read:
+            self.top_read = max(real_read)
+        if real_write:
+            self.top_write = max(real_write)
+
+        if snapshots:
+            last = snapshots[-1]
+            if last.disk_io and isinstance(last.disk_io, dict):
+                self.last_timestamp = last.timestamp
+                self.last_read_bytes = sum(d.get("read_bytes", 0) for d in last.disk_io.values() if isinstance(d, dict))
+                self.last_write_bytes = sum(d.get("write_bytes", 0) for d in last.disk_io.values() if isinstance(d, dict))
+
+        self.disk_graph.load_history(write_vals, read_vals, timeline_seconds=time_span)

monitorify/ui/tui/widgets/networkWidget.py

@@ -0,0 +1,98 @@
+# pyrefly: ignore [missing-import]
+from textual.widgets import Static
+# pyrefly: ignore [missing-import]
+from textual.containers import Container, Vertical
+from monitorify.ui.tui.widgets.brailleGraph import BrailleGraph, make_time_grid
+
+
+def format_bps(bps):
+    if bps >= 1024 * 1024:
+        return f"{bps / (1024 * 1024):.1f} MB/s"
+    elif bps >= 1024:
+        return f"{bps / 1024:.1f} KB/s"
+    else:
+        return f"{bps:.0f} B/s"
+
+def format_bytes(b):
+    if b >= 1024 ** 3:
+        return f"{b / (1024 ** 3):.1f} GB"
+    elif b >= 1024 ** 2:
+        return f"{b / (1024 ** 2):.1f} MB"
+    elif b >= 1024:
+        return f"{b / 1024:.1f} KB"
+    else:
+        return f"{b:.0f} B"
+
+
+class NetworkInfo(Container):
+    def compose(self):
+        self.rx_current = Static("▼ 0 B/s", classes="rx_text")
+        self.rx_top = Static("▼ Top: 0 B/s", classes="rx_text")
+
+        self.tx_current = Static("▲ 0 B/s", classes="tx_text")
+        self.tx_top = Static("▲ Top: 0 B/s", classes="tx_text")
+
+        yield self.rx_current
+        yield self.rx_top
+        yield Static("")  # Spacer
+        yield self.tx_current
+        yield self.tx_top
+
+
+class NetworkWidget(Container):
+    BORDER_TITLE = "NET"
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.top_rx = 0
+        self.top_tx = 0
+
+    def compose(self):
+        self.network_graph = BrailleGraph(
+            data_lines=2, color1="#61afef", color2="#c678dd",
+            show_scale=True, scale_fmt=format_bps,
+            show_timeline=True,
+            id="network_graph"
+        )
+        yield self.network_graph
+
+        with Vertical(id="network_info_wrapper"):
+            self.network_info = NetworkInfo(id="network_info")
+            self.network_info.border_title = "download"
+            self.network_info.border_subtitle = "upload"
+            yield self.network_info
+
+    def update_network(self, snapshot) -> None:
+        """Update labels and append one live data point to the graph."""
+        rx_bps, tx_bps = snapshot.network
+        self.top_rx = max(self.top_rx, rx_bps)
+        self.top_tx = max(self.top_tx, tx_bps)
+        self._refresh_labels(rx_bps, tx_bps)
+        self.network_graph.update_value(rx_bps, tx_bps)
+
+    def update_labels(self, snapshot) -> None:
+        """Update only the text labels — does not touch the graph."""
+        rx_bps, tx_bps = snapshot.network
+        self.top_rx = max(self.top_rx, rx_bps)
+        self.top_tx = max(self.top_tx, tx_bps)
+        self._refresh_labels(rx_bps, tx_bps)
+
+    def _refresh_labels(self, rx_bps: float, tx_bps: float) -> None:
+        info = self.network_info
+        info.rx_current.update(f"▼ {format_bps(rx_bps)}")
+        info.rx_top.update(f"▼ Top: {format_bps(self.top_rx)}")
+        info.tx_current.update(f"▲ {format_bps(tx_bps)}")
+        info.tx_top.update(f"▲ Top: {format_bps(self.top_tx)}")
+
+    def load_history(self, snapshots: list, time_span: float = 0.0) -> None:
+        """Bulk-load network history, time-positioned to show real gaps."""
+        w = self.network_graph.size.width * 2 or 400
+        rx_vals = make_time_grid(snapshots, lambda s: s.network[0], time_span, w)
+        tx_vals = make_time_grid(snapshots, lambda s: s.network[1], time_span, w)
+        real_rx = [v for v in rx_vals if v is not None]
+        real_tx = [v for v in tx_vals if v is not None]
+        if real_rx:
+            self.top_rx = max(real_rx)
+        if real_tx:
+            self.top_tx = max(real_tx)
+        self.network_graph.load_history(rx_vals, tx_vals, timeline_seconds=time_span)

monitorify/ui/tui/widgets/procInfoWidget.py

@@ -0,0 +1,44 @@
+# pyrefly: ignore [missing-import]
+from textual.containers import Container
+# pyrefly: ignore [missing-import]
+from textual.widgets import Static
+from monitorify.stats.programmList import get_process_state, get_process_running_time
+
+
+class ProcInfoWidget(Container):
+    BORDER_TITLE = "Process"
+
+    def compose(self):
+        self.pid_label = Static("PID: -")
+        yield self.pid_label
+
+        self.name_label = Static("Name: -")
+        yield self.name_label
+
+        self.state_label = Static("State: -")
+        yield self.state_label
+
+        self.cpu_label = Static("CPU: -")
+        yield self.cpu_label
+
+        self.ram_label = Static("RAM: -")
+        yield self.ram_label
+
+        self.uptime_label = Static("Uptime: -")
+        yield self.uptime_label
+
+    def update_process(self, d: dict):
+        pid = d.get("pid", 0)
+        name = d.get("name", "Unknown")
+        state = d.get("state") or (get_process_state(pid) if pid else "Unknown")
+        uptime = d.get("running_time") or (get_process_running_time(pid) if pid else "Unknown")
+        cpu = d.get("cpu_ussage", 0.0)
+        ram = d.get("ram_ussage", 0.0)
+
+        self.border_title = f"PID: {pid}"
+        self.pid_label.update(f"PID: {pid}")
+        self.name_label.update(f"Name: {name}")
+        self.state_label.update(f"State: {state}")
+        self.cpu_label.update(f"CPU: {cpu:.1f}%")
+        self.ram_label.update(f"RAM: {ram:.1f} MB")
+        self.uptime_label.update(f"Uptime: {uptime}")

monitorify/ui/tui/widgets/programmListWidget.py

@@ -0,0 +1,202 @@
+# pyrefly: ignore [missing-import]
+from textual.containers import Container
+# pyrefly: ignore [missing-import]
+from textual.widgets import ListItem, ListView, Static
+from textual import on
+from textual.events import Click
+from monitorify.stats.programmList import (
+    get_latest_process_items_data,
+    start_process_cache_thread,
+    _format_process_item,
+)
+from monitorify.ui.tui.widgets.procInfoWidget import ProcInfoWidget
+
+
+class FastListView(ListView):
+    """ListView subclass with instant reactive callbacks on scroll or index changes."""
+
+    def watch_scroll_y(self, old_value: float, new_value: float) -> None:
+        super().watch_scroll_y(old_value, new_value)
+        if hasattr(self, "on_scroll_cb") and self.on_scroll_cb:
+            self.on_scroll_cb()
+
+    def watch_index(self, old_value: int | None, new_value: int | None) -> None:
+        super().watch_index(old_value, new_value)
+        if hasattr(self, "on_scroll_cb") and self.on_scroll_cb:
+            self.on_scroll_cb()
+        if hasattr(self, "on_highlight_cb") and self.on_highlight_cb:
+            self.on_highlight_cb()
+
+
+class ProgrammListWidget(Container):
+    BORDER_TITLE = "PROC"
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.last_cache_version = -1
+        self.rendered_limit = 0
+        self.sort_by = "cpu_ussage"
+        self.sort_reverse = True
+        self.current_sorted_data = []
+        self.total_count = 0
+        self.active_info_pid = None
+
+    def compose(self):
+        self.info_static = Static("Processes: 0", id="programm_list_info")
+        yield self.info_static
+
+        header_str = f"[bold underline]{'PID':>6}[/bold underline]  [bold underline]{'NAME':<25}[/bold underline] [bold underline]{'RAM(MB)':>10}[/bold underline]  [bold underline]{'CPU(%)':>7}[/bold underline]"
+        self.header_static = Static(header_str, id="programm_list_header")
+        yield self.header_static
+
+        self.list_view = FastListView(classes="programm_list_view")
+        self.list_view.on_scroll_cb = self.check_expand
+        self.list_view.on_highlight_cb = self.update_details
+        yield self.list_view
+
+    def on_mount(self):
+        start_process_cache_thread(interval=1.5)
+        self.proc_info_box = ProcInfoWidget(id="proc_info_box")
+        self.screen.mount(self.proc_info_box)
+        self.update_list()
+
+    def update_info_box_position(self):
+        if hasattr(self, "proc_info_box") and self.proc_info_box:
+            box_width = 30  # matches StatusWidget width
+            self.proc_info_box.styles.offset = (
+                self.region.x + self.size.width - box_width,
+                self.region.y,
+            )
+
+    def on_resize(self):
+        self.update_info_box_position()
+
+    @on(ListView.Selected)
+    def on_list_view_selected(self, event: ListView.Selected) -> None:
+        idx = self.list_view.index
+        if idx is not None and 0 <= idx < len(self.current_sorted_data):
+            d = self.current_sorted_data[idx]
+            pid = d.get("pid")
+            if pid is not None:
+                if self.active_info_pid == pid:
+                    self.active_info_pid = None
+                else:
+                    self.active_info_pid = pid
+                self.update_details()
+
+    @on(ListView.Highlighted)
+    def on_list_view_highlighted(self, event: ListView.Highlighted) -> None:
+        if self.active_info_pid is not None:
+            idx = self.list_view.index
+            if idx is not None and 0 <= idx < len(self.current_sorted_data):
+                d = self.current_sorted_data[idx]
+                pid = d.get("pid")
+                if pid is not None:
+                    self.active_info_pid = pid
+                    self.update_details()
+
+    def update_details(self) -> None:
+        if not hasattr(self, "info_static") or not hasattr(self, "list_view"):
+            return
+
+        self.info_static.update(f"Processes: {self.total_count}")
+
+        if not self.display or self.active_info_pid is None:
+            if hasattr(self, "proc_info_box") and self.proc_info_box:
+                self.proc_info_box.display = False
+            return
+
+        self.update_info_box_position()
+
+        active_data = None
+        for d in self.current_sorted_data:
+            if d.get("pid") == self.active_info_pid:
+                active_data = d
+                break
+
+        if active_data and hasattr(self, "proc_info_box") and self.proc_info_box:
+            self.proc_info_box.update_process(active_data)
+            self.proc_info_box.display = True
+        else:
+            if hasattr(self, "proc_info_box") and self.proc_info_box:
+                self.proc_info_box.display = False
+
+    def check_expand(self):
+        if not hasattr(self, "list_view"):
+            return
+        idx = self.list_view.index or 0
+        scroll_y = int(self.list_view.scroll_y)
+        height = self.size.height or 20
+        needed = max(idx, scroll_y + height) + 30
+        if needed > self.rendered_limit:
+            self.rendered_limit = max(self.rendered_limit, needed + int(height * 4))
+            self.update_list(force=True)
+
+    @on(Click, "#programm_list_header")
+    def on_header_click(self, event: Click) -> None:
+        x = event.x
+        new_sort = self.sort_by
+        if x <= 7:
+            new_sort = "pid"
+        elif x <= 34:
+            new_sort = "name"
+        elif x <= 46:
+            new_sort = "ram_ussage"
+        else:
+            new_sort = "cpu_ussage"
+            
+        if self.sort_by == new_sort:
+            self.sort_reverse = not self.sort_reverse
+        else:
+            self.sort_by = new_sort
+            self.sort_reverse = True if new_sort in ["ram_ussage", "cpu_ussage"] else False
+            
+        self.update_list(force=True)
+
+    def update_list(self, force: bool = False):
+        if not hasattr(self, "info_static") or not hasattr(self, "list_view"):
+            return
+
+        version, count, items_data = get_latest_process_items_data()
+        self.total_count = count
+
+        if not force and version == self.last_cache_version:
+            self.update_details()
+            return
+
+        self.last_cache_version = version
+        
+        # Sort items_data based on user selection
+        if self.sort_by in ["pid", "ram_ussage", "cpu_ussage"]:
+            items_data.sort(key=lambda d: d.get(self.sort_by, 0), reverse=self.sort_reverse)
+        else:
+            items_data.sort(key=lambda d: str(d.get(self.sort_by, "")).lower(), reverse=self.sort_reverse)
+
+        height = self.size.height or 20
+        max_visible = max(20, int(height * 2.5))
+        current_index = self.list_view.index or 0
+        scroll_y = int(self.list_view.scroll_y)
+
+        needed = max(current_index, scroll_y + height) + 30
+        self.rendered_limit = max(self.rendered_limit, max_visible, needed)
+
+        sliced_data = items_data[:self.rendered_limit]
+        self.current_sorted_data = sliced_data
+        existing_items = list(self.list_view.query(ListItem))
+        new_count = len(sliced_data)
+        existing_count = len(existing_items)
+
+        # In-place update
+        update_limit = min(existing_count, new_count)
+        for i in range(update_limit):
+            formatted_text = _format_process_item(sliced_data[i])
+            existing_items[i].query_one(Static).update(formatted_text)
+
+        if new_count > existing_count:
+            new_items = [ListItem(Static(_format_process_item(d))) for d in sliced_data[existing_count:]]
+            self.list_view.extend(new_items)
+        elif existing_count > new_count:
+            for item in existing_items[new_count:]:
+                item.remove()
+
+        self.update_details()

monitorify/ui/tui/widgets/ramWidget.py

@@ -0,0 +1,36 @@
+# pyrefly: ignore [missing-import]
+from textual.widgets import Static
+# pyrefly: ignore [missing-import]
+from textual.containers import Container
+from monitorify.ui.tui.widgets.brailleGraph import BrailleGraph, make_time_grid
+
+
+class RamWidget(Container):
+    BORDER_TITLE = "MEM"
+
+    def compose(self):
+        self.ram_usage_static = Static("–%")
+        yield self.ram_usage_static
+
+        self.sparkline = BrailleGraph(
+            data_lines=1, color1="#c678dd", y_max=100.0,
+            show_timeline=True,
+            id="ram_sparkline"
+        )
+        yield self.sparkline
+
+    def update_ram(self, snapshot) -> None:
+        """Update label and append one live data point to the graph."""
+        usage = snapshot.ram
+        self.ram_usage_static.update(f"{usage:.1f}%")
+        self.sparkline.update_value(usage)
+
+    def update_text(self, snapshot) -> None:
+        """Update only the label — does not touch the graph."""
+        self.ram_usage_static.update(f"{snapshot.ram:.1f}%")
+
+    def load_history(self, snapshots: list, time_span: float = 0.0) -> None:
+        """Bulk-load RAM history, time-positioned to show real gaps."""
+        w = self.sparkline.size.width * 2 or 400
+        values = make_time_grid(snapshots, lambda s: s.ram, time_span, w)
+        self.sparkline.load_history(values, timeline_seconds=time_span)

monitorify/ui/tui/widgets/statusWidget.py

@@ -0,0 +1,45 @@
+from textual.containers import Container
+from textual.widgets import Static
+import socket
+
+class StatusWidget(Container):
+    BORDER_TITLE = "Status"
+    
+    def compose(self):
+        self.system_info = Static(f"System: {get_kernel_version()}")
+        yield self.system_info
+
+        self.hostname = Static(f"Hostname: {get_hostname()}")
+        yield self.hostname
+        
+        self.uptime = Static(f"Uptime: {get_uptime()}")
+        yield self.uptime
+
+    def on_mount(self):
+        self.set_interval(1, self.update_uptime)
+
+    def update_uptime(self):
+        self.uptime.update(f"Uptime: {get_uptime()}")
+    
+def get_uptime():
+    with open("/proc/uptime", "r") as f:
+        uptime = float(f.read().split()[0])
+        hours = int(uptime // 3600)
+        minutes = int((uptime % 3600) // 60)
+        seconds = int(uptime % 60)
+        return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+
+def get_hostname():
+    return socket.gethostname()
+
+def get_OS_name():
+    with open("/etc/os-release", "r") as f:
+        for line in f:
+            if line.startswith("NAME="):
+                name = line.split("=")[1].strip().strip('"')
+                return name.replace("Linux", "").strip()
+    return "Unknown"
+
+def get_kernel_version():
+    with open("/proc/version", "r") as f:
+        return f.read().split()[2]