runmonitor 0.2.0__tar.gz

runmonitor-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 k
+
+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.

runmonitor-0.2.0/MANIFEST.in

@@ -0,0 +1,5 @@
+include LICENSE
+include README.md
+include pyproject.toml
+recursive-include templates *.html
+recursive-include static *.css

runmonitor-0.2.0/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: runmonitor
+Version: 0.2.0
+Summary: Lean, local experiment tracker with a live, terminal-styled web dashboard.
+Author-email: bub4tz <ezgroupnl@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 k
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/empero-org/runmonitor
+Project-URL: Repository, https://github.com/empero-org/runmonitor
+Project-URL: Issues, https://github.com/empero-org/runmonitor/issues
+Keywords: machine-learning,experiment-tracking,metrics,dashboard,training,monitoring,mlops,tensorboard,wandb
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: flask>=2.0
+Provides-Extra: system
+Requires-Dist: psutil>=5.0; extra == "system"
+Dynamic: license-file
+
+# runmonitor
+
+Lean, local experiment tracker with a live, **terminal-styled** web dashboard. Import and go.
+
+```python
+import runmonitor as rm
+
+run = rm.init("my-experiment", config={"lr": 0.001, "batch_size": 32}, total_steps=1000)
+
+for step in range(1000):
+    loss, acc = train_step()
+    run.log({"loss": loss, "accuracy": acc}, step)
+    if step % 100 == 0:
+        run.save("checkpoint.pt")
+
+run.finish()
+```
+
+Open `http://localhost:8080` — your loss curve is already live and drawing itself.
+
+## Install
+
+```bash
+pip install runmonitor                 # core
+pip install "runmonitor[system]"       # + CPU/RAM tracking (psutil)
+```
+
+Then in any training script:
+
+```python
+import runmonitor as rm
+```
+
+Or run the dashboard on its own (no training script needed):
+
+```bash
+runmonitor                 # opens the dashboard in your browser
+python -m runmonitor       # equivalent, for a checkout/vendored copy
+RUNMONITOR_PORT=9000 runmonitor   # pick a port (set before launch)
+```
+
+## The dashboard
+
+A single, evolving view in the empero black/purple palette:
+
+| Element | What it shows |
+|---|---|
+| **Metric ticker** | Every logged metric as `key=value`. Click one to **select** it. |
+| **Live hero curve** | The selected metric, drawn point-by-point and growing every step. |
+| **Anomaly detection** | Rolling z-score flags spikes — vertical markers on the curve + a status line ("⚠ anomaly at step N" / "● all calm"). |
+| **Run header** | Run id, current step, status pill, elapsed, steps/sec, ETA, progress bar. |
+| **Streak / best badges** | 🔥 improving-streak and 🏆 personal-best on the selected metric (direction-aware). |
+| **Compare** | Pick a second run to overlay on the selected metric. |
+| **System pane** | CPU % and RAM % over time (needs `psutil`). |
+| **Hyperparameters / Artifacts** | Config passed to `rm.init()` and any saved files. |
+| **Export** | Download the full run as CSV or JSON. |
+| **Theme** | Midnight (black/purple) by default; toggle to light bone-paper. |
+
+## API
+
+```python
+# Start a run (creates the project if new)
+run = rm.init(project: str, name: str | None = None,
+              config: dict | None = None,
+              total_steps: int | None = None) -> Run
+
+run.log(metrics: dict[str, float], step: int)   # log metrics at a step
+run.save(filepath: str) -> dict                  # save an artifact file
+run.finish()                                     # mark finished
+run.fail()                                       # mark crashed
+```
+
+## Storage
+
+Everything lives in `~/.runmonitor/`:
+- `runs.db` — SQLite database (WAL mode, thread-safe)
+- `artifacts/<run_id>/` — saved files per run
+
+No database setup, no API keys, no cloud.
+
+## Requirements
+
+- Python 3.10+
+- Flask
+- Chart.js (loaded from CDN in the dashboard)
+- `psutil` (optional, for system metrics)
+
+## Publishing to PyPI (maintainers)
+
+```bash
+python -m pip install --upgrade build twine
+python -m build                 # → dist/runmonitor-<version>.tar.gz + .whl
+python -m twine check dist/*
+python -m twine upload dist/*   # needs a PyPI account + API token
+```
+
+Bump `version` in `pyproject.toml` before each release.

runmonitor-0.2.0/README.md

@@ -0,0 +1,97 @@
+# runmonitor
+
+Lean, local experiment tracker with a live, **terminal-styled** web dashboard. Import and go.
+
+```python
+import runmonitor as rm
+
+run = rm.init("my-experiment", config={"lr": 0.001, "batch_size": 32}, total_steps=1000)
+
+for step in range(1000):
+    loss, acc = train_step()
+    run.log({"loss": loss, "accuracy": acc}, step)
+    if step % 100 == 0:
+        run.save("checkpoint.pt")
+
+run.finish()
+```
+
+Open `http://localhost:8080` — your loss curve is already live and drawing itself.
+
+## Install
+
+```bash
+pip install runmonitor                 # core
+pip install "runmonitor[system]"       # + CPU/RAM tracking (psutil)
+```
+
+Then in any training script:
+
+```python
+import runmonitor as rm
+```
+
+Or run the dashboard on its own (no training script needed):
+
+```bash
+runmonitor                 # opens the dashboard in your browser
+python -m runmonitor       # equivalent, for a checkout/vendored copy
+RUNMONITOR_PORT=9000 runmonitor   # pick a port (set before launch)
+```
+
+## The dashboard
+
+A single, evolving view in the empero black/purple palette:
+
+| Element | What it shows |
+|---|---|
+| **Metric ticker** | Every logged metric as `key=value`. Click one to **select** it. |
+| **Live hero curve** | The selected metric, drawn point-by-point and growing every step. |
+| **Anomaly detection** | Rolling z-score flags spikes — vertical markers on the curve + a status line ("⚠ anomaly at step N" / "● all calm"). |
+| **Run header** | Run id, current step, status pill, elapsed, steps/sec, ETA, progress bar. |
+| **Streak / best badges** | 🔥 improving-streak and 🏆 personal-best on the selected metric (direction-aware). |
+| **Compare** | Pick a second run to overlay on the selected metric. |
+| **System pane** | CPU % and RAM % over time (needs `psutil`). |
+| **Hyperparameters / Artifacts** | Config passed to `rm.init()` and any saved files. |
+| **Export** | Download the full run as CSV or JSON. |
+| **Theme** | Midnight (black/purple) by default; toggle to light bone-paper. |
+
+## API
+
+```python
+# Start a run (creates the project if new)
+run = rm.init(project: str, name: str | None = None,
+              config: dict | None = None,
+              total_steps: int | None = None) -> Run
+
+run.log(metrics: dict[str, float], step: int)   # log metrics at a step
+run.save(filepath: str) -> dict                  # save an artifact file
+run.finish()                                     # mark finished
+run.fail()                                       # mark crashed
+```
+
+## Storage
+
+Everything lives in `~/.runmonitor/`:
+- `runs.db` — SQLite database (WAL mode, thread-safe)
+- `artifacts/<run_id>/` — saved files per run
+
+No database setup, no API keys, no cloud.
+
+## Requirements
+
+- Python 3.10+
+- Flask
+- Chart.js (loaded from CDN in the dashboard)
+- `psutil` (optional, for system metrics)
+
+## Publishing to PyPI (maintainers)
+
+```bash
+python -m pip install --upgrade build twine
+python -m build                 # → dist/runmonitor-<version>.tar.gz + .whl
+python -m twine check dist/*
+python -m twine upload dist/*   # needs a PyPI account + API token
+```
+
+Bump `version` in `pyproject.toml` before each release.

runmonitor-0.2.0/__init__.py

@@ -0,0 +1,125 @@
+"""
+runmonitor — a lean, local experiment tracker with a live web dashboard.
+Import and go.  Dashboard auto-starts on port 8080.
+"""
+
+import json
+import uuid
+import atexit
+import threading
+import time
+from . import server  # noqa: F401 — starts the daemon
+from . import storage
+
+
+class Run:
+    """A single experiment run.  Created via rm.init()."""
+
+    def __init__(self, run_id: str, project_id: int, name: str | None,
+                 config: dict, total_steps: int | None):
+        self._id = run_id
+        self._project_id = project_id
+        self._name = name
+        self._config = config
+        self._total_steps = total_steps
+        self._finished = False
+        self._sysmon_stop = threading.Event()
+        self._sysmon_thread = None
+        self._start_sysmon()
+        atexit.register(self._on_exit)
+
+    @property
+    def id(self) -> str:
+        return self._id
+
+    @property
+    def name(self) -> str | None:
+        return self._name
+
+    def log(self, metrics: dict, step: int) -> None:
+        """Log a dictionary of metric-name → float at a given step."""
+        if self._finished:
+            raise RuntimeError("Cannot log to a finished run.")
+        if not isinstance(metrics, dict):
+            raise TypeError("metrics must be a dict")
+        storage.log_metrics(self._id, metrics, step)
+
+    def save(self, filepath: str) -> dict:
+        """Save an artifact file alongside this run. Returns artifact info dict."""
+        return storage.save_artifact(self._id, filepath)
+
+    def finish(self) -> None:
+        """Mark the run as successfully finished."""
+        if self._finished:
+            return
+        self._stop_sysmon()
+        storage.finish_run(self._id, "finished")
+        self._finished = True
+
+    def fail(self) -> None:
+        """Mark the run as crashed."""
+        if self._finished:
+            return
+        self._stop_sysmon()
+        storage.finish_run(self._id, "crashed")
+        self._finished = True
+
+    # ── system metrics background thread ───────────────────
+
+    def _start_sysmon(self):
+        """Start a daemon thread that logs CPU/RAM every 10 seconds."""
+        def _collect():
+            try:
+                import psutil
+                has_psutil = True
+            except ImportError:
+                has_psutil = False
+
+            last_cpu_sample = None
+            step_counter = 0
+            while not self._sysmon_stop.wait(timeout=10):
+                if not has_psutil:
+                    return
+                step_counter += 1
+                try:
+                    cpu = psutil.cpu_percent(interval=0.1)
+                    mem = psutil.virtual_memory().percent
+                    storage.log_system_metrics(self._id, step_counter, cpu, mem)
+                except Exception:
+                    pass
+
+        self._sysmon_thread = threading.Thread(
+            target=_collect, name="rm-sysmon", daemon=True
+        )
+        self._sysmon_thread.start()
+
+    def _stop_sysmon(self):
+        self._sysmon_stop.set()
+        if self._sysmon_thread:
+            self._sysmon_thread.join(timeout=2)
+
+    def _on_exit(self):
+        """Mark the run as crashed if it exits without finish()/fail()."""
+        if self._finished:
+            return
+        self._stop_sysmon()
+        storage.finish_run(self._id, "crashed")
+        self._finished = True
+
+
+def init(project: str, name: str | None = None, config: dict | None = None,
+         total_steps: int | None = None) -> Run:
+    """
+    Create (or reuse) a project and start a new run.
+
+        import runmonitor as rm
+        run = rm.init("mnist-experiment", config={"lr": 0.001}, total_steps=1000)
+
+    Opens http://localhost:8080 for the live dashboard.
+    """
+    storage.init_db()
+    project_id = storage.create_project(project)
+    run_id = uuid.uuid4().hex[:12]
+    config_json = json.dumps(config or {})
+    storage.create_run(run_id, project_id, name, config_json, total_steps)
+    return Run(run_id, project_id, name, config or {}, total_steps)

runmonitor-0.2.0/__main__.py

@@ -0,0 +1,54 @@
+"""Run the dashboard standalone — no training script needed.
+
+    runmonitor                     # if pip-installed (console script)
+    python -m runmonitor           # from a checkout / vendored copy
+    RUNMONITOR_PORT=9000 runmonitor # choose a port (set before launch)
+
+Importing ``runmonitor`` already auto-starts the dashboard daemon, so this
+just makes sure it's up, opens a browser, and keeps the process alive.
+"""
+import argparse
+import os
+import threading
+import webbrowser
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="runmonitor",
+        description="Live, terminal-styled experiment-tracking dashboard.",
+    )
+    parser.add_argument(
+        "--port", type=int, default=None,
+        help="Preferred port (most reliable via RUNMONITOR_PORT before launch).",
+    )
+    parser.add_argument(
+        "--no-browser", action="store_true",
+        help="Do not open a browser window.",
+    )
+    args = parser.parse_args()
+    if args.port:
+        os.environ.setdefault("RUNMONITOR_PORT", str(args.port))
+
+    from .storage import init_db
+    from . import server
+
+    init_db()
+    server._start_server()  # idempotent — reuses the daemon if already running
+    url = f"http://localhost:{server._port}"
+    print(f"  runmonitor dashboard → {url}")
+    if args.port and args.port != server._port:
+        print(f"  (port {args.port} was unavailable; bound {server._port} instead)")
+    if not args.no_browser:
+        try:
+            webbrowser.open(url)
+        except Exception:
+            pass
+    try:
+        threading.Event().wait()  # block forever; Ctrl-C to quit
+    except KeyboardInterrupt:
+        print("\n  bye.")
+
+
+if __name__ == "__main__":
+    main()

runmonitor-0.2.0/pyproject.toml

@@ -0,0 +1,52 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "runmonitor"
+version = "0.2.0"
+description = "Lean, local experiment tracker with a live, terminal-styled web dashboard."
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.10"
+authors = [{ name = "bub4tz", email = "ezgroupnl@gmail.com" }]
+keywords = [
+  "machine-learning", "experiment-tracking", "metrics", "dashboard",
+  "training", "monitoring", "mlops", "tensorboard", "wandb",
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Intended Audience :: Science/Research",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+  "Topic :: System :: Monitoring",
+]
+dependencies = ["flask>=2.0"]
+
+[project.optional-dependencies]
+system = ["psutil>=5.0"]
+
+[project.scripts]
+runmonitor = "runmonitor.__main__:main"
+
+[project.urls]
+Homepage = "https://github.com/empero-org/runmonitor"
+Repository = "https://github.com/empero-org/runmonitor"
+Issues = "https://github.com/empero-org/runmonitor/issues"
+
+[tool.setuptools]
+packages = ["runmonitor"]
+include-package-data = true
+
+[tool.setuptools.package-dir]
+runmonitor = "."
+
+[tool.setuptools.package-data]
+runmonitor = ["templates/*.html", "static/*.css"]

runmonitor-0.2.0/runmonitor.egg-info/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: runmonitor
+Version: 0.2.0
+Summary: Lean, local experiment tracker with a live, terminal-styled web dashboard.
+Author-email: bub4tz <ezgroupnl@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 k
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/empero-org/runmonitor
+Project-URL: Repository, https://github.com/empero-org/runmonitor
+Project-URL: Issues, https://github.com/empero-org/runmonitor/issues
+Keywords: machine-learning,experiment-tracking,metrics,dashboard,training,monitoring,mlops,tensorboard,wandb
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: flask>=2.0
+Provides-Extra: system
+Requires-Dist: psutil>=5.0; extra == "system"
+Dynamic: license-file
+
+# runmonitor
+
+Lean, local experiment tracker with a live, **terminal-styled** web dashboard. Import and go.
+
+```python
+import runmonitor as rm
+
+run = rm.init("my-experiment", config={"lr": 0.001, "batch_size": 32}, total_steps=1000)
+
+for step in range(1000):
+    loss, acc = train_step()
+    run.log({"loss": loss, "accuracy": acc}, step)
+    if step % 100 == 0:
+        run.save("checkpoint.pt")
+
+run.finish()
+```
+
+Open `http://localhost:8080` — your loss curve is already live and drawing itself.
+
+## Install
+
+```bash
+pip install runmonitor                 # core
+pip install "runmonitor[system]"       # + CPU/RAM tracking (psutil)
+```
+
+Then in any training script:
+
+```python
+import runmonitor as rm
+```
+
+Or run the dashboard on its own (no training script needed):
+
+```bash
+runmonitor                 # opens the dashboard in your browser
+python -m runmonitor       # equivalent, for a checkout/vendored copy
+RUNMONITOR_PORT=9000 runmonitor   # pick a port (set before launch)
+```
+
+## The dashboard
+
+A single, evolving view in the empero black/purple palette:
+
+| Element | What it shows |
+|---|---|
+| **Metric ticker** | Every logged metric as `key=value`. Click one to **select** it. |
+| **Live hero curve** | The selected metric, drawn point-by-point and growing every step. |
+| **Anomaly detection** | Rolling z-score flags spikes — vertical markers on the curve + a status line ("⚠ anomaly at step N" / "● all calm"). |
+| **Run header** | Run id, current step, status pill, elapsed, steps/sec, ETA, progress bar. |
+| **Streak / best badges** | 🔥 improving-streak and 🏆 personal-best on the selected metric (direction-aware). |
+| **Compare** | Pick a second run to overlay on the selected metric. |
+| **System pane** | CPU % and RAM % over time (needs `psutil`). |
+| **Hyperparameters / Artifacts** | Config passed to `rm.init()` and any saved files. |
+| **Export** | Download the full run as CSV or JSON. |
+| **Theme** | Midnight (black/purple) by default; toggle to light bone-paper. |
+
+## API
+
+```python
+# Start a run (creates the project if new)
+run = rm.init(project: str, name: str | None = None,
+              config: dict | None = None,
+              total_steps: int | None = None) -> Run
+
+run.log(metrics: dict[str, float], step: int)   # log metrics at a step
+run.save(filepath: str) -> dict                  # save an artifact file
+run.finish()                                     # mark finished
+run.fail()                                       # mark crashed
+```
+
+## Storage
+
+Everything lives in `~/.runmonitor/`:
+- `runs.db` — SQLite database (WAL mode, thread-safe)
+- `artifacts/<run_id>/` — saved files per run
+
+No database setup, no API keys, no cloud.
+
+## Requirements
+
+- Python 3.10+
+- Flask
+- Chart.js (loaded from CDN in the dashboard)
+- `psutil` (optional, for system metrics)
+
+## Publishing to PyPI (maintainers)
+
+```bash
+python -m pip install --upgrade build twine
+python -m build                 # → dist/runmonitor-<version>.tar.gz + .whl
+python -m twine check dist/*
+python -m twine upload dist/*   # needs a PyPI account + API token
+```
+
+Bump `version` in `pyproject.toml` before each release.

runmonitor-0.2.0/runmonitor.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+LICENSE
+MANIFEST.in
+README.md
+__init__.py
+__main__.py
+pyproject.toml
+server.py
+storage.py
+./__init__.py
+./__main__.py
+./server.py
+./storage.py
+./static/style.css
+./templates/dashboard.html
+runmonitor.egg-info/PKG-INFO
+runmonitor.egg-info/SOURCES.txt
+runmonitor.egg-info/dependency_links.txt
+runmonitor.egg-info/entry_points.txt
+runmonitor.egg-info/requires.txt
+runmonitor.egg-info/top_level.txt
+static/style.css
+templates/dashboard.html

runmonitor-0.2.0/runmonitor.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

runmonitor-0.2.0/runmonitor.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+runmonitor = runmonitor.__main__:main

runmonitor-0.2.0/runmonitor.egg-info/requires.txt

@@ -0,0 +1,4 @@
+flask>=2.0
+
+[system]
+psutil>=5.0