boneIO 1.0.0.dev7__py3-none-any.whl → 1.0.0.dev8__py3-none-any.whl

boneio/components/output/basic.py

@@ -2,7 +2,6 @@
 from __future__ import annotations
 
 import asyncio
-import json
 import logging
 import time
 
@@ -12,147 +11,11 @@ from boneio.models.events import OutputEvent
 from boneio.core.events import EventBus, async_track_point_in_time, utcnow
 from boneio.integration.interlock import SoftwareInterlockManager
 from boneio.core.utils import callback
-from boneio.core.messaging.basic import MessageBus
 from boneio.models import OutputState
 
 _LOGGER = logging.getLogger(__name__)
 
 
-class VirtualEnergySensor:
-
-    def __init__(self, message_bus: MessageBus, loop: asyncio.AbstractEventLoop, topic_prefix: str, parent: BasicOutput, virtual_power_usage: float | None = None, virtual_volume_flow_rate: float | None = None):
-        self._loop = loop or asyncio.get_running_loop()
-        self._message_bus = message_bus
-        self._virtual_sensors_task = None
-        self._parent = parent
-        self._virtual_power_usage = virtual_power_usage
-        self._virtual_volume_flow_rate = virtual_volume_flow_rate
-        # --- Virtual energy counter ---
-        self._energy_consumed_Wh = 0.0
-        self._water_consumed_L = 0.0
-        self._last_on_timestamp = time.time() if self._parent.state == ON else None
-        self._virtual_energy_topic = f"{topic_prefix}/energy/{self._parent.id}"
-        self._subscribe_restore_energy_state()
-
-    def start_virtual_sensors_task(self):
-        """Start periodic task to update and send virtual energy state every 30 seconds."""
-        self._last_on_timestamp = time.time()
-        if self._virtual_sensors_task is not None and not self._virtual_sensors_task.done():
-            return  # Already running
-        self._virtual_sensors_task = self._loop.create_task(self._virtual_sensors_loop())
-        _LOGGER.info(f"Started periodic virtual sensors task for {self._parent.id}")
-
-    def stop_virtual_sensors_task(self):
-        """Stop periodic virtual energy update task."""
-        self._last_on_timestamp = None
-        if self._virtual_sensors_task is not None:
-            self._virtual_sensors_task.cancel()
-            self._virtual_sensors_task = None
-            self._update_virtual_sensors()
-            _LOGGER.info(f"Stopped periodic virtual sensors task for {self._parent.id}")
-
-    @property
-    def last_on_timestamp(self) -> float | None:
-        return self._last_on_timestamp
-
-    @property
-    def virtual_power_usage(self) -> float | None:
-        return self._virtual_power_usage
-
-    @property
-    def virtual_volume_flow_rate(self) -> float | None:
-        return self._virtual_volume_flow_rate
-
-    async def _virtual_sensors_loop(self):
-        """Periodically update and send virtual energy state every 30 seconds while relay is ON."""
-        try:
-            while self._parent.state == ON:
-                self._update_virtual_sensors()
-                await asyncio.sleep(30)
-        except asyncio.CancelledError:
-            pass
-
-    def _update_virtual_sensors(self):
-        """Update virtual sensors if virtual_power_usage is set."""
-        if self.virtual_power_usage is not None or self.virtual_volume_flow_rate is not None:
-            self._update_virtual_energy()
-            self.send_virtual_energy_state()
-
-
-    def _update_virtual_energy(self):
-        """Update energy counter if virtual_power_usage is set."""
-        now = time.time()
-        if self._parent.state == ON and self._last_on_timestamp is not None:
-            elapsed = now - self._last_on_timestamp
-            if self.virtual_power_usage is not None:
-                self._energy_consumed_Wh += (self.virtual_power_usage * elapsed) / 3600.0
-                _LOGGER.debug(f"Energy updated for {self._parent.id}: {self._energy_consumed_Wh:.4f} Wh")
-            if self.virtual_volume_flow_rate is not None:
-                self._water_consumed_L += (self.virtual_volume_flow_rate * elapsed) / 3600.0
-                _LOGGER.debug(f"Volume flow rate updated for {self._parent.id}: {self._water_consumed_L:.4f} L")
-            self._last_on_timestamp = now
-
-    def _subscribe_restore_energy_state(self):
-        """
-        Subscribe to the retained MQTT topic for energy and restore state if available.
-        """
-        async def on_energy_message(_topic, payload):
-            try:
-                payload = json.loads(payload)
-                if isinstance(payload, dict):
-                    if "energy" in payload:
-                        retained_energy_wh = float(payload["energy"])
-                        self._energy_consumed_Wh = retained_energy_wh
-                        _LOGGER.info(f"Restored energy state for {self._parent.id} from MQTT: {self._energy_consumed_Wh:.4f} Wh")
-                    if "water" in payload:
-                        retained_water_consumption_L = float(payload["water"])
-                        self._water_consumed_L = retained_water_consumption_L
-                        _LOGGER.info(f"Restored water consumption state for {self._parent.id} from MQTT: {self._water_consumed_L:.4f} L")
-                else:
-                    _LOGGER.warning(f"Invalid retained payload for {self._parent.id}: {payload}")
-            except Exception as e:
-                _LOGGER.warning(f"Failed to restore energy state for {self._parent.id} from MQTT: {e}")
-            finally:
-                await self._message_bus.unsubscribe_and_stop_listen(self._virtual_energy_topic)
-        # Subscribe (works for both LocalMessageBus and MQTTClient)
-        if hasattr(self, '_message_bus') and self._message_bus is not None:
-            asyncio.create_task(self._message_bus.subscribe_and_listen(self._virtual_energy_topic, on_energy_message))
-        else:
-            _LOGGER.warning(f"Message bus not available for {self._parent.id}, cannot subscribe for retained energy.")
-
-    def get_virtual_power(self) -> float:
-        """Return current virtual power usage in W."""
-        return (self.virtual_power_usage or 0.0) if self._parent.state == ON else 0.0
-
-    def get_virtual_energy(self) -> float:
-        """Return current virtual energy in Wh."""
-        return round(self._energy_consumed_Wh, 3)
-
-    def get_virtual_volume_flow_rate(self) -> float:
-        """Return current virtual volume flow rate in L/h."""
-        return (self.virtual_volume_flow_rate or 0.0) if self._parent.state == ON else 0.0
-
-    def get_virtual_water_consumption(self) -> float:
-        """Return current virtual water consumption in L."""
-        return round(self._water_consumed_L, 3)
-
-    def send_virtual_energy_state(self):
-        """Send virtual power/energy state to MQTT for Home Assistant."""
-        payload = {}
-        if self.virtual_power_usage is not None:
-            payload["power"] = self.get_virtual_power()
-            payload["energy"] = self.get_virtual_energy()
-        if self.virtual_volume_flow_rate is not None:
-            payload["volume_flow_rate"] = self.get_virtual_volume_flow_rate()
-            payload["water"] = self.get_virtual_water_consumption()
-        self._message_bus.send_message(
-            topic=f"{self._virtual_energy_topic}",
-            payload=payload,
-            retain=True,
-        )
-        _LOGGER.info(f"Sent virtual energy state for {self._parent.id}: {payload}")
-
-
 class BasicOutput(BasicMqtt):
     """Basic output class (relay, switch, light, PWM).
     
@@ -166,7 +29,6 @@ class BasicOutput(BasicMqtt):
 
     def __init__(
         self,
-        # callback: Callable[[OutputState], Awaitable[None]],
         id: str,
         event_bus: EventBus,
         topic_prefix: str,
@@ -178,14 +40,9 @@ class BasicOutput(BasicMqtt):
         interlock_groups: list[str] = [],
         **kwargs,
     ) -> None:
-        """Initialize Basic relay.
-        Supports virtual_power_usage for energy monitoring.
-        """
+        """Initialize Basic output."""
         self._momentary_turn_on = kwargs.pop("momentary_turn_on", None)
         self._momentary_turn_off = kwargs.pop("momentary_turn_off", None)
-        virtual_power_usage = kwargs.pop("virtual_power_usage", None)
-        virtual_volume_flow_rate = kwargs.pop("virtual_volume_flow_rate", None)
-        # No parsing needed, Cerberus coerce handles conversion to watts.
         super().__init__(id=id, name=name or id, topic_type=topic_type, topic_prefix=topic_prefix, **kwargs)
         self._output_type: str = output_type
         self._event_bus: EventBus = event_bus
@@ -195,45 +52,23 @@ class BasicOutput(BasicMqtt):
             self._momentary_turn_on = None
             self._momentary_turn_off = None
         self._state = ON if restored_state else OFF
-        # self._callback = callback
         self._momentary_action = None
         self._last_timestamp = 0.0
         self._loop = asyncio.get_running_loop()
         
-        # Subscribe to retained MQTT energy value
-        self._virtual_energy_sensor = None
-        if virtual_power_usage is not None or virtual_volume_flow_rate is not None:
-            self._virtual_energy_sensor = VirtualEnergySensor(
-                message_bus=self._message_bus,
-                loop=self._loop,
-                topic_prefix=topic_prefix,
-                parent=self,
-                virtual_power_usage=virtual_power_usage,
-                virtual_volume_flow_rate=virtual_volume_flow_rate,
-            )
-            self._virtual_sensors_task = None
-        
         # HA area/room assignment (set by OutputManager)
         self.area: str | None = None
 
     def set_interlock(self, interlock_manager: SoftwareInterlockManager, interlock_groups: list[str]):
+        """Set interlock manager and groups."""
         self._interlock_manager = interlock_manager
         self._interlock_groups = interlock_groups
 
-
     @property
     def is_mcp_type(self) -> bool:
         """Check if relay is mcp type."""
         return False
 
-    @property
-    def is_virtual_power(self) -> bool:
-        return self._virtual_energy_sensor is not None and self._virtual_energy_sensor.virtual_power_usage is not None
-
-    @property
-    def is_virtual_volume_flow_rate(self) -> bool:
-        return self._virtual_energy_sensor is not None and self._virtual_energy_sensor.virtual_volume_flow_rate is not None
-
     @property
     def output_type(self) -> str:
         """HA type."""
@@ -291,11 +126,6 @@ class BasicOutput(BasicMqtt):
                 payload={STATE: state},
                 retain=True,
             )
-            if self._virtual_energy_sensor and not optimized_value:
-                if state == ON:
-                    self._virtual_energy_sensor.start_virtual_sensors_task()
-                elif self._virtual_energy_sensor.last_on_timestamp is not None:
-                    self._virtual_energy_sensor.stop_virtual_sensors_task()
         if optimized_value:
             return
         self._last_timestamp = time.time()

boneio/components/sensor/__init__.py

@@ -5,7 +5,9 @@ hardware drivers with business logic.
 """
 
 from boneio.components.sensor.system import SerialNumberSensor
+from boneio.components.sensor.virtual_energy import VirtualEnergySensor
 
 __all__ = [
     "SerialNumberSensor",
+    "VirtualEnergySensor",
 ]

boneio/components/sensor/virtual_energy.py

@@ -0,0 +1,292 @@
+"""Virtual Energy Sensor module.
+
+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
+import json
+import logging
+import time
+from typing import TYPE_CHECKING
+
+from boneio.const import ON
+from boneio.models import SensorState
+from boneio.models.events import SensorEvent
+
+if TYPE_CHECKING:
+    from boneio.core.messaging.basic import MessageBus
+    from boneio.core.events.bus import EventBus
+    from boneio.components.output.basic import BasicOutput
+
+_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
+        output: The output to track
+        message_bus: MessageBus for MQTT communication
+        loop: Event loop
+        topic_prefix: MQTT topic prefix
+        sensor_type: 'power' or 'water'
+        power_usage: Power consumption in Watts (for sensor_type='power')
+        flow_rate: Flow rate in L/h (for sensor_type='water')
+        area: Optional area ID for HA sub-device
+    """
+
+    def __init__(
+        self,
+        id: str,
+        name: str,
+        output: BasicOutput,
+        message_bus: MessageBus,
+        event_bus: "EventBus",
+        loop: asyncio.AbstractEventLoop,
+        topic_prefix: str,
+        sensor_type: str,
+        power_usage: float | None = None,
+        flow_rate: float | None = None,
+        area: str | None = None,
+    ):
+        self._id = id
+        self._name = name
+        self._output = output
+        self._loop = loop or asyncio.get_running_loop()
+        self._message_bus = message_bus
+        self._event_bus = event_bus
+        self._topic_prefix = topic_prefix
+        self._sensor_type = sensor_type
+        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
+        
+        # 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
+        )
+
+    @property
+    def id(self) -> str:
+        """Get sensor ID."""
+        return self._id
+
+    @property
+    def name(self) -> str:
+        """Get sensor name."""
+        return self._name
+
+    @property
+    def output_id(self) -> str:
+        """Get linked output ID."""
+        return self._output.id
+
+    @property
+    def sensor_type(self) -> str:
+        """Get sensor type ('power' or 'water')."""
+        return self._sensor_type
+
+    @property
+    def area(self) -> str | None:
+        """Get area ID."""
+        return self._area
+
+    @property
+    def power_usage(self) -> float | None:
+        """Get power usage in Watts."""
+        return self._power_usage
+
+    @property
+    def flow_rate(self) -> float | None:
+        """Get flow rate in L/h."""
+        return self._flow_rate
+
+    @property
+    def last_on_timestamp(self) -> float | None:
+        """Get timestamp when output was last turned ON."""
+        return self._last_on_timestamp
+
+    def start_tracking(self):
+        """Start tracking consumption (called when output turns ON)."""
+        self._last_on_timestamp = time.time()
+        if self._virtual_sensors_task is not None and not self._virtual_sensors_task.done():
+            return  # Already running
+        self._virtual_sensors_task = self._loop.create_task(self._tracking_loop())
+        _LOGGER.debug("Started tracking for virtual sensor %s", self._id)
+
+    def stop_tracking(self):
+        """Stop tracking consumption (called when output turns OFF)."""
+        # 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()
+        _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:
+            while self._output.state == ON:
+                self._update_consumption()
+                self._send_state()
+                await asyncio.sleep(30)
+        except asyncio.CancelledError:
+            pass
+
+    def _update_consumption(self):
+        """Update consumption counters based on elapsed time."""
+        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
+                )
+            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
+                )
+            
+            self._last_on_timestamp = now
+
+    def _subscribe_restore_state(self):
+        """Subscribe to retained MQTT topic to restore state on startup."""
+        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
+                        )
+                    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
+                        )
+            except Exception as e:
+                _LOGGER.warning("Failed to restore state for %s: %s", self._id, e)
+            finally:
+                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)
+            )
+
+    def get_current_power(self) -> float:
+        """Get current power usage in W (0 if output is OFF)."""
+        if self._sensor_type != "power":
+            return 0.0
+        return (self._power_usage or 0.0) if self._output.state == ON else 0.0
+
+    def get_total_energy(self) -> float:
+        """Get total energy consumed in Wh."""
+        return round(self._energy_consumed_Wh, 3)
+
+    def get_current_flow_rate(self) -> float:
+        """Get current flow rate in L/h (0 if output is OFF)."""
+        if self._sensor_type != "water":
+            return 0.0
+        return (self._flow_rate or 0.0) if self._output.state == ON else 0.0
+
+    def get_total_water(self) -> float:
+        """Get total water consumed in L."""
+        return round(self._water_consumed_L, 3)
+
+    def _send_state(self):
+        """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}_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}_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,
+            retain=True,
+        )
+        _LOGGER.debug("Sent state for %s: %s", self._id, payload)

boneio/const.py

@@ -166,6 +166,7 @@ cover_actions = {
 }
 
 INA219 = "ina219"
+VIRTUAL_ENERGY_SENSOR = "virtual_energy_sensor"
 PINS = {
     # Based on boneio/boards/0.8/input.yaml
     "P8_37": {"chip": 1, "line": 14},

boneio/core/config/config_helper.py

@@ -38,6 +38,7 @@ class ConfigHelper:
         network_info: dict = {},
         is_web_active: bool = False,
         web_port: int = 8090,
+        nginx_proxy_port: int | None = None,
         config_file_path: str | None = None,
     ):
         self._name = name
@@ -47,6 +48,7 @@ class ConfigHelper:
         self._ha_discovery_prefix = ha_discovery_prefix
         self._device_type = device_type
         self._web_port = web_port
+        self._nginx_proxy_port = nginx_proxy_port
         self._fetch_old_discovery = None
         self._autodiscovery_messages = {
             SWITCH: {},
@@ -113,6 +115,16 @@ class ConfigHelper:
     def web_port(self) -> int:
         return self._web_port
 
+    @property
+    def nginx_proxy_port(self) -> int | None:
+        """Get nginx proxy port if configured."""
+        return self._nginx_proxy_port
+
+    @property
+    def ha_configuration_port(self) -> int:
+        """Get port for HA discovery URL. Uses nginx_proxy_port if set, otherwise web_port."""
+        return self._nginx_proxy_port if self._nginx_proxy_port else self._web_port
+
     @property
     def topic_prefix(self) -> str:
         return self._topic_prefix

boneio/core/config/yaml_util.py

@@ -892,6 +892,21 @@ def update_config_section(config_file: str, section: str, data: dict | list) ->
     
     _LOGGER.info(f"Updating section '{section}' with data: {data}")
     
+    # Special handling for mcp23017 - convert hex strings to integers
+    # This ensures YAML writes them as integers which are then read back as hex
+    if section == 'mcp23017' and isinstance(data, list):
+        for entry in data:
+            if isinstance(entry, dict) and 'address' in entry:
+                addr = entry['address']
+                if isinstance(addr, str):
+                    if addr.startswith('0x') or addr.startswith('0X'):
+                        entry['address'] = int(addr, 16)
+                    else:
+                        try:
+                            entry['address'] = int(addr, 10)
+                        except ValueError:
+                            pass  # Keep as string if conversion fails
+    
     # Strip default values to keep YAML clean
     cleaned_data = strip_default_values(data, {}, section)
     _LOGGER.info(f"Cleaned data (defaults removed): {cleaned_data}")

boneio/core/manager/inputs.py

@@ -422,8 +422,6 @@ class InputManager:
         - Removing deleted inputs (from internal state and HA Discovery)
         - Adding inputs that use already-registered GPIO pins (e.g., moving from event to binary_sensor)
         """
-        import asyncio
-        
         _LOGGER.info("Reloading input configuration")
         
         # Get new config
@@ -491,9 +489,42 @@ class InputManager:
         # - Add new inputs if their GPIO pin is already registered
         self._configure_inputs(reload_config=True)
         
-        # Signal WebSocket handlers to re-send all input states to clients
-        from boneio.models.events import InputsReloadedEvent
-        self._manager._event_bus.trigger_event(InputsReloadedEvent())
+        # Broadcast all input states to WebSocket clients
+        # Global listeners will receive these events for all inputs (including new ones)
+        self._broadcast_all_input_states()
+    
+    def _broadcast_all_input_states(self) -> None:
+        """Broadcast current state of all inputs via WebSocket.
+        
+        This is called after reload to ensure frontend receives
+        the updated input list immediately.
+        """
+        import time
+        from boneio.models import InputState
+        from boneio.models.events import InputEvent
+        
+        timestamp = time.time()
+        
+        for input_ in self._inputs.values():
+            try:
+                input_state = InputState(
+                    name=input_.name,
+                    state=input_.last_state,
+                    type=input_.input_type,
+                    pin=input_.pin,
+                    timestamp=timestamp,
+                    boneio_input=input_.boneio_input,
+                    area=input_.area
+                )
+                event = InputEvent(
+                    entity_id=input_.id,
+                    state=input_state,
+                    click_type=None,
+                    duration=None
+                )
+                self._manager._event_bus.trigger_event(event)
+            except Exception as e:
+                _LOGGER.debug("Error broadcasting input state %s: %s", input_.id, e)
     
     def _remove_input_ha_discovery(self, input_id: str, old_area: str | None = None) -> None:
         """Remove HA Discovery entries for an input.
@@ -591,7 +622,6 @@ class InputManager:
         # Get the input instance and retrieve actions for this click type
         input_instance = self._inputs.get(event.entity_id)
         if not input_instance:
-            print(self._inputs)
             _LOGGER.warning("Input %s not found for event handling", event.entity_id)
             return