evlli/hass-core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Use DeviceInfo Class L-M (#58312)

Browse source
This commit is contained in:
Robert Hillis 2021-10-25 17:26:40 -04:00 • committed by GitHub
parent 6341dd4883
commit f2a5c4602e
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
27 changed files with 197 additions and 197 deletions
Download patch file Download diff file Expand all files Collapse all files

36
homeassistant/components/lifx/light.py
View file

@ -34,11 +34,18 @@ from homeassistant.components.light import (
LightEntity,
preprocess_turn_on_alternatives,
)
from homeassistant.const import ATTR_ENTITY_ID, ATTR_MODE, EVENT_HOMEASSISTANT_STOP
from homeassistant.const import (
ATTR_ENTITY_ID,
ATTR_MODE,
ATTR_MODEL,
ATTR_SW_VERSION,
EVENT_HOMEASSISTANT_STOP,
)
from homeassistant.core import callback
from homeassistant.helpers import entity_platform
import homeassistant.helpers.config_validation as cv
import homeassistant.helpers.device_registry as dr
from homeassistant.helpers.entity import DeviceInfo
from homeassistant.helpers.event import async_track_point_in_utc_time
import homeassistant.util.color as color_util
@ -449,24 +456,19 @@ class LIFXLight(LightEntity):
self.lock = asyncio.Lock()
@property
def device_info(self):
def device_info(self) -> DeviceInfo:
"""Return information about the device."""
info = {
"identifiers": {(LIFX_DOMAIN, self.unique_id)},
"name": self.name,
"connections": {(dr.CONNECTION_NETWORK_MAC, self.bulb.mac_addr)},
"manufacturer": "LIFX",
}
_map = aiolifx().products.product_map
info = DeviceInfo(
identifiers={(LIFX_DOMAIN, self.unique_id)},
connections={(dr.CONNECTION_NETWORK_MAC, self.bulb.mac_addr)},
manufacturer="LIFX",
name=self.name,
)
if model := (_map.get(self.bulb.product) or self.bulb.product) is not None:
info[ATTR_MODEL] = str(model)
if (version := self.bulb.host_firmware_version) is not None:
info["sw_version"] = version
product_map = aiolifx().products.product_map
model = product_map.get(self.bulb.product) or self.bulb.product
if model is not None:
info["model"] = str(model)
info[ATTR_SW_VERSION] = version
return info
@property

12
homeassistant/components/litterrobot/entity.py
View file

@ -46,12 +46,12 @@ class LitterRobotEntity(CoordinatorEntity):
@property
def device_info(self) -> DeviceInfo:
"""Return the device information for a Litter-Robot."""
return {
"identifiers": {(DOMAIN, self.robot.serial)},
"name": self.robot.name,
"manufacturer": "Litter-Robot",
"model": self.robot.model,
}
return DeviceInfo(
identifiers={(DOMAIN, self.robot.serial)},
manufacturer="Litter-Robot",
model=self.robot.model,
name=self.robot.name,
)
class LitterRobotControlEntity(LitterRobotEntity):

17
homeassistant/components/logi_circle/camera.py
View file

@ -14,6 +14,7 @@ from homeassistant.const import (
STATE_ON,
)
from homeassistant.helpers.dispatcher import async_dispatcher_connect
from homeassistant.helpers.entity import DeviceInfo
from .const import (
ATTRIBUTION,
@ -116,15 +117,15 @@ class LogiCam(Camera):
return SUPPORT_ON_OFF
@property
def device_info(self):
def device_info(self) -> DeviceInfo:
"""Return information about the device."""
return {
"name": self._camera.name,
"identifiers": {(LOGI_CIRCLE_DOMAIN, self._camera.id)},
"model": self._camera.model_name,
"sw_version": self._camera.firmware,
"manufacturer": DEVICE_BRAND,
}
return DeviceInfo(
identifiers={(LOGI_CIRCLE_DOMAIN, self._camera.id)},
manufacturer=DEVICE_BRAND,
model=self._camera.model_name,
name=self._camera.name,
sw_version=self._camera.firmware,
)
@property
def extra_state_attributes(self):

17
homeassistant/components/logi_circle/sensor.py
View file

@ -13,6 +13,7 @@ from homeassistant.const import (
STATE_OFF,
STATE_ON,
)
from homeassistant.helpers.entity import DeviceInfo
from homeassistant.helpers.icon import icon_for_battery_level
from homeassistant.util.dt import as_local
@ -56,15 +57,15 @@ class LogiSensor(SensorEntity):
self._tz = time_zone
@property
def device_info(self):
def device_info(self) -> DeviceInfo:
"""Return information about the device."""
return {
"name": self._camera.name,
"identifiers": {(LOGI_CIRCLE_DOMAIN, self._camera.id)},
"model": self._camera.model_name,
"sw_version": self._camera.firmware,
"manufacturer": DEVICE_BRAND,
}
return DeviceInfo(
identifiers={(LOGI_CIRCLE_DOMAIN, self._camera.id)},
manufacturer=DEVICE_BRAND,
model=self._camera.model_name,
name=self._camera.name,
sw_version=self._camera.firmware,
)
@property
def extra_state_attributes(self):

4
homeassistant/components/lutron_caseta/__init__.py
View file

@ -333,10 +333,10 @@ class LutronCasetaDevice(Entity):
"""Return the device info."""
return DeviceInfo(
identifiers={(DOMAIN, self.serial)},
name=self.name,
suggested_area=self._device["name"].split("_")[0],
manufacturer=MANUFACTURER,
model=f"{self._device['model']} ({self._device['type']})",
name=self.name,
suggested_area=self._device["name"].split("_")[0],
via_device=(DOMAIN, self._bridge_device["serial"]),
)

12
homeassistant/components/lyric/__init__.py
View file

@ -170,9 +170,9 @@ class LyricDeviceEntity(LyricEntity):
@property
def device_info(self) -> DeviceInfo:
"""Return device information about this Honeywell Lyric instance."""
return {
"connections": {(dr.CONNECTION_NETWORK_MAC, self._mac_id)},
"manufacturer": "Honeywell",
"model": self.device.deviceModel,
"name": self.device.name,
}
return DeviceInfo(
connections={(dr.CONNECTION_NETWORK_MAC, self._mac_id)},
manufacturer="Honeywell",
model=self.device.deviceModel,
name=self.device.name,
)

15
homeassistant/components/mazda/__init__.py
View file

@ -23,6 +23,7 @@ from homeassistant.exceptions import (
)
from homeassistant.helpers import aiohttp_client, device_registry
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity import DeviceInfo
from homeassistant.helpers.update_coordinator import (
CoordinatorEntity,
DataUpdateCoordinator,
@ -229,14 +230,14 @@ class MazdaEntity(CoordinatorEntity):
return self.coordinator.data[self.index]
@property
def device_info(self):
def device_info(self) -> DeviceInfo:
"""Return device info for the Mazda entity."""
return {
"identifiers": {(DOMAIN, self.vin)},
"name": self.get_vehicle_name(),
"manufacturer": "Mazda",
"model": f"{self.data['modelYear']} {self.data['carlineName']}",
}
return DeviceInfo(
identifiers={(DOMAIN, self.vin)},
manufacturer="Mazda",
model=f"{self.data['modelYear']} {self.data['carlineName']}",
name=self.get_vehicle_name(),
)
def get_vehicle_name(self):
"""Return the vehicle name, to be used as a prefix for names of other entities."""

25
homeassistant/components/melcloud/__init__.py
View file

@ -17,6 +17,7 @@ from homeassistant.core import HomeAssistant
from homeassistant.exceptions import ConfigEntryNotReady
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC
from homeassistant.helpers.entity import DeviceInfo
from homeassistant.helpers.typing import ConfigType
from homeassistant.util import Throttle
@ -126,19 +127,19 @@ class MelCloudDevice:
return self.device.building_id
@property
def device_info(self):
def device_info(self) -> DeviceInfo:
"""Return a device description for device registry."""
_device_info = {
"connections": {(CONNECTION_NETWORK_MAC, self.device.mac)},
"identifiers": {(DOMAIN, f"{self.device.mac}-{self.device.serial}")},
"manufacturer": "Mitsubishi Electric",
"name": self.name,
}
if (unit_infos := self.device.units) is not None:
_device_info["model"] = ", ".join(
[x["model"] for x in unit_infos if x["model"]]
)
return _device_info
model = None
unit_infos = self.device.units
if unit_infos is not None:
model = ", ".join([x["model"] for x in unit_infos if x["model"]])
return DeviceInfo(
connections={(CONNECTION_NETWORK_MAC, self.device.mac)},
identifiers={(DOMAIN, f"{self.device.mac}-{self.device.serial}")},
manufacturer="Mitsubishi Electric",
model=model,
name=self.name,
)
async def mel_devices_setup(hass, token) -> list[MelCloudDevice]:

15
homeassistant/components/met/weather.py
View file

@ -30,6 +30,7 @@ from homeassistant.const import (
TEMP_CELSIUS,
)
from homeassistant.helpers import config_validation as cv
from homeassistant.helpers.entity import DeviceInfo
from homeassistant.helpers.update_coordinator import CoordinatorEntity
from homeassistant.util.distance import convert as convert_distance
from homeassistant.util.pressure import convert as convert_pressure
@ -247,10 +248,10 @@ class MetWeather(CoordinatorEntity, WeatherEntity):
@property
def device_info(self):
"""Device info."""
return {
"identifiers": {(DOMAIN,)},
"manufacturer": "Met.no",
"model": "Forecast",
"default_name": "Forecast",
"entry_type": "service",
}
return DeviceInfo(
default_name="Forecast",
entry_type="service",
identifiers={(DOMAIN,)},
manufacturer="Met.no",
model="Forecast",
)

15
homeassistant/components/met_eireann/weather.py
View file

@ -20,6 +20,7 @@ from homeassistant.const import (
PRESSURE_INHG,
TEMP_CELSIUS,
)
from homeassistant.helpers.entity import DeviceInfo
from homeassistant.helpers.update_coordinator import CoordinatorEntity
from homeassistant.util import dt as dt_util
from homeassistant.util.distance import convert as convert_distance
@ -182,10 +183,10 @@ class MetEireannWeather(CoordinatorEntity, WeatherEntity):
@property
def device_info(self):
"""Device info."""
return {
"identifiers": {(DOMAIN,)},
"manufacturer": "Met Éireann",
"model": "Forecast",
"default_name": "Forecast",
"entry_type": "service",
}
return DeviceInfo(
default_name="Forecast",
entry_type="service",
identifiers={(DOMAIN,)},
manufacturer="Met Éireann",
model="Forecast",
)

17
homeassistant/components/meteo_france/sensor.py
View file

@ -8,6 +8,7 @@ from homeassistant.components.sensor import SensorEntity
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import ATTR_ATTRIBUTION
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity import DeviceInfo
from homeassistant.helpers.update_coordinator import (
CoordinatorEntity,
DataUpdateCoordinator,
@ -92,15 +93,15 @@ class MeteoFranceSensor(CoordinatorEntity, SensorEntity):
self._attr_extra_state_attributes = {ATTR_ATTRIBUTION: ATTRIBUTION}
@property
def device_info(self):
def device_info(self) -> DeviceInfo:
"""Return the device info."""
return {
"identifiers": {(DOMAIN, self.platform.config_entry.unique_id)},
"name": self.coordinator.name,
"manufacturer": MANUFACTURER,
"model": MODEL,
"entry_type": "service",
}
return DeviceInfo(
entry_type="service",
identifiers={(DOMAIN, self.platform.config_entry.unique_id)},
manufacturer=MANUFACTURER,
model=MODEL,
name=self.coordinator.name,
)
@property
def native_value(self):

17
homeassistant/components/meteo_france/weather.py
View file

@ -15,6 +15,7 @@ from homeassistant.components.weather import (
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import CONF_MODE, TEMP_CELSIUS
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity import DeviceInfo
from homeassistant.helpers.update_coordinator import (
CoordinatorEntity,
DataUpdateCoordinator,
@ -86,15 +87,15 @@ class MeteoFranceWeather(CoordinatorEntity, WeatherEntity):
return self._city_name
@property
def device_info(self):
def device_info(self) -> DeviceInfo:
"""Return the device info."""
return {
"identifiers": {(DOMAIN, self.platform.config_entry.unique_id)},
"name": self.coordinator.name,
"manufacturer": MANUFACTURER,
"model": MODEL,
"entry_type": "service",
}
return DeviceInfo(
entry_type="service",
identifiers={(DOMAIN, self.platform.config_entry.unique_id)},
manufacturer=MANUFACTURER,
model=MODEL,
name=self.coordinator.name,
)
@property
def condition(self):

15
homeassistant/components/meteoclimatic/sensor.py
View file

@ -3,6 +3,7 @@ from homeassistant.components.sensor import SensorEntity, SensorEntityDescriptio
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import ATTR_ATTRIBUTION
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity import DeviceInfo
from homeassistant.helpers.update_coordinator import (
CoordinatorEntity,
DataUpdateCoordinator,
@ -41,13 +42,13 @@ class MeteoclimaticSensor(CoordinatorEntity, SensorEntity):
@property
def device_info(self):
"""Return the device info."""
return {
"identifiers": {(DOMAIN, self.platform.config_entry.unique_id)},
"name": self.coordinator.name,
"manufacturer": MANUFACTURER,
"model": MODEL,
"entry_type": "service",
}
return DeviceInfo(
entry_type="service",
identifiers={(DOMAIN, self.platform.config_entry.unique_id)},
manufacturer=MANUFACTURER,
model=MODEL,
name=self.coordinator.name,
)
@property
def native_value(self):

15
homeassistant/components/meteoclimatic/weather.py
View file

@ -5,6 +5,7 @@ from homeassistant.components.weather import WeatherEntity
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import TEMP_CELSIUS
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity import DeviceInfo
from homeassistant.helpers.entity_platform import AddEntitiesCallback
from homeassistant.helpers.update_coordinator import (
CoordinatorEntity,
@ -55,13 +56,13 @@ class MeteoclimaticWeather(CoordinatorEntity, WeatherEntity):
@property
def device_info(self):
"""Return the device info."""
return {
"identifiers": {(DOMAIN, self.platform.config_entry.unique_id)},
"name": self.coordinator.name,
"manufacturer": MANUFACTURER,
"model": MODEL,
"entry_type": "service",
}
return DeviceInfo(
entry_type="service",
identifiers={(DOMAIN, self.platform.config_entry.unique_id)},
manufacturer=MANUFACTURER,
model=MODEL,
name=self.coordinator.name,
)
@property
def condition(self):

18
homeassistant/components/mikrotik/device_tracker.py
View file

@ -10,6 +10,7 @@ from homeassistant.core import callback
from homeassistant.helpers import entity_registry
from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC
from homeassistant.helpers.dispatcher import async_dispatcher_connect
from homeassistant.helpers.entity import DeviceInfo
import homeassistant.util.dt as dt_util
from .const import DOMAIN
@ -130,16 +131,15 @@ class MikrotikHubTracker(ScannerEntity):
return None
@property
def device_info(self):
def device_info(self) -> DeviceInfo:
"""Return a client description for device registry."""
info = {
"connections": {(CONNECTION_NETWORK_MAC, self.device.mac)},
"identifiers": {(DOMAIN, self.device.mac)},
# We only get generic info from device discovery and so don't want
# to override API specific info that integrations can provide
"default_name": self.name,
}
return info
# We only get generic info from device discovery and so don't want
# to override API specific info that integrations can provide
return DeviceInfo(
connections={(CONNECTION_NETWORK_MAC, self.device.mac)},
default_name=self.name,
identifiers={(DOMAIN, self.device.mac)},
)
async def async_added_to_hass(self):
"""Client entity created."""

2
homeassistant/components/mill/climate.py
View file

@ -86,9 +86,9 @@ class MillHeater(CoordinatorEntity, ClimateEntity):
self._attr_name = heater.name
self._attr_device_info = DeviceInfo(
identifiers={(DOMAIN, heater.device_id)},
name=self.name,
manufacturer=MANUFACTURER,
model=f"generation {1 if heater.is_gen1 else 2}",
name=self.name,
)
if heater.is_gen1:
self._attr_hvac_modes = [HVAC_MODE_HEAT]

2
homeassistant/components/mill/sensor.py
View file

@ -44,9 +44,9 @@ class MillHeaterEnergySensor(CoordinatorEntity, SensorEntity):
self._attr_unique_id = f"{heater.device_id}_{sensor_type}"
self._attr_device_info = DeviceInfo(
identifiers={(DOMAIN, heater.device_id)},
name=self.name,
manufacturer=MANUFACTURER,
model=f"generation {1 if heater.is_gen1 else 2}",
name=self.name,
)
self._update_attr(heater)

19
homeassistant/components/minecraft_server/__init__.py
View file

@ -224,13 +224,13 @@ class MinecraftServerEntity(Entity):
self._name = f"{server.name} {type_name}"
self._icon = icon
self._unique_id = f"{self._server.unique_id}-{type_name}"
self._device_info = {
"identifiers": {(DOMAIN, self._server.unique_id)},
"name": self._server.name,
"manufacturer": MANUFACTURER,
"model": f"Minecraft Server ({self._server.version})",
"sw_version": self._server.protocol_version,
}
self._attr_device_info = DeviceInfo(
identifiers={(DOMAIN, self._server.unique_id)},
manufacturer=MANUFACTURER,
model=f"Minecraft Server ({self._server.version})",
name=self._server.name,
sw_version=self._server.protocol_version,
)
self._device_class = device_class
self._extra_state_attributes = None
self._disconnect_dispatcher = None
@ -245,11 +245,6 @@ class MinecraftServerEntity(Entity):
"""Return unique ID."""
return self._unique_id
@property
def device_info(self) -> DeviceInfo:
"""Return device information."""
return self._device_info
@property
def device_class(self) -> str:
"""Return device class."""

14
homeassistant/components/mobile_app/helpers.py
View file

@ -174,10 +174,10 @@ def webhook_response(
def device_info(registration: dict) -> DeviceInfo:
"""Return the device info for this registration."""
return {
"identifiers": {(DOMAIN, registration[ATTR_DEVICE_ID])},
"manufacturer": registration[ATTR_MANUFACTURER],
"model": registration[ATTR_MODEL],
"name": registration[ATTR_DEVICE_NAME],
"sw_version": registration[ATTR_OS_VERSION],
}
return DeviceInfo(
identifiers={(DOMAIN, registration[ATTR_DEVICE_ID])},
manufacturer=registration[ATTR_MANUFACTURER],
model=registration[ATTR_MODEL],
name=registration[ATTR_DEVICE_NAME],
sw_version=registration[ATTR_OS_VERSION],
)

23
homeassistant/components/modern_forms/__init__.py
View file

@ -17,14 +17,7 @@ from homeassistant.components.light import DOMAIN as LIGHT_DOMAIN
from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import (
ATTR_IDENTIFIERS,
ATTR_MANUFACTURER,
ATTR_MODEL,
ATTR_NAME,
ATTR_SW_VERSION,
CONF_HOST,
)
from homeassistant.const import CONF_HOST
from homeassistant.core import HomeAssistant
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from homeassistant.helpers.entity import DeviceInfo
@ -159,10 +152,10 @@ class ModernFormsDeviceEntity(CoordinatorEntity[ModernFormsDataUpdateCoordinator
@property
def device_info(self) -> DeviceInfo:
"""Return device information about this Modern Forms device."""
return {
ATTR_IDENTIFIERS: {(DOMAIN, self.coordinator.data.info.mac_address)},
ATTR_NAME: self.coordinator.data.info.device_name,
ATTR_MANUFACTURER: "Modern Forms",
ATTR_MODEL: self.coordinator.data.info.fan_type,
ATTR_SW_VERSION: f"{self.coordinator.data.info.firmware_version} / {self.coordinator.data.info.main_mcu_firmware_version}",
}
return DeviceInfo(
identifiers={(DOMAIN, self.coordinator.data.info.mac_address)},
name=self.coordinator.data.info.device_name,
manufacturer="Modern Forms",
model=self.coordinator.data.info.fan_type,
sw_version=f"{self.coordinator.data.info.firmware_version} / {self.coordinator.data.info.main_mcu_firmware_version}",
)

15
homeassistant/components/monoprice/media_player.py
View file

@ -15,6 +15,7 @@ from homeassistant.components.media_player.const import (
)
from homeassistant.const import CONF_PORT, STATE_OFF, STATE_ON
from homeassistant.helpers import config_validation as cv, entity_platform, service
from homeassistant.helpers.entity import DeviceInfo
from .const import (
CONF_SOURCES,
@ -167,14 +168,14 @@ class MonopriceZone(MediaPlayerEntity):
return self._zone_id < 20 or self._update_success
@property
def device_info(self):
def device_info(self) -> DeviceInfo:
"""Return device info for this device."""
return {
"identifiers": {(DOMAIN, self.unique_id)},
"name": self.name,
"manufacturer": "Monoprice",
"model": "6-Zone Amplifier",
}
return DeviceInfo(
identifiers={(DOMAIN, self.unique_id)},
manufacturer="Monoprice",
model="6-Zone Amplifier",
name=self.name,
)
@property
def unique_id(self):

2
homeassistant/components/motion_blinds/cover.py
View file

@ -142,8 +142,8 @@ class MotionPositionDevice(CoordinatorEntity, CoverEntity):
self._attr_device_info = DeviceInfo(
identifiers={(DOMAIN, blind.mac)},
manufacturer=MANUFACTURER,
name=f"{blind.blind_type}-{blind.mac[12:]}",
model=blind.blind_type,
name=f"{blind.blind_type}-{blind.mac[12:]}",
via_device=(DOMAIN, config_entry.unique_id),
)

5
homeassistant/components/motion_blinds/sensor.py
View file

@ -8,6 +8,7 @@ from homeassistant.const import (
PERCENTAGE,
SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
)
from homeassistant.helpers.entity import DeviceInfo
from homeassistant.helpers.update_coordinator import CoordinatorEntity
from .const import ATTR_AVAILABLE, DOMAIN, KEY_COORDINATOR, KEY_GATEWAY
@ -50,7 +51,7 @@ class MotionBatterySensor(CoordinatorEntity, SensorEntity):
super().__init__(coordinator)
self._blind = blind
self._attr_device_info = {"identifiers": {(DOMAIN, blind.mac)}}
self._attr_device_info = DeviceInfo(identifiers={(DOMAIN, blind.mac)})
self._attr_name = f"{blind.blind_type}-battery-{blind.mac[12:]}"
self._attr_unique_id = f"{blind.mac}-battery"
@ -128,7 +129,7 @@ class MotionSignalStrengthSensor(CoordinatorEntity, SensorEntity):
self._device = device
self._device_type = device_type
self._attr_device_info = {"identifiers": {(DOMAIN, device.mac)}}
self._attr_device_info = DeviceInfo(identifiers={(DOMAIN, device.mac)})
self._attr_unique_id = f"{device.mac}-RSSI"
@property

2
homeassistant/components/motioneye/__init__.py
View file

@ -477,4 +477,4 @@ class MotionEyeEntity(CoordinatorEntity):
@property
def device_info(self) -> DeviceInfo:
"""Return the device information."""
return {"identifiers": {self._device_identifier}}
return DeviceInfo(identifiers={self._device_identifier})

17
homeassistant/components/mutesync/binary_sensor.py
View file

@ -1,6 +1,7 @@
"""mütesync binary sensor entities."""
from homeassistant.components.binary_sensor import BinarySensorEntity
from homeassistant.helpers import update_coordinator
from homeassistant.helpers.entity import DeviceInfo
from .const import DOMAIN
@ -42,12 +43,12 @@ class MuteStatus(update_coordinator.CoordinatorEntity, BinarySensorEntity):
return self.coordinator.data[self._sensor_type]
@property
def device_info(self):
def device_info(self) -> DeviceInfo:
"""Return the device info of the sensor."""
return {
"identifiers": {(DOMAIN, self.coordinator.data["user-id"])},
"name": "mutesync",
"manufacturer": "mütesync",
"model": "mutesync app",
"entry_type": "service",
}
return DeviceInfo(
entry_type="service",
identifiers={(DOMAIN, self.coordinator.data["user-id"])},
manufacturer="mütesync",
model="mutesync app",
name="mutesync",
)

31
homeassistant/components/myq/__init__.py
View file

@ -1,4 +1,6 @@
"""The MyQ integration."""
from __future__ import annotations
from datetime import timedelta
import logging
@ -13,12 +15,7 @@ from pymyq.device import MyQDevice
from pymyq.errors import InvalidCredentialsError, MyQError
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import (
ATTR_MODEL,
ATTR_VIA_DEVICE,
CONF_PASSWORD,
CONF_USERNAME,
)
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
from homeassistant.helpers import aiohttp_client
@ -97,24 +94,24 @@ class MyQEntity(CoordinatorEntity):
return self._device.name
@property
def device_info(self) -> DeviceInfo:
def device_info(self):
"""Return the device_info of the device."""
device_info = DeviceInfo(
identifiers={(DOMAIN, self._device.device_id)},
name=self._device.name,
manufacturer=MANUFACTURER,
sw_version=self._device.firmware_version,
)
model = (
KNOWN_MODELS.get(self._device.device_id[2:4])
if self._device.device_id is not None
else None
)
if model:
device_info[ATTR_MODEL] = model
via_device: tuple[str, str] | None = None
if self._device.parent_device_id:
device_info[ATTR_VIA_DEVICE] = (DOMAIN, self._device.parent_device_id)
return device_info
via_device = (DOMAIN, self._device.parent_device_id)
return DeviceInfo(
identifiers={(DOMAIN, self._device.device_id)},
manufacturer=MANUFACTURER,
model=model,
name=self._device.name,
sw_version=self._device.firmware_version,
via_device=via_device,
)
@property
def available(self):

12
homeassistant/components/mysensors/device.py
View file

@ -121,12 +121,12 @@ class MySensorsDevice:
@property
def device_info(self) -> DeviceInfo:
"""Return the device info."""
return {
"identifiers": {(DOMAIN, f"{self.gateway_id}-{self.node_id}")},
"name": self.node_name,
"manufacturer": DOMAIN,
"sw_version": self.sketch_version,
}
return DeviceInfo(
identifiers={(DOMAIN, f"{self.gateway_id}-{self.node_id}")},
manufacturer=DOMAIN,
name=self.node_name,
sw_version=self.sketch_version,
)
@property
def name(self) -> str: