monitorify 1.0.0__py3-none-any.whl

monitorify/ui/tui/css/tui.css

@@ -0,0 +1,168 @@
+Screen {
+    background: transparent;
+    padding: 0;
+}
+
+#main_container {
+    layout: grid;
+    grid-size: 2;
+    grid-columns: 1fr 1fr;
+    height: 100%;
+    width: 100%;
+}
+
+CpuWidget,
+RamWidget,
+NetworkWidget,
+ProgrammListWidget,
+DiskWidget {
+    border: round #5c6370;
+    border-title-color: #61afef;
+    border-title-align: left;
+    padding: 0 1;
+    margin: 0;
+    height: 100%;
+}
+
+NetworkWidget,
+DiskWidget {
+    layout: horizontal;
+}
+
+/* Dynamic layout handled in Python */
+
+CpuWidget>Static,
+RamWidget>Static,
+ProgrammListWidget>Static {
+    text-style: bold;
+    color: #abb2bf;
+    margin-bottom: 1;
+}
+
+#programm_list_view,
+.programm_list_view {
+    height: 1fr;
+    background: transparent;
+    border: none;
+}
+
+#programm_list_view ListItem,
+.programm_list_view ListItem {
+    background: transparent;
+    padding: 0 1;
+}
+
+#programm_list_view ListItem:hover,
+.programm_list_view ListItem:hover {
+    background: #3e4451;
+}
+
+#programm_list_view ListItem.--highlight,
+.programm_list_view ListItem.--highlight {
+    background: #4b5263;
+    color: #61afef;
+}
+
+#network_graph,
+#disk_graph {
+    width: 1fr;
+    height: 100%;
+}
+
+#network_info_wrapper,
+#disk_info_wrapper {
+    width: 26;
+    height: 100%;
+    align: center middle;
+    margin-left: 1;
+}
+
+#network_info,
+#disk_info {
+    width: 100%;
+    height: auto;
+    border: round #5c6370;
+    border-title-color: #61afef;
+    border-title-align: right;
+    border-subtitle-color: #61afef;
+    border-subtitle-align: right;
+    padding: 0 1;
+}
+
+#network_info Static,
+#disk_info Static {
+    text-style: bold;
+}
+
+.rx_text {
+    color: #61afef;
+}
+
+.tx_text {
+    color: #c678dd;
+}
+
+.storage_text {
+    color: #98c379;
+}
+
+HistorySparkline {
+    color: #c678dd;
+}
+
+#cpu_sparkline {
+    height: 1fr;
+}
+
+StatusWidget {
+    position: absolute;
+    width: 30;
+    height: auto;
+    border: round #5c6370;
+    border-title-color: #61afef;
+    border-title-align: left;
+    padding: 0 1;
+}
+
+Menu {
+    display: none;
+    position: absolute;
+    align: center middle;
+    width: 40;
+    height: auto;
+    border: round #5c6370;
+    padding: 1 2;
+}
+
+#menu_title {
+    text-style: bold;
+    color: #61afef;
+    margin-bottom: 0;
+}
+
+.menu_label {
+    text-style: bold;
+    color: #abb2bf;
+    margin-top: 1;
+    margin-bottom: 0;
+}
+
+#widget_selector {
+    height: 6;
+}
+
+#interval_select {
+    margin-top: 0;
+    margin-bottom: 0;
+}
+
+ProcInfoWidget {
+    position: absolute;
+    width: 30;
+    height: auto;
+    border: round #5c6370;
+    border-title-color: #61afef;
+    border-title-align: left;
+    padding: 0 1;
+    display: none;
+}

monitorify/ui/tui/tui.py

@@ -0,0 +1,187 @@
+import time
+import sys
+from pathlib import Path
+
+# pyrefly: ignore [missing-import]
+from textual.app import App, ComposeResult
+# pyrefly: ignore [missing-import]
+from textual.widgets import Header, Footer, Label
+from textual.containers import Container, Center, Middle
+from monitorify.ui.tui.widgets.cpuWidget import CpuWidget
+from monitorify.ui.tui.widgets.ramWidget import RamWidget
+from monitorify.ui.tui.widgets.networkWidget import NetworkWidget
+from monitorify.ui.tui.widgets.diskWidget import DiskWidget
+from monitorify.ui.tui.components.menu import Menu
+from monitorify.ui.tui.components.widgetManager import WidgetManager
+from monitorify.ui.tui.widgets.programmListWidget import ProgrammListWidget
+from monitorify.storage import Database
+from monitorify import config
+
+
+class MonitorifyApp(App):
+    CSS_PATH = "css/tui.css"
+
+    TITLE = "Monitorify"
+    BINDINGS = [
+        ("q", "quit"),
+        ("c", "quit"),
+        ("m", "menu")
+    ]
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        # Read-only DB connection — data is written by the daemon
+        self.db = Database(config.DB_PATH)
+        self.db.connect()
+        # Default history window: 1 minute
+        self.history_duration: float = 60.0
+        # Tracks when graphs were last refreshed (for long-window throttling)
+        self._last_graph_refresh: float = 0.0
+
+    def compose(self) -> ComposeResult:
+        with Container(id="main_container"):
+            yield CpuWidget(id="cpu_widget")
+            yield RamWidget(id="ram_widget")
+            yield ProgrammListWidget(id="programmList_widget")
+            yield NetworkWidget(id="network_widget")
+            yield DiskWidget(id="disk_widget")
+        yield Menu()
+        with Center(id="warning_container"):
+            with Middle():
+                yield Label("Terminal window is too small!\nPlease resize.", id="warning_label")
+
+    def on_mount(self) -> None:
+        self.action_get_window_size()
+        self.widget_manager = WidgetManager(self.query_one("#main_container"))
+        self.update_layout()
+        self.update_interval = 1.0
+        # Load history from DB on startup
+        self.call_after_refresh(self._load_initial_history)
+        self.update_timer = self.set_interval(self.update_interval, self.update_display)
+
+    def _load_initial_history(self) -> None:
+        """Load history from DB after the first render so widgets have their sizes."""
+        self.set_history_duration(self.history_duration)
+
+    def set_update_interval(self, seconds: float) -> None:
+        """Updates the graph refresh interval."""
+        self.update_interval = seconds
+        if hasattr(self, "update_timer") and self.update_timer:
+            self.update_timer.stop()
+        self.update_timer = self.set_interval(self.update_interval, self.update_display)
+
+    def set_history_duration(self, seconds: float) -> None:
+        """Load historical metrics from DB and push them into all graph widgets."""
+        self.history_duration = seconds
+        start_time = time.time() - seconds
+        snapshots = self.db.get_history(limit=10000, start_time=start_time)
+
+        try:
+            self.query_one(CpuWidget).load_history(snapshots, time_span=seconds)
+        except Exception:
+            pass
+        try:
+            self.query_one(RamWidget).load_history(snapshots, time_span=seconds)
+        except Exception:
+            pass
+        try:
+            self.query_one(NetworkWidget).load_history(snapshots, time_span=seconds)
+        except Exception:
+            pass
+        try:
+            self.query_one(DiskWidget).load_history(snapshots, time_span=seconds)
+        except Exception:
+            pass
+
+    def update_layout(self) -> None:
+        """Delegates layout updates to WidgetManager."""
+        if hasattr(self, "widget_manager"):
+            self.widget_manager.update_layout()
+
+    def update_display(self) -> None:
+        """Fetch the latest snapshot and update widgets.
+
+        Text labels always update every tick for a live feel.
+        Graphs are only updated when at least one visual slot worth of time
+        has passed — prevents meaningless scrolling on long history windows.
+        """
+        self.action_get_window_size()
+
+        if not self.query_one("#main_container").display:
+            return
+
+        snapshot = self.db.get_latest()
+        if snapshot is None:
+            return
+
+        now = time.time()
+        # Approximate visual width in braille columns
+        approx_graph_w = max(1, self.size.width * 2)
+        slot_secs = self.history_duration / approx_graph_w
+        # Graphs update at most once per visual slot, but at least as often as update_interval
+        graph_refresh_due = (now - self._last_graph_refresh) >= max(slot_secs, self.update_interval)
+
+        try:
+            if graph_refresh_due:
+                self.query_one(CpuWidget).update_cpu(snapshot)
+            else:
+                self.query_one(CpuWidget).update_text(snapshot)
+        except Exception:
+            pass
+        try:
+            if graph_refresh_due:
+                self.query_one(RamWidget).update_ram(snapshot)
+            else:
+                self.query_one(RamWidget).update_text(snapshot)
+        except Exception:
+            pass
+        try:
+            if graph_refresh_due:
+                self.query_one(NetworkWidget).update_network(snapshot)
+            else:
+                self.query_one(NetworkWidget).update_labels(snapshot)
+        except Exception:
+            pass
+        try:
+            if graph_refresh_due:
+                self.query_one(DiskWidget).update_disk(snapshot)
+            else:
+                self.query_one(DiskWidget).update_labels(snapshot)
+        except Exception:
+            pass
+        try:
+            self.query_one(ProgrammListWidget).update_list()
+        except Exception:
+            pass
+
+        if graph_refresh_due:
+            self._last_graph_refresh = now
+
+    def action_get_window_size(self) -> None:
+        is_too_small = self.size.width < 80 or self.size.height < 24
+
+        if is_too_small:
+            self.query_one("#main_container").display = False
+            self.query_one("#warning_container").display = True
+        else:
+            self.query_one("#main_container").display = True
+            self.query_one("#warning_container").display = False
+
+    def action_menu(self) -> None:
+        menu = self.query_one(Menu)
+        menu.display = not menu.display
+        if menu.display:
+            menu.populate_menu()
+            try:
+                from textual.widgets import SelectionList
+                menu.query_one(SelectionList).focus()
+            except Exception:
+                pass
+
+    def on_unmount(self) -> None:
+        self.db.disconnect()
+
+
+if __name__ == "__main__":
+    app = MonitorifyApp()
+    app.run()

monitorify/ui/tui/widgets/__init__.py

@@ -0,0 +1 @@
+from monitorify.ui.tui.widgets.diskWidget import DiskWidget

monitorify/ui/tui/widgets/brailleGraph.py

@@ -0,0 +1,261 @@
+import time as _time
+from textual.widget import Widget
+from textual.app import RenderResult
+from collections import deque
+from rich.text import Text
+from rich.style import Style
+
+_SCALE_W = 7   # chars reserved for Y-axis scale
+_DIM = Style(color="#3e4452")
+_TICK = Style(color="#abb2bf")
+
+
+def make_time_grid(snapshots, value_fn, time_span: float, width: int) -> list:
+    """Map snapshots to a time-positioned list[float | None].
+    Slots with no snapshot remain None — the graph draws nothing there.
+    This ensures gaps where no daemon was running appear as empty space.
+    """
+    if not snapshots or time_span <= 0 or width <= 0:
+        # Fall back to plain chronological list (no gap info)
+        return [value_fn(s) for s in snapshots]
+
+    now = _time.time()
+    start = now - time_span
+    grid: list = [None] * width
+
+    for s in snapshots:
+        if s.timestamp < start:
+            continue
+        pos = int((s.timestamp - start) / time_span * (width - 1))
+        pos = max(0, min(width - 1, pos))
+        grid[pos] = value_fn(s)
+
+    return grid
+
+
+class BrailleGraph(Widget):
+    DEFAULT_CSS = """
+    BrailleGraph {
+        height: 1fr;
+        min-height: 4;
+    }
+    """
+
+    def __init__(
+        self,
+        data_lines: int = 1,
+        max_points: int = 2000,
+        color1: str = "#c678dd",
+        color2: str = "#61afef",
+        y_max: float | None = None,
+        min_dots: int = 1,
+        show_scale: bool = False,
+        scale_fmt=None,
+        show_timeline: bool = False,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.data_lines = data_lines
+        self.max_points = max_points
+        self.color1 = Style(color=color1)
+        self.color2 = Style(color=color2)
+        self.y_max = y_max
+        self.min_dots = min_dots
+        self.show_scale = show_scale
+        self.scale_fmt = scale_fmt or (lambda v: f"{v:.1f}%")
+        self.show_timeline = show_timeline
+        self.timeline_seconds: float = 0.0
+
+        self.history1 = deque(maxlen=max_points)
+        if self.data_lines > 1:
+            self.history2 = deque(maxlen=max_points)
+
+    # ── helpers ──────────────────────────────────────────────────────────────
+
+    @staticmethod
+    def _fmt_age(secs: float) -> str:
+        """Format a number of seconds as a short age label."""
+        if secs < 1:
+            return "now"
+        if secs < 60:
+            return f"{int(secs)}s"
+        if secs < 3600:
+            return f"{int(secs / 60)}m"
+        h = secs / 3600
+        return f"{h:.0f}h" if h == int(h) else f"{h:.1f}h"
+
+    def _build_timeline_row(self, width_chars: int) -> Text:
+        """Build the timeline row shown below the graph."""
+        row = list("─" * width_chars)
+
+        if self.timeline_seconds > 0 and width_chars >= 8:
+            num_ticks = min(5, max(2, width_chars // 8))
+            for i in range(num_ticks):
+                frac = i / (num_ticks - 1) if num_ticks > 1 else 0
+                age = self.timeline_seconds * (1 - frac)
+                label = self._fmt_age(age)
+                pos = int(frac * (width_chars - 1))
+                start = pos - len(label) // 2
+                start = max(0, min(start, width_chars - len(label)))
+                for j, ch in enumerate(label):
+                    if 0 <= start + j < width_chars:
+                        row[start + j] = ch
+
+        text = Text()
+        for ch in row:
+            text.append(ch, _TICK if ch != "─" else _DIM)
+        return text
+
+    def _make_scale_label(self, value: float, style: Style) -> Text:
+        """Right-aligned, separator-prefixed scale label."""
+        label = self.scale_fmt(value)[-(_SCALE_W - 1):]
+        text = Text()
+        text.append("┤", _DIM)
+        text.append(label.rjust(_SCALE_W - 1), style)
+        return text
+
+    # ── public API ────────────────────────────────────────────────────────────
+
+    def load_history(
+        self,
+        values1: list,
+        values2: list | None = None,
+        timeline_seconds: float = 0.0,
+    ) -> None:
+        """Load historical data (list[float | None]) into the graph.
+        None entries represent time slots with no data — nothing is drawn there.
+        """
+        self.timeline_seconds = timeline_seconds
+        self.history1 = deque(values1, maxlen=self.max_points)
+        if self.data_lines > 1 and values2 is not None:
+            self.history2 = deque(values2, maxlen=self.max_points)
+        self.refresh()
+
+    def update_value(self, val1: float, val2: float = 0):
+        self.history1.append(val1)
+        if self.data_lines > 1:
+            self.history2.append(val2)
+        self.refresh()
+
+    # ── render ────────────────────────────────────────────────────────────────
+
+    def render(self) -> RenderResult:
+        width_chars = self.size.width
+        height_chars = self.size.height
+        if width_chars <= 0 or height_chars <= 0:
+            return ""
+
+        timeline_rows = 1 if (self.show_timeline and height_chars > 2) else 0
+        scale_w = _SCALE_W if self.show_scale else 0
+        graph_chars = max(1, width_chars - scale_w)
+        graph_rows = max(1, height_chars - timeline_rows)
+
+        w = graph_chars * 2
+        h = graph_rows * 4
+
+        if w > self.max_points:
+            self.max_points = w
+            self.history1 = deque(self.history1, maxlen=self.max_points)
+            if self.data_lines > 1:
+                self.history2 = deque(self.history2, maxlen=self.max_points)
+
+        grid = [[False] * w for _ in range(h)]
+        data1 = list(self.history1)
+
+        if self.data_lines == 1:
+            real_vals = [v for v in data1 if v is not None]
+            if self.y_max is not None:
+                max_val = self.y_max
+            else:
+                max_val = max(real_vals) if real_vals else 1
+                max_val = max(max_val, 1)
+
+            num_points = min(w, len(data1))
+            start_x = w - num_points
+
+            for i in range(num_points):
+                x = start_x + i
+                val = data1[len(data1) - num_points + i]
+                if val is None:
+                    continue  # Gap — no daemon data for this slot
+                dots = max(self.min_dots, round((val / max_val) * h))
+                for y in range(h - dots, h):
+                    if 0 <= y < h:
+                        grid[y][x] = True
+
+        else:
+            data2 = list(self.history2)
+            if self.y_max is not None:
+                max_val = self.y_max
+            else:
+                real1 = [v for v in data1 if v is not None]
+                real2 = [v for v in data2 if v is not None]
+                max_val = max(
+                    max(real1) if real1 else 1,
+                    max(real2) if real2 else 1,
+                    1,
+                )
+
+            center_y = h // 2
+            num_points = min(w, len(data1))
+            start_x = w - num_points
+
+            for i in range(num_points):
+                x = start_x + i
+                idx = len(data1) - num_points + i
+                v1 = data1[idx]
+                v2 = data2[idx] if idx < len(data2) else None
+                if v1 is None and v2 is None:
+                    continue  # Gap — skip entirely
+                v1 = v1 or 0.0
+                v2 = v2 or 0.0
+                dots1 = int((v1 / max_val) * (h / 2))
+                if v1 > 0 and dots1 == 0:
+                    dots1 = self.min_dots
+                dots2 = int((v2 / max_val) * (h / 2))
+                if v2 > 0 and dots2 == 0:
+                    dots2 = self.min_dots
+                for y in range(center_y - dots1, center_y):
+                    if 0 <= y < h:
+                        grid[y][x] = True
+                for y in range(center_y, center_y + dots2):
+                    if 0 <= y < h:
+                        grid[y][x] = True
+
+        braille_map = [[0x01, 0x08], [0x02, 0x10], [0x04, 0x20], [0x40, 0x80]]
+        lines = []
+
+        for row_idx, cy in enumerate(range(0, h, 4)):
+            line_str = ""
+            for cx in range(0, w, 2):
+                char_val = 0x2800
+                for dy in range(4):
+                    for dx in range(2):
+                        if grid[cy + dy][cx + dx]:
+                            char_val += braille_map[dy][dx]
+                line_str += chr(char_val)
+
+            style = self.color1 if (self.data_lines == 1 or cy < h // 2) else self.color2
+            line = Text(line_str, style=style)
+
+            if self.show_scale:
+                is_top = row_idx == 0
+                is_bot = row_idx == graph_rows - 1
+                is_mid = self.data_lines > 1 and row_idx == graph_rows // 2
+                if is_top:
+                    line.append_text(self._make_scale_label(max_val, self.color1))
+                elif is_mid:
+                    line.append_text(self._make_scale_label(0, Style(color="#5c6370")))
+                elif is_bot:
+                    bot_style = self.color2 if self.data_lines > 1 else self.color1
+                    bot_val = max_val if self.data_lines > 1 else 0
+                    line.append_text(self._make_scale_label(bot_val, bot_style))
+                else:
+                    line.append(" " * scale_w)
+
+            lines.append(line)
+
+        if timeline_rows:
+            lines.append(self._build_timeline_row(width_chars))
+
+        return Text("\n").join(lines)

monitorify/ui/tui/widgets/cpuWidget.py

@@ -0,0 +1,46 @@
+# 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
+from monitorify.ui.tui.widgets.statusWidget import StatusWidget
+
+
+class CpuWidget(Container):
+    BORDER_TITLE = "CPU │ [bold #c678dd]M[/bold #c678dd]enu   [bold #c678dd]Q[/bold #c678dd]uit"
+
+    def compose(self):
+        self.cpu_usage_static = Static("–%")
+        yield self.cpu_usage_static
+
+        self.sparkline = BrailleGraph(
+            data_lines=1, color1="#61afef", y_max=100.0,
+            show_timeline=True,
+            id="cpu_sparkline"
+        )
+        yield self.sparkline
+
+    def on_mount(self):
+        self.status_box = StatusWidget(id="status_box")
+        self.screen.mount(self.status_box)
+
+    def on_resize(self):
+        if hasattr(self, "status_box"):
+            box_width = 30
+            self.status_box.styles.offset = (self.region.x + self.size.width - box_width, self.region.y)
+
+    def update_cpu(self, snapshot) -> None:
+        """Update label and append one live data point to the graph."""
+        usage = snapshot.cpu
+        self.cpu_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.cpu_usage_static.update(f"{snapshot.cpu:.1f}%")
+
+    def load_history(self, snapshots: list, time_span: float = 0.0) -> None:
+        """Bulk-load CPU history, time-positioned to show real gaps."""
+        w = self.sparkline.size.width * 2 or 400
+        values = make_time_grid(snapshots, lambda s: s.cpu, time_span, w)
+        self.sparkline.load_history(values, timeline_seconds=time_span)