juham-automation 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

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)

juham_automation/automation/heatingoptimizer.py

@@ -8,13 +8,12 @@ from juham_core import Juham
 from juham_core.timeutils import (
     quantize,
     timestamp,
-    timestamp_hour,
     timestampstr,
-    is_hour_within_schedule,
-    timestamp_hour_local,
 )
 
 
+
+
 class HeatingOptimizer(Juham):
     """Automation class for optimized control of temperature driven home energy consumers e.g hot
     water radiators. Reads spot prices, solar electricity forecast,  power meter and
@@ -39,14 +38,14 @@ class HeatingOptimizer(Juham):
     radiator_power: float = 6000  # W
     """Radiator power in Watts. This is the maximum power that the radiator can consume."""
 
-    heating_hours_per_day: float = 4
-    """ Number of hours per day the radiator is allowed to heat."""
+    heating_slots_per_day: float = 4
+    """ Number of slots per day the radiator is allowed to heat."""
 
-    schedule_start_hour: float = 0
-    """Start hour of the heating schedule."""
+    schedule_start_slot: float = 0
+    """Start slots of the heating schedule."""
 
-    schedule_stop_hour: float = 0
-    """Stop hour of the heating schedule. Heating is allowed only between these two hours."""
+    schedule_stop_slot: float = 0
+    """Stop slot of the heating schedule. Heating is allowed only between start-stop slots."""
 
     timezone: str = "Europe/Helsinki"
     """ Timezone of the heating system. This is used to convert UTC timestamps to local time."""
@@ -64,11 +63,11 @@ class HeatingOptimizer(Juham):
         1: (60.0, 65.0),  # January
         2: (55.0, 65.0),  # February
         3: (50.0, 64.0),  # March
-        4: (40.0, 60.0),  # April
-        5: (10.0, 50.0),  # May
-        6: (10.0, 40.0),  # June
-        7: (10.0, 40.0),  # July
-        8: (35.0, 45.0),  # August
+        4: (20.0, 50.0),  # April
+        5: (10.0, 40.0),  # May
+        6: (10.0, 38.0),  # June
+        7: (10.0, 38.0),  # July
+        8: (35.0, 40.0),  # August
         9: (40.0, 50.0),  # September
         10: (45.0, 55.0),  # October
         11: (50.0, 58.0),  # November
@@ -116,8 +115,8 @@ class HeatingOptimizer(Juham):
         """
         super().__init__(name)
 
-        self.heating_hours_per_day = num_hours
-        self.start_hour = start_hour
+        self.heating_slots_per_day = num_hours * ( 3600 / self.energy_balancing_interval)
+        self.start_slot = start_hour * (3600 / self.energy_balancing_interval)
         self.spot_limit = spot_limit
 
         self.topic_in_spot = self.make_topic_name("spot")
@@ -128,13 +127,12 @@ class HeatingOptimizer(Juham):
         self.topic_out_energybalance = self.make_topic_name("energybalance/consumers")
         self.topic_out_power = self.make_topic_name("power")
 
-        self.current_temperature = 100
-        self.current_heating_plan = 0
-        self.current_relay_state = -1
-        self.heating_plan: list[dict[str, int]] = []
-        self.power_plan: list[dict[str, Any]] = []
-        self.ranked_spot_prices: list[dict[Any, Any]] = []
-        self.ranked_solarpower: list[dict[Any, Any]] = []
+        self.current_temperature : float = 100.0
+        self.current_relay_state : int = -1
+        self.heating_plan: list[dict[str, int]] = [] # in slots
+        self.power_plan: list[dict[str, Any]] = [] # in slots
+        self.ranked_spot_prices: list[dict[Any, Any]] = [] # in slots
+        self.ranked_solarpower: list[dict[Any, Any]] = [] # in hours
         self.relay: bool = False
         self.relay_started_ts: float = 0
         self.net_energy_balance_mode: bool = False
@@ -149,6 +147,43 @@ class HeatingOptimizer(Juham):
             self.subscribe(self.topic_in_energybalance)
             self.register_as_consumer()
 
+    def is_slot_within_schedule(self, slot: int, start_slot: int, stop_slot: int) -> bool:
+        """Check if the given slot is within the schedule.
+
+        Args:
+            slot (int): slot to check
+            start_slot (int): start slot of the schedule
+            stop_slot (int): stop slot of the schedule  
+        Returns:
+            bool: true if the slot is within the schedule
+        """
+        if start_slot < stop_slot:
+            return slot >= start_slot and slot < stop_slot
+        else:
+            return slot >= start_slot or slot < stop_slot   
+        
+
+    def slots_per_day(self) -> int:
+        return int(24 * 3600 / self.energy_balancing_interval)
+
+
+    def timestamp_slot(self, ts: float) -> int:
+        """Get the time slot for the given timestamp and interval.
+
+        Args:
+            ts (float): timestamp
+            interval (float): interval in seconds
+        
+        Returns:
+            float: time slot
+        """
+        dt = datetime.utcfromtimestamp(ts)
+        total_seconds = dt.hour * 3600 + dt.minute * 60 + dt.second
+        slot : int = total_seconds // self.energy_balancing_interval
+        return slot
+
+
+
     def register_as_consumer(self) -> None:
         """Register this device as a consumer to the energy balancer. The energy balancer will then add this device
         to its list of consumers and will tell the device when to heat."""
@@ -177,7 +212,7 @@ class HeatingOptimizer(Juham):
         return min_temp, max_temp
 
     def sort_by_rank(
-        self, hours: list[dict[str, Any]], ts_utc_now: float
+        self, slot: list[dict[str, Any]], ts_utc_now: float
     ) -> list[dict[str, Any]]:
         """Sort the given electricity prices by their rank value. Given a list
         of electricity prices, return a sorted list from the cheapest to the
@@ -191,11 +226,11 @@ class HeatingOptimizer(Juham):
         Returns:
             list: sorted list of electricity prices
         """
-        sh = sorted(hours, key=lambda x: x["Rank"])
+        sh = sorted(slot, key=lambda x: x["Rank"])
         ranked_hours: list[dict[str, Any]] = []
         for h in sh:
             utc_ts = h["Timestamp"]
-            if utc_ts > ts_utc_now:
+            if utc_ts >= ts_utc_now:
                 ranked_hours.append(h)
 
         return ranked_hours
@@ -224,16 +259,16 @@ class HeatingOptimizer(Juham):
         self.debug(
             f"{self.name} sorted {len(sh)} days of forecast starting at {timestampstr(ts_utc)}"
         )
-        ranked_hours: list[dict[str, Any]] = []
+        ranked_slots: list[dict[str, Any]] = []
 
         for h in sh:
             utc_ts: float = float(h["ts"])
             if utc_ts >= ts_utc:
-                ranked_hours.append(h)
+                ranked_slots.append(h)
         self.debug(
-            f"{self.name} forecast sorted for the next {str(len(ranked_hours))} hours"
+            f"{self.name} forecast sorted for the next {str(len(ranked_slots))} hours"
         )
-        return ranked_hours
+        return ranked_slots
 
     def on_spot(self, m: list[dict[str, Any]], ts_quantized: float) -> None:
         """Handle the spot prices.
@@ -268,7 +303,7 @@ class HeatingOptimizer(Juham):
     def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
         m = None
         ts: float = timestamp()
-        ts_utc_quantized: float = quantize(3600, ts - 3600)
+        ts_utc_quantized: float = quantize(self.energy_balancing_interval, ts - self.energy_balancing_interval)
         if msg.topic == self.topic_in_spot:
             self.on_spot(json.loads(msg.payload.decode()), ts_utc_quantized)
             return
@@ -399,19 +434,19 @@ class HeatingOptimizer(Juham):
             )
             return 1
 
-        hour = timestamp_hour(ts)
+        slot : int = self.timestamp_slot(ts)
         state: int = -1
 
         # check if we are within the heating plan and see what the plan says
         for pp in self.heating_plan:
             ppts: float = pp["Timestamp"]
-            h: float = timestamp_hour(ppts)
-            if h == hour:
+            h: float = self.timestamp_slot(ppts)
+            if h == slot:
                 state = pp["State"]
                 break
 
         if state == -1:
-            self.error(f"{self.name} cannot find heating plan for hour {hour}")
+            self.error(f"{self.name} cannot find heating plan for hour {slot}")
             return 0
 
         min_temp, max_temp = self.get_temperature_limits_for_current_month()
@@ -438,20 +473,20 @@ class HeatingOptimizer(Juham):
     def compute_uoi(
         self,
         price: float,
-        hour: float,
+        slot: float,
     ) -> float:
         """Compute UOI - utilization optimization index.
 
         Args:
             price (float): effective price for this device
-            hour  (float) : the hour of the day
+            slot  (float) : the slot of the day
 
         Returns:
             float: utilization optimization index
         """
 
-        if not is_hour_within_schedule(
-            hour, self.schedule_start_hour, self.schedule_stop_hour
+        if not self.is_slot_within_schedule(
+            slot, self.schedule_start_slot, self.schedule_stop_slot
         ):
             return 0.0
 
@@ -473,7 +508,6 @@ class HeatingOptimizer(Juham):
             requested_power (float): requested power
             available_solpower (float): current solar power forecast
             spot (float): spot price
-            hour  (float) : the hour of the day
 
         Returns:
             float: effective price for the requested power
@@ -490,13 +524,30 @@ class HeatingOptimizer(Juham):
 
         return effective_spot
 
+    def align_forecast_to_slots(self, solar_forecast: list[dict]) -> list[dict]:
+        """Resample hourly solar forecast to match slot interval."""
+        slots_per_hour = 3600 // self.energy_balancing_interval
+        expanded = []
+
+        for entry in solar_forecast:  # each entry has "ts" (start of hour) and "solarenergy" (in kW)
+            start_ts = entry["Timestamp"]
+            for i in range(slots_per_hour):
+                slot_ts = start_ts + i * self.energy_balancing_interval
+                expanded.append({
+                    "Timestamp": slot_ts,
+                    "Solarenergy": entry["Solarenergy"] / slots_per_hour  # split evenly
+                })
+
+        return expanded
+
+
     def create_power_plan(self) -> list[dict[Any, Any]]:
         """Create power plan.
 
         Returns:
             list: list of utilization entries
         """
-        ts_utc_quantized = quantize(3600, timestamp() - 3600)
+        ts_utc_quantized = quantize(self.energy_balancing_interval, timestamp() - self.energy_balancing_interval)
         starts: str = timestampstr(ts_utc_quantized)
         self.info(
             f"{self.name} created power plan starting at {starts} with {len(self.ranked_spot_prices)} hours of spot prices",
@@ -521,10 +572,16 @@ class HeatingOptimizer(Juham):
             f"Have spot prices for the next {len(spots)} hours",
             "",
         )
-        powers: list[dict[str, Any]] = []
-        for s in self.ranked_solarpower:
-            if s["ts"] >= ts_utc_quantized:
-                powers.append({"Timestamp": s["ts"], "Solarenergy": s["solarenergy"]})
+
+        # Expand solar forecast to match spot price resolution
+        raw_powers = [
+            {"Timestamp": s["ts"], "Solarenergy": s["solarenergy"]}
+            for s in self.ranked_solarpower
+            if s["ts"] >= ts_utc_quantized
+        ]
+
+        powers : list[dict[str, Any]]  = self.align_forecast_to_slots(raw_powers)
+
 
         num_powers: int = len(powers)
         if num_powers == 0:
@@ -538,8 +595,8 @@ class HeatingOptimizer(Juham):
                 "",
             )
         hplan: list[dict[str, Any]] = []
-        hour: float = 0
-        if len(powers) >= 8:  # at least 8 hours of solar energy forecast
+        slot: int = 0
+        if len(powers) >= 8:  # at least 8 slot of solar energy forecast
             for spot, solar in zip(spots, powers):
                 ts = spot["Timestamp"]
                 solarenergy = solar["Solarenergy"] * 1000  # argh, this is in kW
@@ -547,8 +604,8 @@ class HeatingOptimizer(Juham):
                 effective_price: float = self.compute_effective_price(
                     self.radiator_power, solarenergy, spotprice
                 )
-                hour = timestamp_hour_local(ts, self.timezone)
-                fom = self.compute_uoi(spotprice, hour)
+                slot = self.timestamp_slot(ts)
+                fom = self.compute_uoi(spotprice, slot)
                 plan: dict[str, Any] = {
                     "Timestamp": ts,
                     "FOM": fom,
@@ -561,8 +618,8 @@ class HeatingOptimizer(Juham):
                 solarenergy = 0.0
                 spotprice = spot["PriceWithTax"]
                 effective_price = spotprice  # no free energy available
-                hour = timestamp_hour_local(ts, self.timezone)
-                fom = self.compute_uoi(effective_price, hour)
+                slot = timestamp_slot(ts)
+                fom = self.compute_uoi(effective_price, slot)
                 plan = {
                     "Timestamp": spot["Timestamp"],
                     "FOM": fom,
@@ -572,15 +629,15 @@ class HeatingOptimizer(Juham):
 
         shplan = sorted(hplan, key=lambda x: x["FOM"], reverse=True)
 
-        self.debug(f"{self.name} powerplan starts {starts} up to {len(shplan)} hours")
+        self.debug(f"{self.name} powerplan starts {starts} up to {len(shplan)} slots")
         return shplan
 
     def enable_relay(
-        self, hour: float, spot: float, fom: float, end_hour: float
+        self, slot: int, spot: float, fom: float, end_slot: int
     ) -> bool:
         return (
-            hour >= self.start_hour
-            and hour < end_hour
+            slot >= self.start_slot
+            and slot < end_slot
             and float(spot) < self.spot_limit
             and fom > self.uoi_threshold
         )
@@ -594,18 +651,18 @@ class HeatingOptimizer(Juham):
 
         state = 0
         heating_plan: list[dict[str, Any]] = []
-        hour: int = 0
+        slot: int = 0
         for hp in self.power_plan:
             ts: float = hp["Timestamp"]
             fom = hp["FOM"]
             spot = hp["Spot"]
-            end_hour: float = self.start_hour + self.heating_hours_per_day
-            local_hour: float = timestamp_hour_local(ts, self.timezone)
-            schedule_on: bool = is_hour_within_schedule(
-                local_hour, self.schedule_start_hour, self.schedule_stop_hour
+            end_slot: float = self.start_slot + self.heating_slots_per_day
+            slot: float = self.timestamp_slot(ts)
+            schedule_on: bool = self.is_slot_within_schedule(
+                slot, self.schedule_start_slot, self.schedule_stop_slot
             )
 
-            if self.enable_relay(hour, spot, fom, end_hour) and schedule_on:
+            if self.enable_relay(slot, spot, fom, end_slot) and schedule_on:
                 state = 1
             else:
                 state = 0
@@ -620,7 +677,7 @@ class HeatingOptimizer(Juham):
 
             self.publish(self.topic_powerplan, json.dumps(heat), 1, False)
             heating_plan.append(heat)
-            hour = hour + 1
+            slot = slot + 1
 
-        self.info(f"{self.name} heating plan of {len(heating_plan)} hours created", "")
+        self.info(f"{self.name} heating plan of {len(heating_plan)} slots created", "")
         return heating_plan

{juham_automation-0.1.2.dist-info → juham_automation-0.1.4.dist-info}/METADATA

@@ -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.dist-info → juham_automation-0.1.4.dist-info}/RECORD

@@ -3,8 +3,8 @@ juham_automation/japp.py,sha256=L2u1mfKvun2fiXhB3AEJD9zMDcdFZ3_doXZYJJzu9tg,1646
 juham_automation/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 juham_automation/automation/__init__.py,sha256=uxkIrcRSp1cFikn-oBRtQ8XiT9cSf7xjm3CS1RN7lAQ,522
 juham_automation/automation/energybalancer.py,sha256=Mf9bK-Xo4zNalePL5EIGvlFObMkjWgeh76gvcU-ydIk,11532
-juham_automation/automation/energycostcalculator.py,sha256=v30wxRpuY2gGBSMJifrFRTjsRU9t-iCiq33Vds7s3O8,10877
-juham_automation/automation/heatingoptimizer.py,sha256=cf3bKQfWvZoeo4eSWQKKKXwYZyZziGZPIwuuNrgW81g,24601
+juham_automation/automation/energycostcalculator.py,sha256=dYZxfnPtCw5FqIOAyBU0POf-ulTnZ8iUL45MEh4KLfE,13022
+juham_automation/automation/heatingoptimizer.py,sha256=xFDalR86CGyyJ2z-MCDGUv0tOZW3_KSM-J39VIgJ404,26644
 juham_automation/automation/powermeter_simulator.py,sha256=3WZcjByRTdqnC77l7LjP-TEjmZ8XBEO4hClYsrjxmBE,4549
 juham_automation/automation/spothintafi.py,sha256=cZbi7w2fVweHX_fh1r5MTjGdesX9wDQta2mfVjtiwvw,4331
 juham_automation/automation/watercirculator.py,sha256=a8meMNaONbHcIH3y0vP0UulJc1-gZiLZpw7H8kAOreY,6410
@@ -17,9 +17,9 @@ juham_automation/ts/log_ts.py,sha256=XsNaazuPmRUZLUqxU0DZae_frtT6kAFcXJTc598CtOA
 juham_automation/ts/power_ts.py,sha256=e7bSeZjitY4C_gLup9L0NjvU_WnQsl3ayDhVShj32KY,1399
 juham_automation/ts/powermeter_ts.py,sha256=gXzfK2S4SzrQ9GqM0tsLaV6z_vYmTkBatTcaivASSXs,2188
 juham_automation/ts/powerplan_ts.py,sha256=LZeE7TnzPCDaugggKlaV-K48lDwwnC1ZNum50JYAWaY,1482
-juham_automation-0.1.2.dist-info/licenses/LICENSE.rst,sha256=QVHD5V5_HSys2PdPdig_xKggDj8cGX33ALKqRsYyjtI,1089
-juham_automation-0.1.2.dist-info/METADATA,sha256=ar-n8K6GfYNwv0KccMCW8bjP71JxGYCvbnGxm9SxY50,7133
-juham_automation-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-juham_automation-0.1.2.dist-info/entry_points.txt,sha256=h-KzuKjmGPd4_iX_oiGvxx4IEc97dVbGGlhdh5ctbpI,605
-juham_automation-0.1.2.dist-info/top_level.txt,sha256=jfohvtocvX_gfT21AhJk7Iay5ZiQsS3HzrDjF7S4Qp0,17
-juham_automation-0.1.2.dist-info/RECORD,,
+juham_automation-0.1.4.dist-info/licenses/LICENSE.rst,sha256=QVHD5V5_HSys2PdPdig_xKggDj8cGX33ALKqRsYyjtI,1089
+juham_automation-0.1.4.dist-info/METADATA,sha256=ibE3-7LrwwYJygOyuLmrkWKFxfpTdoZPZtd3mlWoykQ,6992
+juham_automation-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+juham_automation-0.1.4.dist-info/entry_points.txt,sha256=h-KzuKjmGPd4_iX_oiGvxx4IEc97dVbGGlhdh5ctbpI,605
+juham_automation-0.1.4.dist-info/top_level.txt,sha256=jfohvtocvX_gfT21AhJk7Iay5ZiQsS3HzrDjF7S4Qp0,17
+juham_automation-0.1.4.dist-info/RECORD,,