juham-automation 0.0.2__py3-none-any.whl → 0.2.8__py3-none-any.whl

juham_automation/ts/energybalancer_ts.py

@@ -0,0 +1,73 @@
+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 EnergyBalancerTs(JuhamTs):
+    """Record energy balance data to time series database.
+
+    This class listens the "energybalance" MQTT topic and records the
+    messages to time series database.
+    """
+
+    def __init__(self, name: str = "energybalancer_ts") -> None:
+        """Construct record object with the given name."""
+
+        super().__init__(name)
+        self.topic_in_status = self.make_topic_name("energybalance/status")
+        self.topic_in_diagnostics = self.make_topic_name("energybalance/diagnostics")
+
+    @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.topic_in_status)
+            self.subscribe(self.topic_in_diagnostics)
+
+    @override
+    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
+        if msg.topic == self.topic_in_status:
+            self.on_status(json.loads(msg.payload.decode()))
+        elif msg.topic == self.topic_in_diagnostics:
+            self.on_diagnostics(json.loads(msg.payload.decode()))
+        else:
+            super().on_message(client, userdata, msg)
+
+    def on_status(self, m: dict[str, Any]) -> None:
+        """Handle energybalance message.
+        Args:
+            m (dict[str, Any]): Message from energybalance topic.
+        """
+        if not "Power" in m or not "Timestamp" in m:
+            self.error(f"INVALID STATUS msg {m}")            
+            return
+        point = (
+            self.measurement("energybalance")
+            .tag("Unit", m["Unit"])
+            .field("Mode", m["Mode"])
+            .field("Power", float(m["Power"]))
+            .time(epoc2utc(m["Timestamp"]))
+        )
+        self.write(point)
+
+    def on_diagnostics(self, m: dict[str, Any]) -> None:
+        """Handle energybalance diagnostics.
+        Args:
+            m (dict[str, Any]): Message from energybalance topic.
+        """
+        if not "Timestamp" in m:
+            self.error(f"INVALID DIAGNOSTICS msg {m}")
+            return
+        point = (
+            self.measurement("energybalance")
+            .tag("EnergyBalancer", m["EnergyBalancer"])
+            .field("CurrentBalance", m["CurrentBalance"])
+            .field("NeededBalance", m["NeededBalance"])
+            .time(epoc2utc(m["Timestamp"]))
+        )
+        self.write(point)

juham_automation/ts/energycostcalculator_ts.py

@@ -0,0 +1,45 @@
+from typing import Any
+from typing_extensions import override
+import json
+
+from masterpiece.mqtt import MqttMsg
+
+from juham_core import JuhamTs
+from juham_core.timeutils import (
+    epoc2utc,
+    timestampstr,
+)
+
+
+class EnergyCostCalculatorTs(JuhamTs):
+    """The EnergyCostCalculator recorder."""
+
+    def __init__(self, name: str = "ecc_ts") -> None:
+        super().__init__(name)
+        self.topic_net_energy_balance = self.make_topic_name("net_energy_cost")
+
+    @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.topic_net_energy_balance)
+
+    @override
+    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
+        if msg.topic == self.topic_net_energy_balance:
+            m = json.loads(msg.payload.decode())
+            self.record_powerconsumption(m)
+        else:
+            super().on_message(client, userdata, msg)
+
+
+    def record_powerconsumption(self, m: dict[str, Any]) -> None:
+        """Record powerconsumption
+
+        Args:
+            m (dict[str, Any]): to be recorded
+        """
+
+        self.write_point(
+            "energycost", {"site": m["name"]}, m, timestampstr(m["ts"])
+        )

juham_automation/ts/forecast_ts.py

@@ -0,0 +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"
+        )

juham_automation/ts/log_ts.py

@@ -0,0 +1,60 @@
+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:
+        if msg.topic == self.topic_name:
+            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:
+                print(f"ERROR: Cannot write log event {m['Msg']} {e}")
+        else:
+            super().on_message(client, userdata, msg)

juham_automation/ts/power_ts.py

@@ -0,0 +1,52 @@
+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.
+        """
+        if msg.topic == self.topic_name:
+            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)
+        else:
+            super().on_message(client, userdata, msg)
+            

juham_automation/ts/powermeter_ts.py

@@ -0,0 +1,68 @@
+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:
+        if msg.topic == self.power_topic:
+            m = json.loads(msg.payload.decode())
+            self.record_power(m)
+        else:
+            super().on_message(client, userdata, msg)
+            
+    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)
+        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

@@ -0,0 +1,64 @@
+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:
+        if msg.topic == self.powerplan_topic:
+            m = json.loads(msg.payload.decode())
+            schedule = m["Schedule"]
+            uoi = m["UOI"]
+            ts = m["Timestamp"]
+            
+            # optional fields
+            tempForecast = m.get("NextDayTemperature")
+            solarForecast = m.get("NextDaySolarpower")
+            minTemp  = m.get("MinTempLimit")
+            maxTemp  = m.get("MaxTempLimit")
+
+            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))
+            )
+
+            # Add optional fields only if they are present in the message
+            if minTemp is not None:
+                point = point.field("MinTemp", float(minTemp))
+            if maxTemp is not None:
+                point = point.field("MaxTemp", float(maxTemp))
+            if tempForecast is not None:
+                point = point.field("TempForecast", float(tempForecast))
+            if solarForecast is not None:
+                point = point.field("SolarForecast", float(solarForecast))
+
+            self.write(point)
+        else:
+            super().on_message(client, userdata, msg)

juham_automation-0.2.8.dist-info/METADATA

@@ -0,0 +1,199 @@
+Metadata-Version: 2.4
+Name: juham-automation
+Version: 0.2.8
+Summary: Juha's Ultimate Home Automation Masterpiece
+Author-email: J Meskanen <juham.api@gmail.com>
+Maintainer-email: "J. Meskanen" <juham.api@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://gitlab.com/juham/juham/juham-automation
+Project-URL: Bug Reports, https://gitlab.com/juham/juham/juham-automationt
+Project-URL: Funding, https://meskanen.com
+Project-URL: Say Thanks!, http://meskanen.com
+Project-URL: Source, https://gitlab.com/juham/juham/juham-automation
+Keywords: home,automation,juham
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development
+Classifier: Programming Language :: Python :: 3.8
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.rst
+Requires-Dist: juham_core>=0.2.4
+Provides-Extra: dev
+Requires-Dist: check-manifest; extra == "dev"
+Requires-Dist: coverage>=7.0; extra == "dev"
+Dynamic: license-file
+
+Welcome to Juham™ - Juha's Ultimate Home Automation Masterpiece
+===============================================================
+
+Project Description
+-------------------
+
+Beyond its super-cool name, this package provides essential home automation building blocks that address most common needs.
+
+It consists of two main sub-modules:
+
+``automation``:
+
+This folder contains automation classes that listen to Juham™ MQTT topics and control various home automation tasks.
+
+- **spothintafi**: Acquires electricity prices in Finland.
+- **watercirculator**: Automates a water circulator pump based on hot water temperature and motion detection.
+- **heatingoptimizer**: Controls hot water radiators based on temperature sensors and electricity price data.
+- **energycostcalculator**: Monitors power consumption and electricity prices, and computes the energy balance in euros.
+- **energybalancer**: Handles real-time energy balancing and net billing.
+
+``ts``:
+
+This folder contains time series recorders that listen for Juham™ topics and store the data in a time series database for later inspection.
+
+- **electricityprice_ts** : publishes electricity prices to timeseries database.
+- **energybalancer_ts**: for monitoring the operation of energy balancer.
+- **energycostcalculator_ts**: publishes actualized energy prices per hour and per day.
+- **forecast_ts**: publishes the forecast datat to timeseries database.
+- **log_ts**: Writes log events to timeseries datbase.
+- **powerplan_ts**: publishes power plan data to timeseries database, when relays are planned to be switched on/off.
+- **powermeter_ts**: publishes powermeter data to timeseries database.
+
+
+Project Status
+--------------
+
+**Current State**: **Beta (Status 4)**
+
+All classes have been tested to some extent, and no known bugs have been reported. 
+
+
+Project Links
+-------------
+
+- **Source code:** https://gitlab.com/juham/juham/juham-automation
+- **Issue tracker:** https://gitlab.com/juham/juham/juham-automation/-/issues
+- **Documentation:** https://juham-automation-c6383e.gitlab.io
+- **PyPI page:** https://pypi.org/project/juham-automation
+
+  
+
+Features
+--------
+
+**HeatingAutomater** listens to the power meter to compute the net energy balance.
+
+  .. image:: _static/images/juham_powermeter.png
+     :alt: Powermeter
+     :width: 400px
+
+  Powermeter is needed to measure the real-time energy consumption
+
+
+**Energy Revenue** is computed based on the electricity price and transmission costs. This is the total cost one has to pay for consuming energy.
+  
+  .. image:: _static/images/juham_energyrevenue.png
+     :alt: Energy Revenue
+     :width: 400px
+
+  Energy revenue per hour and per day
+
+
+**Real-time temperature** trends monitored by the **Shelly Plus Add-on** and **DS18B20** sensors
+  
+  .. image:: _static/images/juham_boilertemperatures.png
+     :alt: Energy Revenue
+     :width: 400px
+
+  Temperature time series.
+
+
+**Real-time humidity** trends monitored by the **Shelly Plus Add-on** and **DHT22** sensors
+  
+  .. image:: _static/images/juham_humiditysensors.png
+     :alt: Energy Revenue
+     :width: 400px
+
+  Relative humidity time series.
+
+
+  
+**Utilization Optimization Index**: The Utilization Optimization Index predicts the optimal hours for energy consumption by factoring in electricity prices, temperature, and forecasts for wind and solar energy. It identifies the best times to activate heating systems. The cheapest hours within the current period may be skipped if the solar forecast predicts free electricity in the next period.period.
+
+  .. image:: _static/images/juham_uoi.png
+     :alt: Power Plan
+     :width: 400px
+
+  UOI cast for heating the primary and sun pre-heating boilers for two types of solar panels and boilers: electric-based panels and solar thermal panels, which use water circulation. The primary one is electrically heated, while the secondary ‘pre-heating’ boiler is heated by the hot water from the solar thermal panels, or by electricity when there's a positive energy balance.
+
+
+**Power Plan** is computed for the next 12 hours based on the electricity price and solar energy forecast. If no solar energy is available, the power plan determines power consumption, e.g., when the hot water radiators are enabled.
+
+  .. image:: _static/images/juham_powerplan.png
+     :alt: Power Plan
+     :width: 400px
+
+  Powerplan optimizing consumers to use the cheapest hours
+
+
+**Energy Balancer**: When the energy balance is positive (e.g., when solar panels produce more energy than is currently being consumed), the energy balancer is activated. It monitors the energy balance in 15-minute (or one-hour) intervals and computes when a consumer with a specific power demand should be activated to consume all the energy produced so far.
+
+  .. image:: _static/images/juham_automation_energybalancer.png
+     :alt: Energy Balancer
+     :width: 400px
+
+  Energy balancer activating consumers based on the actual real-time net energy
+
+
+**Power Diagnosis**: All controlled relays are monitored to ensure their correct operation. This ensures that relays are enabled according to the power plan and energy balancer commands.
+
+  .. image:: _static/images/juham_automation_relays.png
+     :alt: Relays
+     :width: 400px
+
+  The operation of the relays for diagnosis.
+
+
+Installing
+----------
+
+Juham™ ships with a minimal yet fully functional home automation application that can be found in the **examples** folder.
+It creates a **PowerMeterSimulator** and **ShellyMotionSimulator** objets to generate simulated motion sensor and power meter readings.
+Later, you can replace it with your actual power meter, as well as plug in other input sensors to read and relays to control.
+
+1. Set up a Mosquitto MQTT broker service. For more information read the manuals.
+
+   .. code-block:: bash
+
+      sudo apt install mosquitto mosquitto-clients
+
+2. Configure Juham to talk to Mosquitto.
+
+   In ``PahoMqtt.json``:
+
+   .. code-block:: json
+
+      {"paho_version" : 2}
+
+   In ``Juham.json``:
+
+   .. code-block:: json
+
+      {"mqtt_class_id": "PahoMqtt", "mqtt_root_topic": "myapp", "mqtt_host": "localhost", "mqtt_port": 1883}
+
+   In ``Timeseries.json``:
+
+   .. code-block:: json
+
+      {
+         "token": "your-influx-token",
+         "org": "your-organization",
+         "host": "https://us-east-1-1.aws.cloud2.influxdata.com",
+         "database": "your-database"
+      }
+
+3. In the ``juham/examples`` folder, run:
+
+   .. code-block:: bash
+
+      python3 myapp.py
+
+The application will start and time series data will show up in your InfluxDB database,
+which you can then visualize with tools such as Grafana.

juham_automation-0.2.8.dist-info/RECORD

@@ -0,0 +1,25 @@
+juham_automation/__init__.py,sha256=Y_fUDerXnXFkv1z2p7FeqKQlJ2EuIDY6AEK7xVQ1tXE,914
+juham_automation/japp.py,sha256=L2u1mfKvun2fiXhB3AEJD9zMDcdFZ3_doXZYJJzu9tg,1646
+juham_automation/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+juham_automation/automation/__init__.py,sha256=0FYYSo2qSMMibH5YHIFgdT6gc5Cmf8XlpQHFSrswE5I,500
+juham_automation/automation/energybalancer.py,sha256=Kw0Czah4JLOgDVAx6ca4nJpFpfZa9LXmv6pr612f-Fg,11473
+juham_automation/automation/energycostcalculator.py,sha256=96pidMxi4tK9g8iLepn9XuTeauZhxi74qGXvvQJe-6s,13023
+juham_automation/automation/heatingoptimizer.py,sha256=AO1VHBHfgQJ8kENsgZH3O3GHZjSksQx_CrsdZZoxjoM,39038
+juham_automation/automation/leakdetector.py,sha256=Q-3X0NOFJf0C5MlR7R_QQp8yw5XvTt85oduuTRYIu_0,6003
+juham_automation/automation/spothintafi.py,sha256=cZbi7w2fVweHX_fh1r5MTjGdesX9wDQta2mfVjtiwvw,4331
+juham_automation/automation/watercirculator.py,sha256=QcLAP9oLA-tYYRH2SjnPT6_kIOdiQbOSf2tQPMitEN0,5471
+juham_automation/ts/__init__.py,sha256=kTEzVkDi6ednH4-fxKxrY6enlTuTXmSw09pPAQX3CMc,612
+juham_automation/ts/electricityprice_ts.py,sha256=kRIewAAtTPi5JvHLEgGGVp_28LkWyB6lGyUH_2dKqBQ,1677
+juham_automation/ts/energybalancer_ts.py,sha256=XHl56G5fBjJOCSIJtdjzGpSTMAQN1xsnXpC4Ipl7ynw,2585
+juham_automation/ts/energycostcalculator_ts.py,sha256=ceYvZOvpXftJmAMW7bb33zI1lh1o0nf71XBJGuijD0s,1296
+juham_automation/ts/forecast_ts.py,sha256=Gk46hIlS8ijxs-zyy8fBvXrhI7J-8e5Gt2QEe6gFB6s,3158
+juham_automation/ts/log_ts.py,sha256=GLOqnwmk2cJdoWPWlrC3XAADp-N1JdfZ407YNQxnxhA,1901
+juham_automation/ts/power_ts.py,sha256=_i_mBPtaVFfH9ycv426uQ4VtSzHacLJB6mEApe26fhE,1571
+juham_automation/ts/powermeter_ts.py,sha256=a4sVERj7k397QlJF_VFg-S7DXSg8oAanPcxdYQBzN4w,2218
+juham_automation/ts/powerplan_ts.py,sha256=TXD4aI8TAv2oGrbHZRjxkhrWkOubJ4Lq3sdotsgAn2Q,2358
+juham_automation-0.2.8.dist-info/licenses/LICENSE.rst,sha256=QVHD5V5_HSys2PdPdig_xKggDj8cGX33ALKqRsYyjtI,1089
+juham_automation-0.2.8.dist-info/METADATA,sha256=swuuGZKrrFBlQCoJDqOUkPJVGJ5wqPOgk2OK-NcmOQs,7620
+juham_automation-0.2.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+juham_automation-0.2.8.dist-info/entry_points.txt,sha256=h-KzuKjmGPd4_iX_oiGvxx4IEc97dVbGGlhdh5ctbpI,605
+juham_automation-0.2.8.dist-info/top_level.txt,sha256=jfohvtocvX_gfT21AhJk7Iay5ZiQsS3HzrDjF7S4Qp0,17
+juham_automation-0.2.8.dist-info/RECORD,,