juham-automation 0.0.12__py3-none-any.whl → 0.0.14__py3-none-any.whl

juham_automation/ts/forecast_ts.py

@@ -1,97 +1,97 @@
-import json
-from typing import Any
-from typing_extensions import override
-
-from masterpiece.mqtt import MqttMsg
-from juham_core import JuhamTs
-from juham_core.timeutils import epoc2utc
-
-
-class ForecastTs(JuhamTs):
-    """Forecast database record.
-
-    This class listens the forecast topic and writes to the time series
-    database.
-    """
-
-    def __init__(self, name: str = "forecast_ts") -> None:
-        """Construct forecast record object with the given name."""
-        super().__init__(name)
-        self.forecast_topic = self.make_topic_name("forecast")
-
-    @override
-    def on_connect(self, client: object, userdata: Any, flags: int, rc: int) -> None:
-        """Standard mqtt connect notification.
-
-        This method is called when the client connection with the MQTT
-        broker is established.
-        """
-        super().on_connect(client, userdata, flags, rc)
-        self.subscribe(self.forecast_topic)
-        self.debug(f"Subscribed to {self.forecast_topic}")
-
-    @override
-    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
-        """Standard mqtt message notification method.
-
-        This method is called upon new arrived message.
-        """
-        if msg.topic == self.forecast_topic:
-            m = json.loads(msg.payload.decode())
-            self.on_forecast(m)
-        else:
-            super().on_message(client, userdata, msg)
-
-    def on_forecast(self, em: dict[Any, Any]) -> None:
-        """Handle weather forecast data. Writes the received hourly forecast
-        data to timeseries database.
-
-        Args:
-            em (dict): forecast
-        """
-
-        # List of fields you want to add
-        fields = [
-            "ts",
-            "day",
-            "solarradiation",
-            "solarenergy",
-            "cloudcover",
-            "snowdepth",
-            "uvindex",
-            "pressure",
-            "humidity",
-            "windspeed",
-            "winddir",
-            "temp",
-            "feels",
-        ]
-        days: int = 0
-        for m in em:
-            senderid: str = "unknown"
-            if "id" in m:
-                senderid = m["id"]
-            if not "hour" in m:
-                self.error(
-                    f"No hour key in forecast record from {senderid}, skipped", str(m)
-                )
-            else:
-                point = (
-                    self.measurement("forecast")
-                    .tag("hour", m.get("hour"))
-                    .tag("source", senderid)
-                    .field("hr", str(m["hour"]))
-                )
-                # Conditionally add each field
-                for field in fields:
-                    if field in m:
-                        if field == "day" or field == "ts":
-                            point = point.field(field, m[field])
-                        else:
-                            point = point.field(field, float(m[field]))
-                    point = point.time(epoc2utc(m["ts"]))
-                self.write(point)
-                days = days + 1
-        self.info(
-            f"Forecast from {senderid} for the next {days} days written to time series database"
-        )
+import json
+from typing import Any
+from typing_extensions import override
+
+from masterpiece.mqtt import MqttMsg
+from juham_core import JuhamTs
+from juham_core.timeutils import epoc2utc
+
+
+class ForecastTs(JuhamTs):
+    """Forecast database record.
+
+    This class listens the forecast topic and writes to the time series
+    database.
+    """
+
+    def __init__(self, name: str = "forecast_ts") -> None:
+        """Construct forecast record object with the given name."""
+        super().__init__(name)
+        self.forecast_topic = self.make_topic_name("forecast")
+
+    @override
+    def on_connect(self, client: object, userdata: Any, flags: int, rc: int) -> None:
+        """Standard mqtt connect notification.
+
+        This method is called when the client connection with the MQTT
+        broker is established.
+        """
+        super().on_connect(client, userdata, flags, rc)
+        self.subscribe(self.forecast_topic)
+        self.debug(f"Subscribed to {self.forecast_topic}")
+
+    @override
+    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
+        """Standard mqtt message notification method.
+
+        This method is called upon new arrived message.
+        """
+        if msg.topic == self.forecast_topic:
+            m = json.loads(msg.payload.decode())
+            self.on_forecast(m)
+        else:
+            super().on_message(client, userdata, msg)
+
+    def on_forecast(self, em: dict[Any, Any]) -> None:
+        """Handle weather forecast data. Writes the received hourly forecast
+        data to timeseries database.
+
+        Args:
+            em (dict): forecast
+        """
+
+        # List of fields you want to add
+        fields = [
+            "ts",
+            "day",
+            "solarradiation",
+            "solarenergy",
+            "cloudcover",
+            "snowdepth",
+            "uvindex",
+            "pressure",
+            "humidity",
+            "windspeed",
+            "winddir",
+            "temp",
+            "feels",
+        ]
+        days: int = 0
+        for m in em:
+            senderid: str = "unknown"
+            if "id" in m:
+                senderid = m["id"]
+            if not "hour" in m:
+                self.error(
+                    f"No hour key in forecast record from {senderid}, skipped", str(m)
+                )
+            else:
+                point = (
+                    self.measurement("forecast")
+                    .tag("hour", m.get("hour"))
+                    .tag("source", senderid)
+                    .field("hr", str(m["hour"]))
+                )
+                # Conditionally add each field
+                for field in fields:
+                    if field in m:
+                        if field == "day" or field == "ts":
+                            point = point.field(field, m[field])
+                        else:
+                            point = point.field(field, float(m[field]))
+                    point = point.time(epoc2utc(m["ts"]))
+                self.write(point)
+                days = days + 1
+        self.info(
+            f"Forecast from {senderid} for the next {days} days written to time series database"
+        )

juham_automation/ts/log_ts.py

@@ -1,57 +1,57 @@
-import json
-from typing import Any
-from typing_extensions import override
-
-from masterpiece.mqtt import MqttMsg
-from juham_core import JuhamTs
-from juham_core.timeutils import epoc2utc
-
-
-class LogTs(JuhamTs):
-    """Class recording application events, such as warnings and errors,
-    to time series database."""
-
-    def __init__(self, name: str = "log_ts") -> None:
-        """Creates mqtt client for recording log events to time series
-        database.
-
-        Args:
-            name (str): name for the client
-        """
-        super().__init__(name)
-        self.topic_name = self.make_topic_name("log")
-
-    @override
-    def on_connect(self, client: object, userdata: Any, flags: int, rc: int) -> None:
-        """Connects the client to mqtt broker.
-
-        Args:
-            client (obj): client to be connected
-            userdata (any): caller specific data
-            flags (int): implementation specific shit
-
-        Returns:
-            rc (bool): True if successful
-        """
-        super().on_connect(client, userdata, flags, rc)
-        if rc == 0:
-            self.subscribe(self.topic_name)
-
-    @override
-    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
-        m = json.loads(msg.payload.decode())
-        ts = epoc2utc(m["Timestamp"])
-
-        point = (
-            self.measurement("log")
-            .tag("class", m["Class"])
-            .field("source", m["Source"])
-            .field("msg", m["Msg"])
-            .field("details", m["Details"])
-            .field("Timestamp", m["Timestamp"])
-            .time(ts)
-        )
-        try:
-            self.write(point)
-        except Exception as e:
-            self.log_message("Error", f"Cannot write log event {m['Msg']}", str(e))
+import json
+from typing import Any
+from typing_extensions import override
+
+from masterpiece.mqtt import MqttMsg
+from juham_core import JuhamTs
+from juham_core.timeutils import epoc2utc
+
+
+class LogTs(JuhamTs):
+    """Class recording application events, such as warnings and errors,
+    to time series database."""
+
+    def __init__(self, name: str = "log_ts") -> None:
+        """Creates mqtt client for recording log events to time series
+        database.
+
+        Args:
+            name (str): name for the client
+        """
+        super().__init__(name)
+        self.topic_name = self.make_topic_name("log")
+
+    @override
+    def on_connect(self, client: object, userdata: Any, flags: int, rc: int) -> None:
+        """Connects the client to mqtt broker.
+
+        Args:
+            client (obj): client to be connected
+            userdata (any): caller specific data
+            flags (int): implementation specific shit
+
+        Returns:
+            rc (bool): True if successful
+        """
+        super().on_connect(client, userdata, flags, rc)
+        if rc == 0:
+            self.subscribe(self.topic_name)
+
+    @override
+    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
+        m = json.loads(msg.payload.decode())
+        ts = epoc2utc(m["Timestamp"])
+
+        point = (
+            self.measurement("log")
+            .tag("class", m["Class"])
+            .field("source", m["Source"])
+            .field("msg", m["Msg"])
+            .field("details", m["Details"])
+            .field("Timestamp", m["Timestamp"])
+            .time(ts)
+        )
+        try:
+            self.write(point)
+        except Exception as e:
+            self.log_message("Error", f"Cannot write log event {m['Msg']}", str(e))

juham_automation/ts/power_ts.py

@@ -1,49 +1,49 @@
-import json
-from typing import Any
-from typing_extensions import override
-
-from masterpiece.mqtt import MqttMsg
-
-from juham_core import JuhamTs
-from juham_core.timeutils import epoc2utc
-
-
-class PowerTs(JuhamTs):
-    """Power utilization record.
-
-    This class listens the power utilization message and writes the
-    state to time series database.
-    """
-
-    def __init__(self, name: str = "power_ts") -> None:
-        """Construct power record object with the given name."""
-
-        super().__init__(name)
-        self.topic_name = self.make_topic_name("power")
-
-    @override
-    def on_connect(self, client: object, userdata: Any, flags: int, rc: int) -> None:
-        super().on_connect(client, userdata, flags, rc)
-        self.subscribe(self.topic_name)
-        self.debug(f"Subscribed to {self.topic_name}")
-
-    @override
-    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
-        """Standard mqtt message notification method.
-
-        This method is called upon new arrived message.
-        """
-
-        m = json.loads(msg.payload.decode())
-        if not "Unit" in m:
-            return
-        unit = m["Unit"]
-        ts = m["Timestamp"]
-        state = m["State"]
-        point = (
-            self.measurement("power")
-            .tag("unit", unit)
-            .field("state", state)
-            .time(epoc2utc(ts))
-        )
-        self.write(point)
+import json
+from typing import Any
+from typing_extensions import override
+
+from masterpiece.mqtt import MqttMsg
+
+from juham_core import JuhamTs
+from juham_core.timeutils import epoc2utc
+
+
+class PowerTs(JuhamTs):
+    """Power utilization record.
+
+    This class listens the power utilization message and writes the
+    state to time series database.
+    """
+
+    def __init__(self, name: str = "power_ts") -> None:
+        """Construct power record object with the given name."""
+
+        super().__init__(name)
+        self.topic_name = self.make_topic_name("power")
+
+    @override
+    def on_connect(self, client: object, userdata: Any, flags: int, rc: int) -> None:
+        super().on_connect(client, userdata, flags, rc)
+        self.subscribe(self.topic_name)
+        self.debug(f"Subscribed to {self.topic_name}")
+
+    @override
+    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
+        """Standard mqtt message notification method.
+
+        This method is called upon new arrived message.
+        """
+
+        m = json.loads(msg.payload.decode())
+        if not "Unit" in m:
+            return
+        unit = m["Unit"]
+        ts = m["Timestamp"]
+        state = m["State"]
+        point = (
+            self.measurement("power")
+            .tag("unit", unit)
+            .field("state", state)
+            .time(epoc2utc(ts))
+        )
+        self.write(point)

juham_automation/ts/powermeter_ts.py

@@ -1,70 +1,70 @@
-import json
-from typing import Any, Dict
-from typing_extensions import override
-
-from masterpiece.mqtt import MqttMsg
-from juham_core import JuhamTs
-from juham_core.timeutils import epoc2utc
-
-
-class PowerMeterTs(JuhamTs):
-    """Power meter recorder.
-
-    Listens 'powerconsumption' topic and records the corresponding
-    time series.
-    """
-
-    def __init__(self, name: str = "powermeter_record") -> None:
-        super().__init__(name)
-        self.power_topic = self.make_topic_name("powerconsumption")  # topic to listen
-
-    @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.power_topic)
-
-    @override
-    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
-        super().on_message(client, userdata, msg)
-        if msg.topic == self.power_topic:
-            m = json.loads(msg.payload.decode())
-            self.record_power(m)
-
-    def record_power(self, em: dict[str, Any]) -> None:
-        """Write from the power (energy) meter to the time
-        series database accordingly.
-
-        Args:
-            ts (float): utc time
-            em (dict): energy meter message
-        """
-        point = (
-            self.measurement("powermeter")
-            .tag("sensor", "em0")
-            .field("real_A", em["real_a"])
-            .field("real_B", em["real_b"])
-            .field("real_C", em["real_c"])
-            .field("total_real_power", em["real_total"])
-            .time(epoc2utc(em["timestamp"]))
-        )
-        try:
-            self.write(point)
-            # self.debug(
-            #    f"PowerMeter event recorded {epoc2utc(em['timestamp'])} - {em['real_a']} {em['real_b']} {em['real_c']}"
-            # )
-        except Exception as e:
-            self.error(f"Writing to influx failed {str(e)}")
-
-    def to_dict(self) -> Dict[str, Any]:
-        data: Dict[str, Any] = super().to_dict()
-        data["_powermeter_record"] = {
-            "power_topic": self.power_topic,
-        }
-        return data
-
-    def from_dict(self, data: Dict[str, Any]) -> None:
-        super().from_dict(data)
-        if "_powermeter_record" in data:
-            for key, value in data["_powermeter_record"].items():
-                setattr(self, key, value)
+import json
+from typing import Any, Dict
+from typing_extensions import override
+
+from masterpiece.mqtt import MqttMsg
+from juham_core import JuhamTs
+from juham_core.timeutils import epoc2utc
+
+
+class PowerMeterTs(JuhamTs):
+    """Power meter recorder.
+
+    Listens 'powerconsumption' topic and records the corresponding
+    time series.
+    """
+
+    def __init__(self, name: str = "powermeter_record") -> None:
+        super().__init__(name)
+        self.power_topic = self.make_topic_name("powerconsumption")  # topic to listen
+
+    @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.power_topic)
+
+    @override
+    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
+        super().on_message(client, userdata, msg)
+        if msg.topic == self.power_topic:
+            m = json.loads(msg.payload.decode())
+            self.record_power(m)
+
+    def record_power(self, em: dict[str, Any]) -> None:
+        """Write from the power (energy) meter to the time
+        series database accordingly.
+
+        Args:
+            ts (float): utc time
+            em (dict): energy meter message
+        """
+        point = (
+            self.measurement("powermeter")
+            .tag("sensor", "em0")
+            .field("real_A", em["real_a"])
+            .field("real_B", em["real_b"])
+            .field("real_C", em["real_c"])
+            .field("total_real_power", em["real_total"])
+            .time(epoc2utc(em["timestamp"]))
+        )
+        try:
+            self.write(point)
+            # self.debug(
+            #    f"PowerMeter event recorded {epoc2utc(em['timestamp'])} - {em['real_a']} {em['real_b']} {em['real_c']}"
+            # )
+        except Exception as e:
+            self.error(f"Writing to influx failed {str(e)}")
+
+    def to_dict(self) -> Dict[str, Any]:
+        data: Dict[str, Any] = super().to_dict()
+        data["_powermeter_record"] = {
+            "power_topic": self.power_topic,
+        }
+        return data
+
+    def from_dict(self, data: Dict[str, Any]) -> None:
+        super().from_dict(data)
+        if "_powermeter_record" in data:
+            for key, value in data["_powermeter_record"].items():
+                setattr(self, key, value)

juham_automation/ts/powerplan_ts.py

@@ -1,45 +1,45 @@
-import json
-from typing import Any
-from typing_extensions import override
-
-from masterpiece.mqtt import MqttMsg
-from juham_core import JuhamTs
-from juham_core.timeutils import epoc2utc
-
-
-class PowerPlanTs(JuhamTs):
-    """Power plan time series record.
-
-    Listens powerplan topic and updates time series database
-    accordingly.
-    """
-
-    def __init__(self, name: str = "powerplan_ts") -> None:
-        super().__init__(name)
-        self.powerplan_topic = self.make_topic_name("powerplan")
-
-    @override
-    def on_connect(self, client: object, userdata: Any, flags: int, rc: int) -> None:
-        super().on_connect(client, userdata, flags, rc)
-        self.subscribe(self.powerplan_topic)
-
-    @override
-    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
-        super().on_message(client, userdata, msg)
-        m = json.loads(msg.payload.decode())
-        schedule = m["Schedule"]
-        uoi = m["UOI"]
-        ts = m["Timestamp"]
-
-        point = (
-            self.measurement("powerplan")
-            .tag("unit", m["Unit"])
-            .field("state", m["State"])  # 1 on, 0 off
-            .field("name", m["Unit"])  # e.g main_boiler
-            .field("type", "C")  # C=consumption, S = supply
-            .field("power", 16.0)  # kW
-            .field("Schedule", schedule)  # figures of merit
-            .field("UOI", float(uoi))  # Utilitzation Optimizing Index
-            .time(epoc2utc(ts))
-        )
-        self.write(point)
+import json
+from typing import Any
+from typing_extensions import override
+
+from masterpiece.mqtt import MqttMsg
+from juham_core import JuhamTs
+from juham_core.timeutils import epoc2utc
+
+
+class PowerPlanTs(JuhamTs):
+    """Power plan time series record.
+
+    Listens powerplan topic and updates time series database
+    accordingly.
+    """
+
+    def __init__(self, name: str = "powerplan_ts") -> None:
+        super().__init__(name)
+        self.powerplan_topic = self.make_topic_name("powerplan")
+
+    @override
+    def on_connect(self, client: object, userdata: Any, flags: int, rc: int) -> None:
+        super().on_connect(client, userdata, flags, rc)
+        self.subscribe(self.powerplan_topic)
+
+    @override
+    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
+        super().on_message(client, userdata, msg)
+        m = json.loads(msg.payload.decode())
+        schedule = m["Schedule"]
+        uoi = m["UOI"]
+        ts = m["Timestamp"]
+
+        point = (
+            self.measurement("powerplan")
+            .tag("unit", m["Unit"])
+            .field("state", m["State"])  # 1 on, 0 off
+            .field("name", m["Unit"])  # e.g main_boiler
+            .field("type", "C")  # C=consumption, S = supply
+            .field("power", 16.0)  # kW
+            .field("Schedule", schedule)  # figures of merit
+            .field("UOI", float(uoi))  # Utilitzation Optimizing Index
+            .time(epoc2utc(ts))
+        )
+        self.write(point)