monitorify 1.0.0__tar.gz → 1.0.2__tar.gz

monitorify-1.0.2/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: monitorify
+Version: 1.0.2
+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 terminal montioring tool for linux
+
+- Features
+- CPU monitoring 
+- RAM monitoring
+- Network monitoring
+- Disk monitoring (I/O and storage capacity)
+- Process monitoring
+- Background daemon
+- Customization menu (toggle widgets, set intervals, and change history window)
+- Historical graphs
+## Installation
+### Using pipx
+```bash
+pipx install git+https://github.com/leonst036/Monitorify.git
+```
+
+### Using pip
+```bash
+pip install git+https://github.com/leonst036/Monitorify.git
+```
+
+### Using source
+```bash
+git clone https://github.com/leonst036/Monitorify.git
+cd Monitorify
+pip install . 
+```
+
+## Usage
+```bash
+monitorify
+```
+
+## Tech Stack
+
+* **Language & TUI:** Python, Textual
+* **Database:** SQLite
+* **Target OS:** Linux
+
+## Remote
+
+To use Monitorify remotely over SSH on your server, you can set the following parameters:
+
+- `--ip` – Set the target IP address.
+- `--port` – Set the SSH port.
+- `--username` – Set the username for the remote host.
+- `--password` – Set the password for the SSH server.
+- `--key_filename` – Set the path to an SSH key *(optional)*.

monitorify-1.0.2/README.md

@@ -0,0 +1,50 @@
+# Monitorify
+### A terminal montioring tool for linux
+
+- Features
+- CPU monitoring 
+- RAM monitoring
+- Network monitoring
+- Disk monitoring (I/O and storage capacity)
+- Process monitoring
+- Background daemon
+- Customization menu (toggle widgets, set intervals, and change history window)
+- Historical graphs
+## Installation
+### Using pipx
+```bash
+pipx install git+https://github.com/leonst036/Monitorify.git
+```
+
+### Using pip
+```bash
+pip install git+https://github.com/leonst036/Monitorify.git
+```
+
+### Using source
+```bash
+git clone https://github.com/leonst036/Monitorify.git
+cd Monitorify
+pip install . 
+```
+
+## Usage
+```bash
+monitorify
+```
+
+## Tech Stack
+
+* **Language & TUI:** Python, Textual
+* **Database:** SQLite
+* **Target OS:** Linux
+
+## Remote
+
+To use Monitorify remotely over SSH on your server, you can set the following parameters:
+
+- `--ip` – Set the target IP address.
+- `--port` – Set the SSH port.
+- `--username` – Set the username for the remote host.
+- `--password` – Set the password for the SSH server.
+- `--key_filename` – Set the path to an SSH key *(optional)*.

{monitorify-1.0.0 → monitorify-1.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "monitorify"
-version = "1.0.0"
+version = "1.0.2"
 description = "A lightweight Linux terminal system monitor built with Textual"
 readme = "README.md"
 authors = [

{monitorify-1.0.0 → monitorify-1.0.2}/src/monitorify/__init__.py

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

{monitorify-1.0.0 → monitorify-1.0.2}/src/monitorify/collector/manager.py

@@ -1,9 +1,9 @@
-from typing import List, Optional, Any, Callable
+from typing import List, Optional, Any, Callable, Union
 from monitorify.collector.worker import Worker
 
 
 class Manager:
-    def __init__(self, db: Optional[Any] = None, interval: float = 1.0):
+    def __init__(self, db: Optional[Any] = None, interval: Union[float, Callable[[], float]] = 1.0):
         self._workers: List[Worker] = []
         self._interval = interval
         if db is None:

{monitorify-1.0.0 → monitorify-1.0.2}/src/monitorify/collector/worker.py

@@ -3,10 +3,10 @@ from threading import Thread
 from monitorify.stats import cpuStats, ramStats, networkStats, programmList, DiskStats
 from monitorify.collector.schema import MetricSnapshot
 
-from typing import Callable, Optional
+from typing import Callable, Optional, Union
 
 class Worker:
-    def __init__(self, interval: float = 1.0, on_data: Optional[Callable[[MetricSnapshot], None]] = None):
+    def __init__(self, interval: Union[float, Callable[[], float]] = 1.0, on_data: Optional[Callable[[MetricSnapshot], None]] = None):
         self._interval = interval
         self._on_data = on_data
         self._running = False
@@ -22,6 +22,17 @@ class Worker:
         if self._thread:
             self._thread.join()
 
+    def _get_interval(self) -> float:
+        if callable(self._interval):
+            try:
+                return float(self._interval())
+            except Exception:
+                return 1.0
+        try:
+            return float(self._interval)
+        except Exception:
+            return 1.0
+
     def _worker_loop(self):
         while self._running:
             snapshot = self.collect()
@@ -30,7 +41,7 @@ class Worker:
                     self._on_data(snapshot)
                 except Exception as e:
                     print(f"Error handling metric snapshot: {e}")
-            time.sleep(self._interval)
+            time.sleep(max(0.1, self._get_interval()))
 
     def collect(self) -> MetricSnapshot:
         return MetricSnapshot(

monitorify-1.0.2/src/monitorify/config/__init__.py

@@ -0,0 +1,29 @@
+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"))
+
+# User configuration file path
+CONFIG_PATH = Path(os.getenv("MONITORIFY_CONFIG_PATH", str(DATA_DIR / "config.json")))
+
+# 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.2/src/monitorify/config/configManager.py

@@ -0,0 +1,47 @@
+import json
+from pathlib import Path
+
+
+class configManager:
+    def __init__(self, config_path: str):
+        self.config_path = config_path
+        self.config_data = {}
+        self.load_config()
+
+    def load_config(self) -> dict:
+        path = Path(self.config_path)
+        if not path.exists():
+            self.config_data = {}
+            return self.config_data
+
+        try:
+            with path.open("r", encoding="utf-8") as file:
+                data = json.load(file)
+            if isinstance(data, dict):
+                self.config_data = data
+            else:
+                self.config_data = {}
+        except (json.JSONDecodeError, OSError):
+            self.config_data = {}
+
+        return self.config_data
+
+    def save_config(self, config_data: dict):
+        try:
+            path = Path(self.config_path)
+            path.parent.mkdir(parents=True, exist_ok=True)
+            with path.open("w", encoding="utf-8") as file:
+                json.dump(config_data, file, indent=4)
+            self.config_data = config_data
+        except Exception as e:
+            print(f"Error saving configuration: {e}")
+
+    def get(self, key: str, default=None):
+        return self.config_data.get(key, default)
+
+    def get_connfig(self, key: str):
+        return self.get(key, None)
+
+    def set(self, key: str, value):
+        self.config_data[key] = value
+        self.save_config(self.config_data)

{monitorify-1.0.0 → monitorify-1.0.2}/src/monitorify/config.py

@@ -16,6 +16,9 @@ except Exception:
 # Database settings
 DB_PATH = os.getenv("MONITORIFY_DB_PATH", str(DATA_DIR / "monitorify.db"))
 
+# User configuration file path
+CONFIG_PATH = Path(os.getenv("MONITORIFY_CONFIG_PATH", str(DATA_DIR / "config.json")))
+
 # Daemon PID file path
 DAEMON_PIDFILE = Path(os.getenv("MONITORIFY_PID_PATH", str(RUNTIME_DIR / "daemon.pid")))
 

monitorify-1.0.2/src/monitorify/config_manager.py

@@ -0,0 +1,47 @@
+import json
+from pathlib import Path
+
+
+class configManager:
+    def __init__(self, config_path: str):
+        self.config_path = config_path
+        self.config_data = {}
+        self.load_config()
+
+    def load_config(self) -> dict:
+        path = Path(self.config_path)
+        if not path.exists():
+            self.config_data = {}
+            return self.config_data
+
+        try:
+            with path.open("r", encoding="utf-8") as file:
+                data = json.load(file)
+            if isinstance(data, dict):
+                self.config_data = data
+            else:
+                self.config_data = {}
+        except (json.JSONDecodeError, OSError):
+            self.config_data = {}
+
+        return self.config_data
+
+    def save_config(self, config_data: dict):
+        try:
+            path = Path(self.config_path)
+            path.parent.mkdir(parents=True, exist_ok=True)
+            with path.open("w", encoding="utf-8") as file:
+                json.dump(config_data, file, indent=4)
+            self.config_data = config_data
+        except Exception as e:
+            print(f"Error saving configuration: {e}")
+
+    def get(self, key: str, default=None):
+        return self.config_data.get(key, default)
+
+    def get_connfig(self, key: str):
+        return self.get(key, None)
+
+    def set(self, key: str, value):
+        self.config_data[key] = value
+        self.save_config(self.config_data)

monitorify-1.0.2/src/monitorify/daemon.py

@@ -0,0 +1,46 @@
+import time
+import signal
+import sys
+from monitorify.collector import Manager
+from monitorify.storage import Database
+from monitorify import config
+from monitorify.config.configManager import configManager
+
+
+def get_collection_interval() -> float:
+    try:
+        cfg = configManager(str(config.CONFIG_PATH))
+        for key in ("update_interval", "collection_interval", "interval"):
+            val = cfg.get(key)
+            if val is not None:
+                return float(val)
+    except Exception:
+        pass
+    return config.DEFAULT_COLLECTION_INTERVAL
+
+
+def main():
+    print("Starting Monitorify background metrics collector daemon...")
+    db = Database(config.DB_PATH)
+    interval = get_collection_interval()
+    manager = Manager(db=db, interval=get_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: {interval}s, DB: {config.DB_PATH}). Press Ctrl+C to stop."
+    )
+
+    while True:
+        time.sleep(1)
+
+
+if __name__ == "__main__":
+    main()

monitorify-1.0.2/src/monitorify/main.py

@@ -0,0 +1,107 @@
+import subprocess
+import sys
+import os
+from monitorify import config
+from monitorify.ui.tui.tui import MonitorifyApp
+import argparse
+
+def parse_args():
+    """Parse CLI arguments."""
+    parser = argparse.ArgumentParser(description="Monitorify")
+    parser.add_argument("--ip", type=str, default=None, help="IP address of the remote machine")
+    parser.add_argument("--port", type=int, default=None, help="Port of the remote machine (default: 22)")
+    parser.add_argument("--username", type=str, default=None, help="Username for the remote machine")
+    parser.add_argument("--password", type=str, default=None, help="Password for the remote machine")
+    parser.add_argument("--key_filename", type=str, default=None, help="Path to the key file for the remote machine")
+    args = parser.parse_args()
+
+    if not args.ip and (args.port is not None or args.username or args.password or args.key_filename):
+        parser.error("--ip is required when specifying remote connection arguments")
+
+    return args
+
+
+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"""
+    args = parse_args()
+
+    if args.ip:
+        from monitorify.remote.connector import RemoteConnector
+
+        try:
+            connector = RemoteConnector(
+                host=args.ip,
+                port=args.port or 22,
+                username=args.username,
+                password=args.password,
+                key_filename=args.key_filename,
+            )
+            client = connector.connect()
+            try:
+                if not args.command and not connector.is_installed(client):
+                    print(f"Error: Monitorify is not installed on the remote host ({args.ip}).")
+                    response = input("Do you want to install it? (y/n): ").strip().lower()
+                    if response == "y":
+                        success = connector.install(client)
+                        if not success:
+                            print("Installation failed.")
+                            sys.exit(1)
+                    else:
+                        sys.exit(1)
+
+                remote_cmd = args.command or "bash -l -c 'monitorify || python3 -m monitorify'"
+                connector.run_interactive(client, command=remote_cmd)
+            finally:
+                client.close()
+        except ConnectionError as e:
+            print(f"Connection failed: {e}")
+            sys.exit(1)
+        except KeyboardInterrupt:
+            pass
+        return
+
+    # Local mode
+    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.2/src/monitorify/remote/__init__.py

@@ -0,0 +1,3 @@
+from monitorify.remote.connector import RemoteConnector
+
+__all__ = ["RemoteConnector"]

monitorify-1.0.2/src/monitorify/remote/connector.py

@@ -0,0 +1,115 @@
+import paramiko
+
+class RemoteConnector:
+    def __init__(
+        self,
+        host: str,
+        port: int = 22,
+        username: str | None = None,
+        password: str | None = None,
+        key_filename: str | None = None,
+    ):
+        self.host = host
+        self.port = port
+        self.username = username
+        self.password = password
+        self.key_filename = key_filename
+
+    def connect(self):
+        client = paramiko.SSHClient()
+        client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+        try: 
+            client.connect(hostname=self.host, port=self.port, username=self.username, password=self.password, key_filename=self.key_filename)
+        except paramiko.AuthenticationException as e:
+            raise ConnectionError(f"Authentication failed: {e}")
+        except paramiko.SSHException as e:
+            raise ConnectionError(f"SSH error: {e}")
+        except Exception as e:
+            raise ConnectionError(f"Error: {e}")
+        return client
+
+    def is_installed(self, client: paramiko.SSHClient) -> bool:
+        """Check if monitorify is installed on the remote host."""
+        try:
+            _, stdout, _ = client.exec_command(
+                "bash -l -c 'command -v monitorify >/dev/null 2>&1 || python3 -c \"import monitorify\" >/dev/null 2>&1'"
+            )
+            return stdout.channel.recv_exit_status() == 0
+        except Exception:
+            return False
+
+    def install(self, client: paramiko.SSHClient) -> bool:
+        """Install monitorify on the remote host using install.sh."""
+        import shlex
+        from pathlib import Path
+
+        script_path = Path(__file__).parent / "install.sh"
+        script_content = script_path.read_text(encoding="utf-8")
+        install_cmd = f"bash -l -c {shlex.quote(script_content)}"
+        self.run_interactive(client, command=install_cmd)
+        return self.is_installed(client)
+
+    def run_interactive(self, client: paramiko.SSHClient, command: str = "monitorify") -> None:
+        """Run a command interactively on the remote host with a PTY."""
+        import os
+        import select
+        import shutil
+        import signal
+        import sys
+        import termios
+        import tty
+
+        transport = client.get_transport()
+        if transport is None:
+            raise ConnectionError("SSH transport is not active")
+
+        channel = transport.open_session()
+        cols, rows = shutil.get_terminal_size()
+        term = os.environ.get("TERM", "xterm-256color")
+        channel.get_pty(term=term, width=cols, height=rows)
+        channel.exec_command(command)
+
+        stdin_fd = sys.stdin.fileno()
+        stdout_fd = sys.stdout.fileno()
+        is_atty = sys.stdin.isatty()
+        old_tty = termios.tcgetattr(stdin_fd) if is_atty else None
+
+        def handle_resize(signum, frame):
+            w, h = shutil.get_terminal_size()
+            try:
+                channel.resize_pty(width=w, height=h)
+            except Exception:
+                pass
+
+        try:
+            signal.signal(signal.SIGWINCH, handle_resize)
+        except Exception:
+            pass
+
+        try:
+            if is_atty:
+                tty.setraw(stdin_fd)
+            channel.setblocking(0)
+
+            while True:
+                r, _, _ = select.select([channel, stdin_fd], [], [])
+                if channel in r:
+                    try:
+                        data = channel.recv(4096)
+                        if not data:
+                            break
+                        os.write(stdout_fd, data)
+                    except Exception:
+                        break
+                if stdin_fd in r:
+                    try:
+                        user_input = os.read(stdin_fd, 4096)
+                        if not user_input:
+                            break
+                        channel.sendall(user_input)
+                    except Exception:
+                        break
+        finally:
+            if is_atty and old_tty is not None:
+                termios.tcsetattr(stdin_fd, termios.TCSADRAIN, old_tty)
+            channel.close()

{monitorify-1.0.0 → monitorify-1.0.2}/src/monitorify/stats/DiskStats.py

@@ -10,7 +10,7 @@ def get_real_disks() -> list:
                 continue
             
             disk_name = parts[2]
-            # Check if it is a real physical disk (not a partition or virtual device)
+            # Check if it is a real physical disk
             if not os.path.exists(f"/sys/block/{disk_name}/device"):
                 continue
             
@@ -32,7 +32,6 @@ def get_disk_IO(disks: list = None) -> dict:
             
             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] = {
@@ -60,7 +59,7 @@ def get_disk_storage(disks: list = None) -> dict:
                     mounts.setdefault(parts[0], parts[1])
     
     for disk in disks:
-        # Read total raw hardware capacity from /sys/block/<disk>/size (512-byte sectors)
+        # Read total raw hardware capacity from /sys/block/<disk>/size
         total_hw = 0
         size_file = f"/sys/block/{disk}/size"
         if os.path.exists(size_file):
@@ -76,7 +75,7 @@ def get_disk_storage(disks: list = None) -> dict:
         
         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)
+            # Match disk or its partitions
             if dev_name == disk or dev_name.startswith(disk):
                 try:
                     st = os.statvfs(mount_point)