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

juham_automation/automation/energycostcalculator.py

@@ -72,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:
@@ -93,14 +93,29 @@ class EnergyCostCalculator(Juham):
         return price * self._joule_to_kwh_coeff
 
 
-
     def get_price_at(self, ts: float) -> float:
         """Return the spot price applicable at the given timestamp.
+
         Args:
-            ts (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.
         """
+        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]
@@ -111,10 +126,18 @@ class EnergyCostCalculator(Juham):
                 return r0["PriceWithTax"]
 
         # If timestamp is exactly equal to the last spot timestamp or beyond
-        if ts >= self.spots[-1]["Timestamp"]:
-            return self.spots[-1]["PriceWithTax"]
-
-        self.error(f"PANIC: Timestamp {ts} out of bounds for spot price lookup")
+        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
 
 
@@ -170,12 +193,12 @@ class EnergyCostCalculator(Juham):
             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(
-                3600, ts_now
-            )
             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)
@@ -206,7 +229,7 @@ class EnergyCostCalculator(Juham):
 
             # 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 = {

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."""
@@ -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")
@@ -130,10 +129,10 @@ class HeatingOptimizer(Juham):
 
         self.current_temperature : float = 100.0
         self.current_relay_state : int = -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.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
@@ -148,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."""
@@ -176,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
@@ -190,7 +226,7 @@ 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"]
@@ -223,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.
@@ -398,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()
@@ -437,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
 
@@ -472,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
@@ -489,6 +524,23 @@ 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.
 
@@ -520,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:
@@ -537,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
@@ -546,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,
@@ -560,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,
@@ -571,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
         )
@@ -593,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
@@ -619,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.3.dist-info → juham_automation-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: juham-automation
-Version: 0.1.3
+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>
@@ -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.3.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=OOvKhRbQ99wtnmoy9R3kGdAPMSkoDLa5GnZswpu52u0,11853
-juham_automation/automation/heatingoptimizer.py,sha256=M03r9sZLAPavjj0LlFXiVZqAKHN5ZUvcDVi2QR5yOrk,24684
+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.3.dist-info/licenses/LICENSE.rst,sha256=QVHD5V5_HSys2PdPdig_xKggDj8cGX33ALKqRsYyjtI,1089
-juham_automation-0.1.3.dist-info/METADATA,sha256=5Suhmsd8drHmj91gPngyVohtnA3sPdwsjsVIGYaQR7w,7122
-juham_automation-0.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-juham_automation-0.1.3.dist-info/entry_points.txt,sha256=h-KzuKjmGPd4_iX_oiGvxx4IEc97dVbGGlhdh5ctbpI,605
-juham_automation-0.1.3.dist-info/top_level.txt,sha256=jfohvtocvX_gfT21AhJk7Iay5ZiQsS3HzrDjF7S4Qp0,17
-juham_automation-0.1.3.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,,