Merge pull request #59 from rleschuk/main

версия 0.3.12

Author: rleschuk

custom_components/haier_evo/api.py

@@ -215,7 +215,7 @@ def save_tokens(self) -> None:
         except Exception as e:
             _LOGGER.error(f"Failed to save tokens file: {e}")
         else:
-            _LOGGER.info(f"Saved tokens file: {filename}")
+            _LOGGER.debug(f"Saved tokens file: {filename}")
 
     def clear_tokens(self) -> None:
         self.token = None
@@ -284,7 +284,7 @@ def make_request(self, method: str, url: str, **kwargs) -> requests.Response:
     def auth_login(self) -> AuthResponse:
         try:
             path = urljoin(C.API_PATH, C.API_LOGIN)
-            _LOGGER.info(f"Logging in to {path} with email {self.email}")
+            _LOGGER.debug(f"Logging in to {path} with email {self.email}")
             response = AuthResponse(self.make_request('POST', path, data={
                 'email': self.email,
                 'password': self.password
@@ -418,7 +418,7 @@ def pull_device_data(self, device_mac: str) -> dict:
                 headers={"X-Auth-token": self.token},
                 timeout=C.API_TIMEOUT
             )
-            _LOGGER.info(f"Update device {device_mac} status code: {response.status_code}")
+            _LOGGER.debug(f"Update device {device_mac} status code: {response.status_code}")
             _LOGGER.debug(response.text)
             response.raise_for_status()
             data = response.json()
@@ -542,12 +542,12 @@ def connect(self) -> None:
             try:
                 self.socket_status = SocketStatus.INITIALIZING
                 self._init_ws()
-                self.socket_app.run_forever(ping_interval=30, ping_timeout=2)
+                self.socket_app.run_forever(ping_interval=10, ping_timeout=2)
             except WebSocketException: # socket is already opened
                 pass
             except Exception as e:
                 _LOGGER.error(f"Error connecting to websocket: {e}")
-        _LOGGER.info("Connection stoped")
+        _LOGGER.debug("Connection stoped")
 
     def connect_in_thread(self) -> None:
         self.socket_thread = thread = threading.Thread(target=self.connect)

custom_components/haier_evo/binary_sensor.py

@@ -17,7 +17,7 @@ async def async_setup_entry(hass: HomeAssistant, config_entry, async_add_entitie
 
 
 class HaierBinarySensor(BinarySensorEntity):
-    # _attr_should_poll = False
+    _attr_should_poll = False
 
     def __init__(self, device: api.HaierDevice) -> None:
         self._device = weakref.proxy(device)

custom_components/haier_evo/config.py

@@ -50,7 +50,7 @@ def _load_config_file(self) -> None:
             _LOGGER.error(f"Failed to load config: {e}")
             self._config = {}
         else:
-            _LOGGER.info("Loaded device config %s", fname)
+            _LOGGER.debug("Loaded device config %s", fname)
 
     def to_dict(self) -> dict:
         return {

custom_components/haier_evo/devices/HEC07HRC03R.yaml

@@ -1,15 +1,4 @@
 attributes:
-  - name: mode
-    id: "5"
-    mappings:
-      - haier: "0"
-        value: "auto"
-      - haier: "1"
-        value: "cool"
-      - haier: "2"
-        value: "dry"
-      - haier: "4"
-        value: "heat"
   - name: swing_mode
     id: "8"
     mappings:

custom_components/haier_evo/devices/HEC09HRC03R.yaml

@@ -1,15 +1,4 @@
 attributes:
-  - name: mode
-    id: "5"
-    mappings:
-      - haier: "0"
-        value: "auto"
-      - haier: "1"
-        value: "cool"
-      - haier: "2"
-        value: "dry"
-      - haier: "4"
-        value: "heat"
   - name: swing_mode
     id: "8"
     mappings:

custom_components/haier_evo/manifest.json

@@ -9,6 +9,6 @@
   "iot_class": "cloud_polling",
   "issue_tracker": "https://github.com/and7ey/haier_evo/issues",
   "requirements": ["requests"],
-  "version": "0.3.11",
+  "version": "0.3.12",
   "zeroconf": []
 }

custom_components/haier_evo/select.py

@@ -17,10 +17,12 @@ async def async_setup_entry(hass: HomeAssistant, config_entry, async_add_entitie
 
 
 class HaierSelect(SelectEntity):
+    _attr_should_poll = False
     _attr_icon = "mdi:format-list-bulleted"
 
     def __init__(self, device: api.HaierDevice) -> None:
         self._device = weakref.proxy(device)
+        self._device_attr_name = None
         self._attr_options = []
 
         device.add_write_ha_state_callback(self.async_write_ha_state)
@@ -33,76 +35,55 @@ def device_info(self) -> dict:
     def available(self) -> bool:
         return self._device.available
 
+    @property
+    def current_option(self) -> str:
+        return getattr(self._device, self._device_attr_name, None)
+
     async def async_select_option(self, option: str) -> None:
-        if option not in self.options:
-            raise ValueError(f"{option} is not a valid option")
         await self.hass.async_add_executor_job(self.set_option, option)
-        self.async_write_ha_state()
 
     def set_option(self, value) -> None:
-        pass
+        method = getattr(self._device, f"set_{self._device_attr_name}", None)
+        if method is not None:
+            method(value)
 
 
 class HaierACEcoSensorSelect(HaierSelect):
     _attr_translation_key = "conditioner_eco_sensor"
 
     def __init__(self, device: api.HaierAC) -> None:
         super().__init__(device)
+        self._device_attr_name = "eco_sensor"
         self._attr_unique_id = f"{device.device_id}_{device.device_model}_eco_sensor"
         self._attr_name = f"{device.device_name} Эко-датчик"
         self._attr_options = device.get_eco_sensor_options()
 
-    @property
-    def current_option(self) -> str:
-        return self._device.eco_sensor
-
-    def set_option(self, value) -> None:
-        self._device.set_eco_sensor(value)
-
 
 class HaierREFFridgeModeSelect(HaierSelect):
 
     def __init__(self, device: api.HaierREF) -> None:
         super().__init__(device)
+        self._device_attr_name = "fridge_mode"
         self._attr_unique_id = f"{device.device_id}_{device.device_model}_fridge_mode_select"
         self._attr_name = f"{device.device_name} Режим холодильной камеры"
         self._attr_options = device.get_fridge_mode_options()
 
-    @property
-    def current_option(self) -> str:
-        return self._device.fridge_mode
-
-    def set_option(self, value) -> None:
-        self._device.set_fridge_mode(value)
-
 
 class HaierREFFreezerModeSelect(HaierSelect):
 
     def __init__(self, device: api.HaierREF) -> None:
         super().__init__(device)
+        self._device_attr_name = "freezer_mode"
         self._attr_unique_id = f"{device.device_id}_{device.device_model}_freezer_mode_select"
         self._attr_name = f"{device.device_name} Режим морозильной камеры"
         self._attr_options = device.get_freezer_mode_options()
 
-    @property
-    def current_option(self) -> str:
-        return self._device.freezer_mode
-
-    def set_option(self, value) -> None:
-        self._device.set_freezer_mode(value)
-
 
 class HaierREFMyZoneSelect(HaierSelect):
 
     def __init__(self, device: api.HaierREF) -> None:
         super().__init__(device)
+        self._device_attr_name = "my_zone"
         self._attr_unique_id = f"{device.device_id}_{device.device_model}_my_zone"
         self._attr_name = f"{device.device_name} My Zone"
         self._attr_options = device.get_my_zone_options()
-
-    @property
-    def current_option(self) -> str:
-        return self._device.my_zone
-
-    def set_option(self, value) -> None:
-        self._device.set_my_zone(value)

custom_components/haier_evo/sensor.py

@@ -23,7 +23,6 @@ class HaierSensor(SensorEntity):
     def __init__(self, device: api.HaierDevice):
         self._device = weakref.proxy(device)
         self._device_attr_name = None
-        self._attr_is_on = False
 
         device.add_write_ha_state_callback(self.async_write_ha_state)
 

custom_components/haier_evo/switch.py

@@ -18,18 +18,14 @@ async def async_setup_entry(hass: HomeAssistant, config_entry, async_add_entitie
 
 
 class HaierSwitch(SwitchEntity):
-    # _attr_should_poll = False
+    _attr_should_poll = False
     _attr_icon = "mdi:toggle-switch"
 
     def __init__(self, device: api.HaierDevice) -> None:
         self._device = weakref.proxy(device)
         self._device_attr_name = None
-        self._attr_is_on = False
 
-        def write_ha_state_callback():
-            self.update_state()
-            self.async_write_ha_state()
-        device.add_write_ha_state_callback(write_ha_state_callback)
+        device.add_write_ha_state_callback(self.async_write_ha_state)
 
     @property
     def device_info(self) -> dict:
@@ -41,8 +37,6 @@ def available(self) -> bool:
 
     async def async_turn_on(self, **kwargs):
         await self.hass.async_add_executor_job(self.turn_on)
-        self._attr_is_on = True
-        self.async_write_ha_state()
 
     def turn_on(self) -> None:
         method = getattr(self._device, f"set_{self._device_attr_name}", None)
@@ -51,19 +45,15 @@ def turn_on(self) -> None:
 
     async def async_turn_off(self, **kwargs):
         await self.hass.async_add_executor_job(self.turn_off)
-        self._attr_is_on = False
-        self.async_write_ha_state()
 
     def turn_off(self, **kwargs) -> None:
         method = getattr(self._device, f"set_{self._device_attr_name}", None)
         if method is not None:
             method(False)
 
-    def update_state(self) -> None:
-        self._attr_is_on = bool(getattr(self._device, self._device_attr_name, None))
-
-    async def async_update(self):
-        self.update_state()
+    @property
+    def is_on(self) -> bool:
+        return bool(getattr(self._device, self._device_attr_name, None))
 
 
 class HaierACLightSwitch(HaierSwitch):