juham-systemstatus 0.1.2__py3-none-any.whl

juham_systemstatus/__init__.py

@@ -0,0 +1,13 @@
+"""
+Description
+===========
+
+System info 
+
+"""
+
+from .systemstatus import SystemStatus
+
+__all__ = [
+    "SystemStatus",
+]

juham_systemstatus/py.typed

@@ -0,0 +1 @@
+

juham_systemstatus/systemstatus.py

@@ -0,0 +1,244 @@
+from datetime import datetime, timedelta, timezone
+import json
+import psutil
+import threading
+from typing import Any, Optional, cast
+from typing_extensions import override
+from masterpiece.mqtt import MqttMsg, Mqtt
+from masterpiece import MasterPieceThread
+from juham.core import RThread
+from juham.core.time import timestamp, epoc2utc
+
+
+class SystemStatusThread(MasterPieceThread):
+    """Asynchronous thread for acquiring system info. Currently fetches
+    memory usage, disk usage, for each partition and CPU utilization, all in percentages.
+    """
+
+    # class attributes
+    _systemstatus_topic: str = ""
+    _interval: float = 60  # seconds
+    _location = "unknown"
+
+    def __init__(self, client: Optional[Mqtt] = None):
+        """Construct with the given mqtt client. Acquires system metrics
+        e.g. CPU load and space left on the device and publishes the data to
+        systemstatus_topic.
+
+        Args:
+            client (object, optional): MQTT client. Defaults to None.
+        """
+        super().__init__(client)
+        self.mqtt_client: Optional[Mqtt] = client
+
+    def init(self, topic: str, interval: float, location: str) -> None:
+        """Initialize the  data acquisition thread
+
+        Args:
+            topic (str): mqtt topic to publish the acquired system info
+            interval (float): update interval in seconds
+            location (str): geographic location
+        """
+        self._systemstatus_topic = topic
+        self._interval = interval
+        self._location = location
+
+    def get_thread_counts(self) -> dict[str, int]:
+        """Fetch the number of total, active and idle threads in the current process.
+
+        Returns:
+            Thread info (dict[str, int])
+        """
+        all_threads = threading.enumerate()
+        total_threads = len(all_threads)
+        active_threads = sum(1 for thread in all_threads if thread.is_alive())
+
+        return {
+            "total_threads": total_threads,
+            "active_threads": active_threads,
+            "idle_threads": total_threads - active_threads,
+        }
+
+    def get_system_info(self) -> dict[str, dict]:
+        """Fetch system info e.g. CPU loads, thread count, disk and ram usage.
+
+        Returns:
+            Thread info (dict[str, dict])
+        """
+        cpus = psutil.cpu_percent(interval=1, percpu=True)  # List of CPU loads per core
+
+        cpu_loads: dict[str, float] = {}
+        i: int = 0
+        for cpu in cpus:
+            cpu_loads[f"cpu{i}"] = cpu
+            i = i + i
+
+        # Memory info
+        memory = psutil.virtual_memory()  # Virtual memory details
+        available_memory = memory.available  # Available memory in bytes
+        total_memory = memory.total  # Total memory in bytes
+
+        # Disk space info per partition
+        partitions = psutil.disk_partitions()
+        disk_info = {}
+        for partition in partitions:
+            try:
+                usage = psutil.disk_usage(partition.mountpoint)
+                disk_info[partition.device] = {
+                    "mountpoint": partition.mountpoint,
+                    "total": usage.total,
+                    "free": usage.free,
+                    "used": usage.used,
+                    "percent": usage.percent,
+                }
+            except PermissionError:
+                # Skip partitions that we don't have permission to access
+                continue
+
+        return {
+            "cpu_loads": cpu_loads,
+            "memory": {
+                "avail_memory": available_memory,
+                "total_memory": total_memory,
+                "memory_usage": available_memory / total_memory * 100.0,
+            },
+            "disk_info": disk_info,
+        }
+
+    @override
+    def update_interval(self) -> float:
+        return self._interval
+
+    @override
+    def update(self) -> bool:
+        sysinfo: dict[str, dict] = self.get_system_info()
+        sysinfo.update({"threads": self.get_thread_counts()})
+        msg = json.dumps(sysinfo)
+        self.publish(self._systemstatus_topic, msg, qos=1, retain=False)
+        # self.debug(f"System status  published to {self._systemstatus_topic}")
+        return True
+
+
+class SystemStatus(RThread):
+    """Constructs a data acquisition thread for reading system status
+    info, e.g. available disk space and publishes the data to the systemstatus topic.
+
+    """
+
+    _SYSTEMSTATUS: str = "systemstatus"
+
+    workerThreadId: str = SystemStatusThread.get_class_id()
+    update_interval: float = 60
+    topic = "system"
+    location = "home"
+
+    def __init__(self, name="systemstatus") -> None:
+        """Constructs system status automation object for acquiring and publishing
+        system info e.g. available memory and CPU loads.
+
+        Args:
+            name (str, optional): name of the object.
+        """
+        super().__init__(name)
+        self.worker: Optional[SystemStatusThread] = None
+        self.systemstatus_topic: str = self.make_topic_name(self.topic)
+        self.debug(f"System status with name {name} created")
+
+    @override
+    def on_connect(self, client: object, userdata: Any, flags: int, rc: int) -> None:
+        super().on_connect(client, userdata, flags, rc)
+        if rc == 0:
+            self.subscribe(self.systemstatus_topic)
+
+    @override
+    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
+        if msg.topic == self.systemstatus_topic:
+            em = json.loads(msg.payload.decode())
+            self.record(timestamp(), em)
+        else:
+            super().on_message(client, userdata, msg)
+
+    def record(self, ts: float, info: dict[str, Any]) -> None:
+        """Writes system info to the time series database
+
+        Args:
+            ts (float): utc time
+            em (dict): energy meter message
+        """
+
+        cpu_loads: dict[str, float] = info["cpu_loads"]
+        disk_info: dict[str, float] = info["disk_info"]
+        memory: dict[str, int] = info["memory"]
+        threads: dict[str, int] = info["threads"]
+
+        try:
+            self.write_point(
+                "systemstatus",
+                {"location": self.location, "category": "threads"},
+                threads,
+                epoc2utc(ts),
+            )
+        except Exception as e:
+            self.error(f"Writing memory to influx failed {str(e)}")
+
+        try:
+            self.write_point(
+                "systemstatus",
+                {"location": self.location, "category": "memory"},
+                memory,
+                epoc2utc(ts),
+            )
+        except Exception as e:
+            self.error(f"Writing memory to influx failed {str(e)}")
+
+        try:
+            self.write_point(
+                "systemstatus",
+                {"location": self.location, "category": "cpu"},
+                cpu_loads,
+                epoc2utc(ts),
+            )
+        except Exception as e:
+            self.error(f"Writing cpu_loads to influx failed {str(e)}")
+
+        try:
+            value: Any
+            for attr, value in disk_info.items():
+                self.write_point(
+                    "systemstatus",
+                    {"location": self.location, "category": "disk"},
+                    {"mountpoint": value["mountpoint"], "percent": value["percent"]},
+                    epoc2utc(ts),
+                )
+        except Exception as e:
+            self.error(f"Writing disk_info to influx failed {str(e)}")
+
+    @override
+    def run(self) -> None:
+        # create, initialize and start the asynchronous thread for acquiring forecast
+
+        self.worker = cast(
+            SystemStatusThread, self.instantiate(SystemStatus.workerThreadId)
+        )
+        self.worker.init(
+            self.systemstatus_topic,
+            self.update_interval,
+            self.location,
+        )
+        super().run()
+
+    @override
+    def to_dict(self) -> dict:
+        data = super().to_dict()
+        data[self._SYSTEMSTATUS] = {
+            "topic": self.systemstatus_topic,
+            "interval": self.update_interval,
+        }
+        return data
+
+    @override
+    def from_dict(self, data) -> None:
+        super().from_dict(data)
+        if self._SYSTEMSTATUS in data:
+            for key, value in data[self._SYSTEMSTATUS].items():
+                setattr(self, key, value)

juham_systemstatus-0.1.2.dist-info/METADATA

@@ -0,0 +1,48 @@
+Metadata-Version: 2.1
+Name: juham_systemstatus
+Version: 0.1.2
+Summary: A Weather forecast  plugin extending `Juham` applications
+Author-email: J Meskanen <juham.api@gmail.com>
+Maintainer-email: "J. Meskanen" <juham.api@gmail.com>
+License: MIT License
+        ===========
+        
+        Copyright (c) 2024, Juha Meskanen
+        
+        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
+        
+        
+Project-URL: Homepage, https://meskanen.com
+Project-URL: Bug Reports, https://meskanen.com
+Project-URL: Funding, https://meskanen.com
+Project-URL: Say Thanks!, http://meskanen.com
+Project-URL: Source, https://meskanen.com
+Keywords: object-oriented,plugin,framework
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.8
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: juham>=0.1.5
+Requires-Dist: pytz>=2024.1
+Requires-Dist: psutil>=5.9.0
+Requires-Dist: importlib-metadata
+Provides-Extra: dev
+Requires-Dist: check-manifest; extra == "dev"

juham_systemstatus-0.1.2.dist-info/RECORD

@@ -0,0 +1,8 @@
+juham_systemstatus/__init__.py,sha256=QNlqbx5_OuhcdnTI1y2gbhwWm9Q1TPHA0KwuRZFl3fo,135
+juham_systemstatus/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+juham_systemstatus/systemstatus.py,sha256=og50rzdekR5WrNahnUb4uZD7RweUBY2C6iDnVfIeD1w,8509
+juham_systemstatus-0.1.2.dist-info/METADATA,sha256=qwA6UuKcxi_Ts1CGBBQ_p_5ZUlRPSJEWiQUss2fl-4U,2286
+juham_systemstatus-0.1.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+juham_systemstatus-0.1.2.dist-info/entry_points.txt,sha256=8ibdfYNmRXQ2VYHmCkMpx3gI39Vd-hVUMF2Jx2goQbU,70
+juham_systemstatus-0.1.2.dist-info/top_level.txt,sha256=s5k8_U-Q95qDGgjtC6l1tniPEILNDQ3U5qxVGXoAhLc,19
+juham_systemstatus-0.1.2.dist-info/RECORD,,

juham_systemstatus-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.6.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

juham_systemstatus-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[juham.plugins]
+systemstatus_plugin = juham_systemstatus:SystemStatus

juham_systemstatus-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+juham_systemstatus