monitorify 1.0.0__tar.gz

monitorify-1.0.0/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: monitorify
+Version: 1.0.0
+Summary: A lightweight Linux terminal system monitor built with Textual
+Author: Leon
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: textual>=0.80.0
+Requires-Dist: platformdirs>=4.0.0
+Requires-Dist: rich>=13.0.0
+
+# Monitorify
+
+A lightweight system monitor that runs right in your terminal. It tracks CPU usage, memory consumption, network activity, disk metrics, and process states in real time with historical graphing — no bloated dependencies, just a clean, high-performance TUI dashboard.
+
+Built with Python and [Textual](https://github.com/Textualize/textual). Reads directly from `/proc` and `/sys` for lightning-fast, native performance on Linux.
+
+---
+
+## Features
+
+* **CPU & System Info** — Live CPU percentage, multi-timeframe braille graphing, OS kernel, hostname, and system uptime.
+* **Memory (RAM)** — Real-time memory utilization, percentage, and historical graph.
+* **Network Throughput** — Split-view upload/download graph with current speed, peak throughput, and total transferred bytes.
+* **Disk Metrics** — I/O activity rates (reads/writes) and storage capacity breakdown for physical disks.
+* **Process Monitor** — Interactive list of running processes with CPU/RAM metrics, process state, uptime, and real-time inspector.
+* **Background Collector Daemon** — Lightweight collector logging metrics to an SQLite database (`~/.local/share/monitorify/monitorify.db`) with automatic pruning.
+* **Customizable Menu (`m`)** — Toggle widget visibility, adjust collection frequency, and set history graph duration (1m, 5m, 10m, 30m, 1h, or custom durations like `2h`, `1d`).
+
+---
+
+## Quick Start
+
+```bash
+# Recommended — isolated install via pipx
+pipx install git+https://github.com/leonst036/Monitorify.git
+
+# Then launch the dashboard
+monitorify
+```
+
+> For full installation options (pip, source, systemd daemon) see **[INSTALL.md](INSTALL.md)**.
+
+---
+
+## Usage
+
+### Dashboard
+
+```bash
+monitorify
+```
+
+| Key | Action |
+|-----|--------|
+| `m` | Open settings menu (toggle widgets, set intervals, change history window) |
+| `q` / `c` | Quit |
+
+### Standalone Background Daemon
+
+```bash
+monitorify-daemon
+```
+
+Metrics are written to `~/.local/share/monitorify/monitorify.db` continuously.
+
+---
+
+## Configuration & Paths
+
+Monitorify follows XDG base directory conventions:
+
+| Purpose | Default Path | Environment Variable |
+|---|---|---|
+| **Database** | `~/.local/share/monitorify/monitorify.db` | `MONITORIFY_DB_PATH` |
+| **Daemon PID** | `/run/user/<uid>/monitorify/daemon.pid` | `MONITORIFY_PID_PATH` |
+| **Interval** | `1.0` seconds | `MONITORIFY_INTERVAL` |
+| **Retention** | `604800` seconds (7 days) | `MONITORIFY_RETENTION` |
+
+---
+
+## Project Structure
+
+```
+Monitorify/
+├── pyproject.toml               # Package build configuration & entry points
+├── README.md                    # This file
+├── INSTALL.md                   # Full installation guide
+├── main.py                      # Developer entrypoint shim
+├── src/
+│   └── monitorify/
+│       ├── __init__.py          # Package metadata (__version__)
+│       ├── __main__.py          # python -m monitorify entrypoint
+│       ├── config.py            # XDG path handling & environment settings
+│       ├── main.py              # Dashboard runner & daemon supervisor
+│       ├── daemon.py            # Standalone metrics collector daemon
+│       ├── collector/
+│       │   ├── manager.py       # Worker lifecycle coordinator
+│       │   ├── worker.py        # Background metric collection thread
+│       │   └── schema.py        # Dataclass metric structures
+│       ├── stats/
+│       │   ├── cpuStats.py      # /proc/stat CPU calculator
+│       │   ├── ramStats.py      # /proc/meminfo RAM calculator
+│       │   ├── networkStats.py  # /proc/net/dev throughput calculator
+│       │   ├── DiskStats.py     # /proc/diskstats I/O & storage parser
+│       │   └── programmList.py  # /proc process parser & cache thread
+│       ├── storage/
+│       │   └── db.py            # SQLite metrics storage & historical queries
+│       └── ui/
+│           └── tui/
+│               ├── tui.py       # Main Textual App
+│               ├── css/
+│               │   └── tui.css  # TUI styling & themes
+│               ├── components/
+│               │   ├── menu.py          # Settings sidebar component
+│               │   └── widgetManager.py # Dynamic grid layout organizer
+│               └── widgets/
+│                   ├── brailleGraph.py       # High-density Unicode graph
+│                   ├── cpuWidget.py          # CPU monitor widget
+│                   ├── ramWidget.py          # RAM monitor widget
+│                   ├── networkWidget.py      # Network monitor widget
+│                   ├── diskWidget.py         # Disk I/O & storage widget
+│                   ├── programmListWidget.py # Interactive process list
+│                   ├── procInfoWidget.py     # Process details panel
+│                   └── statusWidget.py       # Host & kernel status
+```
+
+---
+
+## Requirements
+
+* **Python:** 3.10+
+* **OS:** Linux (relies on `/proc` and `/sys` filesystems)
+* **Terminal:** Minimum 80 columns × 24 lines recommended

monitorify-1.0.0/README.md

@@ -0,0 +1,123 @@
+# Monitorify
+
+A lightweight system monitor that runs right in your terminal. It tracks CPU usage, memory consumption, network activity, disk metrics, and process states in real time with historical graphing — no bloated dependencies, just a clean, high-performance TUI dashboard.
+
+Built with Python and [Textual](https://github.com/Textualize/textual). Reads directly from `/proc` and `/sys` for lightning-fast, native performance on Linux.
+
+---
+
+## Features
+
+* **CPU & System Info** — Live CPU percentage, multi-timeframe braille graphing, OS kernel, hostname, and system uptime.
+* **Memory (RAM)** — Real-time memory utilization, percentage, and historical graph.
+* **Network Throughput** — Split-view upload/download graph with current speed, peak throughput, and total transferred bytes.
+* **Disk Metrics** — I/O activity rates (reads/writes) and storage capacity breakdown for physical disks.
+* **Process Monitor** — Interactive list of running processes with CPU/RAM metrics, process state, uptime, and real-time inspector.
+* **Background Collector Daemon** — Lightweight collector logging metrics to an SQLite database (`~/.local/share/monitorify/monitorify.db`) with automatic pruning.
+* **Customizable Menu (`m`)** — Toggle widget visibility, adjust collection frequency, and set history graph duration (1m, 5m, 10m, 30m, 1h, or custom durations like `2h`, `1d`).
+
+---
+
+## Quick Start
+
+```bash
+# Recommended — isolated install via pipx
+pipx install git+https://github.com/leonst036/Monitorify.git
+
+# Then launch the dashboard
+monitorify
+```
+
+> For full installation options (pip, source, systemd daemon) see **[INSTALL.md](INSTALL.md)**.
+
+---
+
+## Usage
+
+### Dashboard
+
+```bash
+monitorify
+```
+
+| Key | Action |
+|-----|--------|
+| `m` | Open settings menu (toggle widgets, set intervals, change history window) |
+| `q` / `c` | Quit |
+
+### Standalone Background Daemon
+
+```bash
+monitorify-daemon
+```
+
+Metrics are written to `~/.local/share/monitorify/monitorify.db` continuously.
+
+---
+
+## Configuration & Paths
+
+Monitorify follows XDG base directory conventions:
+
+| Purpose | Default Path | Environment Variable |
+|---|---|---|
+| **Database** | `~/.local/share/monitorify/monitorify.db` | `MONITORIFY_DB_PATH` |
+| **Daemon PID** | `/run/user/<uid>/monitorify/daemon.pid` | `MONITORIFY_PID_PATH` |
+| **Interval** | `1.0` seconds | `MONITORIFY_INTERVAL` |
+| **Retention** | `604800` seconds (7 days) | `MONITORIFY_RETENTION` |
+
+---
+
+## Project Structure
+
+```
+Monitorify/
+├── pyproject.toml               # Package build configuration & entry points
+├── README.md                    # This file
+├── INSTALL.md                   # Full installation guide
+├── main.py                      # Developer entrypoint shim
+├── src/
+│   └── monitorify/
+│       ├── __init__.py          # Package metadata (__version__)
+│       ├── __main__.py          # python -m monitorify entrypoint
+│       ├── config.py            # XDG path handling & environment settings
+│       ├── main.py              # Dashboard runner & daemon supervisor
+│       ├── daemon.py            # Standalone metrics collector daemon
+│       ├── collector/
+│       │   ├── manager.py       # Worker lifecycle coordinator
+│       │   ├── worker.py        # Background metric collection thread
+│       │   └── schema.py        # Dataclass metric structures
+│       ├── stats/
+│       │   ├── cpuStats.py      # /proc/stat CPU calculator
+│       │   ├── ramStats.py      # /proc/meminfo RAM calculator
+│       │   ├── networkStats.py  # /proc/net/dev throughput calculator
+│       │   ├── DiskStats.py     # /proc/diskstats I/O & storage parser
+│       │   └── programmList.py  # /proc process parser & cache thread
+│       ├── storage/
+│       │   └── db.py            # SQLite metrics storage & historical queries
+│       └── ui/
+│           └── tui/
+│               ├── tui.py       # Main Textual App
+│               ├── css/
+│               │   └── tui.css  # TUI styling & themes
+│               ├── components/
+│               │   ├── menu.py          # Settings sidebar component
+│               │   └── widgetManager.py # Dynamic grid layout organizer
+│               └── widgets/
+│                   ├── brailleGraph.py       # High-density Unicode graph
+│                   ├── cpuWidget.py          # CPU monitor widget
+│                   ├── ramWidget.py          # RAM monitor widget
+│                   ├── networkWidget.py      # Network monitor widget
+│                   ├── diskWidget.py         # Disk I/O & storage widget
+│                   ├── programmListWidget.py # Interactive process list
+│                   ├── procInfoWidget.py     # Process details panel
+│                   └── statusWidget.py       # Host & kernel status
+```
+
+---
+
+## Requirements
+
+* **Python:** 3.10+
+* **OS:** Linux (relies on `/proc` and `/sys` filesystems)
+* **Terminal:** Minimum 80 columns × 24 lines recommended

monitorify-1.0.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "monitorify"
+version = "1.0.0"
+description = "A lightweight Linux terminal system monitor built with Textual"
+readme = "README.md"
+authors = [
+    { name = "Leon" }
+]
+requires-python = ">=3.10"
+license = { text = "MIT" }
+dependencies = [
+    "textual>=0.80.0",
+    "platformdirs>=4.0.0",
+    "rich>=13.0.0",
+]
+
+[project.scripts]
+monitorify = "monitorify.main:cli"
+monitorify-daemon = "monitorify.daemon:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"monitorify.ui.tui" = ["css/*.css"]

monitorify-1.0.0/setup.cfg

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

monitorify-1.0.0/src/monitorify/__init__.py

@@ -0,0 +1,3 @@
+"""Monitorify - A lightweight Linux terminal system monitor."""
+
+__version__ = "0.1.0"

monitorify-1.0.0/src/monitorify/__main__.py

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

monitorify-1.0.0/src/monitorify/collector/__init__.py

@@ -0,0 +1,5 @@
+from .manager import Manager
+from .worker import Worker
+from .schema import MetricSnapshot, NetworkMetrics
+
+__all__ = ["Manager", "Worker", "MetricSnapshot", "NetworkMetrics"]

monitorify-1.0.0/src/monitorify/collector/manager.py

@@ -0,0 +1,48 @@
+from typing import List, Optional, Any, Callable
+from monitorify.collector.worker import Worker
+
+
+class Manager:
+    def __init__(self, db: Optional[Any] = None, interval: float = 1.0):
+        self._workers: List[Worker] = []
+        self._interval = interval
+        if db is None:
+            from monitorify.storage.db import Database
+            self._db = Database()
+        else:
+            self._db = db
+        self._is_running = False
+
+    @property
+    def is_running(self) -> bool:
+        return self._is_running
+
+    def add_worker(self, worker: Worker):
+        self._workers.append(worker)
+
+    def setup_default_worker(self) -> Worker:
+        """Create and register default metric worker connected to Database."""
+        worker = Worker(interval=self._interval, on_data=self._db.save)
+        self.add_worker(worker)
+        return worker
+
+    def start(self):
+        if self._is_running:
+            return
+        self._db.connect()
+        self._is_running = True
+        if not self._workers:
+            self.setup_default_worker()
+        for worker in self._workers:
+            worker.start()
+
+    def stop(self):
+        if not self._is_running:
+            return
+        for worker in self._workers:
+            worker.stop()
+        self._db.disconnect()
+        self._is_running = False
+
+
+    

monitorify-1.0.0/src/monitorify/collector/schema.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass, asdict
+from typing import Dict, Any, Tuple, Optional
+
+@dataclass
+class NetworkMetrics:
+    rx_bytes: float
+    tx_bytes: float
+
+@dataclass
+class MetricSnapshot:
+    timestamp: float
+    cpu: float
+    ram: float
+    network: Tuple[float, float]
+    processes_count: int
+    disk_io: Optional[Dict[str, Any]] = None
+    disk_storage: Optional[Dict[str, Any]] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Converts the dataclass object into a standard dictionary."""
+        return asdict(self)
+

monitorify-1.0.0/src/monitorify/collector/worker.py

@@ -0,0 +1,44 @@
+import time
+from threading import Thread
+from monitorify.stats import cpuStats, ramStats, networkStats, programmList, DiskStats
+from monitorify.collector.schema import MetricSnapshot
+
+from typing import Callable, Optional
+
+class Worker:
+    def __init__(self, interval: float = 1.0, on_data: Optional[Callable[[MetricSnapshot], None]] = None):
+        self._interval = interval
+        self._on_data = on_data
+        self._running = False
+        self._thread = None
+
+    def start(self):
+        self._running = True
+        self._thread = Thread(target=self._worker_loop)
+        self._thread.start()
+
+    def stop(self):
+        self._running = False
+        if self._thread:
+            self._thread.join()
+
+    def _worker_loop(self):
+        while self._running:
+            snapshot = self.collect()
+            if self._on_data:
+                try:
+                    self._on_data(snapshot)
+                except Exception as e:
+                    print(f"Error handling metric snapshot: {e}")
+            time.sleep(self._interval)
+
+    def collect(self) -> MetricSnapshot:
+        return MetricSnapshot(
+            timestamp=time.time(),
+            cpu=cpuStats.get_cpu_usage(),
+            ram=ramStats.get_ram_usage(),
+            network=networkStats.get_network_usage(),
+            processes_count=len(programmList.get_process_list()),
+            disk_io=DiskStats.get_disk_IO(),
+            disk_storage=DiskStats.get_disk_storage(),
+        )

monitorify-1.0.0/src/monitorify/config.py

@@ -0,0 +1,26 @@
+import os
+from pathlib import Path
+from platformdirs import user_data_dir, user_runtime_dir
+
+# Data directory for database storage
+DATA_DIR = Path(user_data_dir("monitorify", appauthor=False))
+DATA_DIR.mkdir(parents=True, exist_ok=True)
+
+# Runtime directory for PID files
+try:
+    RUNTIME_DIR = Path(user_runtime_dir("monitorify", appauthor=False))
+    RUNTIME_DIR.mkdir(parents=True, exist_ok=True)
+except Exception:
+    RUNTIME_DIR = DATA_DIR
+
+# Database settings
+DB_PATH = os.getenv("MONITORIFY_DB_PATH", str(DATA_DIR / "monitorify.db"))
+
+# Daemon PID file path
+DAEMON_PIDFILE = Path(os.getenv("MONITORIFY_PID_PATH", str(RUNTIME_DIR / "daemon.pid")))
+
+# Collection settings (seconds)
+DEFAULT_COLLECTION_INTERVAL = float(os.getenv("MONITORIFY_INTERVAL", "1.0"))
+
+# Retention settings (default: 7 days in seconds)
+RETENTION_SECONDS = float(os.getenv("MONITORIFY_RETENTION", str(7 * 24 * 3600)))

monitorify-1.0.0/src/monitorify/daemon.py

@@ -0,0 +1,32 @@
+import time
+import signal
+import sys
+from monitorify.collector import Manager
+from monitorify.storage import Database
+from monitorify import config
+
+
+def main():
+    print("Starting Monitorify background metrics collector daemon...")
+    db = Database(config.DB_PATH)
+    manager = Manager(db=db, interval=config.DEFAULT_COLLECTION_INTERVAL)
+
+    def signal_handler(sig, frame):
+        print("\nStopping Monitorify daemon...")
+        manager.stop()
+        sys.exit(0)
+
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    manager.start()
+    print(
+        f"Metrics collector running (Interval: {config.DEFAULT_COLLECTION_INTERVAL}s, DB: {config.DB_PATH}). Press Ctrl+C to stop."
+    )
+
+    while True:
+        time.sleep(1)
+
+
+if __name__ == "__main__":
+    main()

monitorify-1.0.0/src/monitorify/main.py

@@ -0,0 +1,53 @@
+import subprocess
+import sys
+import os
+from monitorify import config
+from monitorify.ui.tui.tui import MonitorifyApp
+
+
+def daemon_already_running() -> bool:
+    """Check if a daemon process from a previous run is still alive."""
+    if not config.DAEMON_PIDFILE.exists():
+        return False
+    try:
+        pid = int(config.DAEMON_PIDFILE.read_text().strip())
+        # Signal 0 checks if the process exists without killing it
+        os.kill(pid, 0)
+        return True
+    except (ValueError, ProcessLookupError, PermissionError):
+        config.DAEMON_PIDFILE.unlink(missing_ok=True)
+        return False
+
+
+def start_daemon() -> subprocess.Popen | None:
+    """Start the daemon as a background subprocess if not already running."""
+    if daemon_already_running():
+        return None
+
+    proc = subprocess.Popen(
+        [sys.executable, "-m", "monitorify.daemon"],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+    config.DAEMON_PIDFILE.write_text(str(proc.pid))
+    return proc
+
+
+def cli():
+    """Main CLI entrypoint for Monitorify."""
+    daemon = start_daemon()
+    try:
+        app = MonitorifyApp()
+        app.run()
+    finally:
+        if daemon is not None:
+            daemon.terminate()
+            try:
+                daemon.wait(timeout=2)
+            except subprocess.TimeoutExpired:
+                daemon.kill()
+            config.DAEMON_PIDFILE.unlink(missing_ok=True)
+
+
+if __name__ == "__main__":
+    cli()

monitorify-1.0.0/src/monitorify/stats/DiskStats.py

@@ -0,0 +1,108 @@
+import os
+
+def get_real_disks() -> list:
+    disks = []
+    
+    with open("/proc/diskstats", "r") as f:
+        for line in f:
+            parts = line.split()
+            if len(parts) < 3:
+                continue
+            
+            disk_name = parts[2]
+            # Check if it is a real physical disk (not a partition or virtual device)
+            if not os.path.exists(f"/sys/block/{disk_name}/device"):
+                continue
+            
+            disks.append(disk_name)
+            
+    return disks
+
+def get_disk_IO(disks: list = None) -> dict:
+    if disks is None:
+        disks = get_real_disks()
+        
+    disk_io = {}
+    
+    with open("/proc/diskstats", "r") as f:
+        for line in f:
+            parts = line.split()
+            if len(parts) < 14:
+                continue
+            
+            disk_name = parts[2]
+            if disk_name in disks:
+                # Sector size in Linux is 512 bytes
+                read_bytes = int(parts[5]) * 512
+                write_bytes = int(parts[9]) * 512
+                disk_io[disk_name] = {
+                    "read_bytes": read_bytes,
+                    "write_bytes": write_bytes,
+                    "reads": int(parts[3]),
+                    "writes": int(parts[7]),
+                }
+            
+    return disk_io
+
+def get_disk_storage(disks: list = None) -> dict:
+    if disks is None:
+        disks = get_real_disks()
+        
+    disk_storage = {}
+    
+    # Map mount points for each device partition
+    mounts = {}
+    if os.path.exists("/proc/mounts"):
+        with open("/proc/mounts", "r") as f:
+            for line in f:
+                parts = line.split()
+                if len(parts) >= 2 and parts[0].startswith("/dev/"):
+                    mounts.setdefault(parts[0], parts[1])
+    
+    for disk in disks:
+        # Read total raw hardware capacity from /sys/block/<disk>/size (512-byte sectors)
+        total_hw = 0
+        size_file = f"/sys/block/{disk}/size"
+        if os.path.exists(size_file):
+            try:
+                with open(size_file, "r") as f:
+                    total_hw = int(f.read().strip()) * 512
+            except (ValueError, IOError):
+                total_hw = 0
+                
+        total_fs = 0
+        used_fs = 0
+        free_fs = 0
+        
+        for dev_path, mount_point in mounts.items():
+            dev_name = os.path.basename(dev_path)
+            # Match disk or its partitions (e.g. sda1 -> sda, nvme0n1p1 -> nvme0n1)
+            if dev_name == disk or dev_name.startswith(disk):
+                try:
+                    st = os.statvfs(mount_point)
+                    total_fs += st.f_blocks * st.f_frsize
+                    free_fs += st.f_bavail * st.f_frsize
+                    used_fs += (st.f_blocks - st.f_bfree) * st.f_frsize
+                except OSError:
+                    pass
+                    
+        total = total_fs if total_fs > 0 else total_hw
+        used = used_fs
+        free = free_fs if total_fs > 0 else max(0, total_hw - used_fs)
+        
+        disk_storage[disk] = {
+            "total": total,
+            "used": used,
+            "free": free,
+        }
+    
+    return disk_storage
+
+if __name__ == "__main__":
+    disks = get_real_disks()
+    disk_IO = get_disk_IO(disks)
+    disk_storage = get_disk_storage(disks)
+    print("Disks:", disks)
+    print("Disk IO:", disk_IO)
+    print("Disk Storage:", disk_storage)
+

monitorify-1.0.0/src/monitorify/stats/__init__.py

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