sot 1.0.0__py3-none-any.whl

sot/__about__.py

@@ -0,0 +1,4 @@
+from datetime import datetime
+
+__version__ = "1.0.0"
+__current_year__ = datetime.now().year

sot/__init__.py

@@ -0,0 +1,6 @@
+from .__about__ import __version__, __current_year__
+from ._app import run
+from .blockchar_stream import BlockCharStream
+from .braille_stream import BrailleStream
+
+__all__ = ["BrailleStream", "BlockCharStream", "run", "__version__", "__current_year__"]

sot/_app.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import argparse
+from sys import version_info
+
+from textual.app import App
+
+from .__about__ import __version__, __current_year__
+from ._cpu import CPU
+from ._disk import Disk
+from ._info import InfoLine
+from ._mem import Mem
+from ._net import Net
+from ._procs_list import ProcsList
+# from ._sot import Sot
+
+def run(argv=None):
+    parser = argparse.ArgumentParser(
+        description="Command-line System Obervation Tool ≈",
+        formatter_class=argparse.RawTextHelpFormatter,
+        add_help=False
+    )
+
+    parser.add_argument(
+        "--help",
+        "-H",
+        action="help",
+        default=argparse.SUPPRESS,
+        help="Show this help message and exit."
+    )
+
+    parser.add_argument(
+        "--version",
+        "-V",
+        action="version",
+        version=_get_version_text(),
+        help="Display version information",
+    )
+
+    parser.add_argument(
+        "--log",
+        "-L",
+        type=str,
+        default=None,
+        help="Debug log file",
+    )
+
+    parser.add_argument(
+        "--net",
+        "-N",
+        type=str,
+        default=None,
+        help="Network interface to display (default: auto)",
+    )
+
+    args = parser.parse_args(argv)
+
+    # with a grid
+    class sotApp(App):
+        async def on_mount(self) -> None:
+            grid = await self.view.dock_grid(edge="left")
+
+            grid.add_column(fraction=36, name="left")
+            # grid.add_column(fraction=15, name="middle")
+            # grid.add_column(fraction=36, name="right")
+            grid.add_column(fraction=45, name="right")
+
+            grid.add_row(size=1, name="r0")
+            grid.add_row(fraction=1, name="r1")
+            grid.add_row(fraction=1, name="r2")
+            grid.add_row(fraction=1, name="r3")
+            grid.add_areas(
+                area0="left-start|right-end,r0",
+                area1="left,r1",
+                # area2a="middle,r1-start|r1-end",
+                # area2b="middle,r2-start|r2-end",
+                # area2c="middle,r3-start|r3-end",
+                area3a="right,r1",
+                area3b="right,r2",
+                area3c="right,r3",
+                area4="left,r2-start|r3-end",
+            )
+            grid.place(
+                area0=InfoLine(),
+                area1=CPU(),
+                # area2b=Sot(),
+                area3a=Mem(),
+                area3b=Disk(),
+                area3c=Net(args.net),
+                area4=ProcsList(),
+            )
+
+        async def on_load(self, _):
+            await self.bind("q", "quit", "quit")
+
+    sotApp.run(log=args.log)
+
+
+def _get_version_text():
+    python_version = f"{version_info.major}.{version_info.minor}.{version_info.micro}"
+
+    return "\n".join(
+        [
+            f"sot {__version__} [Python {python_version}]",
+            f"Copyright (c) 2024-{__current_year__} Kumar Anirudha",
+        ]
+    )

sot/_battery.py

@@ -0,0 +1,62 @@
+import psutil
+from rich import box
+from rich.panel import Panel
+from rich.text import Text
+from textual.widget import Widget
+
+from .braille_stream import BrailleStream
+
+
+class Battery(Widget):
+    def on_mount(self):
+        self.bat_stream = BrailleStream(40, 3, 0.0, 100.0)
+
+        self.panel = Panel(
+            "",
+            title="",
+            title_align="left",
+            # border_style="yellow",
+            border_style="bright_black",
+            box=box.SQUARE,
+        )
+        self.collect_data()
+        # update frequency: 1 min
+        self.set_interval(60.0, self.collect_data)
+
+    def collect_data(self):
+        bat = psutil.sensors_battery()
+        assert bat is not None
+
+        self.bat_stream.add_value(bat.percent)
+        self.refresh_graph()
+
+        if bat.power_plugged:
+            status = "charging"
+        else:
+            mm = bat.secsleft // 60
+            hh, mm = divmod(mm, 60)
+            time_left_str = []
+            if hh > 0:
+                time_left_str.append(f"{hh}h")
+            if mm > 0:
+                time_left_str.append(f"{mm}min")
+            status = " ".join(time_left_str) + " left"
+
+        title = f"[b]battery[/] - {self.bat_stream.values[-1]:.1f}% - {status}"
+        if bat.percent < 15 and not bat.power_plugged:
+            title = "[red3 reverse bold]" + title + "[/]"
+
+        self.panel.title = title
+
+        self.refresh()
+
+    def refresh_graph(self):
+        self.panel.renderable = Text("\n".join(self.bat_stream.graph), style="yellow")
+
+    def render(self) -> Panel:
+        return self.panel
+
+    async def on_resize(self, event):
+        self.bat_stream.reset_width(event.width - 4)
+        self.bat_stream.reset_height(event.height - 2)
+        self.refresh_graph()

sot/_cpu.py

@@ -0,0 +1,346 @@
+import re
+from pathlib import Path
+
+import psutil
+from rich import box
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+from textual.widget import Widget
+
+from .braille_stream import BrailleStream
+
+
+def val_to_color(val: float, minval: float, maxval: float) -> str:
+    t = (val - minval) / (maxval - minval)
+    k = round(t * 3)
+    return {0: "yellow", 1: "dark_orange", 2: "sky_blue3", 3: "aquamarine3"}[k]
+
+
+# https://stackoverflow.com/a/312464/353337
+def chunks(lst, n):
+    for i in range(0, len(lst), n):
+        yield lst[i : i + n]
+
+
+# https://stackoverflow.com/a/6473724/353337
+def transpose(lst):
+    return list(map(list, zip(*lst)))
+
+
+def flatten(lst):
+    return [item for sublist in lst for item in sublist]
+
+
+def get_cpu_model():
+    # cpuinfo does computation in addition to reading data, see
+    # <https://github.com/workhorsy/py-cpuinfo/issues/155#issuecomment-678923252>.
+    # Try to work around this.
+    # TODO keep an eye on the above bug.
+    try:
+        # On Linux, the file contains lines like
+        # ```
+        # model name	: Intel(R) Core(TM) i5-8350U CPU @ 1.70GHz
+        # ```
+        with open("/proc/cpuinfo") as f:
+            content = f.read()
+        m = re.search(r"model name\t: (.*)", content)
+        model_name = m.group(1)
+    except Exception:
+        import cpuinfo
+
+        model_name = cpuinfo.get_cpu_info()["brand_raw"]
+    return model_name
+
+
+def get_current_temps():
+    # First try manually reading the temperatures. (pyutil is slow.)
+    for key in ["coretemp", "k10temp"]:
+        path = Path(f"/sys/devices/platform/{key}.0/hwmon/hwmon6/")
+        if not path.is_dir():
+            continue
+
+        k = 1
+        temps = []
+        while True:
+            file = path / f"temp{k}_input"
+            if not file.exists():
+                break
+            with open(file) as f:
+                content = f.read()
+            temps.append(int(content) / 1000)
+            k += 1
+
+        return temps
+
+    # Not try psutil.sensors_temperatures().
+    # Slow, see <https://github.com/giampaolo/psutil/issues/2082>.
+    try:
+        temps = psutil.sensors_temperatures()
+    except AttributeError:
+        return None
+    else:
+        # coretemp: intel, k10temp: amd
+        # <https://github.com/nschloe/tiptop/issues/37>
+        for key in ["coretemp", "k10temp"]:
+            if key not in temps:
+                continue
+            return [t.current for t in temps[key]]
+
+    return None
+
+
+def get_current_freq():
+    # psutil.cpu_freq() is slow, so first try something else:
+    # <https://github.com/nschloe/tiptop/issues/37>
+    candidates = [
+        "/sys/devices/system/cpu/cpufreq/policy0/scaling_cur_freq",
+        "/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq",
+    ]
+    for candidate in candidates:
+        if Path(candidate).exists():
+            with open(candidate) as f:
+                content = f.read()
+            return int(content) / 1000
+
+    try:
+        cpu_freq = psutil.cpu_freq().current
+    except Exception:
+        # https://github.com/nschloe/tiptop/issues/25#issuecomment-1061390966
+        return None
+
+    if psutil.__version__ == "5.9.0" and cpu_freq < 10:
+        # Work around <https://github.com/giampaolo/psutil/issues/2049>
+        cpu_freq *= 1000
+    return cpu_freq
+
+
+class CPU(Widget):
+    def on_mount(self):
+        self.width = 0
+        self.height = 0
+
+        # self.max_graph_width = 200
+
+        self.num_cores = psutil.cpu_count(logical=False)
+        num_threads = psutil.cpu_count(logical=True)
+
+        # 8 threads, 4 cores -> [[0, 4], [1, 5], [2, 6], [3, 7]]
+        assert num_threads % self.num_cores == 0
+        self.core_threads = transpose(list(chunks(range(num_threads), self.num_cores)))
+
+        self.cpu_total_stream = BrailleStream(50, 7, 0.0, 100.0)
+
+        self.thread_load_streams = [
+            BrailleStream(10, 1, 0.0, 100.0)
+            for _ in range(num_threads)
+            # BlockCharStream(10, 1, 0.0, 100.0) for _ in range(num_threads)
+        ]
+
+        temps = get_current_temps()
+
+        if temps is None:
+            self.has_cpu_temp = False
+            self.has_core_temps = False
+        else:
+            self.has_cpu_temp = len(temps) > 0
+            self.has_core_temps = len(temps) == 1 + self.num_cores
+
+            temp_low = 30.0
+            # TODO read from file
+            temp_high = 100.0
+
+            if self.has_cpu_temp:
+                self.temp_total_stream = BrailleStream(
+                    50, 7, temp_low, temp_high, flipud=True
+                )
+
+            if self.has_core_temps:
+                self.core_temp_streams = [
+                    BrailleStream(5, 1, temp_low, temp_high)
+                    for _ in range(self.num_cores)
+                ]
+
+        self.has_fan_rpm = False
+        try:
+            fan_current = list(psutil.sensors_fans().values())[0][0].current
+        except (AttributeError, IndexError):
+            pass
+        else:
+            self.has_fan_rpm = True
+            fan_low = 0
+            # Sometimes, psutil/computers will incorrectly report a fan
+            # speed of 2 ** 16 - 1; dismiss that.
+            if fan_current == 65535:
+                fan_current = 1
+            fan_high = max(fan_current, 1)
+            self.fan_stream = BrailleStream(50, 1, fan_low, fan_high)
+
+        box_title = ", ".join(
+            [
+                f"{self.num_cores} core" + ("s" if self.num_cores > 1 else ""),
+                f"{num_threads} thread" + ("s" if num_threads > 1 else ""),
+            ]
+        )
+        self.info_box = Panel(
+            "",
+            title=box_title,
+            title_align="left",
+            subtitle=None,
+            subtitle_align="left",
+            border_style="bright_black",
+            box=box.SQUARE,
+            expand=False,
+        )
+
+        self.panel = Panel(
+            "",
+            title=f"[b]CPU[/] - {get_cpu_model()}",
+            title_align="left",
+            border_style="bright_black",
+            box=box.SQUARE,
+        )
+
+        # immediately collect data to refresh info_box_width
+        self.collect_data()
+        self.set_interval(2.0, self.collect_data)
+
+    def collect_data(self):
+        # CPU loads
+        self.cpu_total_stream.add_value(psutil.cpu_percent())
+        #
+        load_per_thread = psutil.cpu_percent(percpu=True)
+        assert isinstance(load_per_thread, list)
+        for stream, load in zip(self.thread_load_streams, load_per_thread):
+            stream.add_value(load)
+
+        # CPU temperatures
+        if self.has_cpu_temp or self.has_core_temps:
+            temps = get_current_temps()
+            assert temps is not None
+
+            if self.has_cpu_temp:
+                self.temp_total_stream.add_value(temps[0])
+
+            if self.has_core_temps:
+                for stream, temp in zip(self.core_temp_streams, temps[1:]):
+                    stream.add_value(temp)
+
+        lines_cpu = self.cpu_total_stream.graph
+        current_val_string = f"{self.cpu_total_stream.values[-1]:5.1f}%"
+        lines0 = lines_cpu[0][: -len(current_val_string)] + current_val_string
+        lines_cpu = [lines0] + lines_cpu[1:]
+        #
+        cpu_total_graph = "[yellow]" + "\n".join(lines_cpu) + "[/]\n"
+        #
+        if self.has_cpu_temp:
+            lines_temp = self.temp_total_stream.graph
+            current_val_string = f"{round(self.temp_total_stream.values[-1]):3d}°C"
+            lines0 = lines_temp[-1][: -len(current_val_string)] + current_val_string
+            lines_temp = lines_temp[:-1] + [lines0]
+            cpu_total_graph += "[slate_blue1]" + "\n".join(lines_temp) + "[/]"
+
+        # construct right info box
+        self._refresh_info_box(load_per_thread)
+
+        t = Table(expand=True, show_header=False, padding=0, box=None)
+        # Add ratio 1 to expand that column as much as possible
+        t.add_column("graph", no_wrap=True, ratio=1)
+        t.add_column("box", no_wrap=True, justify="left", vertical="middle")
+        t.add_row(cpu_total_graph, self.info_box)
+
+        if self.has_fan_rpm:
+            fan_current = list(psutil.sensors_fans().values())[0][0].current
+
+            # See comment above
+            if fan_current == 65535:
+                fan_current = self.fan_stream.maxval
+
+            if fan_current > self.fan_stream.maxval:
+                # TODO There should be a method that also rewrites all previous values
+                self.fan_stream.maxval = fan_current
+
+            self.fan_stream.add_value(fan_current)
+            string = f" {fan_current}rpm"
+            graph = Text(
+                self.fan_stream.graph[-1][: -len(string)] + string,
+                style="dark_orange",
+            )
+            t.add_row(graph, "")
+
+        self.panel.renderable = t
+
+        # textual method
+        self.refresh()
+
+    def _refresh_info_box(self, load_per_thread):
+        lines = []
+        for core_id, thread_ids in enumerate(self.core_threads):
+            line = []
+            for i in thread_ids:
+                color = val_to_color(load_per_thread[i], 0.0, 100.0)
+                line.append(
+                    f"[{color}]"
+                    + f"{self.thread_load_streams[i].graph[0]}"
+                    + f"{round(self.thread_load_streams[i].values[-1]):3d}%"
+                    + "[/]"
+                )
+            if self.has_core_temps:
+                stream = self.core_temp_streams[core_id]
+                val = stream.values[-1]
+                color = "slate_blue1" if val < 70.0 else "red3"
+                line.append(
+                    f"[{color}]{stream.graph[0]} {round(stream.values[-1])}°C[/]"
+                )
+
+            lines.append(" ".join(line))
+
+        self.info_box.renderable = "\n".join(lines)
+
+        cpu_freq = get_current_freq()
+
+        if cpu_freq is None:
+            # https://github.com/nschloe/tiptop/issues/25
+            self.info_box.subtitle = None
+        else:
+            self.info_box.subtitle = f"{round(cpu_freq):4d} MHz"
+
+        # https://github.com/willmcgugan/rich/discussions/1559#discussioncomment-1459008
+        self.info_box_width = 4 + len(Text.from_markup(lines[0]))
+
+    def render(self):
+        return self.panel
+
+    async def on_resize(self, event):
+        self.width = event.width
+        self.height = event.height
+
+        # reset graph widths
+        graph_width = self.width - self.info_box_width - 5
+        self.cpu_total_stream.reset_width(graph_width)
+        if self.has_cpu_temp:
+            self.temp_total_stream.reset_width(graph_width)
+        if self.has_fan_rpm:
+            self.fan_stream.reset_width(graph_width)
+
+        # reset graph heights
+        # subtract border
+        total_height = self.height - 2
+        if self.has_cpu_temp:
+            # cpu total stream height: divide by two and round _down_
+            self.cpu_total_stream.reset_height(total_height // 2)
+            #
+            # temp total stream height: divide by two and round _up_. Subtract
+            # one if a fan stream is present.
+            temp_stream_height = -((-total_height) // 2)
+            if self.has_fan_rpm:
+                temp_stream_height -= 1
+
+            self.temp_total_stream.reset_height(temp_stream_height)
+        else:
+            # full size cpu stream
+            cpu_stream_height = total_height
+            if self.has_fan_rpm:
+                cpu_stream_height -= 1
+
+            self.cpu_total_stream.reset_height(cpu_stream_height)