feat: add is_ready property to base class and expose all telemetry properties

- Implement is_ready in OmniEquipment base class to check backyard service mode state
- Update all equipment classes to call super().is_ready before their own readiness checks
- Add telemetry properties to Backyard
- Add telemetry and config properties to Bow

Author: cryptk

pyomnilogic_local/_base.py

@@ -4,6 +4,7 @@
 from pyomnilogic_local.api.api import OmniLogicAPI
 from pyomnilogic_local.models import MSPEquipmentType, Telemetry
 from pyomnilogic_local.models.telemetry import TelemetryType
+from pyomnilogic_local.omnitypes import BackyardState
 
 if TYPE_CHECKING:
     from pyomnilogic_local.omnilogic import OmniLogic
@@ -67,6 +68,28 @@ def omni_type(self) -> str | None:
         """The OmniType of the equipment."""
         return self.mspconfig.omni_type
 
+    @property
+    def is_ready(self) -> bool:
+        """Check if the equipment is ready to accept commands.
+
+        Equipment is not ready when the backyard is in service or configuration mode.
+        This is the base implementation that checks backyard state.
+        Subclasses should call super().is_ready first and add their own checks.
+
+        Returns:
+            bool: False if backyard is in SERVICE_MODE, CONFIG_MODE, or TIMED_SERVICE_MODE,
+                  True otherwise (equipment-specific checks in subclasses)
+        """
+        # Check if backyard state allows equipment operations
+        backyard_state = self._omni.backyard.telemetry.state
+        if backyard_state in (
+            BackyardState.SERVICE_MODE,
+            BackyardState.CONFIG_MODE,
+            BackyardState.TIMED_SERVICE_MODE,
+        ):
+            return False
+        return True
+
     def update(self, mspconfig: MSPConfigT, telemetry: Telemetry | None) -> None:
         """Update both the configuration and telemetry data for the equipment."""
         self.update_config(mspconfig)

pyomnilogic_local/backyard.py

@@ -4,6 +4,7 @@
 from pyomnilogic_local.collections import EquipmentDict
 from pyomnilogic_local.models.mspconfig import MSPBackyard
 from pyomnilogic_local.models.telemetry import Telemetry, TelemetryBackyard
+from pyomnilogic_local.omnitypes import BackyardState
 
 from ._base import OmniEquipment
 from .bow import Bow
@@ -30,6 +31,54 @@ class Backyard(OmniEquipment[MSPBackyard, TelemetryBackyard]):
     def __init__(self, omni: "OmniLogic", mspconfig: MSPBackyard, telemetry: Telemetry) -> None:
         super().__init__(omni, mspconfig, telemetry)
 
+    @property
+    def status_version(self) -> int:
+        """Telemetry status version number."""
+        return self.telemetry.status_version
+
+    @property
+    def air_temp(self) -> int | None:
+        """Current air temperature reading from the backyard sensor.
+
+        Note: Temperature is in Fahrenheit. May be None if sensor is not available.
+        """
+        return self.telemetry.air_temp
+
+    @property
+    def state(self) -> BackyardState:
+        """Current backyard state (OFF, ON, SERVICE_MODE, CONFIG_MODE, TIMED_SERVICE_MODE)."""
+        return self.telemetry.state
+
+    @property
+    def config_checksum(self) -> int | None:
+        """Configuration checksum value.
+
+        Note: Only available when status_version >= 11. Returns None otherwise.
+        """
+        return self.telemetry.config_checksum
+
+    @property
+    def msp_version(self) -> str | None:
+        """MSP firmware version string.
+
+        Note: Only available when status_version >= 11. Returns None otherwise.
+        Example: "R0408000"
+        """
+        return self.telemetry.msp_version
+
+    @property
+    def is_service_mode(self) -> bool:
+        """Check if the backyard is in any service mode.
+
+        Returns:
+            True if in SERVICE_MODE, CONFIG_MODE, or TIMED_SERVICE_MODE, False otherwise
+        """
+        return self.state in (
+            BackyardState.SERVICE_MODE,
+            BackyardState.CONFIG_MODE,
+            BackyardState.TIMED_SERVICE_MODE,
+        )
+
     def _update_equipment(self, mspconfig: MSPBackyard, telemetry: Telemetry | None) -> None:
         """Update both the configuration and telemetry data for the equipment."""
         if telemetry is None:

pyomnilogic_local/bow.py

@@ -9,6 +9,7 @@
 from pyomnilogic_local.heater import Heater
 from pyomnilogic_local.models.mspconfig import MSPBoW
 from pyomnilogic_local.models.telemetry import Telemetry, TelemetryBoW
+from pyomnilogic_local.omnitypes import BodyOfWaterType
 from pyomnilogic_local.pump import Pump
 from pyomnilogic_local.relay import Relay
 from pyomnilogic_local.sensor import Sensor
@@ -35,10 +36,32 @@ def __init__(self, omni: "OmniLogic", mspconfig: MSPBoW, telemetry: Telemetry) -
         super().__init__(omni, mspconfig, telemetry)
 
     @property
-    def equip_type(self) -> str:
-        """The equipment type of the bow."""
+    def equip_type(self) -> BodyOfWaterType | str:
+        """The equipment type of the bow (POOL or SPA)."""
         return self.mspconfig.equip_type
 
+    @property
+    def supports_spillover(self) -> bool:
+        """Whether this body of water supports spillover functionality."""
+        return self.mspconfig.supports_spillover
+
+    @property
+    def water_temp(self) -> int:
+        """Current water temperature reading from the bow sensor.
+
+        Note: Temperature is in Fahrenheit. Returns -1 if sensor is not available.
+        """
+        return self.telemetry.water_temp
+
+    @property
+    def flow(self) -> int:
+        """Current flow sensor reading.
+
+        Returns:
+            Flow value (255 typically indicates flow present, 0 indicates no flow)
+        """
+        return self.telemetry.flow
+
     def _update_equipment(self, mspconfig: MSPBoW, telemetry: Telemetry | None) -> None:
         """Update both the configuration and telemetry data for the equipment."""
         if telemetry is None:

pyomnilogic_local/chlorinator.py

@@ -303,8 +303,10 @@ def salt_level_status(self) -> str:
     def is_ready(self) -> bool:
         """Check if the chlorinator is ready to accept commands.
 
-        A chlorinator is considered ready if it is authenticated and has no
-        critical errors that would prevent it from operating.
+        A chlorinator is considered ready if:
+        - The backyard is not in service/config mode (checked by parent class)
+        - It is authenticated
+        - It has no critical errors that would prevent it from operating
 
         Returns:
             True if chlorinator can accept commands, False otherwise
@@ -313,4 +315,9 @@ def is_ready(self) -> bool:
             >>> if chlorinator.is_ready:
             ...     await chlorinator.set_chlorine_level(75)
         """
+        # First check if backyard is ready
+        if not super().is_ready:
+            return False
+
+        # Then check chlorinator-specific readiness
         return self.is_authenticated and not self.has_error

pyomnilogic_local/colorlogiclight.py

@@ -83,15 +83,22 @@ def is_ready(self) -> bool:
         """
         Returns whether the light is ready to accept commands.
 
-        The light is not ready when it is in a transitional state:
-        - FIFTEEN_SECONDS_WHITE: Light is in the 15-second white period after power on
-        - CHANGING_SHOW: Light is actively changing between shows
-        - POWERING_OFF: Light is in the process of turning off
-        - COOLDOWN: Light is in cooldown period after being turned off
+        The light is not ready when:
+        - The backyard is in service/config mode (checked by parent class)
+        - The light is in a transitional state:
+          - FIFTEEN_SECONDS_WHITE: Light is in the 15-second white period after power on
+          - CHANGING_SHOW: Light is actively changing between shows
+          - POWERING_OFF: Light is in the process of turning off
+          - COOLDOWN: Light is in cooldown period after being turned off
 
         Returns:
             bool: True if the light can accept commands, False otherwise.
         """
+        # First check if backyard is ready
+        if not super().is_ready:
+            return False
+
+        # Then check light-specific readiness
         return self.state not in [
             ColorLogicPowerState.FIFTEEN_SECONDS_WHITE,
             ColorLogicPowerState.CHANGING_SHOW,

pyomnilogic_local/csad.py

@@ -278,8 +278,10 @@ def ph_offset(self) -> float:
     def is_ready(self) -> bool:
         """Check if the CSAD is ready to accept commands.
 
-        A CSAD is considered ready if it is enabled and in a stable operating mode
-        (AUTO or MONITORING), not in a transitional or error state.
+        A CSAD is considered ready if:
+        - The backyard is not in service/config mode (checked by parent class)
+        - It is enabled and in a stable operating mode (AUTO, MONITORING, or FORCE_ON)
+        - Not in a transitional or error state
 
         Returns:
             True if CSAD can accept commands, False otherwise
@@ -288,4 +290,9 @@ def is_ready(self) -> bool:
             >>> if csad.is_ready:
             ...     await csad.set_mode(CSADMode.AUTO)
         """
+        # First check if backyard is ready
+        if not super().is_ready:
+            return False
+
+        # Then check CSAD-specific readiness
         return self.is_on and self.mode in (CSADMode.AUTO, CSADMode.MONITORING, CSADMode.FORCE_ON)

pyomnilogic_local/filter.py

@@ -115,12 +115,18 @@ def is_on(self) -> bool:
     def is_ready(self) -> bool:
         """Check if the filter is ready to receive commands.
 
-        A filter is considered ready if it's not in a transitional state like
-        priming, waiting to turn off, or cooling down.
+        A filter is considered ready if:
+        - The backyard is not in service/config mode (checked by parent class)
+        - It's not in a transitional state like priming, waiting to turn off, or cooling down
 
         Returns:
             True if filter can accept commands, False otherwise
         """
+        # First check if backyard is ready
+        if not super().is_ready:
+            return False
+
+        # Then check filter-specific readiness
         return self.state in (FilterState.OFF, FilterState.ON)
 
     # Control methods

pyomnilogic_local/pump.py

@@ -98,11 +98,18 @@ def is_on(self) -> bool:
     def is_ready(self) -> bool:
         """Check if the pump is ready to receive commands.
 
-        A pump is considered ready if it's in a stable state (ON or OFF).
+        A pump is considered ready if:
+        - The backyard is not in service/config mode (checked by parent class)
+        - It's in a stable state (ON or OFF)
 
         Returns:
             True if pump can accept commands, False otherwise
         """
+        # First check if backyard is ready
+        if not super().is_ready:
+            return False
+
+        # Then check pump-specific readiness
         return self.state in (PumpState.OFF, PumpState.ON)
 
     # Control methods