monitorify 1.0.0__py3-none-any.whl

monitorify/stats/programmList.py

@@ -0,0 +1,272 @@
+import os
+import time
+import threading
+
+# pyrefly: ignore [missing-import]
+from textual.widgets import ListItem, Static
+
+_cache_lock = threading.Lock()
+_current_cache = {}
+_current_pids = []
+_current_items_data = []
+_cache_version = 0
+_thread_started = False
+
+_PAGE_SIZE = os.sysconf('SC_PAGE_SIZE') if hasattr(os, 'sysconf') else 4096
+_CLK_TCK = float(os.sysconf(os.sysconf_names.get("SC_CLK_TCK", "SC_CLK_TCK"))) if hasattr(os, "sysconf") else 100.0
+
+_previous_cpu_times = {}
+_previous_cpu_timestamp = 0.0
+
+
+def get_process_list():
+    # Get active PIDs
+    try:
+        return [int(p) for p in os.listdir("/proc") if p.isdigit()]
+    except (FileNotFoundError, PermissionError, OSError):
+        return []
+
+
+def get_system_uptime() -> float:
+    """Fetch total system uptime in seconds once per cycle."""
+    try:
+        with open("/proc/uptime", "r") as f:
+            return float(f.read().split()[0])
+    except Exception:
+        return 0.0
+
+
+def _format_running_time(uptime_seconds: float, start_time_ticks: float) -> str:
+    """Format process running time from starttime ticks."""
+    start_time_seconds = start_time_ticks / _CLK_TCK
+    elapsed_seconds = int(uptime_seconds - start_time_seconds)
+
+    if elapsed_seconds < 0:
+        return "00:00"
+
+    days, remainder = divmod(elapsed_seconds, 86400)
+    hours, remainder = divmod(remainder, 3600)
+    minutes, seconds = divmod(remainder, 60)
+
+    if days > 0:
+        return f"{days}d {hours:02d}:{minutes:02d}:{seconds:02d}"
+    elif hours > 0:
+        return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+    else:
+        return f"{minutes:02d}:{seconds:02d}"
+
+
+def build_process_cache(pids=None):
+    """Build process cache in a single pass per process by reading /proc/{pid}/stat."""
+    global _previous_cpu_times, _previous_cpu_timestamp
+    if pids is None:
+        pids = get_process_list()
+
+    current_timestamp = time.time()
+    elapsed_seconds = current_timestamp - _previous_cpu_timestamp
+    if elapsed_seconds <= 0:
+        elapsed_seconds = 0.1
+
+    uptime = get_system_uptime()
+
+    state_map = {
+        'S': 'Sleeping',
+        'R': 'Running',
+        'D': 'Waiting',
+        'Z': 'Zombie',
+        'T': 'Stopped',
+        't': 'Stopped'
+    }
+
+    cache = {}
+    new_cpu_times = {}
+
+    for pid in pids:
+        try:
+            with open(f"/proc/{pid}/stat", "r") as f:
+                data = f.read()
+
+            start = data.find('(')
+            end = data.rfind(')')
+            if start == -1 or end == -1:
+                continue
+
+            name = data[start + 1:end]
+            fields = data[end + 1:].split()
+
+            # State
+            state = state_map.get(fields[0], "Unknown")
+
+            # CPU times: utime (field 11) + stime (field 12)
+            utime = int(fields[11])
+            stime = int(fields[12])
+            cpu_time = utime + stime
+            new_cpu_times[pid] = cpu_time
+
+            # CPU percentage calculation
+            prev_time = _previous_cpu_times.get(pid)
+            if prev_time is not None:
+                delta_ticks = cpu_time - prev_time
+                cpu_usage = round(100.0 * (delta_ticks / _CLK_TCK) / elapsed_seconds, 1)
+            else:
+                cpu_usage = 0.0
+
+            # Running time: starttime (field 19)
+            start_time_ticks = float(fields[19])
+            running_time = _format_running_time(uptime, start_time_ticks)
+
+            # RAM usage: rss (field 21 in pages)
+            ram_bytes = int(fields[21]) * _PAGE_SIZE
+            ram_usage = round(ram_bytes / (1024 ** 2), 1)
+
+            cache[pid] = {
+                'name': name,
+                'ram_ussage': ram_usage,
+                'cpu_ussage': cpu_usage,
+                'state': state,
+                'running_time': running_time,
+            }
+        except (FileNotFoundError, PermissionError, ProcessLookupError, OSError, ValueError, IndexError):
+            continue
+
+    _previous_cpu_times = new_cpu_times
+    _previous_cpu_timestamp = current_timestamp
+
+    return cache
+
+
+def get_process_data_list(pids, cache):
+    if not isinstance(cache, dict):
+        cache = {}
+    if pids is None:
+        return []
+    
+    data_list = []
+    for pid in pids:
+        info = cache.get(pid, {})
+        if isinstance(info, str):
+            info = {'name': info, 'ram_ussage': 0, 'cpu_ussage': 0, 'state': 'Unknown', 'running_time': 'Unknown'}
+        
+        name = info.get('name', 'Unknown')
+        ram = info.get('ram_ussage', 0)
+        cpu = info.get('cpu_ussage', 0)
+        state = info.get('state', 'Unknown')
+        running_time = info.get('running_time', 'Unknown')
+        data_list.append({
+            'pid': pid,
+            'name': name,
+            'ram_ussage': ram,
+            'cpu_ussage': cpu,
+            'state': state,
+            'running_time': running_time
+        })
+    return data_list
+
+
+def _cache_worker(interval: float = 2.0):
+    global _current_cache, _current_pids, _current_items_data, _cache_version
+    while True:
+        pids = get_process_list()
+        if pids:
+            cache = build_process_cache(pids)
+            items_data = get_process_data_list(pids, cache)
+            with _cache_lock:
+                _current_pids = pids
+                _current_cache = cache
+                _current_items_data = items_data
+                _cache_version += 1
+        time.sleep(interval)
+
+
+def start_process_cache_thread(interval: float = 2.0):
+    global _thread_started
+    with _cache_lock:
+        if _thread_started:
+            return
+        _thread_started = True
+
+    t = threading.Thread(target=_cache_worker, args=(interval,), daemon=True)
+    t.start()
+
+
+def get_latest_process_data():
+    """Return latest process data tuple."""
+    global _current_cache, _current_pids, _cache_version
+    start_process_cache_thread()
+    with _cache_lock:
+        if _cache_version == 0:
+            pids = get_process_list()
+            if pids:
+                cache = build_process_cache(pids)
+                _current_pids = pids
+                _current_cache = cache
+                _cache_version = 1
+        version = _cache_version
+        pids = list(_current_pids)
+        cache = dict(_current_cache)
+    data_list = get_process_data_list(pids, cache)
+    return version, pids, data_list
+
+
+def get_latest_process_items_data():
+    """Return (version, count, items_data_list)."""
+    global _current_cache, _current_pids, _current_items_data, _cache_version
+    start_process_cache_thread()
+    with _cache_lock:
+        if _cache_version == 0:
+            pids = get_process_list()
+            if pids:
+                cache = build_process_cache(pids)
+                _current_pids = pids
+                _current_cache = cache
+                _current_items_data = get_process_data_list(pids, cache)
+                _cache_version = 1
+        version = _cache_version
+        count = len(_current_pids)
+        items_data = list(_current_items_data)
+
+    return version, count, items_data
+
+
+def _format_process_item(d: dict) -> str:
+    ram_mb = f"{d['ram_ussage']:.1f} MB" if isinstance(d['ram_ussage'], (int, float)) else "0.0 MB"
+    
+    cpu_val = d.get('cpu_ussage', 0.0)
+    cpu_str = f"{cpu_val:.1f}%" if isinstance(cpu_val, (int, float)) else "0.0%"
+    
+    name = str(d.get('name', ''))
+    if len(name) > 25:
+        name = name[:22] + "..."
+        
+    return f"[bold #61afef]{d.get('pid', 0):>6d}[/bold #61afef]  {name:<25} [yellow]{ram_mb:>10}[/yellow]  [red]{cpu_str:>7}[/red]"
+
+
+def get_latest_process_items():
+    """Return ListItems for UI hot swap."""
+    version, count, items_data = get_latest_process_items_data()
+    list_items = [ListItem(Static(_format_process_item(d))) for d in items_data]
+    return version, count, list_items
+
+
+def get_process_ram_ussage(pids: list[int]):
+    """Deprecated: Standalone RAM fetcher."""
+    cache = build_process_cache(pids)
+    return [cache.get(pid, {}).get('ram_ussage', 0.0) for pid in pids]
+
+
+def get_process_cpu_usage(pids: list[int]):
+    """Deprecated: Standalone CPU fetcher."""
+    cache = build_process_cache(pids)
+    return [cache.get(pid, {}).get('cpu_ussage', 0.0) for pid in pids]
+
+
+def get_process_state(pid: int):
+    """Standalone State fetcher."""
+    cache = build_process_cache([pid])
+    return cache.get(pid, {}).get('state', 'Unknown')
+
+
+def get_process_running_time(pid: int) -> str:
+    """Standalone Running Time fetcher."""
+    cache = build_process_cache([pid])
+    return cache.get(pid, {}).get('running_time', 'Unknown')

monitorify/stats/ramStats.py

@@ -0,0 +1,18 @@
+def get_ram_usage(unit="percent"):
+    mem_available = None
+    mem_total = None
+    with open("/proc/meminfo", "r") as f:
+        for line in f:
+            if line.startswith("MemAvailable:"):
+                mem_available = int(line.split()[1])
+            elif line.startswith("MemTotal:"):
+                mem_total = int(line.split()[1])
+            if mem_available is not None and mem_total is not None:
+                break
+    
+    if unit == "percent":
+        return round((1.0 - (mem_available / mem_total)) * 100, 2)
+    elif unit == "raw":
+        return 1.0 - (mem_available / mem_total)
+    else:
+        raise ValueError("Invalid unit. Use 'percent' or 'raw'.")

monitorify/storage/__init__.py

@@ -0,0 +1,3 @@
+from .db import Database
+
+__all__ = ["Database"]

monitorify/storage/db.py

@@ -0,0 +1,154 @@
+import sqlite3
+import json
+import os
+from typing import List, Optional
+from monitorify.collector.schema import MetricSnapshot
+from monitorify import config
+
+class Database:
+    def __init__(self, path: str = config.DB_PATH):
+        self.path = path
+        self._connection: Optional[sqlite3.Connection] = None
+
+    def connect(self):
+        dir_name = os.path.dirname(self.path)
+        if dir_name and not os.path.exists(dir_name):
+            try:
+                os.makedirs(dir_name, exist_ok=True)
+            except Exception as e:
+                print(f"Error creating directory: {e}")
+
+        # check_same_thread=False enables background worker threads to write safely
+        self._connection = sqlite3.connect(self.path, check_same_thread=False)
+        self._connection.row_factory = sqlite3.Row
+        self._connection.execute(
+            """
+            CREATE TABLE IF NOT EXISTS metrics (
+                timestamp REAL PRIMARY KEY,
+                cpu REAL,
+                ram REAL,
+                network_rx REAL,
+                network_tx REAL,
+                processes_count INTEGER,
+                disk_io TEXT,
+                disk_storage TEXT
+            )
+            """
+        )
+        self._connection.commit()
+
+        # Migrate existing table schema if columns are missing
+        cursor = self._connection.cursor()
+        cursor.execute("PRAGMA table_info(metrics)")
+        columns = [row["name"] for row in cursor.fetchall()]
+        if "disk_io" not in columns:
+            self._connection.execute("ALTER TABLE metrics ADD COLUMN disk_io TEXT")
+        if "disk_storage" not in columns:
+            self._connection.execute("ALTER TABLE metrics ADD COLUMN disk_storage TEXT")
+        self._connection.commit()
+
+    def disconnect(self):
+        if self._connection:
+            self._connection.close()
+            self._connection = None
+
+    def __enter__(self):
+        self.connect()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.disconnect()
+
+    def _ensure_connected(self):
+        if self._connection is None:
+            self.connect()
+
+    def save(self, metric_snapshot: MetricSnapshot):
+        self._ensure_connected()
+        try:
+            disk_io_json = json.dumps(metric_snapshot.disk_io) if metric_snapshot.disk_io is not None else None
+            disk_storage_json = json.dumps(metric_snapshot.disk_storage) if metric_snapshot.disk_storage is not None else None
+
+            self._connection.execute(
+                """
+                INSERT INTO metrics (timestamp, cpu, ram, network_rx, network_tx, processes_count, disk_io, disk_storage)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    metric_snapshot.timestamp,
+                    metric_snapshot.cpu,
+                    metric_snapshot.ram,
+                    metric_snapshot.network[0],
+                    metric_snapshot.network[1],
+                    metric_snapshot.processes_count,
+                    disk_io_json,
+                    disk_storage_json,
+                )
+            )
+            self._connection.commit()
+        except Exception as e:
+            print(f"Error saving metrics: {e}")
+
+    def get_history(self, limit: int = 100, start_time: Optional[float] = None, end_time: Optional[float] = None) -> List[MetricSnapshot]:
+        """Fetch historical metric snapshots."""
+        self._ensure_connected()
+        query = "SELECT timestamp, cpu, ram, network_rx, network_tx, processes_count, disk_io, disk_storage FROM metrics"
+        params = []
+        conditions = []
+
+        if start_time is not None:
+            conditions.append("timestamp >= ?")
+            params.append(start_time)
+        if end_time is not None:
+            conditions.append("timestamp <= ?")
+            params.append(end_time)
+
+        if conditions:
+            query += " WHERE " + " AND ".join(conditions)
+
+        query += " ORDER BY timestamp DESC LIMIT ?"
+        params.append(limit)
+
+        try:
+            cursor = self._connection.cursor()
+            cursor.execute(query, params)
+            rows = cursor.fetchall()
+            
+            snapshots = []
+            for row in reversed(rows):  # Return chronological order
+                disk_io = json.loads(row["disk_io"]) if ("disk_io" in row.keys() and row["disk_io"]) else None
+                disk_storage = json.loads(row["disk_storage"]) if ("disk_storage" in row.keys() and row["disk_storage"]) else None
+
+                snapshots.append(
+                    MetricSnapshot(
+                        timestamp=row["timestamp"],
+                        cpu=row["cpu"],
+                        ram=row["ram"],
+                        network=(row["network_rx"], row["network_tx"]),
+                        processes_count=row["processes_count"],
+                        disk_io=disk_io,
+                        disk_storage=disk_storage,
+                    )
+                )
+            return snapshots
+        except Exception as e:
+            print(f"Error fetching history: {e}")
+            return []
+
+
+    def get_latest(self) -> Optional[MetricSnapshot]:
+        """Fetch the most recent metric snapshot."""
+        history = self.get_history(limit=1)
+        return history[0] if history else None
+
+    def prune_old_metrics(self, max_age_seconds: float):
+        """Remove metrics older than specified seconds."""
+        self._ensure_connected()
+        cutoff_time = os.time.time() if hasattr(os, 'time') else sqlite3.connect  # time reference
+        import time
+        cutoff = time.time() - max_age_seconds
+        try:
+            self._connection.execute("DELETE FROM metrics WHERE timestamp < ?", (cutoff,))
+            self._connection.commit()
+        except Exception as e:
+            print(f"Error pruning metrics: {e}")

monitorify/ui/__init__.py

@@ -0,0 +1 @@
+# Package init

monitorify/ui/tui/__init__.py

@@ -0,0 +1 @@
+# Package init

monitorify/ui/tui/components/menu.py

@@ -0,0 +1,180 @@
+# pyrefly: ignore [missing-import]
+from textual.containers import Container, Vertical
+# pyrefly: ignore [missing-import]
+from textual.widgets import SelectionList, Static, Select, Input
+# pyrefly: ignore [missing-import]
+from textual.widgets.selection_list import Selection
+
+INTERVAL_OPTIONS: list[tuple[str, float]] = [
+    ("0.25s", 0.25),
+    ("0.50s", 0.5),
+    ("1.00s", 1.0),
+    ("2.00s", 2.0),
+    ("5.00s", 5.0),
+]
+
+HISTORY_OPTIONS: list[tuple[str, float | None]] = [
+    ("1m", 60.0),
+    ("5m", 300.0),
+    ("10m", 600.0),
+    ("30m", 1800.0),
+    ("1h", 3600.0),
+    ("custom", None)
+]
+
+
+def parse_duration(text: str) -> float | None:
+    """Parse a human-readable duration string into seconds.
+    Examples: '120s', '2h', '1d', '30m', '1w'.
+    Returns None if the string cannot be parsed.
+    """
+    text = text.strip().lower()
+    units = {"s": 1, "m": 60, "h": 3600, "d": 86400, "w": 604800}
+    for suffix, multiplier in units.items():
+        if text.endswith(suffix):
+            try:
+                return float(text[:-1]) * multiplier
+            except ValueError:
+                return None
+    # Plain number — treat as seconds
+    try:
+        return float(text)
+    except ValueError:
+        return None
+
+
+class Menu(Container):
+
+    def compose(self):
+        with Vertical(id="menu"):
+            yield Static("[bold #61afef]M[/bold #61afef]enu", id="menu_title")
+            yield Static("[bold #abb2bf]Widgets:[/bold #abb2bf]", classes="menu_label")
+            yield SelectionList[str](id="widget_selector")
+            yield Static("[bold #abb2bf]Update Interval:[/bold #abb2bf]", classes="menu_label")
+            yield Select(
+                options=INTERVAL_OPTIONS,
+                value=1.0,
+                id="interval_select",
+                allow_blank=False,
+            )
+            yield Static("[bold #abb2bf]History Duration:[/bold #abb2bf]", classes="menu_label")
+            yield Select(
+                options=HISTORY_OPTIONS,
+                value=60.0,
+                id="history_select",
+                allow_blank=False,
+            )
+            yield Input(
+                placeholder="Duration e.g. 120s, 2h, 1d, 1w",
+                id="custom_history_input",
+            )
+
+    def on_mount(self) -> None:
+        self.query_one("#custom_history_input", Input).display = False
+        self.populate_menu()
+
+    def populate_menu(self) -> None:
+        """Populates selection list with widget options and updates interval select value."""
+        try:
+            selection_list = self.query_one(SelectionList)
+            selection_list.clear_options()
+            for name, widget_id in self.get_available_widgets().items():
+                widget = self.app.query_one(f"#{widget_id}")
+                selection_list.add_option(
+                    Selection(prompt=name, value=name, initial_state=widget.display)
+                )
+        except Exception:
+            pass
+
+        try:
+            interval_select = self.query_one("#interval_select", Select)
+            current_interval = getattr(self.app, "update_interval", 1.0)
+            if interval_select.value != current_interval:
+                interval_select.value = current_interval
+        except Exception:
+            pass
+
+    def on_select_changed(self, event: Select.Changed) -> None:
+        """Handles changes in the update interval and history duration selectors."""
+        if event.select.id == "interval_select" and event.value is not Select.BLANK:
+            if hasattr(self.app, "set_update_interval"):
+                self.app.set_update_interval(float(event.value))
+
+        elif event.select.id == "history_select":
+            custom_input = self.query_one("#custom_history_input", Input)
+            is_custom = event.value is None
+            custom_input.display = is_custom
+            if is_custom:
+                custom_input.focus()
+            else:
+                # Apply the selected preset duration
+                if hasattr(self.app, "set_history_duration"):
+                    self.app.set_history_duration(float(event.value))
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        """Parses and applies custom history duration on Enter."""
+        if event.input.id != "custom_history_input":
+            return
+        duration = parse_duration(event.value)
+        if duration is not None and duration > 0:
+            if hasattr(self.app, "set_history_duration"):
+                self.app.set_history_duration(duration)
+            # Return focus to the selection list so the user isn't trapped
+            try:
+                self.query_one(SelectionList).focus()
+            except Exception:
+                pass
+        else:
+            event.input.placeholder = "Invalid — try: 120s, 2h, 1d, 1w"
+
+    def on_selection_list_selected_changed(self, event: SelectionList.SelectedChanged) -> None:
+        """Toggles widget visibility based on selection changes."""
+        selected_names = event.selection_list.selected
+        for name, widget_id in self.get_available_widgets().items():
+            try:
+                widget = self.app.query_one(f"#{widget_id}")
+                widget.display = name in selected_names
+            except Exception:
+                pass
+        if hasattr(self.app, "update_layout"):
+            self.app.update_layout()
+
+    def get_available_widgets(self) -> dict[str, str]:
+        """Returns a map of {widget_name: widget_id} from main_container."""
+        widgets_map = {}
+        try:
+            main_container = self.app.query_one("#main_container")
+            for child in main_container.children:
+                raw_title = getattr(child, "BORDER_TITLE", child.__class__.__name__)
+                clean_name = raw_title.split()[0] if raw_title else child.__class__.__name__
+                widget_id = child.id or child.__class__.__name__.lower()
+                widgets_map[clean_name] = widget_id
+        except Exception:
+            pass
+        return widgets_map
+
+    def select_widget(self, widget_name: str) -> str | None:
+        """Returns the widget ID for a given widget name."""
+        widgets_map = self.get_available_widgets()
+        for name, widget_id in widgets_map.items():
+            if name.upper() == widget_name.upper():
+                return widget_id
+        return None
+
+    def toggle_widget(self, widget: str) -> None:
+        """Toggles widget visibility by widget name."""
+        widget_id = self.select_widget(widget)
+        if widget_id:
+            if not widget_id.startswith("#"):
+                widget_id = f"#{widget_id}"
+            try:
+                widget_to_toggle = self.app.query_one(widget_id)
+                widget_to_toggle.display = not widget_to_toggle.display
+                if hasattr(self.app, "update_layout"):
+                    self.app.update_layout()
+            except Exception:
+                pass
+
+    def get_history_duration(self) -> float | None:
+        """Returns the currently selected history duration in seconds."""
+        return self.query_one("#history_select").value

monitorify/ui/tui/components/widgetManager.py

@@ -0,0 +1,43 @@
+import math
+from textual.containers import Container
+
+
+class WidgetManager:
+    """Manages dynamic grid layouts for an arbitrary number of widgets."""
+
+    def __init__(self, container: Container):
+        self.container = container
+
+    def update_layout(self) -> None:
+        """Arranges visible widgets dynamically without layout gaps."""
+        try:
+            visible = [child for child in self.container.children if child.display]
+            n = len(visible)
+            if n == 0:
+                return
+
+            if n == 1:
+                visible[0].styles.column_span = 2
+                visible[0].styles.row_span = 2
+            elif n == 2:
+                for w in visible:
+                    w.styles.column_span = 2
+                    w.styles.row_span = 1
+            else:
+                cols = 2
+                rows = math.ceil(n / cols)
+                self.container.styles.grid_size_columns = cols
+                self.container.styles.grid_size_rows = rows
+
+                if n % 2 != 0:
+                    visible[0].styles.column_span = 2
+                    visible[0].styles.row_span = 1
+                    for w in visible[1:]:
+                        w.styles.column_span = 1
+                        w.styles.row_span = 1
+                else:
+                    for w in visible:
+                        w.styles.column_span = 1
+                        w.styles.row_span = 1
+        except Exception:
+            pass