boneio 1.3.0.dev14__tar.gz → 1.3.0.dev16__tar.gz

{boneio-1.3.0.dev14/boneio.egg-info → boneio-1.3.0.dev16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.3.0.dev14
+Version: 1.3.0.dev16
 Summary: Python App for BoneIO
 Author-email: Paweł Szafer <pszafer@gmail.com>
 License: GNU General Public License v3.0

{boneio-1.3.0.dev14 → boneio-1.3.0.dev16}/boneio/components/irrigation/controller.py

@@ -251,7 +251,10 @@ class IrrigationController:
             if skip_count >= zone.run_every_n - 1:
                 _LOGGER.debug(
                     "Irrigation %s: zone %s eligible (skip_count=%d >= %d)",
-                    self.id, zone.id, skip_count, zone.run_every_n - 1,
+                    self.id,
+                    zone.id,
+                    skip_count,
+                    zone.run_every_n - 1,
                 )
                 eligible.append((idx, zone))
                 # Reset counter — will be saved when zone finishes in _advance_to_next_zone
@@ -260,7 +263,10 @@ class IrrigationController:
                 self._save(counter_key, skip_count)
                 _LOGGER.debug(
                     "Irrigation %s: zone %s NOT eligible (skip_count=%d < %d)",
-                    self.id, zone.id, skip_count, zone.run_every_n - 1,
+                    self.id,
+                    zone.id,
+                    skip_count,
+                    zone.run_every_n - 1,
                 )
         return eligible
 
@@ -268,7 +274,10 @@ class IrrigationController:
         controller_state = ON if self._state in (ControllerState.RUNNING, ControllerState.PAUSED) else OFF
         _LOGGER.debug(
             "Irrigation %s publish_all_states: controller=%s (state=%s, active_zone=%s)",
-            self.id, controller_state, self._state.value, self._active_zone_idx,
+            self.id,
+            controller_state,
+            self._state.value,
+            self._active_zone_idx,
         )
         self._publish(self._state_topic(), {"state": controller_state})
         self._publish(
@@ -301,14 +310,18 @@ class IrrigationController:
             active = ON if self._active_zone_idx == idx and self._state == ControllerState.RUNNING else OFF
             _LOGGER.debug(
                 "Irrigation %s: zone %s idx=%d active=%s (active_zone_idx=%s)",
-                self.id, zone.id, idx, active, self._active_zone_idx,
+                self.id,
+                zone.id,
+                idx,
+                active,
+                self._active_zone_idx,
             )
             self._publish(self._zone_state_topic(zone.id), {"state": active})
             self._publish(
                 self._setting_state_topic(f"zone/{zone.id}/enabled"),
                 {"state": ON if zone.enabled else OFF},
             )
-            self._publish(self._zone_duration_topic(zone.id), {"value": zone.run_duration})
+            self._publish(self._zone_duration_topic(zone.id), {"value": max(1, round(zone.run_duration / 60))})
 
         for idx, sched in enumerate(self._schedule):
             self._publish(
@@ -333,7 +346,9 @@ class IrrigationController:
     async def shutdown(self) -> None:
         _LOGGER.debug(
             "Irrigation %s shutdown called (state=%s, active_zone=%s). Caller: %s",
-            self.id, self._state.value, self._active_zone_idx,
+            self.id,
+            self._state.value,
+            self._active_zone_idx,
             "".join(traceback.format_stack(limit=5)),
         )
         self.stop_schedules()
@@ -378,7 +393,10 @@ class IrrigationController:
     async def start_full_cycle(self) -> None:
         _LOGGER.debug(
             "Irrigation %s start_full_cycle: state=%s standby=%s skip_next=%s",
-            self.id, self._state.value, self._standby, self._skip_next_run,
+            self.id,
+            self._state.value,
+            self._standby,
+            self._skip_next_run,
         )
         if self._standby:
             _LOGGER.info("Irrigation %s is in standby mode, not starting", self.id)
@@ -403,7 +421,10 @@ class IrrigationController:
     async def start_single_zone(self, zone_id: str) -> None:
         _LOGGER.debug(
             "Irrigation %s start_single_zone('%s') state=%s standby=%s",
-            self.id, zone_id, self._state.value, self._standby,
+            self.id,
+            zone_id,
+            self._state.value,
+            self._standby,
         )
         if self._standby:
             _LOGGER.info("Irrigation %s is in standby mode, not starting zone", self.id)
@@ -431,7 +452,8 @@ class IrrigationController:
         eligible = self._eligible_zones()
         _LOGGER.debug(
             "Irrigation %s _start_cycle_from_eligible: %d eligible zones: %s",
-            self.id, len(eligible),
+            self.id,
+            len(eligible),
             [(idx, z.id) for idx, z in eligible],
         )
         if not eligible:
@@ -447,7 +469,10 @@ class IrrigationController:
     async def _advance_to_next_zone(self, force: bool = False) -> None:
         _LOGGER.debug(
             "Irrigation %s _advance_to_next_zone(force=%s) active_zone=%s single_zone=%s",
-            self.id, force, self._active_zone_idx, self._single_zone_mode,
+            self.id,
+            force,
+            self._active_zone_idx,
+            self._single_zone_mode,
         )
         if self._active_zone_idx is None:
             _LOGGER.debug("Irrigation %s: no active zone, shutting down", self.id)
@@ -551,8 +576,12 @@ class IrrigationController:
 
         _LOGGER.debug(
             "Irrigation %s _start_zone: idx=%d, zone=%s, valve=%s, duration=%ds, source=%s",
-            self.id, idx, zone.id, zone.valve.id if zone.valve else 'NONE',
-            duration, src.id if src else 'NONE',
+            self.id,
+            idx,
+            zone.id,
+            zone.valve.id if zone.valve else "NONE",
+            duration,
+            src.id if src else "NONE",
         )
 
         self._active_zone_idx = idx
@@ -562,12 +591,19 @@ class IrrigationController:
         if src is not None:
             if src.pump_start_valve_delay_s > 0:
                 # Source first (pump+valve), then zone valve after delay
-                _LOGGER.debug("Irrigation %s: source '%s' ON, then wait %ds", self.id, src.id, src.pump_start_valve_delay_s)
+                _LOGGER.debug(
+                    "Irrigation %s: source '%s' ON, then wait %ds", self.id, src.id, src.pump_start_valve_delay_s
+                )
                 await self._activate_source()
                 await asyncio.sleep(src.pump_start_valve_delay_s)
             elif src.pump_start_pump_delay_s > 0:
                 # Zone valve first, then source after delay
-                _LOGGER.debug("Irrigation %s: zone valve ON first, then source '%s' after %ds", self.id, src.id, src.pump_start_pump_delay_s)
+                _LOGGER.debug(
+                    "Irrigation %s: zone valve ON first, then source '%s' after %ds",
+                    self.id,
+                    src.id,
+                    src.pump_start_pump_delay_s,
+                )
                 try:
                     await zone.valve.async_turn_on(timestamp=time.time())
                 except Exception as err:
@@ -584,7 +620,10 @@ class IrrigationController:
                 except BaseException as err:
                     _LOGGER.error(
                         "Irrigation %s: CRITICAL error after valve ON (pump delay path): %s (%s)",
-                        self.id, err, type(err).__name__, exc_info=True,
+                        self.id,
+                        err,
+                        type(err).__name__,
+                        exc_info=True,
                     )
                 return
             else:
@@ -612,7 +651,10 @@ class IrrigationController:
         except BaseException as err:
             _LOGGER.error(
                 "Irrigation %s: CRITICAL error after valve ON: %s (%s)",
-                self.id, err, type(err).__name__, exc_info=True,
+                self.id,
+                err,
+                type(err).__name__,
+                exc_info=True,
             )
 
     async def _stop_current_zone(self) -> None:
@@ -713,24 +755,28 @@ class IrrigationController:
 
     async def handle_zone_command(self, zone_id: str, payload: str) -> None:
         upper = payload.strip().upper()
-        _LOGGER.debug("Irrigation %s handle_zone_command: zone='%s' payload='%s' → upper='%s'", self.id, zone_id, payload, upper)
+        _LOGGER.debug(
+            "Irrigation %s handle_zone_command: zone='%s' payload='%s' → upper='%s'", self.id, zone_id, payload, upper
+        )
         if upper == ON:
             await self.start_single_zone(zone_id)
         elif upper == OFF:
             await self.shutdown()
 
     async def handle_zone_duration_command(self, zone_id: str, payload: str) -> None:
+        """Handle duration change from HA (value in minutes)."""
         try:
-            duration = int(float(payload))
+            minutes = int(float(payload))
         except (TypeError, ValueError):
             return
-        if duration <= 0:
+        if minutes <= 0:
             return
 
+        duration_s = minutes * 60
         for zone in self._zones:
             if zone.id == zone_id:
-                zone.run_duration = duration
-                self._save(f"zone/{zone.id}/duration", duration)
+                zone.run_duration = duration_s
+                self._save(f"zone/{zone.id}/duration", duration_s)
                 break
         await self.publish_all_states()
 

{boneio-1.3.0.dev14 → boneio-1.3.0.dev16}/boneio/components/sensor/virtual_energy.py

@@ -4,6 +4,7 @@ Creates virtual power/energy or water flow sensors linked to outputs.
 When the linked output is ON, the sensor calculates consumption based on
 configured power_usage or flow_rate.
 """
+
 from __future__ import annotations
 
 import asyncio
@@ -26,10 +27,10 @@ _LOGGER = logging.getLogger(__name__)
 
 class VirtualEnergySensor:
     """Virtual energy/water sensor linked to an output.
-    
+
     Tracks energy consumption (Wh) or water consumption (L) based on
     configured power_usage (W) or flow_rate (L/h) when the linked output is ON.
-    
+
     Args:
         id: Unique sensor identifier
         name: Display name for Home Assistant
@@ -68,23 +69,26 @@ class VirtualEnergySensor:
         self._power_usage = power_usage
         self._flow_rate = flow_rate
         self._area = area
-        
+
         self._virtual_sensors_task = None
-        
+
         # Counters
         self._energy_consumed_Wh = 0.0
         self._water_consumed_L = 0.0
-        self._last_on_timestamp = time.time() if self._output.state == ON else None
-        
+        self._last_on_timestamp = None
+
+        # State restore gate — prevents sending state=0 before
+        # the retained MQTT message with the real value is received.
+        self._restore_done = asyncio.Event()
+
         # MQTT topic for this sensor
         self._sensor_topic = f"{topic_prefix}/energy/{id}"
-        
+
         # Subscribe to restore state from MQTT
         self._subscribe_restore_state()
-        
+
         _LOGGER.info(
-            "Initialized VirtualEnergySensor: id=%s, name=%s, output=%s, type=%s",
-            id, name, output.id, sensor_type
+            "Initialized VirtualEnergySensor: id=%s, name=%s, output=%s, type=%s", id, name, output.id, sensor_type
         )
 
     @property
@@ -140,18 +144,34 @@ class VirtualEnergySensor:
         # Update one last time before stopping
         self._update_consumption()
         self._last_on_timestamp = None
-        
+
         if self._virtual_sensors_task is not None:
             self._virtual_sensors_task.cancel()
             self._virtual_sensors_task = None
-        
-        # Send final state
-        self._send_state()
+
+        # Send final state (only if restore is done)
+        if self._restore_done.is_set():
+            self._send_state()
         _LOGGER.debug("Stopped tracking for virtual sensor %s", self._id)
 
     async def _tracking_loop(self):
         """Periodically update and send state every 30 seconds while output is ON."""
         try:
+            # Wait for state restore before sending any state.
+            # This prevents overwriting the retained MQTT value with 0.
+            # Timeout of 5s ensures we don't hang if MQTT is down.
+            try:
+                await asyncio.wait_for(self._restore_done.wait(), timeout=5.0)
+            except TimeoutError:
+                _LOGGER.warning(
+                    "State restore timeout for %s, starting with energy=%.4f Wh", self._id, self._energy_consumed_Wh
+                )
+                self._restore_done.set()
+
+            # Reset on_timestamp after restore so we don't count
+            # the time elapsed during the restore wait.
+            self._last_on_timestamp = time.time()
+
             while self._output.state == ON:
                 self._update_consumption()
                 self._send_state()
@@ -164,49 +184,42 @@ class VirtualEnergySensor:
         now = time.time()
         if self._output.state == ON and self._last_on_timestamp is not None:
             elapsed = now - self._last_on_timestamp
-            
+
             if self._sensor_type == "power" and self._power_usage is not None:
                 self._energy_consumed_Wh += (self._power_usage * elapsed) / 3600.0
-                _LOGGER.debug(
-                    "Energy updated for %s: %.4f Wh",
-                    self._id, self._energy_consumed_Wh
-                )
+                _LOGGER.debug("Energy updated for %s: %.4f Wh", self._id, self._energy_consumed_Wh)
             elif self._sensor_type == "water" and self._flow_rate is not None:
                 self._water_consumed_L += (self._flow_rate * elapsed) / 3600.0
-                _LOGGER.debug(
-                    "Water updated for %s: %.4f L",
-                    self._id, self._water_consumed_L
-                )
-            
+                _LOGGER.debug("Water updated for %s: %.4f L", self._id, self._water_consumed_L)
+
             self._last_on_timestamp = now
 
     def _subscribe_restore_state(self):
-        """Subscribe to retained MQTT topic to restore state on startup."""
+        """Subscribe to retained MQTT topic to restore state on startup.
+
+        Sets _restore_done event when restore is complete (or if no retained
+        message is available). This gates _send_state() to prevent overwriting
+        the retained value with 0.
+        """
+
         async def on_message(_topic, payload):
             try:
                 data = json.loads(payload)
                 if isinstance(data, dict):
                     if "energy" in data:
                         self._energy_consumed_Wh = float(data["energy"])
-                        _LOGGER.info(
-                            "Restored energy state for %s: %.4f Wh",
-                            self._id, self._energy_consumed_Wh
-                        )
+                        _LOGGER.info("Restored energy state for %s: %.4f Wh", self._id, self._energy_consumed_Wh)
                     if "water" in data:
                         self._water_consumed_L = float(data["water"])
-                        _LOGGER.info(
-                            "Restored water state for %s: %.4f L",
-                            self._id, self._water_consumed_L
-                        )
+                        _LOGGER.info("Restored water state for %s: %.4f L", self._id, self._water_consumed_L)
             except Exception as e:
                 _LOGGER.warning("Failed to restore state for %s: %s", self._id, e)
             finally:
+                self._restore_done.set()
                 await self._message_bus.unsubscribe_and_stop_listen(self._sensor_topic)
-        
+
         if self._message_bus is not None:
-            asyncio.create_task(
-                self._message_bus.subscribe_and_listen(self._sensor_topic, on_message)
-            )
+            asyncio.create_task(self._message_bus.subscribe_and_listen(self._sensor_topic, on_message))
 
     def get_current_power(self) -> float:
         """Get current power usage in W (0 if output is OFF)."""
@@ -232,58 +245,66 @@ class VirtualEnergySensor:
         """Send current state to MQTT and EventBus (for WebSocket/frontend)."""
         payload = {}
         timestamp = int(time.time())
-        
+
         if self._sensor_type == "power":
             payload["power"] = self.get_current_power()
             payload["energy"] = self.get_total_energy()
-            
+
             # Send SensorEvents to frontend via EventBus
-            self._event_bus.trigger_event(SensorEvent(
-                entity_id=f"{self._id}_power",
-                state=SensorState(
-                    id=f"{self._id}_power",
-                    name=f"{self._name} Power",
-                    state=self.get_current_power(),
-                    unit="W",
-                    timestamp=timestamp,
+            self._event_bus.trigger_event(
+                SensorEvent(
+                    entity_id=f"{self._id}_power",
+                    state=SensorState(
+                        id=f"{self._id}_power",
+                        name=f"{self._name} Power",
+                        state=self.get_current_power(),
+                        unit="W",
+                        timestamp=timestamp,
+                    ),
                 )
-            ))
-            self._event_bus.trigger_event(SensorEvent(
-                entity_id=f"{self._id}_energy",
-                state=SensorState(
-                    id=f"{self._id}_energy",
-                    name=f"{self._name} Energy",
-                    state=self.get_total_energy(),
-                    unit="Wh",
-                    timestamp=timestamp,
+            )
+            self._event_bus.trigger_event(
+                SensorEvent(
+                    entity_id=f"{self._id}_energy",
+                    state=SensorState(
+                        id=f"{self._id}_energy",
+                        name=f"{self._name} Energy",
+                        state=self.get_total_energy(),
+                        unit="Wh",
+                        timestamp=timestamp,
+                    ),
                 )
-            ))
+            )
         elif self._sensor_type == "water":
             payload["volume_flow_rate"] = self.get_current_flow_rate()
             payload["water"] = self.get_total_water()
-            
+
             # Send SensorEvents to frontend via EventBus
-            self._event_bus.trigger_event(SensorEvent(
-                entity_id=f"{self._id}_flow",
-                state=SensorState(
-                    id=f"{self._id}_flow",
-                    name=f"{self._name} Flow Rate",
-                    state=self.get_current_flow_rate(),
-                    unit="L/h",
-                    timestamp=timestamp,
+            self._event_bus.trigger_event(
+                SensorEvent(
+                    entity_id=f"{self._id}_flow",
+                    state=SensorState(
+                        id=f"{self._id}_flow",
+                        name=f"{self._name} Flow Rate",
+                        state=self.get_current_flow_rate(),
+                        unit="L/h",
+                        timestamp=timestamp,
+                    ),
                 )
-            ))
-            self._event_bus.trigger_event(SensorEvent(
-                entity_id=f"{self._id}_water",
-                state=SensorState(
-                    id=f"{self._id}_water",
-                    name=f"{self._name} Water",
-                    state=self.get_total_water(),
-                    unit="L",
-                    timestamp=timestamp,
+            )
+            self._event_bus.trigger_event(
+                SensorEvent(
+                    entity_id=f"{self._id}_water",
+                    state=SensorState(
+                        id=f"{self._id}_water",
+                        name=f"{self._name} Water",
+                        state=self.get_total_water(),
+                        unit="L",
+                        timestamp=timestamp,
+                    ),
                 )
-            ))
-        
+            )
+
         self._message_bus.send_message(
             topic=self._sensor_topic,
             payload=payload,

{boneio-1.3.0.dev14 → boneio-1.3.0.dev16}/boneio/core/config/migrations/__init__.py

@@ -17,7 +17,7 @@ from dataclasses import dataclass, field
 _LOGGER = logging.getLogger(__name__)
 
 # Current schema version — bump this when adding new migrations
-CURRENT_SCHEMA_VERSION = 2
+CURRENT_SCHEMA_VERSION = 3
 
 # Minimum app version that introduced each schema version.
 # Used by the WebUI to warn before rolling back to an incompatible version.
@@ -25,6 +25,7 @@ SCHEMA_VERSION_APP_MAP: dict[int, str] = {
     0: "1.0.0",       # original schema
     1: "1.2.0dev1",   # proxy_port rename
     2: "1.3.0dev1",   # transition timeperiod
+    3: "1.3.0dev7",   # irrigation section
 }
 
 

{boneio-1.3.0.dev14 → boneio-1.3.0.dev16}/boneio/core/config/yaml_util.py

@@ -954,7 +954,7 @@ def _full_config_validation(config_file: str, config_yaml: dict) -> dict:
     v = CustomValidator(schema, purge_unknown=True)
     _LOGGER.debug("[STARTUP TIMING] CustomValidator init: %.2fs", _time.monotonic() - _t2)
     
-    # Check if config was created by a newer app version (soft block)
+    # Check if config was created by a newer app version (downgrade scenario)
     from boneio.core.config.migrations import (
         CURRENT_SCHEMA_VERSION as _CURRENT_SCHEMA,
     )
@@ -962,7 +962,8 @@ def _full_config_validation(config_file: str, config_yaml: dict) -> dict:
         get_config_version as _get_cv,
     )
     _cv = _get_cv(config_yaml)
-    if _cv > _CURRENT_SCHEMA:
+    _is_downgraded = _cv > _CURRENT_SCHEMA
+    if _is_downgraded:
         _LOGGER.warning(
             "Config version %d is newer than supported schema version %d. "
             "This config was created by a newer version of boneIO. "
@@ -989,16 +990,26 @@ def _full_config_validation(config_file: str, config_yaml: dict) -> dict:
     # Finally validate
     _t6 = _time.monotonic()
     if not v.validate(merged_doc, schema):  # type: ignore[attr-defined]
-        error_msg = "Configuration validation failed:\n"
-        for field, errors in v.errors.items():  # type: ignore[attr-defined]
-            error_lines = []
-            if "line" in v.errors[field][0]:  # type: ignore[attr-defined]
-                error_lines = [
-                    f"{v.errors[field][0]['line']+1}: {line}"  # type: ignore[attr-defined]
-                    for line in config_yaml.splitlines()[v.errors[field][0]["line"]-1:v.errors[field][0]["line"]+1]  # type: ignore[attr-defined]
-                ]
-            error_msg += f"\n- {field}: {errors}\n{', '.join(error_lines)}"
-        raise ConfigurationException(error_msg)
+        if _is_downgraded:
+            # Downgrade scenario: log validation errors as warnings and continue
+            # with the validated document (cerberus keeps valid fields).
+            _LOGGER.warning(
+                "Config validation errors (ignored due to downgrade from schema v%d): %s",
+                _cv, v.errors,
+            )
+            # Use the validated document which has unknown fields purged
+            merged_doc = v.document  # type: ignore[attr-defined]
+        else:
+            error_msg = "Configuration validation failed:\n"
+            for field, errors in v.errors.items():  # type: ignore[attr-defined]
+                error_lines = []
+                if "line" in v.errors[field][0]:  # type: ignore[attr-defined]
+                    error_lines = [
+                        f"{v.errors[field][0]['line']+1}: {line}"  # type: ignore[attr-defined]
+                        for line in config_yaml.splitlines()[v.errors[field][0]["line"]-1:v.errors[field][0]["line"]+1]  # type: ignore[attr-defined]
+                    ]
+                error_msg += f"\n- {field}: {errors}\n{', '.join(error_lines)}"
+            raise ConfigurationException(error_msg)
     _LOGGER.debug("[STARTUP TIMING] v.validate: %.2fs", _time.monotonic() - _t6)
     
     # Save to cache for next startup

{boneio-1.3.0.dev14 → boneio-1.3.0.dev16}/boneio/core/manager/irrigation.py

@@ -105,7 +105,7 @@ class IrrigationManager:
             return None
 
         run_duration = int(parse_time_to_seconds(zone_cfg.get("run_duration"), 60))
-        run_duration = max(1, run_duration)
+        run_duration = max(60, run_duration)
 
         run_every_n = int(zone_cfg.get("run_every_n", 1))
         run_every_n = max(1, run_every_n)
@@ -535,9 +535,9 @@ class IrrigationManager:
                     suffix=f"zone/{zone.id}/duration",
                     name=f"{ctrl.name} {zone.name} Duration",
                     min_val=1,
-                    max_val=86400,
+                    max_val=1440,
                     step=1,
-                    unit="s",
+                    unit="min",
                     config_helper=cfg,
                 ),
             )

{boneio-1.3.0.dev14 → boneio-1.3.0.dev16}/boneio/core/manager/update.py

@@ -269,17 +269,19 @@ class UpdateManager(AsyncUpdater):
         latest_version = update_info.get("latest_version", current_version)
         
         # Build state payload (JSON format for HA Update entity)
+        # Always include in_progress/update_percentage to clear any retained
+        # progress state left by a previous update (e.g., after restart).
         state_payload = {
             "installed_version": current_version,
             "latest_version": latest_version,
             "title": "boneIO Black Firmware",
             "release_url": update_info.get("release_url", ""),
             "release_summary": update_info.get("release_notes", "")[:255],  # HA limit
+            "entity_picture": "http://boneio.eu/logo_fb_circle.png",
+            "in_progress": False,
+            "update_percentage": None,
         }
         
-        # Add entity_picture (boneIO logo from HA brands)
-        state_payload["entity_picture"] = "http://boneio.eu/logo_fb_circle.png"
-        
         # Convert to JSON
         payload_json = json.dumps(state_payload)
         
@@ -535,7 +537,10 @@ class UpdateManager(AsyncUpdater):
             if on_progress:
                 on_progress(100, "Update complete!", "Restarting service in 2 seconds...")
             
-            await asyncio.sleep(2)
+            # Wait long enough for MQTT to drain the final state message
+            # before killing the process. Short delays risk the retained
+            # "in_progress" message persisting in the broker.
+            await asyncio.sleep(5)
             
             _LOGGER.info("Restarting BoneIO service after update...")
             os._exit(0)

boneio-1.3.0.dev16/boneio/version.py

@@ -0,0 +1,2 @@
+# flake8: noqa
+__version__ = "1.3.0dev16"