def test_get_properties_splitting(mocker, max_properties):
properties = [i for i in range(20)]
send = mocker.patch("miio.Device.send")
d = Device("127.0.0.1", "68ffffffffffffffffffffffffffffff")
d.get_properties(properties, max_properties=max_properties)
if max_properties is None:
max_properties = len(properties)
assert send.call_count == math.ceil(len(properties) / max_properties)
async def check_miio_device(hass, user_input, errors):
host = user_input.get(CONF_HOST)
token = user_input.get(CONF_TOKEN)
try:
device = MiioDevice(host, token)
info = await hass.async_add_executor_job(device.info)
except DeviceException:
device = None
info = None
errors['base'] = 'cannot_connect'
_LOGGER.debug('Xiaomi Miot config flow: %s', {
'user_input': user_input,
'miio_info': info,
'errors': errors,
})
model = ''
if info is not None:
if not user_input.get(CONF_MODEL):
model = str(info.model or '')
user_input[CONF_MODEL] = model
user_input['miio_info'] = dict(info.raw or {})
miot_type = await MiotSpec.async_get_model_type(hass, model)
if not miot_type:
miot_type = await MiotSpec.async_get_model_type(hass,
model,
use_remote=True)
user_input['miot_type'] = miot_type
user_input['unique_did'] = format_mac(info.mac_address)
if miot_type and device:
try:
pms = [
{
'did': 'miot',
'siid': 2,
'piid': 1
},
{
'did': 'miot',
'siid': 2,
'piid': 2
},
{
'did': 'miot',
'siid': 3,
'piid': 1
},
]
results = device.get_properties(
pms, property_getter='get_properties') or []
for prop in results:
if not isinstance(prop, dict):
continue
if prop.get('code') == 0:
# Collect supported models in LAN
await async_analytics_track_event(
hass,
'miot',
'local',
model,
firmware=info.firmware_version,
results=results,
)
break
except DeviceException:
pass
return user_input
class XjxToilet(BinarySensorEntity):
def __init__(self, name, host, token):
self._name = name
self._device = Device(host, token)
self._state = False
self._state_attrs = {}
device_info = self._device.info()
self._unique_id = "{}-{}".format(device_info.model,
device_info.mac_address)
async def async_update(self):
try:
seating = self._device.get_properties(properties=['seating'])
seatTemp = self._device.get_properties(
properties=['seat_temp', 'status_seatheat'])
statusLed = self._device.get_properties(properties=['status_led'])
self._state = seating[0] == 1
self._state_attrs.update({
"status_seatheat": seatTemp[1] == 1,
"seat_temp": seatTemp[0],
"status_led": statusLed[0] == 1
})
except Exception:
_LOGGER.error('Update state error.', exc_info=True)
@property
def name(self):
"""Return the name of the device if any."""
return self._name
@property
def unique_id(self):
"""Return an unique ID."""
return self._unique_id
@property
def is_on(self) -> bool:
"""Return True if the switch is on based on the state machine."""
if self._state is None:
return False
return self._state
@property
def device_class(self):
"""Return the device class of this entity."""
return DEVICE_CLASS_OCCUPANCY
@property
def device_state_attributes(self):
"""Return the state attributes of the device."""
return self._state_attrs
async def flush_on(self, **kwargs):
try:
self._device.send('flush_on', [])
except DeviceException:
raise PlatformNotReady
async def work_seatheat(self, **kwargs):
try:
self._device.send('work_seatheat', [kwargs["status"]])
# 开启马桶圈加热必须同时发送马桶圈温度命令
if kwargs["status"] == 1:
self._device.send('send_seat_heat', [kwargs["status"]])
except DeviceException:
raise PlatformNotReady
async def work_night_led(self, **kwargs):
try:
self._device.send('work_night_led', [kwargs["status"]])
except DeviceException:
raise PlatformNotReady
