juham-automation 0.1.2__tar.gz → 0.1.4__tar.gz

{juham_automation-0.1.2/juham_automation.egg-info → juham_automation-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: juham-automation
-Version: 0.1.2
+Version: 0.1.4
 Summary: Juha's Ultimate Home Automation Masterpiece
 Author-email: J Meskanen <juham.api@gmail.com>
 Maintainer-email: "J. Meskanen" <juham.api@gmail.com>
@@ -30,11 +30,11 @@ License: LICENSE
         SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. **
         
         
-Project-URL: Homepage, https://gitlab.com/juham/juham/juham-automation.git
-Project-URL: Bug Reports, https://gitlab.com/juham/juham/juham-automation.git
+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.git
+Project-URL: Source, https://gitlab.com/juham/juham/juham-automation
 Keywords: home,automation,juham
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
@@ -44,7 +44,7 @@ Classifier: Programming Language :: Python :: 3.8
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE.rst
-Requires-Dist: juham_core>=0.1.5
+Requires-Dist: juham_core>=0.1.6
 Provides-Extra: dev
 Requires-Dist: check-manifest; extra == "dev"
 Requires-Dist: coverage>=7.0; extra == "dev"
@@ -56,9 +56,11 @@ Welcome to Juham™ - Juha's Ultimate Home Automation Masterpiece
 Project Description
 -------------------
 
-This package extends the ``juham_core`` package, providing home automation building blocks that address most common needs. It consists of two main sub-modules:
+This package extends the ``juham_core`` package, providing home automation building blocks that address most common needs. 
+It consists of two main sub-modules:
 
 ``automation``:
+
 - **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.
@@ -66,6 +68,7 @@ This package extends the ``juham_core`` package, providing home automation build
 - **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.
 
 Project Status
@@ -73,7 +76,8 @@ Project Status
 
 **Current State**: **Alpha (Status 3)**
 
-All classes have been tested to some extent, and no known bugs have been reported. However, the code still requires work in terms of design and robustness. For example, electricity prices are currently hard-coded to use euros, but this should be configurable to support multiple currencies.
+All classes have been tested to some extent, and no known bugs have been reported. However, the code still requires 
+work in terms of design and robustness. 
 
 
 Project Links

{juham_automation-0.1.2 → juham_automation-0.1.4}/README.rst

@@ -4,9 +4,11 @@ Welcome to Juham™ - Juha's Ultimate Home Automation Masterpiece
 Project Description
 -------------------
 
-This package extends the ``juham_core`` package, providing home automation building blocks that address most common needs. It consists of two main sub-modules:
+This package extends the ``juham_core`` package, providing home automation building blocks that address most common needs. 
+It consists of two main sub-modules:
 
 ``automation``:
+
 - **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.
@@ -14,6 +16,7 @@ This package extends the ``juham_core`` package, providing home automation build
 - **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.
 
 Project Status
@@ -21,7 +24,8 @@ Project Status
 
 **Current State**: **Alpha (Status 3)**
 
-All classes have been tested to some extent, and no known bugs have been reported. However, the code still requires work in terms of design and robustness. For example, electricity prices are currently hard-coded to use euros, but this should be configurable to support multiple currencies.
+All classes have been tested to some extent, and no known bugs have been reported. However, the code still requires 
+work in terms of design and robustness. 
 
 
 Project Links

{juham_automation-0.1.2 → juham_automation-0.1.4}/juham_automation/automation/energycostcalculator.py

@@ -6,6 +6,7 @@ from juham_core import Juham
 from juham_core.timeutils import (
     elapsed_seconds_in_day,
     elapsed_seconds_in_hour,
+    elapsed_seconds_in_interval,
     quantize,
     timestamp,
 )
@@ -28,17 +29,20 @@ class EnergyCostCalculator(Juham):
     _kwh_to_joule_coeff: float = 1000.0 * 3600
     _joule_to_kwh_coeff: float = 1.0 / _kwh_to_joule_coeff
 
-    energy_balancing_interval: float = 3600
+    energy_balancing_interval: int = 900 # in seconds (15 minutes)
 
     def __init__(self, name: str = "ecc") -> None:
         super().__init__(name)
         self.current_ts: float = 0
+        self.total_balance_interval : float = 0
         self.total_balance_hour: float = 0
         self.total_balance_day: float = 0
+        self.net_energy_balance_cost_interval: float = 0
         self.net_energy_balance_cost_hour: float = 0
         self.net_energy_balance_cost_day: float = 0
-        self.net_energy_balance_start_hour = elapsed_seconds_in_hour(timestamp())
-        self.net_energy_balance_start_day = elapsed_seconds_in_day(timestamp())
+        self.net_energy_balance_start_interval : float = elapsed_seconds_in_interval(timestamp(), self.energy_balancing_interval)
+        self.net_energy_balance_start_hour : float = elapsed_seconds_in_hour(timestamp())
+        self.net_energy_balance_start_day : float = elapsed_seconds_in_day(timestamp())
         self.spots: list[dict[str, float]] = []
         self.init_topics()
 
@@ -68,10 +72,10 @@ class EnergyCostCalculator(Juham):
             self.error(f"Unknown event {msg.topic}")
 
     def on_spot(self, spot: dict[Any, Any]) -> None:
-        """Stores the received per hour electricity prices to spots list.
+        """Stores the received per slot electricity prices to spots list.
 
         Args:
-            spot (list): list of hourly spot prices
+            spot (list): list of spot prices
         """
 
         for s in spot:
@@ -88,76 +92,91 @@ class EnergyCostCalculator(Juham):
         """
         return price * self._joule_to_kwh_coeff
 
-    def get_prices(self, ts_prev: float, ts_now: float) -> tuple[float, float]:
-        """Fetch the electricity prices for the given two subsequent time
-        stamps.
+
+    def get_price_at(self, ts: float) -> float:
+        """Return the spot price applicable at the given timestamp.
 
         Args:
-            ts_prev (float): previous time
-            ts_now (float): current time
+            ts (float): current time (epoch seconds)
+
         Returns:
-            Electricity prices for the given interval
+            float: PriceWithTax for the slot that contains ts. Returns the last
+                known price if ts is equal/after the last spot timestamp.
+                Returns 0.0 and logs an error if no matching slot is found.
         """
-        prev_price = None
-        current_price = None
+        if not self.spots:
+            self.error(f"PANIC: no spot prices available; lookup ts={ts}")
+            return 0.0
+
+        # ensure spots sorted by timestamp (defensive)
+        try:
+            # cheap check — assumes list of dicts with "Timestamp"
+            if any(self.spots[i]["Timestamp"] > self.spots[i + 1]["Timestamp"] for i in range(len(self.spots) - 1)):
+                self.spots.sort(key=lambda r: r["Timestamp"])
+        except Exception:
+            # if unexpected structure, still try safe path below and log
+            self.debug("get_price_at: spot list structure unexpected while checking sort order", "")
 
         for i in range(0, len(self.spots) - 1):
             r0 = self.spots[i]
             r1 = self.spots[i + 1]
             ts0 = r0["Timestamp"]
             ts1 = r1["Timestamp"]
-            if ts_prev >= ts0 and ts_prev <= ts1:
-                prev_price = r0["PriceWithTax"]
-            if ts_now >= ts0 and ts_now <= ts1:
-                current_price = r0["PriceWithTax"]
-            if prev_price is not None and current_price is not None:
-                return prev_price, current_price
-        self.error("PANIC: run out of spot prices")
-        return 0.0, 0.0
+            if ts >= ts0 and ts < ts1:
+                return r0["PriceWithTax"]
+
+        # If timestamp is exactly equal to the last spot timestamp or beyond
+        last = self.spots[-1]
+        if ts >= last["Timestamp"]:
+            return last["PriceWithTax"]
+
+        # If we get here, ts is before the first spot timestamp
+        first = self.spots[0]
+        self.error(
+            f"PANIC: Timestamp {ts} out of bounds for spot price lookup; "
+            f"first=(ts={first['Timestamp']}, price={first.get('PriceWithTax')}), "
+            f"last=(ts={last['Timestamp']}, price={last.get('PriceWithTax')}), "
+            f"len(spots)={len(self.spots)}"
+        )
+        return 0.0
+
+
 
     def calculate_net_energy_cost(
         self, ts_prev: float, ts_now: float, energy: float
     ) -> float:
-        """Given time interval as start and stop Calculate the cost over the
-        given time period. Positive values indicate revenue, negative cost.
+        """
+        Calculate the cost (or revenue) of energy consumed/produced over the given time interval.
+        Positive values indicate revenue, negative values indicate cost.
 
         Args:
-            ts_prev (timestamp): beginning time stamp of the interval
-            ts_now (timestamp): end of the interval
-            energy (float): energy consumed during the time interval
+            ts_prev (float): Start timestamp of the interval
+            ts_now (float): End timestamp of the interval
+            energy (float): Energy consumed during the interval (in watts or Joules)
+
         Returns:
-            Cost or revenue
+            float: Total cost/revenue for the interval
         """
-        cost: float = 0
-        prev = ts_prev
-        while prev < ts_now:
-            elapsed_seconds: float = ts_now - prev
-            if elapsed_seconds > self.energy_balancing_interval:
-                elapsed_seconds = self.energy_balancing_interval
-            now = prev + elapsed_seconds
-            start_per_kwh, stop_per_kwh = self.get_prices(prev, now)
-            start_price = self.map_kwh_prices_to_joules(start_per_kwh)
-            stop_price = self.map_kwh_prices_to_joules(stop_per_kwh)
-            if abs(stop_price - start_price) < 1e-24:
-                cost = cost + energy * elapsed_seconds * start_price
-            else:
-                # interpolate cost over energy balancing interval boundary
-                elapsed = now - prev
-                if elapsed < 0.00001:
-                    return 0.0
-                ts_0 = quantize(self.energy_balancing_interval, now)
-                t1 = (ts_0 - prev) / elapsed
-                t2 = (now - ts_0) / elapsed
-                cost = (
-                    cost
-                    + energy
-                    * ((1.0 - t1) * start_price + t2 * stop_price)
-                    * elapsed_seconds
-                )
-
-            prev = prev + elapsed_seconds
+        cost = 0.0
+        current = ts_prev
+        interval = self.energy_balancing_interval
+
+        while current < ts_now:
+            next_ts = min(ts_now, current + interval)
+            # Get spot price at start and end of interval
+            price_start = self.map_kwh_prices_to_joules(self.get_price_at(current))
+            price_end = self.map_kwh_prices_to_joules(self.get_price_at(next_ts))
+
+            # Trapezoidal integration: average price over interval
+            avg_price = (price_start + price_end) / 2.0
+            dt = next_ts - current
+            cost += energy * avg_price * dt
+
+            current = next_ts
+
         return cost
 
+
     def on_powerconsumption(self, ts_now: float, m: dict[Any, Any]) -> None:
         """Calculate net energy cost and update the hourly consumption attribute
         accordingly.
@@ -170,21 +189,29 @@ class EnergyCostCalculator(Juham):
         if not self.spots:
             self.info("Waiting for electricity prices...")
         elif self.current_ts == 0:
+            self.net_energy_balance_cost_interval = 0.0
             self.net_energy_balance_cost_hour = 0.0
             self.net_energy_balance_cost_day = 0.0
             self.current_ts = ts_now
-            self.net_energy_balance_start_hour = quantize(
+            self.net_energy_balance_start_interval = quantize(
                 self.energy_balancing_interval, ts_now
             )
+            self.net_energy_balance_start_hour = quantize(
+                3600, ts_now
+            )
         else:
             # calculate cost of energy consumed/produced
             dp: float = self.calculate_net_energy_cost(self.current_ts, ts_now, power)
+            self.net_energy_balance_cost_interval = self.net_energy_balance_cost_interval + dp
             self.net_energy_balance_cost_hour = self.net_energy_balance_cost_hour + dp
             self.net_energy_balance_cost_day = self.net_energy_balance_cost_day + dp
 
             # calculate and publish energy balance
             dt = ts_now - self.current_ts  # time elapsed since previous call
             balance = dt * power  # energy consumed/produced in this slot in Joules
+            self.total_balance_interval = (
+                self.total_balance_interval + balance * self._joule_to_kwh_coeff
+            )
             self.total_balance_hour = (
                 self.total_balance_hour + balance * self._joule_to_kwh_coeff
             )
@@ -195,16 +222,32 @@ class EnergyCostCalculator(Juham):
             self.publish_energy_cost(
                 ts_now,
                 self.name,
+                self.net_energy_balance_cost_interval,
                 self.net_energy_balance_cost_hour,
                 self.net_energy_balance_cost_day,
             )
 
             # Check if the current energy balancing interval has ended
             # If so, reset the net_energy_balance attribute for the next interval
-            if (
-                ts_now - self.net_energy_balance_start_hour
-                > self.energy_balancing_interval
-            ):
+            if ts_now - self.net_energy_balance_start_interval > self.energy_balancing_interval:
+                # publish average energy cost per hour
+                if abs(self.total_balance_interval) > 0:
+                    msg = {
+                        "name": self.name,
+                        "average_interval": self.net_energy_balance_cost_interval
+                        / self.total_balance_interval,
+                        "ts": ts_now,
+                    }
+                    self.publish(self.topic_out_energy_cost, json.dumps(msg), 0, False)
+
+                # reset for the next hour
+                self.total_balance_interval = 0
+                self.net_energy_balance_cost_interval = 0.0
+                self.net_energy_balance_start_interval = ts_now
+
+            # Check if the current energy balancing interval has ended
+            # If so, reset the net_energy_balance attribute for the next interval
+            if ts_now - self.net_energy_balance_start_hour > 3600:
                 # publish average energy cost per hour
                 if abs(self.total_balance_hour) > 0:
                     msg = {
@@ -253,9 +296,9 @@ class EnergyCostCalculator(Juham):
         self.publish(self.topic_out_net_energy_balance, json.dumps(msg), 1, True)
 
     def publish_energy_cost(
-        self, ts_now: float, site: str, cost_hour: float, cost_day: float
+        self, ts_now: float, site: str, cost_interval : float, cost_hour: float, cost_day: float
     ) -> None:
-        """Publish daily and hourly energy cost/revenue
+        """Publish daily, hourly and per interval energy cost/revenue
 
         Args:
             ts_now (float): timestamp
@@ -263,5 +306,5 @@ class EnergyCostCalculator(Juham):
             cost_hour (float): cost or revenue per hour.
             cost_day (float) : cost or revenue per day
         """
-        msg = {"name": site, "cost_hour": cost_hour, "cost_day": cost_day, "ts": ts_now}
+        msg = {"name": site, "cost_interval": cost_interval, "cost_hour": cost_hour, "cost_day": cost_day, "ts": ts_now}
         self.publish(self.topic_out_energy_cost, json.dumps(msg), 1, True)