clear codes

Author: al-one

custom_components/xiaomi_miot/__init__.py

@@ -1335,12 +1335,8 @@ def turn_off(self, **kwargs):
 
     def _update_sub_entities(self, properties, services=None, domain=None, option=None, **kwargs):
         actions = kwargs.get('actions', [])
-        from .sensor import MiotSensorSubEntity
-        from .binary_sensor import MiotBinarySensorSubEntity
-        from .switch import MiotSwitchSubEntity
         from .light import MiotLightSubEntity
-        from .fan import (MiotFanSubEntity, MiotModesSubEntity)
-        from .cover import MiotCoverSubEntity
+        from .fan import MiotFanSubEntity
         if isinstance(services, MiotService):
             sls = [services]
         elif services == '*':
@@ -1351,17 +1347,8 @@ def _update_sub_entities(self, properties, services=None, domain=None, option=No
             sls = [properties.service]
         else:
             sls = [self._miot_service]
-        add_sensors = self._add_entities.get('sensor')
-        add_binary_sensors = self._add_entities.get('binary_sensor')
-        add_switches = self._add_entities.get('switch')
         add_lights = self._add_entities.get('light')
         add_fans = self._add_entities.get('fan')
-        add_covers = self._add_entities.get('cover')
-        add_numbers = self._add_entities.get('number')
-        add_selects = self._add_entities.get('select')
-        add_buttons = self._add_entities.get('button')
-        add_texts = self._add_entities.get('text')
-        add_device_trackers = self._add_entities.get('device_tracker')
         exclude_services = self._state_attrs.get('exclude_miot_services') or []
         for s in sls:
             if s.name in exclude_services:
@@ -1390,88 +1377,6 @@ def _update_sub_entities(self, properties, services=None, domain=None, option=No
                 if new and fnm in self._subs:
                     self._check_same_sub_entity(fnm, domain, add=1)
                     self.logger.debug('%s: Added sub entity %s: %s', self.name_model, domain, fnm)
-                continue
-            pls = []
-            if isinstance(properties, MiotProperty):
-                pls = [properties]
-            if properties:
-                pls.extend(s.get_properties(*cv.ensure_list(properties)))
-            if actions:
-                pls.extend(s.get_actions(*cv.ensure_list(actions)))
-            for p in pls:
-                fnm = p.unique_name
-                opt = {
-                    'unique_id': f'{self.unique_did}-{fnm}',
-                    **(option or {}),
-                }
-                tms = self._check_same_sub_entity(fnm, domain)
-                new = True
-                if fnm in self._subs:
-                    new = False
-                    self._subs[fnm].update_from_parent()
-                    self._check_same_sub_entity(fnm, domain, add=1)
-                elif tms > 0:
-                    if tms <= 1:
-                        self.logger.info('%s: Device sub entity %s: %s already exists.', self.name_model, domain, fnm)
-                elif isinstance(p, MiotAction):
-                    """migrate to converter"""
-                elif add_buttons and domain == 'button' and (p.value_list or p.is_bool):
-                    from .button import MiotButtonSubEntity
-                    nls = []
-                    f = fnm
-                    for pv in p.value_list:
-                        vk = pv.get('value')
-                        f = f'{fnm}-{vk}'
-                        if f in self._subs:
-                            new = False
-                            continue
-                        self._subs[f] = MiotButtonSubEntity(self, p, vk, option=opt)
-                        nls.append(self._subs[f])
-                    if p.is_bool:
-                        self._subs[f] = MiotButtonSubEntity(self, p, True, option=opt)
-                        nls.append(self._subs[f])
-                    if nls:
-                        add_buttons(nls, update_before_add=True)
-                        new = True
-                        fnm = f
-                elif p.full_name not in self._state_attrs and not p.writeable and not kwargs.get('whatever'):
-                    continue
-                elif add_switches and domain == 'switch' and (p.format in ['bool', 'uint8']) and p.writeable:
-                    self._subs[fnm] = MiotSwitchSubEntity(self, p, option=opt)
-                    add_switches([self._subs[fnm]], update_before_add=True)
-                elif add_binary_sensors and domain == 'binary_sensor' and (p.is_bool or p.is_integer):
-                    self._subs[fnm] = MiotBinarySensorSubEntity(self, p, option=opt)
-                    add_binary_sensors([self._subs[fnm]], update_before_add=True)
-                elif add_sensors and domain == 'sensor':
-                    if p.full_name == self._state_attrs.get('state_property'):
-                        continue
-                    self._subs[fnm] = MiotSensorSubEntity(self, p, option=opt)
-                    add_sensors([self._subs[fnm]], update_before_add=True)
-                elif add_fans and domain == 'fan':
-                    self._subs[fnm] = MiotModesSubEntity(self, p, option=opt)
-                    add_fans([self._subs[fnm]], update_before_add=True)
-                elif add_covers and domain == 'cover':
-                    self._subs[fnm] = MiotCoverSubEntity(self, p, option=opt)
-                    add_covers([self._subs[fnm]], update_before_add=True)
-                elif add_numbers and domain in ['number', 'number_select'] and p.value_range:
-                    from .number import MiotNumberSubEntity
-                    self._subs[fnm] = MiotNumberSubEntity(self, p, option=opt)
-                    add_numbers([self._subs[fnm]], update_before_add=True)
-                elif add_selects and domain in ['select', 'number_select'] and (p.value_list or p.value_range):
-                    from .select import MiotSelectSubEntity
-                    self._subs[fnm] = MiotSelectSubEntity(self, p, option=opt)
-                    add_selects([self._subs[fnm]], update_before_add=True)
-                elif add_texts and domain == 'text' and p.writeable:
-                    from .text import MiotTextSubEntity
-                    self._subs[fnm] = MiotTextSubEntity(self, p, option=opt)
-                    add_texts([self._subs[fnm]], update_before_add=True)
-                elif add_device_trackers and domain == 'scanner' and (p.is_bool or p.is_integer):
-                    from .device_tracker import MiotScannerSubEntity
-                    self._subs[fnm] = MiotScannerSubEntity(self, p, option=opt)
-                    add_device_trackers([self._subs[fnm]], update_before_add=True)
-                if new and fnm in self._subs:
-                    self._check_same_sub_entity(fnm, domain, add=1)
-                    self.logger.debug('%s: Added sub entity %s: %s', self.name_model, domain, fnm)
 
     async def async_get_device_data(self, key, did=None, throw=False, **kwargs):
         if did is None:

custom_components/xiaomi_miot/binary_sensor.py

@@ -355,9 +355,3 @@ async def async_update(self):
             adt[self._prop_state.full_name] = self._state
         if adt:
             await self.async_update_attrs(adt)
-
-
-class MiotBinarySensorSubEntity(MiotPropertySubEntity, ToggleSubEntity, BaseEntity):
-    def __init__(self, parent, miot_property: MiotProperty, option=None):
-        ToggleSubEntity.__init__(self, parent, miot_property.full_name, option)
-        super().__init__(parent, miot_property, option, domain=ENTITY_DOMAIN)

custom_components/xiaomi_miot/core/device_customizes.py

@@ -1020,6 +1020,7 @@
         'exclude_miot_services': 'battery',
     },
     'midr.rv_mirror.*': {
+        'binary_sensor_properties': 'driving_status',
         'miio_cloud_props': 'Status,Position',
         'miio_cloud_props_template': 'midr_rv_mirror_cloud_props',
     },
@@ -1599,7 +1600,7 @@
         'number_properties': 'target_temperature,boost_value',
     },
     'xiaomi.wifispeaker.*': {
-        'switch_properties': 'sleep_mode,no_disturb',
+        'switch_properties': 'on,sleep_mode,no_disturb',
         'button_actions': 'wake_up,play_music,tv_switchon,stop_alarm',
         'text_actions': 'play_text,execute_text_directive',
     },

custom_components/xiaomi_miot/cover.py

@@ -246,99 +246,3 @@ def stop_cover(self, **kwargs):
         val = self._prop_motor_control.list_first('Pause', 'Stop')
         val = self.custom_config_integer('stop_cover_value', val)
         return self.set_property(self._prop_motor_control, val)
-
-
-class MiotCoverSubEntity(MiotPropertySubEntity, CoverEntity):
-    def __init__(self, parent, miot_property: MiotProperty, option=None):
-        super().__init__(parent, miot_property, option, domain=ENTITY_DOMAIN)
-        self._prop_status = self._option.get('status_property')
-        if self._prop_status:
-            self._option['keys'] = [*(self._option.get('keys') or []), self._prop_status.full_name]
-        self._prop_target_position = self._miot_service.get_property('target_position')
-        self._value_open = self._miot_property.list_first('Open', 'Up', 'All-up', 'Rise')
-        self._value_close = self._miot_property.list_first('Close', 'Down', 'All-down')
-        self._value_stop = self._miot_property.list_first('Pause', 'Stop')
-        if self._value_open is not None:
-            self._supported_features |= CoverEntityFeature.OPEN
-        if self._value_close is not None:
-            self._supported_features |= CoverEntityFeature.CLOSE
-        if self._value_stop is not None:
-            self._supported_features |= CoverEntityFeature.STOP
-        if self._prop_target_position:
-            self._supported_features |= CoverEntityFeature.SET_POSITION
-        if self._miot_property.value_range:
-            self._supported_features |= CoverEntityFeature.OPEN | CoverEntityFeature.CLOSE
-            self._supported_features |= CoverEntityFeature.SET_POSITION
-
-    @property
-    def current_cover_position(self):
-        """Return current position of cover.
-        None is unknown, 0 is closed, 100 is fully open.
-        """
-        if self._miot_property.value_range:
-            val = round(self._miot_property.from_dict(self._state_attrs) or -1, 2)
-            top = self._miot_property.range_max()
-            return round(val / top * 100)
-
-        prop = self._miot_service.get_property('current_position')
-        if self.custom_config_bool('target2current_position'):
-            prop = self._miot_service.get_property('target_position') or prop
-        if prop:
-            return round(prop.from_dict(self._state_attrs) or -1)
-        return None
-
-    def set_cover_position(self, **kwargs):
-        """Move the cover to a specific position."""
-        pos = round(kwargs.get(ATTR_POSITION) or 0)
-        if self._prop_target_position:
-            return self.set_parent_property(pos, self._prop_target_position)
-        if self._miot_property.value_range:
-            stp = self._miot_property.range_step()
-            top = self._miot_property.range_max()
-            pos = round(top * (pos / 100) / stp) * stp
-            return self.set_parent_property(pos)
-        raise NotImplementedError()
-
-    @property
-    def is_closed(self):
-        """Return if the cover is closed or not."""
-        if self._prop_status:
-            val = self._prop_status.from_dict(self._state_attrs)
-            vls = self._prop_status.list_search('Closed', 'Down')
-            if vls and val is not None:
-                return val in vls
-        pos = self.current_cover_position
-        if pos is not None and pos >= 0:
-            return pos <= 0
-        return None
-
-    def open_cover(self, **kwargs):
-        """Open the cover."""
-        val = None
-        if self._miot_property.value_list:
-            val = self._value_open
-        elif self._miot_property.value_range:
-            val = self._miot_property.range_max()
-        if val is not None:
-            return self.set_parent_property(val)
-        raise NotImplementedError()
-
-    def close_cover(self, **kwargs):
-        """Close cover."""
-        val = None
-        if self._miot_property.value_list:
-            val = self._value_close
-        elif self._miot_property.value_range:
-            val = self._miot_property.range_min()
-        if val is not None:
-            return self.set_parent_property(val)
-        raise NotImplementedError()
-
-    def stop_cover(self, **kwargs):
-        """Stop the cover."""
-        val = None
-        if self._miot_property.value_list:
-            val = self._value_stop
-        if val is not None:
-            return self.set_parent_property(val)
-        raise NotImplementedError()

custom_components/xiaomi_miot/device_tracker.py

@@ -119,9 +119,6 @@ async def async_update(self):
             self._attr_location_name = prop.from_dict(self._state_attrs)
         await self.transform_coord()
 
-        for p in self._miot_service.get_properties('driving_status'):
-            self._update_sub_entities(p, None, 'binary_sensor')
-
     async def transform_coord(self, default=None):
         if not (self._attr_latitude or self._attr_longitude):
             return

custom_components/xiaomi_miot/media_player.py

@@ -339,8 +339,6 @@ def __init__(self, config: dict, miot_service: MiotService):
         self._message_router = miot_service.spec.get_service('message_router')
         self.xiaoai_cloud = None
         self.xiaoai_device = None
-        if self._intelligent_speaker:
-            self._state_attrs[ATTR_ATTRIBUTION] = 'Support TTS through service'
         self._supported_features |= MediaPlayerEntityFeature.PLAY_MEDIA
 
     @property
@@ -360,7 +358,6 @@ async def async_update(self):
         await super().async_update()
         if not self._available:
             return
-        self._update_sub_entities('on', domain='switch')
 
         if self._prop_state and not self._prop_state.readable:
             if self.is_volume_muted is False:

custom_components/xiaomi_miot/sensor.py

@@ -338,45 +338,6 @@ def update(self, data=None):
             self._extra_attrs['updated_time'] = now
 
 
-class MiotSensorSubEntity(MiotPropertySubEntity, BaseSensorSubEntity):
-    def __init__(self, parent, miot_property: MiotProperty, option=None):
-        super().__init__(parent, miot_property, option, domain=ENTITY_DOMAIN)
-        self._attr_state_class = miot_property.state_class
-
-        self._prop_battery = None
-        for s in self._miot_service.spec.get_services('battery', self._miot_service.name):
-            p = s.get_property('battery_level')
-            if p:
-                self._prop_battery = p
-        if self._prop_battery:
-            self._option['keys'] = [*(self._option.get('keys') or []), self._prop_battery.full_name]
-
-    async def async_added_to_hass(self):
-        await BaseSensorSubEntity.async_added_to_hass(self)
-
-    def update(self, data=None):
-        super().update(data)
-        if not self._available:
-            return
-        self.update_with_properties()
-        self._miot_property.description_to_dict(self._state_attrs)
-
-    @property
-    def native_value(self):
-        if not self._attr_native_unit_of_measurement:
-            key = f'{self._miot_property.full_name}_desc'
-            if key in self._state_attrs:
-                return f'{self._state_attrs[key]}'.lower()
-        val = self._miot_property.from_dict(self._state_attrs)
-        if val is not None:
-            svd = self.custom_config_number('value_ratio') or 0
-            if svd:
-                val = round(float(val) * svd, 3)
-            elif self.device_class in [SensorDeviceClass.HUMIDITY, SensorDeviceClass.TEMPERATURE]:
-                val = round(float(val), 3)
-        return val
-
-
 class MihomeMessageSensor(MiCoordinatorEntity, BaseEntity, RestoreEntity):
     _filter_homes = None
     _exclude_types = None

custom_components/xiaomi_miot/switch.py

@@ -121,67 +121,6 @@ def update(self, data=None):
         super().update(data)
 
 
-class MiotSwitchSubEntity(MiotPropertySubEntity, SwitchSubEntity):
-    def __init__(self, parent, miot_property: MiotProperty, option=None):
-        super().__init__(parent, miot_property, option, domain=ENTITY_DOMAIN)
-        self._name = self.format_name_by_property(miot_property)
-        self._prop_power = self._miot_service.get_property('on', 'power')
-        if self._prop_power:
-            self._option['keys'] = [*(self._option.get('keys') or []), self._prop_power.full_name]
-            self._option['icon'] = self._prop_power.entity_icon or self._option.get('icon')
-        self._on_descriptions = ['On', 'Open', 'Enable', 'Enabled', 'Yes', '开', '打开']
-        if des := self.custom_config_list('descriptions_for_on'):
-            self._on_descriptions = des
-
-    @property
-    def is_on(self):
-        val = self._miot_property.from_dict(self._state_attrs)
-        if self._miot_property.value_list:
-            if val is not None:
-                self._state = val in self._miot_property.list_search(*self._on_descriptions)
-        elif self._miot_property.value_range:
-            if self._miot_property.range_min() == 0 and self._miot_property.range_max() == 1:
-                self._state = val == self._miot_property.range_max()
-        elif self._miot_property.format in ['bool']:
-            self._state = val
-
-        if self._miot_service.name in ['air_conditioner']:
-            if self._prop_power:
-                self._state = self._state and self._prop_power.from_dict(self._state_attrs)
-
-        if self._reverse_state and self._state is not None:
-            return not self._state
-        return self._state
-
-    def turn_on(self, **kwargs):
-        val = True
-        if self._miot_property.value_range:
-            val = self._miot_property.range_max()
-        if self._miot_property.value_list:
-            ret = self._miot_property.list_first(*self._on_descriptions)
-            val = 1 if ret is None else ret
-        elif self._miot_property.value_range:
-            val = self._miot_property.range_max()
-        if self._reverse_state:
-            val = not val
-        return self.set_parent_property(val)
-
-    def turn_off(self, **kwargs):
-        val = False
-        if self._miot_property.value_range:
-            val = self._miot_property.range_min()
-        if self._miot_property.value_list:
-            if not (des := self.custom_config_list('descriptions_for_off')):
-                des = ['Off', 'Close', 'Closed', '关', '关闭']
-            ret = self._miot_property.list_first(*des)
-            val = 0 if ret is None else ret
-        elif self._miot_property.value_range:
-            val = self._miot_property.range_min()
-        if self._reverse_state:
-            val = not val
-        return self.set_parent_property(val)
-
-
 class MiotSwitchActionSubEntity(MiotPropertySubEntity, SwitchSubEntity):
     def __init__(self, parent, miot_property: MiotProperty, miot_action: MiotAction, option=None):
         SwitchSubEntity.__init__(self, parent, miot_action.full_name, option)