monitorify 1.0.0__py3-none-any.whl

monitorify/__init__.py

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

monitorify/__main__.py

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

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/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/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/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/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/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/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/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/stats/__init__.py

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

monitorify/stats/cpuStats.py

@@ -0,0 +1,46 @@
+import time
+
+prev_cpu = None
+
+def _read_cpu_times():
+    with open("/proc/stat", "r") as f:
+        line = f.readline()
+    parts = [float(x) for x in line.split()[1:]]
+    idle_time = parts[3] + parts[4]  # idle + iowait
+    total_time = sum(parts)
+    return idle_time, total_time
+
+def get_cpu_usage(interval=None, unit="percent"):
+    """Calculate total CPU usage via /proc/stat."""
+    global prev_cpu
+    
+    if prev_cpu is None:
+        t1_idle, t1_total = _read_cpu_times()
+        time.sleep(interval if interval and interval > 0 else 0.1)
+        t2_idle, t2_total = _read_cpu_times()
+        prev_cpu = (t2_idle, t2_total)
+        diff_total = t2_total - t1_total
+        diff_idle = t2_idle - t1_idle
+    elif interval is not None and interval > 0:
+        t1_idle, t1_total = _read_cpu_times()
+        time.sleep(interval)
+        t2_idle, t2_total = _read_cpu_times()
+        prev_cpu = (t2_idle, t2_total)
+        diff_total = t2_total - t1_total
+        diff_idle = t2_idle - t1_idle
+    else:
+        t2_idle, t2_total = _read_cpu_times()
+        prev_idle, prev_total = prev_cpu
+        prev_cpu = (t2_idle, t2_total)
+        diff_total = t2_total - prev_total
+        diff_idle = t2_idle - prev_idle
+
+    if diff_total == 0:
+        return 0.0
+    # Return requested unit
+    if unit == "percent":
+        return round((1.0 - (diff_idle / diff_total)) * 100, 2)
+    elif unit == "raw":
+        return 1.0 - (diff_idle / diff_total)
+    else:
+        raise ValueError("Invalid unit. Use 'percent' or 'raw'.")

monitorify/stats/networkStats.py

@@ -0,0 +1,69 @@
+import time
+
+prev_net = None
+
+def _read_net_dev():
+    with open("/proc/net/dev", "r") as f:
+        next(f)  # Skip header
+        next(f)
+        net_stats = {}
+        for line in f:
+            parts = line.split()
+            interface = parts[0].strip(":")
+            
+            rx_bytes = int(parts[1])
+            
+            tx_bytes = int(parts[9])
+            
+            net_stats[interface] = (rx_bytes, tx_bytes)
+            
+    return net_stats
+
+def get_default_interface():
+    with open("/proc/net/dev", "r") as f:
+        next(f)  # Skip header
+        next(f)
+        for line in f:
+            parts = line.split()
+            interface = parts[0].strip(":")
+            if interface != "lo":
+                return interface
+
+def get_network_usage(interface=None, interval=1, max_speed=None):
+    """Set max_speed as bytes per seconds"""
+    global prev_net
+
+    if callable(interface):
+        interface = interface()
+    elif interface is None:
+        interface = get_default_interface()
+
+    if prev_net is None:
+        prev_net = _read_net_dev()
+        time.sleep(interval if interval and interval > 0 else 1)
+        current_net = _read_net_dev()
+    else:
+        current_net = _read_net_dev()
+
+    prev_rx, prev_tx = prev_net.get(interface, (0, 0))
+    current_rx, current_tx = current_net.get(interface, (0, 0))
+
+    prev_net = current_net
+
+    diff_rx = max(0, current_rx - prev_rx)
+    diff_tx = max(0, current_tx - prev_tx)
+
+    if interval <= 0:
+        interval = 1
+        
+    
+    # Return in bytes per second
+    rx_bps = diff_rx / interval
+    tx_bps = diff_tx / interval
+    return rx_bps, tx_bps
+
+def get_total_network_stats():
+    net_stats = _read_net_dev()
+    total_rx = sum(rx for rx, tx in net_stats.values())
+    total_tx = sum(tx for rx, tx in net_stats.values())
+    return total_rx, total_tx