Home-Assistant
/
core
mirror of https://github.com/home-assistant/core.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add RAPT Bluetooth integration (#87872) 

Co-authored-by: J. Nick Koston <nick@koston.org>
pull/91525/head
Jan Čermák 2023-04-17 05:19:03 +02:00 committed by GitHub
parent 2b6fd0df6a
commit 9680161701
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 648 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CODEOWNERS
View File

@ -963,6 +963,8 @@ build.json @home-assistant/supervisor
/tests/components/rainmachine/ @bachya
/homeassistant/components/random/ @fabaff
/tests/components/random/ @fabaff
/homeassistant/components/rapt_ble/ @sairon
/tests/components/rapt_ble/ @sairon
/homeassistant/components/raspberry_pi/ @home-assistant/core
/tests/components/raspberry_pi/ @home-assistant/core
/homeassistant/components/rdw/ @frenck

49
homeassistant/components/rapt_ble/__init__.py Normal file
View File

@ -0,0 +1,49 @@
"""The rapt_ble integration."""
from __future__ import annotations
import logging
from rapt_ble import RAPTPillBluetoothDeviceData
from homeassistant.components.bluetooth import BluetoothScanningMode
from homeassistant.components.bluetooth.passive_update_processor import (
PassiveBluetoothProcessorCoordinator,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import Platform
from homeassistant.core import HomeAssistant
from .const import DOMAIN
PLATFORMS: list[Platform] = [Platform.SENSOR]
_LOGGER = logging.getLogger(__name__)
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Set up RAPT BLE device from a config entry."""
address = entry.unique_id
assert address is not None
data = RAPTPillBluetoothDeviceData()
coordinator = hass.data.setdefault(DOMAIN, {})[
entry.entry_id
] = PassiveBluetoothProcessorCoordinator(
hass,
_LOGGER,
address=address,
mode=BluetoothScanningMode.ACTIVE,
update_method=data.update,
)
await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
entry.async_on_unload(
coordinator.async_start()
) # only start after all platforms have had a chance to subscribe
return True
async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Unload a config entry."""
if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
hass.data[DOMAIN].pop(entry.entry_id)
return unload_ok

94
homeassistant/components/rapt_ble/config_flow.py Normal file
View File

@ -0,0 +1,94 @@
"""Config flow for rapt_ble."""
from __future__ import annotations
from typing import Any
from rapt_ble import RAPTPillBluetoothDeviceData as DeviceData
import voluptuous as vol
from homeassistant.components.bluetooth import (
BluetoothServiceInfoBleak,
async_discovered_service_info,
)
from homeassistant.config_entries import ConfigFlow
from homeassistant.const import CONF_ADDRESS
from homeassistant.data_entry_flow import FlowResult
from .const import DOMAIN
class RAPTPillConfigFlow(ConfigFlow, domain=DOMAIN):
"""Handle a config flow for rapt_ble."""
VERSION = 1
def __init__(self) -> None:
"""Initialize the config flow."""
self._discovery_info: BluetoothServiceInfoBleak | None = None
self._discovered_device: DeviceData | None = None
self._discovered_devices: dict[str, str] = {}
async def async_step_bluetooth(
self, discovery_info: BluetoothServiceInfoBleak
) -> FlowResult:
"""Handle the bluetooth discovery step."""
await self.async_set_unique_id(discovery_info.address)
self._abort_if_unique_id_configured()
device = DeviceData()
if not device.supported(discovery_info):
return self.async_abort(reason="not_supported")
self._discovery_info = discovery_info
self._discovered_device = device
return await self.async_step_bluetooth_confirm()
async def async_step_bluetooth_confirm(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
"""Confirm discovery."""
assert self._discovered_device is not None
device = self._discovered_device
assert self._discovery_info is not None
discovery_info = self._discovery_info
title = device.title or device.get_device_name() or discovery_info.name
if user_input is not None:
return self.async_create_entry(title=title, data={})
self._set_confirm_only()
placeholders = {"name": title}
self.context["title_placeholders"] = placeholders
return self.async_show_form(
step_id="bluetooth_confirm", description_placeholders=placeholders
)
async def async_step_user(
self, user_input: dict[str, Any] | None = None
) -> FlowResult:
"""Handle the user step to pick discovered device."""
if user_input is not None:
address = user_input[CONF_ADDRESS]
await self.async_set_unique_id(address, raise_on_progress=False)
self._abort_if_unique_id_configured()
return self.async_create_entry(
title=self._discovered_devices[address], data={}
)
current_addresses = self._async_current_ids()
for discovery_info in async_discovered_service_info(self.hass, False):
address = discovery_info.address
if address in current_addresses or address in self._discovered_devices:
continue
device = DeviceData()
if device.supported(discovery_info):
self._discovered_devices[address] = (
device.title or device.get_device_name() or discovery_info.name
)
if not self._discovered_devices:
return self.async_abort(reason="no_devices_found")
return self.async_show_form(
step_id="user",
data_schema=vol.Schema(
{vol.Required(CONF_ADDRESS): vol.In(self._discovered_devices)}
),
)

3
homeassistant/components/rapt_ble/const.py Normal file
View File

@ -0,0 +1,3 @@
"""Constants for the rapt_ble integration."""
DOMAIN = "rapt_ble"

20
homeassistant/components/rapt_ble/manifest.json Normal file
View File

@ -0,0 +1,20 @@
{
"domain": "rapt_ble",
"name": "RAPT Bluetooth",
"bluetooth": [
{
"manufacturer_id": 16722,
"manufacturer_data_start": [80, 84]
},
{
"manufacturer_id": 17739,
"manufacturer_data_start": [71]
}
],
"codeowners": ["@sairon"],
"config_flow": true,
"dependencies": ["bluetooth_adapters"],
"documentation": "https://www.home-assistant.io/integrations/rapt_ble",
"iot_class": "local_push",
"requirements": ["rapt-ble==0.1.0"]
}

125
homeassistant/components/rapt_ble/sensor.py Normal file
View File

@ -0,0 +1,125 @@
"""Support for RAPT Pill hydrometers."""
from __future__ import annotations
from rapt_ble import DeviceClass, DeviceKey, SensorUpdate, Units
from homeassistant import config_entries
from homeassistant.components.bluetooth.passive_update_processor import (
PassiveBluetoothDataProcessor,
PassiveBluetoothDataUpdate,
PassiveBluetoothEntityKey,
PassiveBluetoothProcessorCoordinator,
PassiveBluetoothProcessorEntity,
)
from homeassistant.components.sensor import (
SensorDeviceClass,
SensorEntity,
SensorEntityDescription,
SensorStateClass,
)
from homeassistant.const import (
PERCENTAGE,
SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
EntityCategory,
UnitOfTemperature,
)
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity_platform import AddEntitiesCallback
from homeassistant.helpers.sensor import sensor_device_info_to_hass_device_info
from .const import DOMAIN
SENSOR_DESCRIPTIONS = {
(DeviceClass.TEMPERATURE, Units.TEMP_CELSIUS): SensorEntityDescription(
key=f"{DeviceClass.TEMPERATURE}_{Units.TEMP_CELSIUS}",
device_class=SensorDeviceClass.TEMPERATURE,
native_unit_of_measurement=UnitOfTemperature.CELSIUS,
state_class=SensorStateClass.MEASUREMENT,
),
(DeviceClass.SPECIFIC_GRAVITY, Units.SPECIFIC_GRAVITY): SensorEntityDescription(
key=f"{DeviceClass.SPECIFIC_GRAVITY}_{Units.SPECIFIC_GRAVITY}",
state_class=SensorStateClass.MEASUREMENT,
),
(DeviceClass.BATTERY, Units.PERCENTAGE): SensorEntityDescription(
key=f"{DeviceClass.BATTERY}_{Units.PERCENTAGE}",
device_class=SensorDeviceClass.BATTERY,
native_unit_of_measurement=PERCENTAGE,
state_class=SensorStateClass.MEASUREMENT,
entity_category=EntityCategory.DIAGNOSTIC,
),
(
DeviceClass.SIGNAL_STRENGTH,
Units.SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
): SensorEntityDescription(
key=f"{DeviceClass.SIGNAL_STRENGTH}_{Units.SIGNAL_STRENGTH_DECIBELS_MILLIWATT}",
device_class=SensorDeviceClass.SIGNAL_STRENGTH,
native_unit_of_measurement=SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
state_class=SensorStateClass.MEASUREMENT,
entity_registry_enabled_default=False,
entity_category=EntityCategory.DIAGNOSTIC,
),
}
def _device_key_to_bluetooth_entity_key(
device_key: DeviceKey,
) -> PassiveBluetoothEntityKey:
"""Convert a device key to an entity key."""
return PassiveBluetoothEntityKey(device_key.key, device_key.device_id)
def sensor_update_to_bluetooth_data_update(
sensor_update: SensorUpdate,
) -> PassiveBluetoothDataUpdate:
"""Convert a sensor update to a bluetooth data update."""
return PassiveBluetoothDataUpdate(
devices={
device_id: sensor_device_info_to_hass_device_info(device_info)
for device_id, device_info in sensor_update.devices.items()
},
entity_descriptions={
_device_key_to_bluetooth_entity_key(device_key): SENSOR_DESCRIPTIONS[
(description.device_class, description.native_unit_of_measurement)
]
for device_key, description in sensor_update.entity_descriptions.items()
if description.device_class and description.native_unit_of_measurement
},
entity_data={
_device_key_to_bluetooth_entity_key(device_key): sensor_values.native_value
for device_key, sensor_values in sensor_update.entity_values.items()
},
entity_names={
_device_key_to_bluetooth_entity_key(device_key): sensor_values.name
for device_key, sensor_values in sensor_update.entity_values.items()
},
)
async def async_setup_entry(
hass: HomeAssistant,
entry: config_entries.ConfigEntry,
async_add_entities: AddEntitiesCallback,
) -> None:
"""Set up the RAPT Pill BLE sensors."""
coordinator: PassiveBluetoothProcessorCoordinator = hass.data[DOMAIN][
entry.entry_id
]
processor = PassiveBluetoothDataProcessor(sensor_update_to_bluetooth_data_update)
entry.async_on_unload(
processor.async_add_entities_listener(
RAPTPillBluetoothSensorEntity, async_add_entities
)
)
entry.async_on_unload(coordinator.async_register_processor(processor))
class RAPTPillBluetoothSensorEntity(
PassiveBluetoothProcessorEntity[PassiveBluetoothDataProcessor[float | int | None]],
SensorEntity,
):
"""Representation of a RAPT Pill BLE sensor."""
@property
def native_value(self) -> int | float | None:
"""Return the native value."""
return self.processor.entity_data.get(self.entity_key)

21
homeassistant/components/rapt_ble/strings.json Normal file
View File

@ -0,0 +1,21 @@
{
"config": {
"flow_title": "[%key:component::bluetooth::config::flow_title%]",
"step": {
"user": {
"description": "[%key:component::bluetooth::config::step::user::description%]",
"data": {
"address": "[%key:component::bluetooth::config::step::user::data::address%]"
}
},
"bluetooth_confirm": {
"description": "[%key:component::bluetooth::config::step::bluetooth_confirm::description%]"
}
},
"abort": {
"no_devices_found": "[%key:common::config_flow::abort::no_devices_found%]",
"already_in_progress": "[%key:common::config_flow::abort::already_in_progress%]",
"already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
}
}
}

15
homeassistant/generated/bluetooth.py
View File

@ -327,6 +327,21 @@ BLUETOOTH: list[dict[str, bool | str | int | list[int]]] = [
"domain": "qingping",
"service_data_uuid": "0000fdcd-0000-1000-8000-00805f9b34fb",
},
{
"domain": "rapt_ble",
"manufacturer_data_start": [
80,
84,
],
"manufacturer_id": 16722,
},
{
"domain": "rapt_ble",
"manufacturer_data_start": [
71,
],
"manufacturer_id": 17739,
},
{
"connectable": False,
"domain": "ruuvitag_ble",

1
homeassistant/generated/config_flows.py
View File

@ -350,6 +350,7 @@ FLOWS = {
"rainbird",
"rainforest_eagle",
"rainmachine",
"rapt_ble",
"rdw",
"recollect_waste",
"renault",

6
homeassistant/generated/integrations.json
View File

@ -4419,6 +4419,12 @@
"config_flow": false,
"iot_class": "local_polling"
},
"rapt_ble": {
"name": "RAPT Bluetooth",
"integration_type": "hub",
"config_flow": true,
"iot_class": "local_push"
},
"raspberry_pi": {
"name": "Raspberry Pi",
"integrations": {

3
requirements_all.txt
View File

@ -2222,6 +2222,9 @@ radiotherm==2.1.0
# homeassistant.components.raincloud
raincloudy==0.0.7
# homeassistant.components.rapt_ble
rapt-ble==0.1.0
# homeassistant.components.raspyrfm
raspyrfm-client==1.2.8

3
requirements_test_all.txt
View File

@ -1594,6 +1594,9 @@ radios==0.1.1
# homeassistant.components.radiotherm
radiotherm==2.1.0
# homeassistant.components.rapt_ble
rapt-ble==0.1.0
# homeassistant.components.rainmachine
regenmaschine==2022.11.0

28
tests/components/rapt_ble/__init__.py Normal file
View File

@ -0,0 +1,28 @@
"""Tests for the rapt_ble integration."""
from homeassistant.helpers.service_info.bluetooth import BluetoothServiceInfo
RAPT_MAC = "78:E3:6D:3C:06:66"
NOT_RAPT_SERVICE_INFO = BluetoothServiceInfo(
name="Not it",
address="61DE521B-F0BF-9F44-64D4-75BBE1738105",
rssi=-63,
manufacturer_data={3234: b"\x00\x01"},
service_data={},
service_uuids=[],
source="local",
)
COMPLETE_SERVICE_INFO = BluetoothServiceInfo(
name="",
address=RAPT_MAC,
rssi=-70,
manufacturer_data={
16722: b"PT\x01x\xe3m<\xb9\x94\x94{D|\xc5 47\x02a&\x89*\x83",
17739: b"G20220612_050156_81c6d14",
},
service_data={},
service_uuids=[],
source="local",
)

8
tests/components/rapt_ble/conftest.py Normal file
View File

@ -0,0 +1,8 @@
"""RAPT BLE session fixtures."""
import pytest
@pytest.fixture(autouse=True)
def mock_bluetooth(enable_bluetooth):
"""Auto mock bluetooth."""

204
tests/components/rapt_ble/test_config_flow.py Normal file
View File

@ -0,0 +1,204 @@
"""Test the RAPT config flow."""
from unittest.mock import patch
from homeassistant import config_entries
from homeassistant.components.rapt_ble.const import DOMAIN
from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import FlowResultType
from . import COMPLETE_SERVICE_INFO, NOT_RAPT_SERVICE_INFO, RAPT_MAC
from tests.common import MockConfigEntry
async def test_async_step_bluetooth_valid_device(hass: HomeAssistant) -> None:
"""Test discovery via bluetooth with a valid device."""
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_BLUETOOTH},
data=COMPLETE_SERVICE_INFO,
)
assert result["type"] == FlowResultType.FORM
assert result["step_id"] == "bluetooth_confirm"
with patch(
"homeassistant.components.rapt_ble.async_setup_entry", return_value=True
):
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"], user_input={}
)
assert result2["type"] == FlowResultType.CREATE_ENTRY
assert result2["title"] == "RAPT Pill 0666"
assert result2["data"] == {}
assert result2["result"].unique_id == RAPT_MAC
async def test_async_step_bluetooth_not_rapt(hass: HomeAssistant) -> None:
"""Test discovery via bluetooth not RAPT."""
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_BLUETOOTH},
data=NOT_RAPT_SERVICE_INFO,
)
assert result["type"] == FlowResultType.ABORT
assert result["reason"] == "not_supported"
async def test_async_step_user_no_devices_found(hass: HomeAssistant) -> None:
"""Test setup from service info cache with no devices found."""
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_USER},
)
assert result["type"] == FlowResultType.ABORT
assert result["reason"] == "no_devices_found"
async def test_async_step_user_with_found_devices(hass: HomeAssistant) -> None:
"""Test setup from service info cache with devices found."""
with patch(
"homeassistant.components.rapt_ble.config_flow.async_discovered_service_info",
return_value=[COMPLETE_SERVICE_INFO],
):
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_USER},
)
assert result["type"] == FlowResultType.FORM
assert result["step_id"] == "user"
with patch(
"homeassistant.components.rapt_ble.async_setup_entry", return_value=True
):
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
user_input={"address": RAPT_MAC},
)
assert result2["type"] == FlowResultType.CREATE_ENTRY
assert result2["title"] == "RAPT Pill 0666"
assert result2["data"] == {}
assert result2["result"].unique_id == RAPT_MAC
async def test_async_step_user_device_added_between_steps(hass: HomeAssistant) -> None:
"""Test the device gets added via another flow between steps."""
with patch(
"homeassistant.components.rapt_ble.config_flow.async_discovered_service_info",
return_value=[COMPLETE_SERVICE_INFO],
):
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_USER},
)
assert result["type"] == FlowResultType.FORM
assert result["step_id"] == "user"
entry = MockConfigEntry(
domain=DOMAIN,
unique_id=RAPT_MAC,
)
entry.add_to_hass(hass)
with patch(
"homeassistant.components.rapt_ble.async_setup_entry", return_value=True
):
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
user_input={"address": RAPT_MAC},
)
assert result2["type"] == FlowResultType.ABORT
assert result2["reason"] == "already_configured"
async def test_async_step_user_with_found_devices_already_setup(
hass: HomeAssistant,
) -> None:
"""Test setup from service info cache with devices found."""
entry = MockConfigEntry(
domain=DOMAIN,
unique_id=RAPT_MAC,
)
entry.add_to_hass(hass)
with patch(
"homeassistant.components.rapt_ble.config_flow.async_discovered_service_info",
return_value=[COMPLETE_SERVICE_INFO],
):
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_USER},
)
assert result["type"] == FlowResultType.ABORT
assert result["reason"] == "no_devices_found"
async def test_async_step_bluetooth_devices_already_setup(hass: HomeAssistant) -> None:
"""Test we can't start a flow if there is already a config entry."""
entry = MockConfigEntry(
domain=DOMAIN,
unique_id=RAPT_MAC,
)
entry.add_to_hass(hass)
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_BLUETOOTH},
data=COMPLETE_SERVICE_INFO,
)
assert result["type"] == FlowResultType.ABORT
assert result["reason"] == "already_configured"
async def test_async_step_bluetooth_already_in_progress(hass: HomeAssistant) -> None:
"""Test we can't start a flow for the same device twice."""
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_BLUETOOTH},
data=COMPLETE_SERVICE_INFO,
)
assert result["type"] == FlowResultType.FORM
assert result["step_id"] == "bluetooth_confirm"
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_BLUETOOTH},
data=COMPLETE_SERVICE_INFO,
)
assert result["type"] == FlowResultType.ABORT
assert result["reason"] == "already_in_progress"
async def test_async_step_user_takes_precedence_over_discovery(
hass: HomeAssistant,
) -> None:
"""Test manual setup takes precedence over discovery."""
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_BLUETOOTH},
data=COMPLETE_SERVICE_INFO,
)
assert result["type"] == FlowResultType.FORM
assert result["step_id"] == "bluetooth_confirm"
with patch(
"homeassistant.components.rapt_ble.config_flow.async_discovered_service_info",
return_value=[COMPLETE_SERVICE_INFO],
):
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_USER},
)
assert result["type"] == FlowResultType.FORM
with patch(
"homeassistant.components.rapt_ble.async_setup_entry", return_value=True
):
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
user_input={"address": RAPT_MAC},
)
assert result2["type"] == FlowResultType.CREATE_ENTRY
assert result2["title"] == "RAPT Pill 0666"
assert result2["data"] == {}
assert result2["result"].unique_id == RAPT_MAC
# Verify the original one was aborted
assert not hass.config_entries.flow.async_progress(DOMAIN)

66
tests/components/rapt_ble/test_sensor.py Normal file
View File

@ -0,0 +1,66 @@
"""Test the RAPT Pill BLE sensors."""
from __future__ import annotations
from homeassistant.components.rapt_ble.const import DOMAIN
from homeassistant.components.sensor import ATTR_STATE_CLASS, SensorStateClass
from homeassistant.const import (
ATTR_FRIENDLY_NAME,
ATTR_UNIT_OF_MEASUREMENT,
PERCENTAGE,
UnitOfTemperature,
)
from homeassistant.core import HomeAssistant
from . import COMPLETE_SERVICE_INFO, RAPT_MAC
from tests.common import MockConfigEntry
from tests.components.bluetooth import inject_bluetooth_service_info
async def test_sensors(hass: HomeAssistant):
"""Test setting up creates the sensors."""
entry = MockConfigEntry(
domain=DOMAIN,
unique_id=RAPT_MAC,
)
entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(entry.entry_id)
await hass.async_block_till_done()
assert len(hass.states.async_all()) == 0
inject_bluetooth_service_info(hass, COMPLETE_SERVICE_INFO)
await hass.async_block_till_done()
assert len(hass.states.async_all()) == 3
temp_sensor = hass.states.get("sensor.rapt_pill_0666_battery")
assert temp_sensor is not None
temp_sensor_attributes = temp_sensor.attributes
assert temp_sensor.state == "43"
assert temp_sensor_attributes[ATTR_FRIENDLY_NAME] == "RAPT Pill 0666 Battery"
assert temp_sensor_attributes[ATTR_UNIT_OF_MEASUREMENT] == PERCENTAGE
assert temp_sensor_attributes[ATTR_STATE_CLASS] == SensorStateClass.MEASUREMENT
temp_sensor = hass.states.get("sensor.rapt_pill_0666_temperature")
assert temp_sensor is not None
temp_sensor_attributes = temp_sensor.attributes
assert temp_sensor.state == "23.81"
assert temp_sensor_attributes[ATTR_FRIENDLY_NAME] == "RAPT Pill 0666 Temperature"
assert temp_sensor_attributes[ATTR_UNIT_OF_MEASUREMENT] == UnitOfTemperature.CELSIUS
assert temp_sensor_attributes[ATTR_STATE_CLASS] == SensorStateClass.MEASUREMENT
temp_sensor = hass.states.get("sensor.rapt_pill_0666_specific_gravity")
assert temp_sensor is not None
temp_sensor_attributes = temp_sensor.attributes
assert temp_sensor.state == "1.0111"
assert (
temp_sensor_attributes[ATTR_FRIENDLY_NAME] == "RAPT Pill 0666 Specific Gravity"
)
assert temp_sensor_attributes[ATTR_STATE_CLASS] == SensorStateClass.MEASUREMENT
assert await hass.config_entries.async_unload(entry.entry_id)
await hass.async_block_till_done()