monitorify 1.0.1__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.1 → monitorify-1.0.2}/pyproject.toml

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

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

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

{monitorify-1.0.1 → 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.1 → 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.1 → 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.1 → monitorify-1.0.2}/src/monitorify/main.py

@@ -13,10 +13,9 @@ def parse_args():
     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")
-    parser.add_argument("--command", type=str, default=None, help="Command to run on the remote machine (default: monitorify)")
     args = parser.parse_args()
 
-    if not args.ip and (args.port is not None or args.username or args.password or args.key_filename or args.command):
+    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

{monitorify-1.0.1 → monitorify-1.0.2}/src/monitorify/ui/tui/components/menu.py

@@ -41,6 +41,10 @@ def parse_duration(text: str) -> float | None:
 
 class Menu(Container):
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._syncing_menu_state = False
+
     def compose(self):
         with Vertical(id="menu"):
             yield Static("[bold #61afef]M[/bold #61afef]enu", id="menu_title")
@@ -71,16 +75,25 @@ class Menu(Container):
 
     def populate_menu(self) -> None:
         """Populates selection list with widget options and updates interval select value."""
+        self._syncing_menu_state = True
         try:
             selection_list = self.query_one(SelectionList)
             selection_list.clear_options()
-            for name, widget_id in self.get_available_widgets().items():
+            saved_visible = self.app.config_manager.get("visible_widgets")
+            widgets = self.get_available_widgets()
+            for name, widget_id in widgets.items():
                 widget = self.app.query_one(f"#{widget_id}")
+                if saved_visible is not None:
+                    initial_state = widget_id in saved_visible
+                else:
+                    initial_state = widget.display
                 selection_list.add_option(
-                    Selection(prompt=name, value=name, initial_state=widget.display)
+                    Selection(prompt=name, value=name, initial_state=initial_state)
                 )
         except Exception:
             pass
+        finally:
+            self._syncing_menu_state = False
 
         try:
             interval_select = self.query_one("#interval_select", Select)
@@ -90,6 +103,16 @@ class Menu(Container):
         except Exception:
             pass
 
+        try:
+            history_select = self.query_one("#history_select", Select)
+            current_history = getattr(self.app, "history_duration", 60.0)
+            if history_select.value != current_history:
+                history_select.value = current_history
+            custom_input = self.query_one("#custom_history_input", Input)
+            custom_input.display = history_select.value is None
+        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:
@@ -124,6 +147,8 @@ class Menu(Container):
 
     def on_selection_list_selected_changed(self, event: SelectionList.SelectedChanged) -> None:
         """Toggles widget visibility based on selection changes."""
+        if self._syncing_menu_state:
+            return
         selected_names = event.selection_list.selected
         for name, widget_id in self.get_available_widgets().items():
             try:
@@ -133,6 +158,8 @@ class Menu(Container):
                 pass
         if hasattr(self.app, "update_layout"):
             self.app.update_layout()
+        if hasattr(self.app, "persist_config"):
+            self.app.persist_config()
 
     def get_available_widgets(self) -> dict[str, str]:
         """Returns a map of {widget_name: widget_id} from main_container."""

{monitorify-1.0.1 → monitorify-1.0.2}/src/monitorify/ui/tui/tui.py

@@ -16,6 +16,7 @@ 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
+from monitorify.config.configManager import configManager
 
 
 class MonitorifyApp(App):
@@ -30,13 +31,30 @@ class MonitorifyApp(App):
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
+        self.config_manager = configManager(str(config.CONFIG_PATH))
         # Read-only DB connection
         self.db = Database(config.DB_PATH)
         self.db.connect()
-        # Default history window: 1 minute
-        self.history_duration: float = 60.0
+        # Load saved preferences from config
+        self.update_interval = float(self.config_manager.get("update_interval", 1.0))
+        self.history_duration: float = float(self.config_manager.get("history_duration", 60.0))
         self._last_graph_refresh: float = 0.0
 
+    def persist_config(self) -> None:
+        visible_widgets = []
+        for widget_id in ["cpu_widget", "ram_widget", "programmList_widget", "network_widget", "disk_widget"]:
+            try:
+                if self.query_one(f"#{widget_id}").display:
+                    visible_widgets.append(widget_id)
+            except Exception:
+                pass
+
+        self.config_manager.save_config({
+            "update_interval": float(self.update_interval),
+            "history_duration": float(self.history_duration),
+            "visible_widgets": visible_widgets,
+        })
+
     def compose(self) -> ComposeResult:
         with Container(id="main_container"):
             yield CpuWidget(id="cpu_widget")
@@ -52,15 +70,25 @@ class MonitorifyApp(App):
     def on_mount(self) -> None:
         self.action_get_window_size()
         self.widget_manager = WidgetManager(self.query_one("#main_container"))
+        saved_visible = self.config_manager.get("visible_widgets")
+        if saved_visible is not None:
+            visible_widgets = set(saved_visible)
+        else:
+            visible_widgets = set()
+        for widget_id in ["cpu_widget", "ram_widget", "programmList_widget", "network_widget", "disk_widget"]:
+            try:
+                widget = self.query_one(f"#{widget_id}")
+                widget.display = widget_id in visible_widgets if saved_visible is not None else widget.display
+            except Exception:
+                pass
         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)
+        self.set_history_duration(self.history_duration, persist=False)
 
     def set_update_interval(self, seconds: float) -> None:
         """Updates the graph refresh interval."""
@@ -68,10 +96,13 @@ class MonitorifyApp(App):
         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)
+        self.persist_config()
 
-    def set_history_duration(self, seconds: float) -> None:
+    def set_history_duration(self, seconds: float, persist: bool = True) -> None:
         """Load historical metrics from DB and push them into all graph widgets."""
         self.history_duration = seconds
+        if persist:
+            self.persist_config()
         start_time = time.time() - seconds
         snapshots = self.db.get_history(limit=10000, start_time=start_time)
 

monitorify-1.0.2/src/monitorify.egg-info/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.1 → monitorify-1.0.2}/src/monitorify.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ pyproject.toml
 src/monitorify/__init__.py
 src/monitorify/__main__.py
 src/monitorify/config.py
+src/monitorify/config_manager.py
 src/monitorify/daemon.py
 src/monitorify/main.py
 src/monitorify.egg-info/PKG-INFO
@@ -15,6 +16,8 @@ src/monitorify/collector/__init__.py
 src/monitorify/collector/manager.py
 src/monitorify/collector/schema.py
 src/monitorify/collector/worker.py
+src/monitorify/config/__init__.py
+src/monitorify/config/configManager.py
 src/monitorify/remote/__init__.py
 src/monitorify/remote/connector.py
 src/monitorify/stats/DiskStats.py

monitorify-1.0.1/PKG-INFO

@@ -1,52 +0,0 @@
-Metadata-Version: 2.4
-Name: monitorify
-Version: 1.0.1
-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
-### Python | Textual
-### SQLite
-### Linux

monitorify-1.0.1/README.md

@@ -1,40 +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
-### Python | Textual
-### SQLite
-### Linux

monitorify-1.0.1/src/monitorify/daemon.py

@@ -1,32 +0,0 @@
-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.1/src/monitorify.egg-info/PKG-INFO

@@ -1,52 +0,0 @@
-Metadata-Version: 2.4
-Name: monitorify
-Version: 1.0.1
-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
-### Python | Textual
-### SQLite
-### Linux