Support local binary sensors in mapping

Author: Muriel2Horak

custom_components/oig_cloud/data_source.py

@@ -170,19 +170,22 @@ def _get_latest_local_entity_update(
     """Return the most recent update timestamp among local telemetry entities for a box."""
     if not (isinstance(box_id, str) and box_id.isdigit()):
         return None
-    prefix = f"sensor.oig_local_{box_id}_"
     try:
         latest: Optional[dt_util.dt.datetime] = None
-        for st in hass.states.async_all("sensor"):
-            if not st.entity_id.startswith(prefix):
-                continue
-            if st.state in (None, "", "unknown", "unavailable"):
-                continue
-            dt = st.last_updated or st.last_changed
-            if dt is None:
-                continue
-            dt_utc = dt_util.as_utc(dt) if dt.tzinfo else dt.replace(tzinfo=dt_util.UTC)
-            latest = dt_utc if latest is None else max(latest, dt_utc)
+        for domain in ("sensor", "binary_sensor"):
+            prefix = f"{domain}.oig_local_{box_id}_"
+            for st in hass.states.async_all(domain):
+                if not st.entity_id.startswith(prefix):
+                    continue
+                if st.state in (None, "", "unknown", "unavailable"):
+                    continue
+                dt = st.last_updated or st.last_changed
+                if dt is None:
+                    continue
+                dt_utc = (
+                    dt_util.as_utc(dt) if dt.tzinfo else dt.replace(tzinfo=dt_util.UTC)
+                )
+                latest = dt_utc if latest is None else max(latest, dt_utc)
         return latest
     except Exception:
         return None
@@ -282,7 +285,7 @@ def init_data_source_state(hass: HomeAssistant, entry: ConfigEntry) -> DataSourc
 class DataSourceController:
     """Controls effective data source mode based on local proxy health."""
 
-    _LOCAL_ENTITY_RE = re.compile(r"^sensor\.oig_local_(\d+)_")
+    _LOCAL_ENTITY_RE = re.compile(r"^(?:sensor|binary_sensor)\.oig_local_(\d+)_")
 
     def __init__(
         self,
@@ -399,7 +402,10 @@ def _on_any_state_change(self, event: Any) -> None:
         entity_id = event.data.get("entity_id")
         if not isinstance(entity_id, str):
             return
-        if not entity_id.startswith("sensor.oig_local_"):
+        if not (
+            entity_id.startswith("sensor.oig_local_")
+            or entity_id.startswith("binary_sensor.oig_local_")
+        ):
             return
 
         # Ensure the local update belongs to this entry's box_id (prevents cross-device wiring).

custom_components/oig_cloud/local_mapper.py

@@ -72,6 +72,46 @@ def _normalize_box_mode(value: Any) -> Optional[int]:
     return None
 
 
+def _normalize_domains(value: Any) -> Tuple[str, ...]:
+    if isinstance(value, str):
+        raw = [value]
+    elif isinstance(value, (list, tuple, set)):
+        raw = list(value)
+    else:
+        raw = []
+
+    domains: List[str] = []
+    for item in raw:
+        if not isinstance(item, str):
+            continue
+        domain = item.strip()
+        if domain in {"sensor", "binary_sensor"} and domain not in domains:
+            domains.append(domain)
+
+    if not domains:
+        domains = ["sensor"]
+    return tuple(domains)
+
+
+def _normalize_value_map(value: Any) -> Optional[Dict[str, Any]]:
+    if not isinstance(value, dict):
+        return None
+    out: Dict[str, Any] = {}
+    for key, mapped in value.items():
+        if not isinstance(key, str):
+            continue
+        out[key.strip().lower()] = mapped
+    return out or None
+
+
+def _apply_value_map(value: Any, value_map: Optional[Dict[str, Any]]) -> Any:
+    if isinstance(value, str) and value_map:
+        key = value.strip().lower()
+        if key in value_map:
+            return value_map[key]
+    return _coerce_number(value)
+
+
 # Extended "values" layout used by OigCloudDataSensor._get_extended_value()
 _EXTENDED_INDEX_BY_SENSOR_TYPE: Dict[str, Tuple[str, int]] = {
     # battery -> extended_batt
@@ -118,14 +158,40 @@ class _ExtendedUpdate:
 LocalUpdate = _NodeUpdate | _ExtendedUpdate
 
 
-def _build_suffix_updates() -> Dict[str, List[LocalUpdate]]:
-    out: Dict[str, List[LocalUpdate]] = {}
+@dataclass(frozen=True, slots=True)
+class _SuffixConfig:
+    updates: Tuple[LocalUpdate, ...]
+    domains: Tuple[str, ...]
+    value_map: Optional[Dict[str, Any]]
+
+
+def _build_suffix_updates() -> Dict[str, _SuffixConfig]:
+    raw: Dict[str, Dict[str, Any]] = {}
     for sensor_type, cfg in SENSOR_TYPES.items():
         suffix = cfg.get("local_entity_suffix")
         if not isinstance(suffix, str) or not suffix:
             continue
-
-        updates: List[LocalUpdate] = out.setdefault(suffix, [])
+        entry = raw.setdefault(
+            suffix,
+            {
+                "updates": [],
+                "domains": [],
+                "value_map": None,
+            },
+        )
+
+        domains = _normalize_domains(cfg.get("local_entity_domains"))
+        for domain in domains:
+            if domain not in entry["domains"]:
+                entry["domains"].append(domain)
+
+        value_map = _normalize_value_map(cfg.get("local_value_map"))
+        if value_map:
+            if entry["value_map"] is None:
+                entry["value_map"] = {}
+            entry["value_map"].update(value_map)
+
+        updates: List[LocalUpdate] = entry["updates"]
 
         node_id = cfg.get("node_id")
         node_key = cfg.get("node_key")
@@ -142,10 +208,18 @@ def _build_suffix_updates() -> Dict[str, List[LocalUpdate]]:
             group, index = ext
             updates.append(_ExtendedUpdate(group=group, index=index))
 
+    out: Dict[str, _SuffixConfig] = {}
+    for suffix, entry in raw.items():
+        domains = tuple(entry["domains"]) if entry["domains"] else ("sensor",)
+        out[suffix] = _SuffixConfig(
+            updates=tuple(entry["updates"]),
+            domains=domains,
+            value_map=entry["value_map"],
+        )
     return out
 
 
-_SUFFIX_UPDATES: Dict[str, List[LocalUpdate]] = _build_suffix_updates()
+_SUFFIX_UPDATES: Dict[str, _SuffixConfig] = _build_suffix_updates()
 
 
 class LocalUpdateApplier:
@@ -162,15 +236,24 @@ def apply_state(
         last_updated: Optional[datetime],
     ) -> bool:
         """Return True if payload changed."""
-        prefix = f"sensor.oig_local_{self.box_id}_"
-        if not (isinstance(entity_id, str) and entity_id.startswith(prefix)):
+        if not isinstance(entity_id, str):
             return False
-        suffix = entity_id[len(prefix) :]
-        updates = _SUFFIX_UPDATES.get(suffix)
-        if not updates:
+        domain = None
+        suffix = None
+        for candidate_domain in ("sensor", "binary_sensor"):
+            prefix = f"{candidate_domain}.oig_local_{self.box_id}_"
+            if entity_id.startswith(prefix):
+                domain = candidate_domain
+                suffix = entity_id[len(prefix) :]
+                break
+        if domain is None or suffix is None:
+            return False
+
+        suffix_cfg = _SUFFIX_UPDATES.get(suffix)
+        if not suffix_cfg or domain not in suffix_cfg.domains:
             return False
 
-        value = _coerce_number(state)
+        value = _apply_value_map(state, suffix_cfg.value_map)
         if value is None:
             return False
 
@@ -183,7 +266,7 @@ def apply_state(
             payload[self.box_id] = {}
             box = payload[self.box_id]
 
-        for upd in updates:
+        for upd in suffix_cfg.updates:
             if isinstance(upd, _NodeUpdate):
                 node = box.setdefault(upd.node_id, {})
                 if not isinstance(node, dict):

custom_components/oig_cloud/oig_cloud_data_sensor.py

@@ -551,7 +551,20 @@ def _get_local_entity_id_for_config(
 
         suffix = sensor_config.get("local_entity_suffix")
         if suffix and self._box_id and self._box_id != "unknown":
-            return f"sensor.oig_local_{self._box_id}_{suffix}"
+            domains = sensor_config.get("local_entity_domains")
+            if isinstance(domains, str):
+                domain_list = [domains]
+            elif isinstance(domains, (list, tuple, set)):
+                domain_list = [d for d in domains if isinstance(d, str)]
+            else:
+                domain_list = ["sensor"]
+            if not domain_list:
+                domain_list = ["sensor"]
+            for domain in domain_list:
+                candidate = f"{domain}.oig_local_{self._box_id}_{suffix}"
+                if self.hass.states.get(candidate):
+                    return candidate
+            return f"{domain_list[0]}.oig_local_{self._box_id}_{suffix}"
         return None
 
     def _coerce_number(self, value: Any) -> Any:
@@ -562,6 +575,16 @@ def _coerce_number(self, value: Any) -> Any:
         except ValueError:
             return value
 
+    def _apply_local_value_map(self, value: Any, sensor_config: Dict[str, Any]) -> Any:
+        if value is None:
+            return None
+        value_map = sensor_config.get("local_value_map")
+        if isinstance(value, str) and isinstance(value_map, dict):
+            key = value.strip().lower()
+            if key in value_map:
+                return value_map[key]
+        return self._coerce_number(value)
+
     def _fallback_value(self) -> Optional[Any]:
         if self._last_state is not None:
             return self._last_state
@@ -579,7 +602,7 @@ def _get_local_value(self) -> Optional[Any]:
         st = self.hass.states.get(local_entity_id)
         if not st or st.state in (None, "unknown", "unavailable"):
             return None
-        return self._coerce_number(st.state)
+        return self._apply_local_value_map(st.state, self._sensor_config)
 
     def _get_local_value_for_sensor_type(self, sensor_type: str) -> Optional[Any]:
         try:
@@ -594,7 +617,7 @@ def _get_local_value_for_sensor_type(self, sensor_type: str) -> Optional[Any]:
             st = self.hass.states.get(local_entity_id)
             if not st or st.state in (None, "unknown", "unavailable"):
                 return None
-            return self._coerce_number(st.state)
+            return self._apply_local_value_map(st.state, cfg)
         except Exception:
             return None
 

custom_components/oig_cloud/sensors/SENSOR_TYPES_BOILER.py

@@ -50,6 +50,8 @@
         "unit_of_measurement": None,
         "node_id": "boiler_prms",
         "node_key": "manual",
+        "local_entity_domains": ["sensor", "binary_sensor"],
+        "local_value_map": {"on": 1, "off": 0},
         "local_entity_suffix": "tbl_boiler_prms_manual",
         "entity_category": EntityCategory.DIAGNOSTIC,
         "state_class": None,
@@ -64,6 +66,8 @@
         "unit_of_measurement": None,
         "node_id": "boiler_prms",
         "node_key": "ssr0",
+        "local_entity_domains": ["sensor", "binary_sensor"],
+        "local_value_map": {"on": 1, "off": 0},
         "local_entity_suffix": "tbl_boiler_prms_ssr0",
         "entity_category": EntityCategory.DIAGNOSTIC,
         "state_class": None,
@@ -78,6 +82,8 @@
         "unit_of_measurement": None,
         "node_id": "boiler_prms",
         "node_key": "ssr1",
+        "local_entity_domains": ["sensor", "binary_sensor"],
+        "local_value_map": {"on": 1, "off": 0},
         "local_entity_suffix": "tbl_boiler_prms_ssr1",
         "entity_category": EntityCategory.DIAGNOSTIC,
         "state_class": None,
@@ -92,6 +98,8 @@
         "unit_of_measurement": None,
         "node_id": "boiler_prms",
         "node_key": "ssr2",
+        "local_entity_domains": ["sensor", "binary_sensor"],
+        "local_value_map": {"on": 1, "off": 0},
         "local_entity_suffix": "tbl_boiler_prms_ssr2",
         "entity_category": EntityCategory.DIAGNOSTIC,
         "state_class": None,
@@ -106,6 +114,8 @@
         "unit_of_measurement": None,
         "node_id": "boiler_prms",
         "node_key": "ison",
+        "local_entity_domains": ["sensor", "binary_sensor"],
+        "local_value_map": {"on": 1, "off": 0},
         "local_entity_suffix": "tbl_boiler_prms_ison",
         "entity_category": EntityCategory.DIAGNOSTIC,
         "state_class": None,

custom_components/oig_cloud/sensors/SENSOR_TYPES_MISC.py

@@ -53,6 +53,8 @@
         "options": ["Vypnuto / Off", "Zapnuto / On", "S omezením / Limited"],
         "sensor_type_category": "data",
         "device_mapping": "main",
+        "local_entity_domains": ["sensor", "binary_sensor"],
+        "local_value_map": {"on": 1, "off": 0},
         "local_entity_suffix": "tbl_invertor_prms_to_grid",
     },
     "installed_battery_capacity_kwh": {

custom_components/oig_cloud/telemetry_store.py

@@ -77,11 +77,12 @@ def apply_local_events(self, entity_ids: Iterable[str]) -> bool:
 
     def seed_from_existing_local_states(self) -> bool:
         """Seed payload from all currently-known local entity states for this box."""
-        prefix = f"sensor.oig_local_{self.box_id}_"
         entity_ids = []
-        for st in self.hass.states.async_all("sensor"):
-            if st.entity_id.startswith(prefix):
-                entity_ids.append(st.entity_id)
+        for domain in ("sensor", "binary_sensor"):
+            prefix = f"{domain}.oig_local_{self.box_id}_"
+            for st in self.hass.states.async_all(domain):
+                if st.entity_id.startswith(prefix):
+                    entity_ids.append(st.entity_id)
         return self.apply_local_events(entity_ids)
 
     def get_snapshot(self) -> TelemetrySnapshot: