Improve code quality telnet (#65239)

homeassistant/components/telnet/switch.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 from datetime import timedelta
 import logging
 import telnetlib
+from typing import Any
 
 import voluptuous as vol
 
@@ -26,6 +27,7 @@ from homeassistant.const import (
 from homeassistant.core import HomeAssistant
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.helpers.template import Template
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
 _LOGGER = logging.getLogger(__name__)
@@ -60,27 +62,26 @@ def setup_platform(
     discovery_info: DiscoveryInfoType | None = None,
 ) -> None:
     """Find and return switches controlled by telnet commands."""
-    devices = config.get(CONF_SWITCHES, {})
+    devices: dict[str, Any] = config[CONF_SWITCHES]
     switches = []
 
     for object_id, device_config in devices.items():
-        value_template = device_config.get(CONF_VALUE_TEMPLATE)
+        value_template: Template | None = device_config.get(CONF_VALUE_TEMPLATE)
 
         if value_template is not None:
             value_template.hass = hass
 
         switches.append(
             TelnetSwitch(
-                hass,
                 object_id,
-                device_config.get(CONF_RESOURCE),
-                device_config.get(CONF_PORT),
+                device_config[CONF_RESOURCE],
+                device_config[CONF_PORT],
                 device_config.get(CONF_NAME, object_id),
-                device_config.get(CONF_COMMAND_ON),
-                device_config.get(CONF_COMMAND_OFF),
+                device_config[CONF_COMMAND_ON],
+                device_config[CONF_COMMAND_OFF],
                 device_config.get(CONF_COMMAND_STATE),
                 value_template,
-                device_config.get(CONF_TIMEOUT),
+                device_config[CONF_TIMEOUT],
             )
         )
 
@@ -96,82 +97,65 @@ class TelnetSwitch(SwitchEntity):
 
     def __init__(
         self,
-        hass,
-        object_id,
-        resource,
-        port,
-        friendly_name,
-        command_on,
-        command_off,
-        command_state,
-        value_template,
-        timeout,
-    ):
+        object_id: str,
+        resource: str,
+        port: int,
+        friendly_name: str,
+        command_on: str,
+        command_off: str,
+        command_state: str | None,
+        value_template: Template | None,
+        timeout: float,
+    ) -> None:
         """Initialize the switch."""
-        self._hass = hass
         self.entity_id = ENTITY_ID_FORMAT.format(object_id)
         self._resource = resource
         self._port = port
-        self._name = friendly_name
-        self._state = False
+        self._attr_name = friendly_name
+        self._attr_is_on = False
         self._command_on = command_on
         self._command_off = command_off
         self._command_state = command_state
         self._value_template = value_template
         self._timeout = timeout
+        self._attr_should_poll = bool(command_state)
+        self._attr_assumed_state = bool(command_state is None)
 
-    def _telnet_command(self, command):
+    def _telnet_command(self, command: str) -> str | None:
         try:
             telnet = telnetlib.Telnet(self._resource, self._port)
             telnet.write(command.encode("ASCII") + b"\r")
             response = telnet.read_until(b"\r", timeout=self._timeout)
-            _LOGGER.debug("telnet response: %s", response.decode("ASCII").strip())
-            return response.decode("ASCII").strip()
         except OSError as error:
             _LOGGER.error(
                 'Command "%s" failed with exception: %s', command, repr(error)
             )
             return None
+        _LOGGER.debug("telnet response: %s", response.decode("ASCII").strip())
+        return response.decode("ASCII").strip()
 
-    @property
-    def name(self):
-        """Return the name of the switch."""
-        return self._name
-
-    @property
-    def should_poll(self):
-        """Only poll if we have state command."""
-        return self._command_state is not None
-
-    @property
-    def is_on(self):
-        """Return true if device is on."""
-        return self._state
-
-    @property
-    def assumed_state(self):
-        """Return true if no state command is defined, false otherwise."""
-        return self._command_state is None
-
-    def update(self):
+    def update(self) -> None:
         """Update device state."""
+        if not self._command_state:
+            return
         response = self._telnet_command(self._command_state)
-        if response:
+        if response and self._value_template:
             rendered = self._value_template.render_with_possible_json_value(response)
-            self._state = rendered == "True"
         else:
             _LOGGER.warning("Empty response for command: %s", self._command_state)
+            return None
+        self._attr_is_on = rendered == "True"
 
-    def turn_on(self, **kwargs):
+    def turn_on(self, **kwargs) -> None:
         """Turn the device on."""
         self._telnet_command(self._command_on)
         if self.assumed_state:
-            self._state = True
+            self._attr_is_on = True
             self.schedule_update_ha_state()
 
-    def turn_off(self, **kwargs):
+    def turn_off(self, **kwargs) -> None:
         """Turn the device off."""
         self._telnet_command(self._command_off)
         if self.assumed_state:
-            self._state = False
+            self._attr_is_on = False
             self.schedule_update_ha_state()