netwatchpy 0.2.9__tar.gz

netwatchpy-0.2.9/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Pranav Kishan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

netwatchpy-0.2.9/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: netwatchpy
+Version: 0.2.9
+Summary: A TUI network usage monitor.
+Author-email: Pranav Kishan <ty.pranavkishan7905@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Destroyer795/Netwatchpy-package
+Project-URL: Issues, https://github.com/Destroyer795/Netwatchpy-package/issues
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: textual
+Requires-Dist: psutil
+Requires-Dist: platformdirs
+Requires-Dist: desktop-notifier; platform_system != "Linux"
+Requires-Dist: desktop-notifier[dbus]; platform_system == "Linux"
+Dynamic: license-file
+
+# Netwatch TUI (netwatchpy)
+
+[![PyPI Version](https://img.shields.io/pypi/v/netwatchpy.svg)](https://pypi.org/project/netwatchpy/)
+![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)
+
+A TUI (Text-based User Interface) for monitoring network usage in real-time, with support for data limits and desktop notifications.
+
+---
+<p align="center">
+<img width="800" height="500" alt="netwatch_demo" src="/assets/demo.png" />
+</p>
+
+---
+
+## Features
+
+* **Real-time Dashboard:** A clean, terminal-based dashboard showing total download, upload, and current speeds.
+* **Persistent Quota:** Automatically saves your total usage, so you can track a monthly data cap across multiple sessions.
+
+* **Data Cap Monitoring:** Set a data limit (e.g., `10GB`) and see your usage on a real-time progress bar.
+* **Desktop Notifications:** Get native desktop notifications when you hit 80% and 100% of your data limit.
+* **Live Activity Log:** An interactive, scrolling log of all network activity, updated every second.
+* **Command Palette & Dark Mode:** A modern TUI experience with a built-in command palette (`Ctrl+P`) and dark mode support (`Ctrl+D`).
+* **CSV Logging:** Optionally log all network traffic to a CSV file for later analysis.
+* **Cross-Platform:** Runs on Windows, macOS, and Linux.
+
+---
+
+## Installation
+
+`netwatchpy` is available on PyPI. All you need is Python 3.8+ and `pip`.
+
+```bash
+pip install netwatchpy
+```
+---
+
+## Usage
+
+Once installed, the netwatch command will be available in your terminal.
+
+**To start the monitor (monitors all interfaces):**
+
+```bash
+netwatch
+```
+
+**To see all available options and help:**
+
+```bash
+netwatch --help
+```
+---
+## Command-Line Arguments
+
+You can control the monitor with these arguments:
+
+*   **`-h`,` --help`**
+    
+    *   Shows the help message and all options.
+        
+*   **`-i INTERFACE`,` --interface INTERFACE`**
+    
+    *   Monitors a single, specific network interface (e.g., -i "Wi-Fi"). Defaults to "all".
+        
+*   **`-l LIMIT`,` --limit LIMIT`**
+    
+    *   Sets a data cap and shows a progress bar (e.g., -l "10GB" or -l "500MB").
+        
+*   **`--log LOG`**
+    
+    *   Saves all network activity to a specified CSV file (e.g., --log "usage.csv").
+        
+---
+
+### Examples
+
+**Set a 10GB data limit:**
+
+```bash
+netwatch -l "10GB"
+```
+
+**Monitor a specific interface ("Wi-Fi") and log to a file:**
+
+```bash
+netwatch -i "Wi-Fi" --log "my_usage.csv"
+```
+---
+### In-App Keybindings
+
+*   **`Ctrl+p`**: Open the Command Palette
+    
+*   **`Ctrl+d`**: Toggle Dark / Light Mode
+
+*   **`Ctrl+s`**: Toggle Dark / Light Mode
+    
+*   **`r`**: Reset all counters back to zero
+    
+*   **`Ctrl+q`**: Quit the application
+    
+---
+
+Bug Reports & Feature Requests
+---------------------------------
+
+Found a bug or have a great idea? Please [open an issue]([https://github.com/destroyer795/Netwatchpy-package/issues](https://github.com/destroyer795/Netwatchpy-package/issues)) on the GitHub repository.
+
+License
+----------
+
+This project is licensed under the MIT License.

netwatchpy-0.2.9/README.md

@@ -0,0 +1,112 @@
+# Netwatch TUI (netwatchpy)
+
+[![PyPI Version](https://img.shields.io/pypi/v/netwatchpy.svg)](https://pypi.org/project/netwatchpy/)
+![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)
+
+A TUI (Text-based User Interface) for monitoring network usage in real-time, with support for data limits and desktop notifications.
+
+---
+<p align="center">
+<img width="800" height="500" alt="netwatch_demo" src="/assets/demo.png" />
+</p>
+
+---
+
+## Features
+
+* **Real-time Dashboard:** A clean, terminal-based dashboard showing total download, upload, and current speeds.
+* **Persistent Quota:** Automatically saves your total usage, so you can track a monthly data cap across multiple sessions.
+
+* **Data Cap Monitoring:** Set a data limit (e.g., `10GB`) and see your usage on a real-time progress bar.
+* **Desktop Notifications:** Get native desktop notifications when you hit 80% and 100% of your data limit.
+* **Live Activity Log:** An interactive, scrolling log of all network activity, updated every second.
+* **Command Palette & Dark Mode:** A modern TUI experience with a built-in command palette (`Ctrl+P`) and dark mode support (`Ctrl+D`).
+* **CSV Logging:** Optionally log all network traffic to a CSV file for later analysis.
+* **Cross-Platform:** Runs on Windows, macOS, and Linux.
+
+---
+
+## Installation
+
+`netwatchpy` is available on PyPI. All you need is Python 3.8+ and `pip`.
+
+```bash
+pip install netwatchpy
+```
+---
+
+## Usage
+
+Once installed, the netwatch command will be available in your terminal.
+
+**To start the monitor (monitors all interfaces):**
+
+```bash
+netwatch
+```
+
+**To see all available options and help:**
+
+```bash
+netwatch --help
+```
+---
+## Command-Line Arguments
+
+You can control the monitor with these arguments:
+
+*   **`-h`,` --help`**
+    
+    *   Shows the help message and all options.
+        
+*   **`-i INTERFACE`,` --interface INTERFACE`**
+    
+    *   Monitors a single, specific network interface (e.g., -i "Wi-Fi"). Defaults to "all".
+        
+*   **`-l LIMIT`,` --limit LIMIT`**
+    
+    *   Sets a data cap and shows a progress bar (e.g., -l "10GB" or -l "500MB").
+        
+*   **`--log LOG`**
+    
+    *   Saves all network activity to a specified CSV file (e.g., --log "usage.csv").
+        
+---
+
+### Examples
+
+**Set a 10GB data limit:**
+
+```bash
+netwatch -l "10GB"
+```
+
+**Monitor a specific interface ("Wi-Fi") and log to a file:**
+
+```bash
+netwatch -i "Wi-Fi" --log "my_usage.csv"
+```
+---
+### In-App Keybindings
+
+*   **`Ctrl+p`**: Open the Command Palette
+    
+*   **`Ctrl+d`**: Toggle Dark / Light Mode
+
+*   **`Ctrl+s`**: Toggle Dark / Light Mode
+    
+*   **`r`**: Reset all counters back to zero
+    
+*   **`Ctrl+q`**: Quit the application
+    
+---
+
+Bug Reports & Feature Requests
+---------------------------------
+
+Found a bug or have a great idea? Please [open an issue]([https://github.com/destroyer795/Netwatchpy-package/issues](https://github.com/destroyer795/Netwatchpy-package/issues)) on the GitHub repository.
+
+License
+----------
+
+This project is licensed under the MIT License.

netwatchpy-0.2.9/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "netwatchpy"
+version = "0.2.9"
+authors = [
+    { name = "Pranav Kishan", email = "ty.pranavkishan7905@gmail.com" }
+]
+description = "A TUI network usage monitor."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+
+dependencies = [
+    "textual",
+    "psutil",
+    "platformdirs",
+    "desktop-notifier; platform_system != 'Linux'",
+    "desktop-notifier[dbus]; platform_system == 'Linux'"
+]
+
+[project.scripts]
+netwatch = "netwatch.tui:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+packages = ["netwatch"]
+
+[project.urls]
+Homepage = "https://github.com/Destroyer795/Netwatchpy-package"
+Issues = "https://github.com/Destroyer795/Netwatchpy-package/issues"

netwatchpy-0.2.9/setup.cfg

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

netwatchpy-0.2.9/src/netwatch/monitor.py

@@ -0,0 +1,108 @@
+import psutil
+import threading
+from datetime import datetime
+import csv
+from .utils import get_size
+
+
+class NetworkMonitorThread(threading.Thread):
+    def __init__(self, callback, interface="all", log_file=None,
+                 initial_upload=0, initial_download=0, interval=1.0):
+        super().__init__()
+        self.daemon = True
+        self.callback = callback
+        self.interface = interface
+        self.log_file = log_file
+        self.interval = interval
+        self.stop_event = threading.Event()
+
+        self.total_up = int(initial_upload)
+        self.total_down = int(initial_download)
+        if self.log_file:
+            try:
+                file_exists = False
+                try:
+                    with open(self.log_file, "r", encoding="utf-8"):
+                        file_exists = True
+                except FileNotFoundError:
+                    file_exists = False
+                with open(self.log_file, "a", newline="", encoding="utf-8") as f:
+                    writer = csv.writer(f)
+                    if not file_exists:
+                        writer.writerow(["Timestamp", "Upload Speed (B/s)", "Download Speed (B/s)", "Total Upload", "Total Download", "Total Usage"])
+            except Exception:
+                self.log_file = None
+
+    def stop(self):
+        self.stop_event.set()
+
+    def run(self):
+        try:
+            last = psutil.net_io_counters(pernic=True)
+        except Exception:
+            self.callback({"error": "Failed to get initial network stats."})
+            return
+
+        if not last:
+            self.callback({"error": "No network interfaces found."})
+            return
+        if self.interface != 'all' and self.interface not in last:
+            self.callback({"error": f"Interface '{self.interface}' not found."})
+            return
+            
+        while not self.stop_event.is_set():
+            try:
+                self.stop_event.wait(self.interval)
+                if self.stop_event.is_set():
+                    break
+
+                now = psutil.net_io_counters(pernic=True)
+                if not now:
+                    continue
+
+                up = 0
+                down = 0
+
+                if self.interface == "all":
+                    for iface in now:
+                        if iface in last:
+                            up += now[iface].bytes_sent - last[iface].bytes_sent
+                            down += now[iface].bytes_recv - last[iface].bytes_recv
+                else:
+                    if self.interface in now and self.interface in last:
+                        up = now[self.interface].bytes_sent - last[self.interface].bytes_sent
+                        down = now[self.interface].bytes_recv - last[self.interface].bytes_recv
+
+                last = now
+
+                up = max(0, int(up))
+                down = max(0, int(down))
+
+                self.total_up += up
+                self.total_down += down
+
+                packet = {
+                    "upload_speed": up,
+                    "download_speed": down,
+                    "total_upload": self.total_up,
+                    "total_download": self.total_down,
+                    "total_usage": self.total_up + self.total_down,
+                    "timestamp": datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+                }
+
+                if self.log_file:
+                    try:
+                        with open(self.log_file, "a", newline="", encoding="utf-8") as f:
+                            writer = csv.writer(f)
+                            writer.writerow([packet["timestamp"], up, down, get_size(self.total_up), get_size(self.total_down), get_size(packet["total_usage"])])
+                    except Exception:
+                        self.log_file = None
+
+                if self.stop_event.is_set():
+                    break
+                self.callback(packet)
+            
+            except Exception as e:
+                if not self.stop_event.is_set():
+                    self.callback({"error": f"Error in monitor loop: {e}"})
+                    self.stop_event.wait(3.0)

netwatchpy-0.2.9/src/netwatch/tui.py

@@ -0,0 +1,370 @@
+import argparse
+import json
+import os
+import sys
+from textwrap import dedent
+from platformdirs import user_config_dir
+
+from textual.app import App, ComposeResult
+from textual.containers import VerticalScroll, Horizontal, Container
+from textual.widgets import Header, Footer, DataTable, ProgressBar, Static
+from textual.reactive import var
+from desktop_notifier import DesktopNotifier
+
+from .utils import get_size, parse_limit
+from .monitor import NetworkMonitorThread
+
+
+
+class NetMonitorTUI(App):
+    TITLE = "Network Usage Monitor"
+    SUB_TITLE = "Press Ctrl+P for commands, Ctrl+Q to quit"
+
+    BINDINGS = [
+        ("ctrl+p", "command_palette", "Command Palette"),
+        ("ctrl+d", "toggle_dark", "Toggle Dark Mode"),
+        ("r", "reset_counters", "Reset Counters"),
+        ("ctrl+s", "save_quota", "Save Quota"),
+        ("ctrl+q", "quit", "Quit"),
+    ]
+
+    CSS = dedent("""
+        Screen { background: #f8f8f8; color: black; }
+        .-dark-mode Screen { background: #101010; color: #f0f0f0; }
+
+        #main_container { layout: vertical; }
+        #summary_cards { layout: horizontal; height: auto; padding: 1 0; }
+
+        .summary_card {
+            width: 1fr;
+            min-height: 5;
+            border: solid black;
+            padding: 1;
+            margin: 0 1;
+            background: #e8e8e8;
+        }
+        .-dark-mode .summary_card {
+            border: solid #888;
+            background: #222;
+            color: #e0e0e0;
+        }
+
+        #limit_container { height: auto; padding: 0 1 1 1; }
+        
+        #stats_table {
+            height: 1fr;
+            margin: 0 1;
+            border: solid black;
+            background: white; /* Light mode background */
+            color: black;      /* Light mode text */
+        }
+        .-dark-mode #stats_table {
+            border: solid #666;
+            background: #222; /* Dark mode background */
+            color: #e0e0e0;   /* Dark mode text */
+        }
+        
+        ProgressBar {
+            background: #e8e8e8; /* Light mode track */
+        }
+        .-dark-mode ProgressBar {
+            background: #222; /* Dark mode track */
+        }
+
+        ProgressBar > .progress-bar--bar { background: #007acc; }
+        .-dark-mode ProgressBar > .progress-bar--bar { background: #55aaff; }
+
+        #error_box {
+            height: auto;
+            padding: 1 2;
+            color: red;
+            display: none;
+        }
+    """)
+
+    # Reactive vars (auto update UI)
+    total_upload = var(0)
+    total_download = var(0)
+    total_usage = var(0)
+    upload_speed = var(0)
+    download_speed = var(0)
+    dark = var(False)
+
+    def __init__(self, interface="all", limit_str=None, log_file=None):
+        super().__init__()
+        self.interface = interface
+        self.limit_bytes = parse_limit(limit_str)
+        self.limit_str = limit_str or "No Limit"
+        self.log_file = log_file
+
+        self.notifier = DesktopNotifier(app_name="Netwatch")
+        self.monitor_thread = None
+        self._save_lock = None # added in on_mount
+        
+        self.alert_80_sent = False
+        self.alert_100_sent = False
+
+        # Persistent storage location
+        self.config_dir = user_config_dir("netwatchpy")
+        self.quota_file = os.path.join(self.config_dir, "quota.json")
+
+    def _load_persistent_quota(self):
+        try:
+            with open(self.quota_file, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            return (
+                int(data.get("total_upload", 0)),
+                int(data.get("total_download", 0)),
+            )
+        except Exception:
+            return 0, 0
+
+    def _save_persistent_quota(self):
+        """Safe atomic save of totals."""
+        try:
+            os.makedirs(self.config_dir, exist_ok=True)
+
+            payload = {
+                "total_upload": int(self.total_upload),
+                "total_download": int(self.total_download),
+            }
+
+            tmp = self.quota_file + ".tmp"
+            with open(tmp, "w", encoding="utf-8") as f:
+                json.dump(payload, f, indent=2)
+
+            os.replace(tmp, self.quota_file)
+        except Exception as e:
+            print(f"[netwatch save error] {e}", file=sys.stderr)
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+
+        with VerticalScroll(id="main_container"):
+            with Horizontal(id="summary_cards"):
+                yield Static("Total Download\n[b]0.00 B[/b]", id="total-dl-card", classes="summary_card")
+                yield Static("Total Upload\n[b]0.00 B[/b]", id="total-ul-card", classes="summary_card")
+                yield Static("Total Usage\n[b]0.00 B[/b]", id="total-usage-card", classes="summary_card")
+
+            with Container(id="limit_container"):
+                if self.limit_bytes:
+                    yield Static(f"Usage Limit: {get_size(self.limit_bytes)}")
+                    yield ProgressBar(id="limit_bar", total=self.limit_bytes, show_eta=False)
+                else:
+                    yield Static("Usage Limit: Not Set")
+
+            yield Static(id="error_box")
+            yield DataTable(id="stats_table")
+
+        yield Footer()
+
+    def on_mount(self):
+        """Executed when TUI is ready."""
+        from threading import Lock
+        self._save_lock = Lock()
+
+        # Build table
+        table = self.query_one(DataTable)
+        table.add_column("Time")
+        table.add_column("Up Speed")
+        table.add_column("Down Speed")
+        table.add_column("Total Up")
+        table.add_column("Total Down")
+        table.add_column("Total Usage")
+
+        # Load saved totals before thread start
+        up, down = self._load_persistent_quota()
+        self.total_upload = up
+        self.total_download = down
+        self.total_usage = up + down
+
+        if self.limit_bytes:
+            try:
+                bar = self.query_one(ProgressBar)
+                bar.progress = self.total_usage
+            except Exception:
+                pass
+
+        # Start autosave (every 10 seconds)
+        self.set_interval(10, self._autosave_job)
+
+        self.monitor_thread = NetworkMonitorThread(
+            self.on_data_update,
+            interface=self.interface,
+            log_file=self.log_file,
+            initial_upload=up,
+            initial_download=down,
+        )
+        self.monitor_thread.start()
+
+    def on_exit(self):
+        """
+        Stop the thread, then do a final save.
+        """
+        if self.monitor_thread:
+            self.monitor_thread.stop()
+            self.monitor_thread.join(timeout=1.5)
+        
+        print("\n[netwatch] Quitting... saving final quota.")
+        if self._save_lock.acquire(timeout=2.0):
+            try:
+                self._save_persistent_quota()
+                print("[netwatch] Final save complete.")
+            except Exception as e:
+                print(f"[netwatch] Final save failed: {e}", file=sys.stderr)
+            finally:
+                self._save_lock.release()
+        else:
+            print("[netwatch] Could not acquire lock, final save skipped.", file=sys.stderr)
+
+    def _autosave_job(self):
+        """Called every 10 seconds."""
+        if self._save_lock.acquire(timeout=0.1):
+            try:
+                self._save_persistent_quota()
+            finally:
+                self._save_lock.release()
+
+    def on_data_update(self, data: dict):
+        self.call_from_thread(self._process_data_packet, data)
+
+    def _process_data_packet(self, data: dict):
+        if "error" in data:
+            box = self.query_one("#error_box")
+            box.update("ERROR: " + data["error"])
+            box.styles.display = "block"
+            return
+
+        if "timestamp" not in data:
+            return
+
+        self.upload_speed = data["upload_speed"]
+        self.download_speed = data["download_speed"]
+        self.total_upload = data["total_upload"]
+        self.total_download = data["total_download"]
+        self.total_usage = data["total_usage"]
+
+        table = self.query_one(DataTable)
+        table.add_row(
+            data["timestamp"].split(" ")[1],
+            f"{get_size(self.upload_speed)}/s",
+            f"{get_size(self.download_speed)}/s",
+            get_size(self.total_upload),
+            get_size(self.total_download),
+            get_size(self.total_usage),
+        )
+        table.scroll_end(animate=False)
+
+        if table.row_count > 50:
+            first_key = next(iter(table.rows.keys()))
+            table.remove_row(first_key)
+
+    def watch_total_download(self, new):
+        self.query_one("#total-dl-card").update(
+            f"Total Download\n[b]{get_size(new)}[/b]"
+        )
+
+    def watch_total_upload(self, new):
+        self.query_one("#total-ul-card").update(
+            f"Total Upload\n[b]{get_size(new)}[/b]"
+        )
+
+    async def watch_total_usage(self, new_total_usage: int):
+        self.query_one("#total-usage-card").update(
+            f"Total Usage\n[b]{get_size(new_total_usage)}[/b]"
+        )
+        
+        if self.limit_bytes:
+            bar = self.query_one(ProgressBar)
+            bar.progress = new_total_usage
+
+            # 80% warning
+            if new_total_usage >= 0.8 * self.limit_bytes and not self.alert_80_sent:
+                self.alert_80_sent = True
+                bar.styles.color = "yellow"
+                self.sub_title = "⚠️ 80% of limit reached!"
+                try:
+                    await self.notifier.send(
+                        title="Netwatch: 80% Usage Warning",
+                        message=f"You have used {get_size(new_total_usage)} of your {get_size(self.limit_bytes)} limit."
+                    )
+                except Exception as e:
+                    print(f"[Notification Error] {e}", file=sys.stderr) # Log to stderr
+
+            # 100% alert
+            if new_total_usage >= self.limit_bytes and not self.alert_100_sent:
+                self.alert_100_sent = True
+                bar.styles.color = "red"
+                self.sub_title = "🚨 Data limit exceeded!"
+                try:
+                    await self.notifier.send(
+                        title="Netwatch: Data Limit Exceeded!",
+                        message=f"You have exceeded your {get_size(self.limit_bytes)} data limit."
+                    )
+                except Exception as e:
+                    print(f"[Notification Error] {e}", file=sys.stderr) # Log to stderr
+
+    def action_toggle_dark(self):
+        self.dark = not self.dark
+        self.set_class(self.dark, "-dark-mode")
+        self.sub_title = "🌙 Dark Mode" if self.dark else "☀️ Light Mode"
+
+    def action_reset_counters(self):
+        """Resets all counters to 0 and saves this reset."""
+        if self.monitor_thread:
+            self.monitor_thread.stop()
+            self.monitor_thread.join(timeout=1)
+
+        self.total_upload = 0
+        self.total_download = 0
+        self.total_usage = 0
+        self.sub_title = "Quota Reset to 0"
+
+        self.alert_80_sent = False
+        self.alert_100_sent = False
+
+        # get lock to save the reset
+        if self._save_lock.acquire(timeout=1.0):
+            try:
+                self._save_persistent_quota()
+            finally:
+                self._save_lock.release()
+
+        # Restart fresh thread
+        self.monitor_thread = NetworkMonitorThread(
+            self.on_data_update,
+            interface=self.interface,
+            log_file=self.log_file,
+            initial_upload=0,
+            initial_download=0,
+        )
+        self.monitor_thread.start()
+
+    def action_save_quota(self) -> None:
+        """Manually save the current quota totals."""
+        if self._save_lock.acquire(timeout=0.1):
+            try:
+                self._save_persistent_quota()
+                self.sub_title = "Quota Saved!"
+            finally:
+                self._save_lock.release()
+        else:
+            self.sub_title = "Saving... please wait."
+
+def main():
+    parser = argparse.ArgumentParser(description="Network Usage Monitor TUI")
+    parser.add_argument("-i", "--interface", default="all")
+    parser.add_argument("-l", "--limit")
+    parser.add_argument("--log")
+    args = parser.parse_args()
+
+    app = NetMonitorTUI(
+        interface=args.interface,
+        limit_str=args.limit,
+        log_file=args.log,
+    )
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

netwatchpy-0.2.9/src/netwatch/utils.py

@@ -0,0 +1,31 @@
+def get_size(byte_val):
+    """Convert bytes into human readable string."""
+    if byte_val is None:
+        return "0 B"
+    power = 1024
+    n = 0
+    units = ["", "K", "M", "G", "T"]
+    while byte_val >= power and n < len(units) - 1:
+        byte_val /= power
+        n += 1
+    return f"{byte_val:.2f} {units[n]}B"
+
+
+def parse_limit(size_str):
+    """Parse a string like '10GB' or '500MB' into bytes."""
+    if not size_str:
+        return None
+    s = size_str.upper().strip()
+
+    if s.endswith("GB"):
+        return int(float(s[:-2]) * 1024**3)
+    if s.endswith("MB"):
+        return int(float(s[:-2]) * 1024**2)
+    if s.endswith("KB"):
+        return int(float(s[:-2]) * 1024)
+
+    # fallback: maybe a plain number
+    try:
+        return int(float(s))
+    except ValueError:
+        return None

netwatchpy-0.2.9/src/netwatchpy.egg-info/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: netwatchpy
+Version: 0.2.9
+Summary: A TUI network usage monitor.
+Author-email: Pranav Kishan <ty.pranavkishan7905@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Destroyer795/Netwatchpy-package
+Project-URL: Issues, https://github.com/Destroyer795/Netwatchpy-package/issues
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: textual
+Requires-Dist: psutil
+Requires-Dist: platformdirs
+Requires-Dist: desktop-notifier; platform_system != "Linux"
+Requires-Dist: desktop-notifier[dbus]; platform_system == "Linux"
+Dynamic: license-file
+
+# Netwatch TUI (netwatchpy)
+
+[![PyPI Version](https://img.shields.io/pypi/v/netwatchpy.svg)](https://pypi.org/project/netwatchpy/)
+![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)
+
+A TUI (Text-based User Interface) for monitoring network usage in real-time, with support for data limits and desktop notifications.
+
+---
+<p align="center">
+<img width="800" height="500" alt="netwatch_demo" src="/assets/demo.png" />
+</p>
+
+---
+
+## Features
+
+* **Real-time Dashboard:** A clean, terminal-based dashboard showing total download, upload, and current speeds.
+* **Persistent Quota:** Automatically saves your total usage, so you can track a monthly data cap across multiple sessions.
+
+* **Data Cap Monitoring:** Set a data limit (e.g., `10GB`) and see your usage on a real-time progress bar.
+* **Desktop Notifications:** Get native desktop notifications when you hit 80% and 100% of your data limit.
+* **Live Activity Log:** An interactive, scrolling log of all network activity, updated every second.
+* **Command Palette & Dark Mode:** A modern TUI experience with a built-in command palette (`Ctrl+P`) and dark mode support (`Ctrl+D`).
+* **CSV Logging:** Optionally log all network traffic to a CSV file for later analysis.
+* **Cross-Platform:** Runs on Windows, macOS, and Linux.
+
+---
+
+## Installation
+
+`netwatchpy` is available on PyPI. All you need is Python 3.8+ and `pip`.
+
+```bash
+pip install netwatchpy
+```
+---
+
+## Usage
+
+Once installed, the netwatch command will be available in your terminal.
+
+**To start the monitor (monitors all interfaces):**
+
+```bash
+netwatch
+```
+
+**To see all available options and help:**
+
+```bash
+netwatch --help
+```
+---
+## Command-Line Arguments
+
+You can control the monitor with these arguments:
+
+*   **`-h`,` --help`**
+    
+    *   Shows the help message and all options.
+        
+*   **`-i INTERFACE`,` --interface INTERFACE`**
+    
+    *   Monitors a single, specific network interface (e.g., -i "Wi-Fi"). Defaults to "all".
+        
+*   **`-l LIMIT`,` --limit LIMIT`**
+    
+    *   Sets a data cap and shows a progress bar (e.g., -l "10GB" or -l "500MB").
+        
+*   **`--log LOG`**
+    
+    *   Saves all network activity to a specified CSV file (e.g., --log "usage.csv").
+        
+---
+
+### Examples
+
+**Set a 10GB data limit:**
+
+```bash
+netwatch -l "10GB"
+```
+
+**Monitor a specific interface ("Wi-Fi") and log to a file:**
+
+```bash
+netwatch -i "Wi-Fi" --log "my_usage.csv"
+```
+---
+### In-App Keybindings
+
+*   **`Ctrl+p`**: Open the Command Palette
+    
+*   **`Ctrl+d`**: Toggle Dark / Light Mode
+
+*   **`Ctrl+s`**: Toggle Dark / Light Mode
+    
+*   **`r`**: Reset all counters back to zero
+    
+*   **`Ctrl+q`**: Quit the application
+    
+---
+
+Bug Reports & Feature Requests
+---------------------------------
+
+Found a bug or have a great idea? Please [open an issue]([https://github.com/destroyer795/Netwatchpy-package/issues](https://github.com/destroyer795/Netwatchpy-package/issues)) on the GitHub repository.
+
+License
+----------
+
+This project is licensed under the MIT License.

netwatchpy-0.2.9/src/netwatchpy.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+src/netwatch/__init__.py
+src/netwatch/monitor.py
+src/netwatch/tui.py
+src/netwatch/utils.py
+src/netwatchpy.egg-info/PKG-INFO
+src/netwatchpy.egg-info/SOURCES.txt
+src/netwatchpy.egg-info/dependency_links.txt
+src/netwatchpy.egg-info/entry_points.txt
+src/netwatchpy.egg-info/requires.txt
+src/netwatchpy.egg-info/top_level.txt

netwatchpy-0.2.9/src/netwatchpy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

netwatchpy-0.2.9/src/netwatchpy.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+netwatch = netwatch.tui:main

netwatchpy-0.2.9/src/netwatchpy.egg-info/requires.txt

@@ -0,0 +1,9 @@
+textual
+psutil
+platformdirs
+
+[:platform_system != "Linux"]
+desktop-notifier
+
+[:platform_system == "Linux"]
+desktop-notifier[dbus]

netwatchpy-0.2.9/src/netwatchpy.egg-info/top_level.txt

@@ -0,0 +1 @@
+netwatch