jeans/core
jeans/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2025-07-23 21:27:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #46383 from home-assistant/rc

Browse Source
This commit is contained in:
Franck Nijhof 2021-02-11 12:52:44 +01:00 committed by GitHub
commit c10bf079f7
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
41 changed files with 752 additions and 329 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
homeassistant/components/alexa/state_report.py
View File

@ -8,7 +8,7 @@ import aiohttp
import async_timeout
from homeassistant.const import HTTP_ACCEPTED, MATCH_ALL, STATE_ON
from homeassistant.core import State
from homeassistant.core import HomeAssistant, State, callback
from homeassistant.helpers.significant_change import create_checker
import homeassistant.util.dt as dt_util
@ -28,7 +28,20 @@ async def async_enable_proactive_mode(hass, smart_home_config):
# Validate we can get access token.
await smart_home_config.async_get_access_token()
checker = await create_checker(hass, DOMAIN)
@callback
def extra_significant_check(
hass: HomeAssistant,
old_state: str,
old_attrs: dict,
old_extra_arg: dict,
new_state: str,
new_attrs: dict,
new_extra_arg: dict,
):
"""Check if the serialized data has changed."""
return old_extra_arg is not None and old_extra_arg != new_extra_arg
checker = await create_checker(hass, DOMAIN, extra_significant_check)
async def async_entity_state_listener(
changed_entity: str,
@ -70,15 +83,22 @@ async def async_enable_proactive_mode(hass, smart_home_config):
if not should_report and not should_doorbell:
return
if not checker.async_is_significant_change(new_state):
return
if should_doorbell:
should_report = False
if should_report:
alexa_properties = list(alexa_changed_entity.serialize_properties())
else:
alexa_properties = None
if not checker.async_is_significant_change(
new_state, extra_arg=alexa_properties
):
return
if should_report:
await async_send_changereport_message(
hass, smart_home_config, alexa_changed_entity
hass, smart_home_config, alexa_changed_entity, alexa_properties
)
elif should_doorbell:
@ -92,7 +112,7 @@ async def async_enable_proactive_mode(hass, smart_home_config):
async def async_send_changereport_message(
hass, config, alexa_entity, *, invalidate_access_token=True
hass, config, alexa_entity, alexa_properties, *, invalidate_access_token=True
):
"""Send a ChangeReport message for an Alexa entity.
@ -107,7 +127,7 @@ async def async_send_changereport_message(
payload = {
API_CHANGE: {
"cause": {"type": Cause.APP_INTERACTION},
"properties": list(alexa_entity.serialize_properties()),
"properties": alexa_properties,
}
}
@ -146,7 +166,7 @@ async def async_send_changereport_message(
):
config.async_invalidate_access_token()
return await async_send_changereport_message(
hass, config, alexa_entity, invalidate_access_token=False
hass, config, alexa_entity, alexa_properties, invalidate_access_token=False
)
_LOGGER.error(

42
homeassistant/components/brother/__init__.py
View File

@ -6,12 +6,13 @@ import logging
from brother import Brother, SnmpError, UnsupportedModel
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import CONF_HOST, CONF_TYPE, EVENT_HOMEASSISTANT_STOP
from homeassistant.const import CONF_HOST, CONF_TYPE
from homeassistant.core import Config, HomeAssistant
from homeassistant.exceptions import ConfigEntryNotReady
from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
from .const import DOMAIN
from .const import DATA_CONFIG_ENTRY, DOMAIN, SNMP
from .utils import get_snmp_engine
PLATFORMS = ["sensor"]
@ -30,15 +31,20 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry):
host = entry.data[CONF_HOST]
kind = entry.data[CONF_TYPE]
coordinator = BrotherDataUpdateCoordinator(hass, host=host, kind=kind)
snmp_engine = get_snmp_engine(hass)
coordinator = BrotherDataUpdateCoordinator(
hass, host=host, kind=kind, snmp_engine=snmp_engine
)
await coordinator.async_refresh()
if not coordinator.last_update_success:
coordinator.shutdown()
raise ConfigEntryNotReady
hass.data.setdefault(DOMAIN, {})
hass.data[DOMAIN][entry.entry_id] = coordinator
hass.data[DOMAIN].setdefault(DATA_CONFIG_ENTRY, {})
hass.data[DOMAIN][DATA_CONFIG_ENTRY][entry.entry_id] = coordinator
hass.data[DOMAIN][SNMP] = snmp_engine
for component in PLATFORMS:
hass.async_create_task(
@ -59,7 +65,10 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry):
)
)
if unload_ok:
hass.data[DOMAIN].pop(entry.entry_id).shutdown()
hass.data[DOMAIN][DATA_CONFIG_ENTRY].pop(entry.entry_id)
if not hass.data[DOMAIN][DATA_CONFIG_ENTRY]:
hass.data[DOMAIN].pop(SNMP)
hass.data[DOMAIN].pop(DATA_CONFIG_ENTRY)
return unload_ok
@ -67,12 +76,9 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry):
class BrotherDataUpdateCoordinator(DataUpdateCoordinator):
"""Class to manage fetching Brother data from the printer."""
def __init__(self, hass, host, kind):
def __init__(self, hass, host, kind, snmp_engine):
"""Initialize."""
self.brother = Brother(host, kind=kind)
self._unsub_stop = hass.bus.async_listen(
EVENT_HOMEASSISTANT_STOP, self._handle_ha_stop
)
self.brother = Brother(host, kind=kind, snmp_engine=snmp_engine)
super().__init__(
hass,
@ -83,22 +89,8 @@ class BrotherDataUpdateCoordinator(DataUpdateCoordinator):
async def _async_update_data(self):
"""Update data via library."""
# Race condition on shutdown. Stop all the fetches.
if self._unsub_stop is None:
return None
try:
await self.brother.async_update()
except (ConnectionError, SnmpError, UnsupportedModel) as error:
raise UpdateFailed(error) from error
return self.brother.data
def shutdown(self):
"""Shutdown the Brother coordinator."""
self._unsub_stop()
self._unsub_stop = None
self.brother.shutdown()
def _handle_ha_stop(self, _):
"""Handle Home Assistant stopping."""
self.shutdown()

10
homeassistant/components/brother/config_flow.py
View File

@ -9,6 +9,7 @@ from homeassistant import config_entries, exceptions
from homeassistant.const import CONF_HOST, CONF_TYPE
from .const import DOMAIN, PRINTER_TYPES # pylint:disable=unused-import
from .utils import get_snmp_engine
DATA_SCHEMA = vol.Schema(
{
@ -48,9 +49,10 @@ class BrotherConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
if not host_valid(user_input[CONF_HOST]):
raise InvalidHost()
brother = Brother(user_input[CONF_HOST])
snmp_engine = get_snmp_engine(self.hass)
brother = Brother(user_input[CONF_HOST], snmp_engine=snmp_engine)
await brother.async_update()
brother.shutdown()
await self.async_set_unique_id(brother.serial.lower())
self._abort_if_unique_id_configured()
@ -83,7 +85,9 @@ class BrotherConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
# Hostname is format: brother.local.
self.host = discovery_info["hostname"].rstrip(".")
self.brother = Brother(self.host)
snmp_engine = get_snmp_engine(self.hass)
self.brother = Brother(self.host, snmp_engine=snmp_engine)
try:
await self.brother.async_update()
except (ConnectionError, SnmpError, UnsupportedModel):

4
homeassistant/components/brother/const.py
View File

@ -41,12 +41,16 @@ ATTR_YELLOW_DRUM_REMAINING_PAGES = "yellow_drum_remaining_pages"
ATTR_YELLOW_INK_REMAINING = "yellow_ink_remaining"
ATTR_YELLOW_TONER_REMAINING = "yellow_toner_remaining"
DATA_CONFIG_ENTRY = "config_entry"
DOMAIN = "brother"
UNIT_PAGES = "p"
PRINTER_TYPES = ["laser", "ink"]
SNMP = "snmp"
SENSOR_TYPES = {
ATTR_STATUS: {
ATTR_ICON: "mdi:printer",

2
homeassistant/components/brother/manifest.json
View File

@ -3,7 +3,7 @@
"name": "Brother Printer",
"documentation": "https://www.home-assistant.io/integrations/brother",
"codeowners": ["@bieniu"],
"requirements": ["brother==0.1.20"],
"requirements": ["brother==0.1.21"],
"zeroconf": [{ "type": "_printer._tcp.local.", "name": "brother*" }],
"config_flow": true,
"quality_scale": "platinum"

3
homeassistant/components/brother/sensor.py
View File

@ -24,6 +24,7 @@ from .const import (
ATTR_YELLOW_DRUM_COUNTER,
ATTR_YELLOW_DRUM_REMAINING_LIFE,
ATTR_YELLOW_DRUM_REMAINING_PAGES,
DATA_CONFIG_ENTRY,
DOMAIN,
SENSOR_TYPES,
)
@ -37,7 +38,7 @@ ATTR_SERIAL = "serial"
async def async_setup_entry(hass, config_entry, async_add_entities):
"""Add Brother entities from a config_entry."""
coordinator = hass.data[DOMAIN][config_entry.entry_id]
coordinator = hass.data[DOMAIN][DATA_CONFIG_ENTRY][config_entry.entry_id]
sensors = []

30
homeassistant/components/brother/utils.py Normal file
View File

@ -0,0 +1,30 @@
"""Brother helpers functions."""
import logging
import pysnmp.hlapi.asyncio as hlapi
from pysnmp.hlapi.asyncio.cmdgen import lcd
from homeassistant.const import EVENT_HOMEASSISTANT_STOP
from homeassistant.core import callback
from homeassistant.helpers import singleton
from .const import DOMAIN, SNMP
_LOGGER = logging.getLogger(__name__)
@singleton.singleton("snmp_engine")
def get_snmp_engine(hass):
"""Get SNMP engine."""
_LOGGER.debug("Creating SNMP engine")
snmp_engine = hlapi.SnmpEngine()
@callback
def shutdown_listener(ev):
if hass.data.get(DOMAIN):
_LOGGER.debug("Unconfiguring SNMP engine")
lcd.unconfigure(hass.data[DOMAIN][SNMP], None)
hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, shutdown_listener)
return snmp_engine

37
homeassistant/components/google_assistant/report_state.py
View File

@ -38,42 +38,59 @@ def async_enable_report_state(hass: HomeAssistant, google_config: AbstractConfig
if not entity.is_supported():
return
if not checker.async_is_significant_change(new_state):
return
try:
entity_data = entity.query_serialize()
except SmartHomeError as err:
_LOGGER.debug("Not reporting state for %s: %s", changed_entity, err.code)
return
if not checker.async_is_significant_change(new_state, extra_arg=entity_data):
return
_LOGGER.debug("Reporting state for %s: %s", changed_entity, entity_data)
await google_config.async_report_state_all(
{"devices": {"states": {changed_entity: entity_data}}}
)
@callback
def extra_significant_check(
hass: HomeAssistant,
old_state: str,
old_attrs: dict,
old_extra_arg: dict,
new_state: str,
new_attrs: dict,
new_extra_arg: dict,
):
"""Check if the serialized data has changed."""
return old_extra_arg != new_extra_arg
async def inital_report(_now):
"""Report initially all states."""
nonlocal unsub, checker
entities = {}
checker = await create_checker(hass, DOMAIN)
checker = await create_checker(hass, DOMAIN, extra_significant_check)
for entity in async_get_entities(hass, google_config):
if not entity.should_expose():
continue
# Tell our significant change checker that we're reporting
# So it knows with subsequent changes what was already reported.
if not checker.async_is_significant_change(entity.state):
continue
try:
entities[entity.entity_id] = entity.query_serialize()
entity_data = entity.query_serialize()
except SmartHomeError:
continue
# Tell our significant change checker that we're reporting
# So it knows with subsequent changes what was already reported.
if not checker.async_is_significant_change(
entity.state, extra_arg=entity_data
):
continue
entities[entity.entity_id] = entity_data
if not entities:
return

2
homeassistant/components/lutron_caseta/manifest.json
View File

@ -3,7 +3,7 @@
"name": "Lutron Caséta",
"documentation": "https://www.home-assistant.io/integrations/lutron_caseta",
"requirements": [
"pylutron-caseta==0.9.0", "aiolip==1.0.1"
"pylutron-caseta==0.9.0", "aiolip==1.1.4"
],
"config_flow": true,
"zeroconf": ["_leap._tcp.local."],

12
homeassistant/components/myq/__init__.py
View File

@ -11,7 +11,7 @@ from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import ConfigEntryNotReady
from homeassistant.helpers import aiohttp_client
from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
from .const import DOMAIN, MYQ_COORDINATOR, MYQ_GATEWAY, PLATFORMS, UPDATE_INTERVAL
@ -40,11 +40,19 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry):
except MyQError as err:
raise ConfigEntryNotReady from err
# Called by DataUpdateCoordinator, allows to capture any MyQError exceptions and to throw an HASS UpdateFailed
# exception instead, preventing traceback in HASS logs.
async def async_update_data():
try:
return await myq.update_device_info()
except MyQError as err:
raise UpdateFailed(str(err)) from err
coordinator = DataUpdateCoordinator(
hass,
_LOGGER,
name="myq devices",
update_method=myq.update_device_info,
update_method=async_update_data,
update_interval=timedelta(seconds=UPDATE_INTERVAL),
)

7
homeassistant/components/myq/binary_sensor.py
View File

@ -1,7 +1,5 @@
"""Support for MyQ gateways."""
from pymyq.const import (
DEVICE_FAMILY as MYQ_DEVICE_FAMILY,
DEVICE_FAMILY_GATEWAY as MYQ_DEVICE_FAMILY_GATEWAY,
DEVICE_STATE as MYQ_DEVICE_STATE,
DEVICE_STATE_ONLINE as MYQ_DEVICE_STATE_ONLINE,
KNOWN_MODELS,
@ -25,9 +23,8 @@ async def async_setup_entry(hass, config_entry, async_add_entities):
entities = []
for device in myq.devices.values():
if device.device_json[MYQ_DEVICE_FAMILY] == MYQ_DEVICE_FAMILY_GATEWAY:
entities.append(MyQBinarySensorEntity(coordinator, device))
for device in myq.gateways.values():
entities.append(MyQBinarySensorEntity(coordinator, device))
async_add_entities(entities, True)

20
homeassistant/components/myq/const.py
View File

@ -1,9 +1,9 @@
"""The MyQ integration."""
from pymyq.device import (
STATE_CLOSED as MYQ_STATE_CLOSED,
STATE_CLOSING as MYQ_STATE_CLOSING,
STATE_OPEN as MYQ_STATE_OPEN,
STATE_OPENING as MYQ_STATE_OPENING,
from pymyq.garagedoor import (
STATE_CLOSED as MYQ_COVER_STATE_CLOSED,
STATE_CLOSING as MYQ_COVER_STATE_CLOSING,
STATE_OPEN as MYQ_COVER_STATE_OPEN,
STATE_OPENING as MYQ_COVER_STATE_OPENING,
)
from homeassistant.const import STATE_CLOSED, STATE_CLOSING, STATE_OPEN, STATE_OPENING
@ -13,10 +13,10 @@ DOMAIN = "myq"
PLATFORMS = ["cover", "binary_sensor"]
MYQ_TO_HASS = {
MYQ_STATE_CLOSED: STATE_CLOSED,
MYQ_STATE_CLOSING: STATE_CLOSING,
MYQ_STATE_OPEN: STATE_OPEN,
MYQ_STATE_OPENING: STATE_OPENING,
MYQ_COVER_STATE_CLOSED: STATE_CLOSED,
MYQ_COVER_STATE_CLOSING: STATE_CLOSING,
MYQ_COVER_STATE_OPEN: STATE_OPEN,
MYQ_COVER_STATE_OPENING: STATE_OPENING,
}
MYQ_GATEWAY = "myq_gateway"
@ -24,7 +24,7 @@ MYQ_COORDINATOR = "coordinator"
# myq has some ratelimits in place
# and 61 seemed to be work every time
UPDATE_INTERVAL = 61
UPDATE_INTERVAL = 15
# Estimated time it takes myq to start transition from one
# state to the next.

103
homeassistant/components/myq/cover.py
View File

@ -1,14 +1,14 @@
"""Support for MyQ-Enabled Garage Doors."""
import time
import logging
from pymyq.const import (
DEVICE_STATE as MYQ_DEVICE_STATE,
DEVICE_STATE_ONLINE as MYQ_DEVICE_STATE_ONLINE,
DEVICE_TYPE as MYQ_DEVICE_TYPE,
DEVICE_TYPE_GATE as MYQ_DEVICE_TYPE_GATE,
KNOWN_MODELS,
MANUFACTURER,
)
from pymyq.errors import MyQError
from homeassistant.components.cover import (
DEVICE_CLASS_GARAGE,
@ -17,19 +17,12 @@ from homeassistant.components.cover import (
SUPPORT_OPEN,
CoverEntity,
)
from homeassistant.const import STATE_CLOSED, STATE_CLOSING, STATE_OPENING
from homeassistant.core import callback
from homeassistant.helpers.event import async_call_later
from homeassistant.const import STATE_CLOSED, STATE_CLOSING, STATE_OPEN, STATE_OPENING
from homeassistant.helpers.update_coordinator import CoordinatorEntity
from .const import (
DOMAIN,
MYQ_COORDINATOR,
MYQ_GATEWAY,
MYQ_TO_HASS,
TRANSITION_COMPLETE_DURATION,
TRANSITION_START_DURATION,
)
from .const import DOMAIN, MYQ_COORDINATOR, MYQ_GATEWAY, MYQ_TO_HASS
_LOGGER = logging.getLogger(__name__)
async def async_setup_entry(hass, config_entry, async_add_entities):
@ -50,13 +43,11 @@ class MyQDevice(CoordinatorEntity, CoverEntity):
"""Initialize with API object, device id."""
super().__init__(coordinator)
self._device = device
self._last_action_timestamp = 0
self._scheduled_transition_update = None
@property
def device_class(self):
"""Define this cover as a garage door."""
device_type = self._device.device_json.get(MYQ_DEVICE_TYPE)
device_type = self._device.device_type
if device_type is not None and device_type == MYQ_DEVICE_TYPE_GATE:
return DEVICE_CLASS_GATE
return DEVICE_CLASS_GARAGE
@ -87,6 +78,11 @@ class MyQDevice(CoordinatorEntity, CoverEntity):
"""Return if the cover is closing or not."""
return MYQ_TO_HASS.get(self._device.state) == STATE_CLOSING
@property
def is_open(self):
"""Return if the cover is opening or not."""
return MYQ_TO_HASS.get(self._device.state) == STATE_OPEN
@property
def is_opening(self):
"""Return if the cover is opening or not."""
@ -104,37 +100,48 @@ class MyQDevice(CoordinatorEntity, CoverEntity):
async def async_close_cover(self, **kwargs):
"""Issue close command to cover."""
self._last_action_timestamp = time.time()
await self._device.close()
self._async_schedule_update_for_transition()
if self.is_closing or self.is_closed:
return
try:
wait_task = await self._device.close(wait_for_state=False)
except MyQError as err:
_LOGGER.error(
"Closing of cover %s failed with error: %s", self._device.name, str(err)
)
return
# Write closing state to HASS
self.async_write_ha_state()
if not await wait_task:
_LOGGER.error("Closing of cover %s failed", self._device.name)
# Write final state to HASS
self.async_write_ha_state()
async def async_open_cover(self, **kwargs):
"""Issue open command to cover."""
self._last_action_timestamp = time.time()
await self._device.open()
self._async_schedule_update_for_transition()
if self.is_opening or self.is_open:
return
@callback
def _async_schedule_update_for_transition(self):
try:
wait_task = await self._device.open(wait_for_state=False)
except MyQError as err:
_LOGGER.error(
"Opening of cover %s failed with error: %s", self._device.name, str(err)
)
return
# Write opening state to HASS
self.async_write_ha_state()
# Cancel any previous updates
if self._scheduled_transition_update:
self._scheduled_transition_update()
if not await wait_task:
_LOGGER.error("Opening of cover %s failed", self._device.name)
# Schedule an update for when we expect the transition
# to be completed so the garage door or gate does not
# seem like its closing or opening for a long time
self._scheduled_transition_update = async_call_later(
self.hass,
TRANSITION_COMPLETE_DURATION,
self._async_complete_schedule_update,
)
async def _async_complete_schedule_update(self, _):
"""Update status of the cover via coordinator."""
self._scheduled_transition_update = None
await self.coordinator.async_request_refresh()
# Write final state to HASS
self.async_write_ha_state()
@property
def device_info(self):
@ -152,22 +159,8 @@ class MyQDevice(CoordinatorEntity, CoverEntity):
device_info["via_device"] = (DOMAIN, self._device.parent_device_id)
return device_info
@callback
def _async_consume_update(self):
if time.time() - self._last_action_timestamp <= TRANSITION_START_DURATION:
# If we just started a transition we need
# to prevent a bouncy state
return
self.async_write_ha_state()
async def async_added_to_hass(self):
"""Subscribe to updates."""
self.async_on_remove(
self.coordinator.async_add_listener(self._async_consume_update)
self.coordinator.async_add_listener(self.async_write_ha_state)
)
async def async_will_remove_from_hass(self):
"""Undo subscription."""
if self._scheduled_transition_update:
self._scheduled_transition_update()

2
homeassistant/components/myq/manifest.json
View File

@ -2,7 +2,7 @@
"domain": "myq",
"name": "MyQ",
"documentation": "https://www.home-assistant.io/integrations/myq",
"requirements": ["pymyq==2.0.14"],
"requirements": ["pymyq==3.0.1"],
"codeowners": ["@bdraco"],
"config_flow": true,
"homekit": {

82
homeassistant/components/powerwall/__init__.py
View File

@ -4,10 +4,15 @@ from datetime import timedelta
import logging
import requests
from tesla_powerwall import MissingAttributeError, Powerwall, PowerwallUnreachableError
from tesla_powerwall import (
AccessDeniedError,
MissingAttributeError,
Powerwall,
PowerwallUnreachableError,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import CONF_IP_ADDRESS
from homeassistant.const import CONF_IP_ADDRESS, CONF_PASSWORD
from homeassistant.core import HomeAssistant, callback
from homeassistant.exceptions import ConfigEntryNotReady
from homeassistant.helpers import entity_registry
@ -93,11 +98,13 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry):
hass.data[DOMAIN].setdefault(entry_id, {})
http_session = requests.Session()
password = entry.data.get(CONF_PASSWORD)
power_wall = Powerwall(entry.data[CONF_IP_ADDRESS], http_session=http_session)
try:
await hass.async_add_executor_job(power_wall.detect_and_pin_version)
await hass.async_add_executor_job(_fetch_powerwall_data, power_wall)
powerwall_data = await hass.async_add_executor_job(call_base_info, power_wall)
powerwall_data = await hass.async_add_executor_job(
_login_and_fetch_base_info, power_wall, password
)
except PowerwallUnreachableError as err:
http_session.close()
raise ConfigEntryNotReady from err
@ -105,6 +112,11 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry):
http_session.close()
await _async_handle_api_changed_error(hass, err)
return False
except AccessDeniedError as err:
_LOGGER.debug("Authentication failed", exc_info=err)
http_session.close()
_async_start_reauth(hass, entry)
return False
await _migrate_old_unique_ids(hass, entry_id, powerwall_data)
@ -112,22 +124,20 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry):
"""Fetch data from API endpoint."""
# Check if we had an error before
_LOGGER.debug("Checking if update failed")
if not hass.data[DOMAIN][entry.entry_id][POWERWALL_API_CHANGED]:
_LOGGER.debug("Updating data")
try:
return await hass.async_add_executor_job(
_fetch_powerwall_data, power_wall
)
except PowerwallUnreachableError as err:
raise UpdateFailed("Unable to fetch data from powerwall") from err
except MissingAttributeError as err:
await _async_handle_api_changed_error(hass, err)
hass.data[DOMAIN][entry.entry_id][POWERWALL_API_CHANGED] = True
# Returns the cached data. This data can also be None
return hass.data[DOMAIN][entry.entry_id][POWERWALL_COORDINATOR].data
else:
if hass.data[DOMAIN][entry.entry_id][POWERWALL_API_CHANGED]:
return hass.data[DOMAIN][entry.entry_id][POWERWALL_COORDINATOR].data
_LOGGER.debug("Updating data")
try:
return await _async_update_powerwall_data(hass, entry, power_wall)
except AccessDeniedError:
if password is None:
raise
# If the session expired, relogin, and try again
await hass.async_add_executor_job(power_wall.login, "", password)
return await _async_update_powerwall_data(hass, entry, power_wall)
coordinator = DataUpdateCoordinator(
hass,
_LOGGER,
@ -156,6 +166,40 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry):
return True
async def _async_update_powerwall_data(
hass: HomeAssistant, entry: ConfigEntry, power_wall: Powerwall
):
"""Fetch updated powerwall data."""
try:
return await hass.async_add_executor_job(_fetch_powerwall_data, power_wall)
except PowerwallUnreachableError as err:
raise UpdateFailed("Unable to fetch data from powerwall") from err
except MissingAttributeError as err:
await _async_handle_api_changed_error(hass, err)
hass.data[DOMAIN][entry.entry_id][POWERWALL_API_CHANGED] = True
# Returns the cached data. This data can also be None
return hass.data[DOMAIN][entry.entry_id][POWERWALL_COORDINATOR].data
def _async_start_reauth(hass: HomeAssistant, entry: ConfigEntry):
hass.async_create_task(
hass.config_entries.flow.async_init(
DOMAIN,
context={"source": "reauth"},
data=entry.data,
)
)
_LOGGER.error("Password is no longer valid. Please reauthenticate")
def _login_and_fetch_base_info(power_wall: Powerwall, password: str):
"""Login to the powerwall and fetch the base info."""
if password is not None:
power_wall.login("", password)
power_wall.detect_and_pin_version()
return call_base_info(power_wall)
def call_base_info(power_wall):
"""Wrap powerwall properties to be a callable."""
serial_numbers = power_wall.get_serial_numbers()

58
homeassistant/components/powerwall/config_flow.py
View File

@ -1,12 +1,17 @@
"""Config flow for Tesla Powerwall integration."""
import logging
from tesla_powerwall import MissingAttributeError, Powerwall, PowerwallUnreachableError
from tesla_powerwall import (
AccessDeniedError,
MissingAttributeError,
Powerwall,
PowerwallUnreachableError,
)
import voluptuous as vol
from homeassistant import config_entries, core, exceptions
from homeassistant.components.dhcp import IP_ADDRESS
from homeassistant.const import CONF_IP_ADDRESS
from homeassistant.const import CONF_IP_ADDRESS, CONF_PASSWORD
from homeassistant.core import callback
from .const import DOMAIN # pylint:disable=unused-import
@ -14,6 +19,14 @@ from .const import DOMAIN # pylint:disable=unused-import
_LOGGER = logging.getLogger(__name__)
def _login_and_fetch_site_info(power_wall: Powerwall, password: str):
"""Login to the powerwall and fetch the base info."""
if password is not None:
power_wall.login("", password)
power_wall.detect_and_pin_version()
return power_wall.get_site_info()
async def validate_input(hass: core.HomeAssistant, data):
"""Validate the user input allows us to connect.
@ -21,12 +34,12 @@ async def validate_input(hass: core.HomeAssistant, data):
"""
power_wall = Powerwall(data[CONF_IP_ADDRESS])
password = data[CONF_PASSWORD]
try:
await hass.async_add_executor_job(power_wall.detect_and_pin_version)
site_info = await hass.async_add_executor_job(power_wall.get_site_info)
except PowerwallUnreachableError as err:
raise CannotConnect from err
site_info = await hass.async_add_executor_job(
_login_and_fetch_site_info, power_wall, password
)
except MissingAttributeError as err:
# Only log the exception without the traceback
_LOGGER.error(str(err))
@ -62,27 +75,44 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
if user_input is not None:
try:
info = await validate_input(self.hass, user_input)
except CannotConnect:
errors["base"] = "cannot_connect"
except PowerwallUnreachableError:
errors[CONF_IP_ADDRESS] = "cannot_connect"
except WrongVersion:
errors["base"] = "wrong_version"
except AccessDeniedError:
errors[CONF_PASSWORD] = "invalid_auth"
except Exception: # pylint: disable=broad-except
_LOGGER.exception("Unexpected exception")
errors["base"] = "unknown"
if "base" not in errors:
await self.async_set_unique_id(user_input[CONF_IP_ADDRESS])
self._abort_if_unique_id_configured()
if not errors:
existing_entry = await self.async_set_unique_id(
user_input[CONF_IP_ADDRESS]
)
if existing_entry:
self.hass.config_entries.async_update_entry(
existing_entry, data=user_input
)
await self.hass.config_entries.async_reload(existing_entry.entry_id)
return self.async_abort(reason="reauth_successful")
return self.async_create_entry(title=info["title"], data=user_input)
return self.async_show_form(
step_id="user",
data_schema=vol.Schema(
{vol.Required(CONF_IP_ADDRESS, default=self.ip_address): str}
{
vol.Required(CONF_IP_ADDRESS, default=self.ip_address): str,
vol.Optional(CONF_PASSWORD): str,
}
),
errors=errors,
)
async def async_step_reauth(self, data):
"""Handle configuration by re-auth."""
self.ip_address = data[CONF_IP_ADDRESS]
return await self.async_step_user()
@callback
def _async_ip_address_already_configured(self, ip_address):
"""See if we already have an entry matching the ip_address."""
@ -92,9 +122,5 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
return False
class CannotConnect(exceptions.HomeAssistantError):
"""Error to indicate we cannot connect."""
class WrongVersion(exceptions.HomeAssistantError):
"""Error to indicate the powerwall uses a software version we cannot interact with."""

2
homeassistant/components/powerwall/manifest.json
View File

@ -3,7 +3,7 @@
"name": "Tesla Powerwall",
"config_flow": true,
"documentation": "https://www.home-assistant.io/integrations/powerwall",
"requirements": ["tesla-powerwall==0.3.3"],
"requirements": ["tesla-powerwall==0.3.5"],
"codeowners": ["@bdraco", "@jrester"],
"dhcp": [
{"hostname":"1118431-*","macaddress":"88DA1A*"},

10
homeassistant/components/powerwall/strings.json
View File

@ -4,18 +4,22 @@
"step": {
"user": {
"title": "Connect to the powerwall",
"description": "The password is usually the last 5 characters of the serial number for Backup Gateway and can be found in the Telsa app; or the last 5 characters of the password found inside the door for Backup Gateway 2.",
"data": {
"ip_address": "[%key:common::config_flow::data::ip%]"
"ip_address": "[%key:common::config_flow::data::ip%]",
"password": "[%key:common::config_flow::data::password%]"
}
}
},
"error": {
"cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
"wrong_version": "Your powerwall uses a software version that is not supported. Please consider upgrading or reporting this issue so it can be resolved.",
"unknown": "[%key:common::config_flow::error::unknown%]"
"unknown": "[%key:common::config_flow::error::unknown%]",
"invalid_auth": "[%key:common::config_flow::error::invalid_auth%]"
},
"abort": {
"already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
"already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
"reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
}
}
}

10
homeassistant/components/powerwall/translations/en.json
View File

@ -1,10 +1,12 @@
{
"config": {
"abort": {
"already_configured": "Device is already configured"
"already_configured": "Device is already configured",
"reauth_successful": "Re-authentication was successful"
},
"error": {
"cannot_connect": "Failed to connect",
"invalid_auth": "Invalid authentication",
"unknown": "Unexpected error",
"wrong_version": "Your powerwall uses a software version that is not supported. Please consider upgrading or reporting this issue so it can be resolved."
},
@ -12,10 +14,12 @@
"step": {
"user": {
"data": {
"ip_address": "IP Address"
"ip_address": "IP Address",
"password": "Password"
},
"description": "The password is usually the last 5 characters of the serial number for Backup Gateway and can be found in the Telsa app; or the last 5 characters of the password found inside the door for Backup Gateway 2.",
"title": "Connect to the powerwall"
}
}
}
}
}

1
homeassistant/components/roku/strings.json
View File

@ -19,6 +19,7 @@
},
"abort": {
"already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
"already_in_progress": "[%key:common::config_flow::abort::already_in_progress%]",
"unknown": "[%key:common::config_flow::error::unknown%]"
}
}

1
homeassistant/components/roku/translations/en.json
View File

@ -2,6 +2,7 @@
"config": {
"abort": {
"already_configured": "Device is already configured",
"already_in_progress": "Configuration flow is already in progress",
"unknown": "Unexpected error"
},
"error": {

2
homeassistant/components/roon/manifest.json
View File

@ -4,7 +4,7 @@
"config_flow": true,
"documentation": "https://www.home-assistant.io/integrations/roon",
"requirements": [
"roonapi==0.0.31"
"roonapi==0.0.32"
],
"codeowners": [
"@pavoni"

11
homeassistant/components/roon/server.py
View File

@ -141,17 +141,6 @@ class RoonServer:
async_dispatcher_send(self.hass, "roon_media_player", player_data)
self.offline_devices.add(dev_id)
async def async_update_playlists(self):
"""Store lists in memory with all playlists - could be used by a custom lovelace card."""
all_playlists = []
roon_playlists = self.roonapi.playlists()
if roon_playlists and "items" in roon_playlists:
all_playlists += [item["title"] for item in roon_playlists["items"]]
roon_playlists = self.roonapi.internet_radio()
if roon_playlists and "items" in roon_playlists:
all_playlists += [item["title"] for item in roon_playlists["items"]]
self.all_playlists = all_playlists
async def async_create_player_data(self, zone, output):
"""Create player object dict by combining zone with output."""
new_dict = zone.copy()

5
homeassistant/components/shelly/light.py
View File

@ -187,6 +187,11 @@ class ShellyLight(ShellyBlockEntity, LightEntity):
async def async_turn_on(self, **kwargs) -> None:
"""Turn on light."""
if self.block.type == "relay":
self.control_result = await self.block.set_state(turn="on")
self.async_write_ha_state()
return
params = {"turn": "on"}
if ATTR_BRIGHTNESS in kwargs:
tmp_brightness = int(kwargs[ATTR_BRIGHTNESS] / 255 * 100)

47
homeassistant/components/tesla/__init__.py
View File

@ -5,10 +5,11 @@ from datetime import timedelta
import logging
import async_timeout
from teslajsonpy import Controller as TeslaAPI, TeslaException
from teslajsonpy import Controller as TeslaAPI
from teslajsonpy.exceptions import IncompleteCredentials, TeslaException
import voluptuous as vol
from homeassistant.config_entries import SOURCE_IMPORT
from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
from homeassistant.const import (
ATTR_BATTERY_CHARGING,
ATTR_BATTERY_LEVEL,
@ -17,8 +18,9 @@ from homeassistant.const import (
CONF_SCAN_INTERVAL,
CONF_TOKEN,
CONF_USERNAME,
HTTP_UNAUTHORIZED,
)
from homeassistant.core import callback
from homeassistant.core import HomeAssistant, callback
from homeassistant.exceptions import ConfigEntryNotReady
from homeassistant.helpers import aiohttp_client, config_validation as cv
from homeassistant.helpers.update_coordinator import (
@ -28,12 +30,7 @@ from homeassistant.helpers.update_coordinator import (
)
from homeassistant.util import slugify
from .config_flow import (
CannotConnect,
InvalidAuth,
configured_instances,
validate_input,
)
from .config_flow import CannotConnect, InvalidAuth, validate_input
from .const import (
CONF_WAKE_ON_START,
DATA_LISTENER,
@ -75,6 +72,16 @@ def _async_save_tokens(hass, config_entry, access_token, refresh_token):
)
@callback
def _async_configured_emails(hass):
"""Return a set of configured Tesla emails."""
return {
entry.data[CONF_USERNAME]
for entry in hass.config_entries.async_entries(DOMAIN)
if CONF_USERNAME in entry.data
}
async def async_setup(hass, base_config):
"""Set up of Tesla component."""
@ -95,7 +102,7 @@ async def async_setup(hass, base_config):
email = config[CONF_USERNAME]
password = config[CONF_PASSWORD]
scan_interval = config[CONF_SCAN_INTERVAL]
if email in configured_instances(hass):
if email in _async_configured_emails(hass):
try:
info = await validate_input(hass, config)
except (CannotConnect, InvalidAuth):
@ -103,6 +110,8 @@ async def async_setup(hass, base_config):
_update_entry(
email,
data={
CONF_USERNAME: email,
CONF_PASSWORD: password,
CONF_ACCESS_TOKEN: info[CONF_ACCESS_TOKEN],
CONF_TOKEN: info[CONF_TOKEN],
},
@ -136,6 +145,8 @@ async def async_setup_entry(hass, config_entry):
try:
controller = TeslaAPI(
websession,
email=config.get(CONF_USERNAME),
password=config.get(CONF_PASSWORD),
refresh_token=config[CONF_TOKEN],
access_token=config[CONF_ACCESS_TOKEN],
update_interval=config_entry.options.get(
@ -147,7 +158,12 @@ async def async_setup_entry(hass, config_entry):
CONF_WAKE_ON_START, DEFAULT_WAKE_ON_START
)
)
except IncompleteCredentials:
_async_start_reauth(hass, config_entry)
return False
except TeslaException as ex:
if ex.code == HTTP_UNAUTHORIZED:
_async_start_reauth(hass, config_entry)
_LOGGER.error("Unable to communicate with Tesla API: %s", ex.message)
return False
_async_save_tokens(hass, config_entry, access_token, refresh_token)
@ -202,6 +218,17 @@ async def async_unload_entry(hass, config_entry) -> bool:
return False
def _async_start_reauth(hass: HomeAssistant, entry: ConfigEntry):
hass.async_create_task(
hass.config_entries.flow.async_init(
DOMAIN,
context={"source": "reauth"},
data=entry.data,
)
)
_LOGGER.error("Credentials are no longer valid. Please reauthenticate")
async def update_listener(hass, config_entry):
"""Update when config_entry options update."""
controller = hass.data[DOMAIN][config_entry.entry_id]["coordinator"].controller

103
homeassistant/components/tesla/config_flow.py
View File

@ -20,22 +20,12 @@ from .const import (
CONF_WAKE_ON_START,
DEFAULT_SCAN_INTERVAL,
DEFAULT_WAKE_ON_START,
DOMAIN,
MIN_SCAN_INTERVAL,
)
from .const import DOMAIN # pylint:disable=unused-import
_LOGGER = logging.getLogger(__name__)
DATA_SCHEMA = vol.Schema(
{vol.Required(CONF_USERNAME): str, vol.Required(CONF_PASSWORD): str}
)
@callback
def configured_instances(hass):
"""Return a set of configured Tesla instances."""
return {entry.title for entry in hass.config_entries.async_entries(DOMAIN)}
class TeslaConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Tesla."""
@ -43,46 +33,56 @@ class TeslaConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
VERSION = 1
CONNECTION_CLASS = config_entries.CONN_CLASS_CLOUD_POLL
def __init__(self):
"""Initialize the tesla flow."""
self.username = None
async def async_step_import(self, import_config):
"""Import a config entry from configuration.yaml."""
return await self.async_step_user(import_config)
async def async_step_user(self, user_input=None):
"""Handle the start of the config flow."""
errors = {}
if not user_input:
return self.async_show_form(
step_id="user",
data_schema=DATA_SCHEMA,
errors={},
description_placeholders={},
)
if user_input is not None:
existing_entry = self._async_entry_for_username(user_input[CONF_USERNAME])
if (
existing_entry
and existing_entry.data[CONF_PASSWORD] == user_input[CONF_PASSWORD]
):
return self.async_abort(reason="already_configured")
if user_input[CONF_USERNAME] in configured_instances(self.hass):
return self.async_show_form(
step_id="user",
data_schema=DATA_SCHEMA,
errors={CONF_USERNAME: "already_configured"},
description_placeholders={},
)
try:
info = await validate_input(self.hass, user_input)
except CannotConnect:
errors["base"] = "cannot_connect"
except InvalidAuth:
errors["base"] = "invalid_auth"
try:
info = await validate_input(self.hass, user_input)
except CannotConnect:
return self.async_show_form(
step_id="user",
data_schema=DATA_SCHEMA,
errors={"base": "cannot_connect"},
description_placeholders={},
)
except InvalidAuth:
return self.async_show_form(
step_id="user",
data_schema=DATA_SCHEMA,
errors={"base": "invalid_auth"},
description_placeholders={},
)
return self.async_create_entry(title=user_input[CONF_USERNAME], data=info)
if not errors:
if existing_entry:
self.hass.config_entries.async_update_entry(
existing_entry, data=info
)
await self.hass.config_entries.async_reload(existing_entry.entry_id)
return self.async_abort(reason="reauth_successful")
return self.async_create_entry(
title=user_input[CONF_USERNAME], data=info
)
return self.async_show_form(
step_id="user",
data_schema=self._async_schema(),
errors=errors,
description_placeholders={},
)
async def async_step_reauth(self, data):
"""Handle configuration by re-auth."""
self.username = data[CONF_USERNAME]
return await self.async_step_user()
@staticmethod
@callback
@ -90,6 +90,23 @@ class TeslaConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
"""Get the options flow for this handler."""
return OptionsFlowHandler(config_entry)
@callback
def _async_schema(self):
"""Fetch schema with defaults."""
return vol.Schema(
{
vol.Required(CONF_USERNAME, default=self.username): str,
vol.Required(CONF_PASSWORD): str,
}
)
@callback
def _async_entry_for_username(self, username):
"""Find an existing entry for a username."""
for entry in self._async_current_entries():
if entry.data.get(CONF_USERNAME) == username:
return entry
class OptionsFlowHandler(config_entries.OptionsFlow):
"""Handle a option flow for Tesla."""
@ -140,6 +157,8 @@ async def validate_input(hass: core.HomeAssistant, data):
(config[CONF_TOKEN], config[CONF_ACCESS_TOKEN]) = await controller.connect(
test_login=True
)
config[CONF_USERNAME] = data[CONF_USERNAME]
config[CONF_PASSWORD] = data[CONF_PASSWORD]
except TeslaException as ex:
if ex.code == HTTP_UNAUTHORIZED:
_LOGGER.error("Invalid credentials: %s", ex)

8
homeassistant/components/tesla/manifest.json
View File

@ -3,11 +3,11 @@
"name": "Tesla",
"config_flow": true,
"documentation": "https://www.home-assistant.io/integrations/tesla",
"requirements": ["teslajsonpy==0.10.4"],
"requirements": ["teslajsonpy==0.11.5"],
"codeowners": ["@zabuldon", "@alandtse"],
"dhcp": [
{"hostname":"tesla_*","macaddress":"4CFCAA*"},
{"hostname":"tesla_*","macaddress":"044EAF*"},
{"hostname":"tesla_*","macaddress":"98ED5C*"}
{ "hostname": "tesla_*", "macaddress": "4CFCAA*" },
{ "hostname": "tesla_*", "macaddress": "044EAF*" },
{ "hostname": "tesla_*", "macaddress": "98ED5C*" }
]
}

4
homeassistant/components/tesla/strings.json
View File

@ -5,6 +5,10 @@
"already_configured": "[%key:common::config_flow::abort::already_configured_account%]",
"invalid_auth": "[%key:common::config_flow::error::invalid_auth%]"
},
"abort": {
"reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
"already_configured": "[%key:common::config_flow::abort::already_configured_account%]"
},
"step": {
"user": {
"data": {

4
homeassistant/components/tesla/translations/en.json
View File

@ -1,5 +1,9 @@
{
"config": {
"abort": {
"already_configured": "Account is already configured",
"reauth_successful": "Re-authentication was successful"
},
"error": {
"already_configured": "Account is already configured",
"cannot_connect": "Failed to connect",

51
homeassistant/components/transmission/__init__.py
View File

@ -397,42 +397,49 @@ class TransmissionData:
def check_completed_torrent(self):
"""Get completed torrent functionality."""
old_completed_torrent_names = {
torrent.name for torrent in self._completed_torrents
}
current_completed_torrents = [
torrent for torrent in self._torrents if torrent.status == "seeding"
]
freshly_completed_torrents = set(current_completed_torrents).difference(
self._completed_torrents
)
self._completed_torrents = current_completed_torrents
for torrent in freshly_completed_torrents:
self.hass.bus.fire(
EVENT_DOWNLOADED_TORRENT, {"name": torrent.name, "id": torrent.id}
)
for torrent in current_completed_torrents:
if torrent.name not in old_completed_torrent_names:
self.hass.bus.fire(
EVENT_DOWNLOADED_TORRENT, {"name": torrent.name, "id": torrent.id}
)
self._completed_torrents = current_completed_torrents
def check_started_torrent(self):
"""Get started torrent functionality."""
old_started_torrent_names = {torrent.name for torrent in self._started_torrents}
current_started_torrents = [
torrent for torrent in self._torrents if torrent.status == "downloading"
]
freshly_started_torrents = set(current_started_torrents).difference(
self._started_torrents
)
self._started_torrents = current_started_torrents
for torrent in freshly_started_torrents:
self.hass.bus.fire(
EVENT_STARTED_TORRENT, {"name": torrent.name, "id": torrent.id}
)
for torrent in current_started_torrents:
if torrent.name not in old_started_torrent_names:
self.hass.bus.fire(
EVENT_STARTED_TORRENT, {"name": torrent.name, "id": torrent.id}
)
self._started_torrents = current_started_torrents
def check_removed_torrent(self):
"""Get removed torrent functionality."""
freshly_removed_torrents = set(self._all_torrents).difference(self._torrents)
self._all_torrents = self._torrents
for torrent in freshly_removed_torrents:
self.hass.bus.fire(
EVENT_REMOVED_TORRENT, {"name": torrent.name, "id": torrent.id}
)
current_torrent_names = {torrent.name for torrent in self._torrents}
for torrent in self._all_torrents:
if torrent.name not in current_torrent_names:
self.hass.bus.fire(
EVENT_REMOVED_TORRENT, {"name": torrent.name, "id": torrent.id}
)
self._all_torrents = self._torrents.copy()
def start_torrents(self):
"""Start all torrents."""

12
homeassistant/components/zwave_js/binary_sensor.py
View File

@ -258,8 +258,10 @@ class ZWaveBooleanBinarySensor(ZWaveBaseEntity, BinarySensorEntity):
"""Representation of a Z-Wave binary_sensor."""
@property
def is_on(self) -> bool:
def is_on(self) -> Optional[bool]:
"""Return if the sensor is on or off."""
if self.info.primary_value.value is None:
return None
return bool(self.info.primary_value.value)
@property
@ -301,8 +303,10 @@ class ZWaveNotificationBinarySensor(ZWaveBaseEntity, BinarySensorEntity):
self._mapping_info = self._get_sensor_mapping()
@property
def is_on(self) -> bool:
def is_on(self) -> Optional[bool]:
"""Return if the sensor is on or off."""
if self.info.primary_value.value is None:
return None
return int(self.info.primary_value.value) == int(self.state_key)
@property
@ -349,8 +353,10 @@ class ZWavePropertyBinarySensor(ZWaveBaseEntity, BinarySensorEntity):
self._mapping_info = self._get_sensor_mapping()
@property
def is_on(self) -> bool:
def is_on(self) -> Optional[bool]:
"""Return if the sensor is on or off."""
if self.info.primary_value.value is None:
return None
return self.info.primary_value.value in self._mapping_info["on_states"]
@property

2
homeassistant/const.py
View File

@ -1,7 +1,7 @@
"""Constants used by Home Assistant components."""
MAJOR_VERSION = 2021
MINOR_VERSION = 2
PATCH_VERSION = "2"
PATCH_VERSION = "3"
__short_version__ = f"{MAJOR_VERSION}.{MINOR_VERSION}"
__version__ = f"{__short_version__}.{PATCH_VERSION}"
REQUIRED_PYTHON_VER = (3, 8, 0)

92
homeassistant/helpers/significant_change.py
View File

@ -27,7 +27,7 @@ The following cases will never be passed to your function:
- state adding/removing
"""
from types import MappingProxyType
from typing import Any, Callable, Dict, Optional, Union
from typing import Any, Callable, Dict, Optional, Tuple, Union
from homeassistant.const import STATE_UNAVAILABLE, STATE_UNKNOWN
from homeassistant.core import HomeAssistant, State, callback
@ -47,13 +47,28 @@ CheckTypeFunc = Callable[
Optional[bool],
]
ExtraCheckTypeFunc = Callable[
[
HomeAssistant,
str,
Union[dict, MappingProxyType],
Any,
str,
Union[dict, MappingProxyType],
Any,
],
Optional[bool],
]
async def create_checker(
hass: HomeAssistant, _domain: str
hass: HomeAssistant,
_domain: str,
extra_significant_check: Optional[ExtraCheckTypeFunc] = None,
) -> "SignificantlyChangedChecker":
"""Create a significantly changed checker for a domain."""
await _initialize(hass)
return SignificantlyChangedChecker(hass)
return SignificantlyChangedChecker(hass, extra_significant_check)
# Marked as singleton so multiple calls all wait for same output.
@ -105,34 +120,46 @@ class SignificantlyChangedChecker:
Will always compare the entity to the last entity that was considered significant.
"""
def __init__(self, hass: HomeAssistant) -> None:
def __init__(
self,
hass: HomeAssistant,
extra_significant_check: Optional[ExtraCheckTypeFunc] = None,
) -> None:
"""Test if an entity has significantly changed."""
self.hass = hass
self.last_approved_entities: Dict[str, State] = {}
self.last_approved_entities: Dict[str, Tuple[State, Any]] = {}
self.extra_significant_check = extra_significant_check
@callback
def async_is_significant_change(self, new_state: State) -> bool:
"""Return if this was a significant change."""
old_state: Optional[State] = self.last_approved_entities.get(
def async_is_significant_change(
self, new_state: State, *, extra_arg: Optional[Any] = None
) -> bool:
"""Return if this was a significant change.
Extra kwargs are passed to the extra significant checker.
"""
old_data: Optional[Tuple[State, Any]] = self.last_approved_entities.get(
new_state.entity_id
)
# First state change is always ok to report
if old_state is None:
self.last_approved_entities[new_state.entity_id] = new_state
if old_data is None:
self.last_approved_entities[new_state.entity_id] = (new_state, extra_arg)
return True
old_state, old_extra_arg = old_data
# Handle state unknown or unavailable
if new_state.state in (STATE_UNKNOWN, STATE_UNAVAILABLE):
if new_state.state == old_state.state:
return False
self.last_approved_entities[new_state.entity_id] = new_state
self.last_approved_entities[new_state.entity_id] = (new_state, extra_arg)
return True
# If last state was unknown/unavailable, also significant.
if old_state.state in (STATE_UNKNOWN, STATE_UNAVAILABLE):
self.last_approved_entities[new_state.entity_id] = new_state
self.last_approved_entities[new_state.entity_id] = (new_state, extra_arg)
return True
functions: Optional[Dict[str, CheckTypeFunc]] = self.hass.data.get(
@ -144,23 +171,36 @@ class SignificantlyChangedChecker:
check_significantly_changed = functions.get(new_state.domain)
# No platform available means always true.
if check_significantly_changed is None:
self.last_approved_entities[new_state.entity_id] = new_state
return True
if check_significantly_changed is not None:
result = check_significantly_changed(
self.hass,
old_state.state,
old_state.attributes,
new_state.state,
new_state.attributes,
)
result = check_significantly_changed(
self.hass,
old_state.state,
old_state.attributes,
new_state.state,
new_state.attributes,
)
if result is False:
return False
if result is False:
return False
if self.extra_significant_check is not None:
result = self.extra_significant_check(
self.hass,
old_state.state,
old_state.attributes,
old_extra_arg,
new_state.state,
new_state.attributes,
extra_arg,
)
if result is False:
return False
# Result is either True or None.
# None means the function doesn't know. For now assume it's True
self.last_approved_entities[new_state.entity_id] = new_state
self.last_approved_entities[new_state.entity_id] = (
new_state,
extra_arg,
)
return True

12
requirements_all.txt
View File

@ -197,7 +197,7 @@ aiolifx==0.6.9
aiolifx_effects==0.2.2
# homeassistant.components.lutron_caseta
aiolip==1.0.1
aiolip==1.1.4
# homeassistant.components.keyboard_remote
aionotify==0.2.0
@ -383,7 +383,7 @@ bravia-tv==1.0.8
broadlink==0.16.0
# homeassistant.components.brother
brother==0.1.20
brother==0.1.21
# homeassistant.components.brottsplatskartan
brottsplatskartan==0.0.1
@ -1545,7 +1545,7 @@ pymsteams==0.1.12
pymusiccast==0.1.6
# homeassistant.components.myq
pymyq==2.0.14
pymyq==3.0.1
# homeassistant.components.mysensors
pymysensors==0.18.0
@ -1961,7 +1961,7 @@ rokuecp==0.6.0
roombapy==1.6.2
# homeassistant.components.roon
roonapi==0.0.31
roonapi==0.0.32
# homeassistant.components.rova
rova==0.1.0
@ -2178,10 +2178,10 @@ temperusb==1.5.3
# tensorflow==2.3.0
# homeassistant.components.powerwall
tesla-powerwall==0.3.3
tesla-powerwall==0.3.5
# homeassistant.components.tesla
teslajsonpy==0.10.4
teslajsonpy==0.11.5
# homeassistant.components.tensorflow
# tf-models-official==2.3.0

12
requirements_test_all.txt
View File

@ -116,7 +116,7 @@ aiohue==2.1.0
aiokafka==0.6.0
# homeassistant.components.lutron_caseta
aiolip==1.0.1
aiolip==1.1.4
# homeassistant.components.notion
aionotion==1.1.0
@ -210,7 +210,7 @@ bravia-tv==1.0.8
broadlink==0.16.0
# homeassistant.components.brother
brother==0.1.20
brother==0.1.21
# homeassistant.components.bsblan
bsblan==0.4.0
@ -802,7 +802,7 @@ pymodbus==2.3.0
pymonoprice==0.3
# homeassistant.components.myq
pymyq==2.0.14
pymyq==3.0.1
# homeassistant.components.nut
pynut2==2.1.2
@ -983,7 +983,7 @@ rokuecp==0.6.0
roombapy==1.6.2
# homeassistant.components.roon
roonapi==0.0.31
roonapi==0.0.32
# homeassistant.components.rpi_power
rpi-bad-power==0.1.0
@ -1087,10 +1087,10 @@ synologydsm-api==1.0.1
tellduslive==0.10.11
# homeassistant.components.powerwall
tesla-powerwall==0.3.3
tesla-powerwall==0.3.5
# homeassistant.components.tesla
teslajsonpy==0.10.4
teslajsonpy==0.11.5
# homeassistant.components.toon
toonapi==0.2.0

25
tests/components/alexa/test_state_report.py
View File

@ -178,6 +178,7 @@ async def test_doorbell_event(hass, aioclient_mock):
async def test_proactive_mode_filter_states(hass, aioclient_mock):
"""Test all the cases that filter states."""
aioclient_mock.post(TEST_URL, text="", status=202)
await state_report.async_enable_proactive_mode(hass, DEFAULT_CONFIG)
# First state should report
@ -186,7 +187,8 @@ async def test_proactive_mode_filter_states(hass, aioclient_mock):
"on",
{"friendly_name": "Test Contact Sensor", "device_class": "door"},
)
assert len(aioclient_mock.mock_calls) == 0
await hass.async_block_till_done()
assert len(aioclient_mock.mock_calls) == 1
aioclient_mock.clear_requests()
@ -238,3 +240,24 @@ async def test_proactive_mode_filter_states(hass, aioclient_mock):
await hass.async_block_till_done()
await hass.async_block_till_done()
assert len(aioclient_mock.mock_calls) == 0
# If serializes to same properties, it should not report
aioclient_mock.post(TEST_URL, text="", status=202)
with patch(
"homeassistant.components.alexa.entities.AlexaEntity.serialize_properties",
return_value=[{"same": "info"}],
):
hass.states.async_set(
"binary_sensor.same_serialize",
"off",
{"friendly_name": "Test Contact Sensor", "device_class": "door"},
)
await hass.async_block_till_done()
hass.states.async_set(
"binary_sensor.same_serialize",
"off",
{"friendly_name": "Test Contact Sensor", "device_class": "door"},
)
await hass.async_block_till_done()
assert len(aioclient_mock.mock_calls) == 1

18
tests/components/google_assistant/test_report_state.py
View File

@ -46,6 +46,24 @@ async def test_report_state(hass, caplog, legacy_patchable_time):
"devices": {"states": {"light.kitchen": {"on": True, "online": True}}}
}
# Test that if serialize returns same value, we don't send
with patch(
"homeassistant.components.google_assistant.report_state.GoogleEntity.query_serialize",
return_value={"same": "info"},
), patch.object(BASIC_CONFIG, "async_report_state_all", AsyncMock()) as mock_report:
# New state, so reported
hass.states.async_set("light.double_report", "on")
await hass.async_block_till_done()
# Changed, but serialize is same, so filtered out by extra check
hass.states.async_set("light.double_report", "off")
await hass.async_block_till_done()
assert len(mock_report.mock_calls) == 1
assert mock_report.mock_calls[0][1][0] == {
"devices": {"states": {"light.double_report": {"same": "info"}}}
}
# Test that only significant state changes are reported
with patch.object(
BASIC_CONFIG, "async_report_state_all", AsyncMock()

32
tests/components/myq/util.py
View File

@ -1,14 +1,18 @@
"""Tests for the myq integration."""
import json
import logging
from unittest.mock import patch
from pymyq.const import ACCOUNTS_ENDPOINT, DEVICES_ENDPOINT
from homeassistant.components.myq.const import DOMAIN
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.core import HomeAssistant
from tests.common import MockConfigEntry, load_fixture
_LOGGER = logging.getLogger(__name__)
async def async_init_integration(
hass: HomeAssistant,
@ -20,16 +24,24 @@ async def async_init_integration(
devices_json = load_fixture(devices_fixture)
devices_dict = json.loads(devices_json)
def _handle_mock_api_request(method, endpoint, **kwargs):
if endpoint == "Login":
return {"SecurityToken": 1234}
if endpoint == "My":
return {"Account": {"Id": 1}}
if endpoint == "Accounts/1/Devices":
return devices_dict
return {}
def _handle_mock_api_oauth_authenticate():
return 1234, 1800
with patch("pymyq.api.API.request", side_effect=_handle_mock_api_request):
def _handle_mock_api_request(method, returns, url, **kwargs):
_LOGGER.debug("URL: %s", url)
if url == ACCOUNTS_ENDPOINT:
_LOGGER.debug("Accounts")
return None, {"accounts": [{"id": 1, "name": "mock"}]}
if url == DEVICES_ENDPOINT.format(account_id=1):
_LOGGER.debug("Devices")
return None, devices_dict
_LOGGER.debug("Something else")
return None, {}
with patch(
"pymyq.api.API._oauth_authenticate",
side_effect=_handle_mock_api_oauth_authenticate,
), patch("pymyq.api.API.request", side_effect=_handle_mock_api_request):
entry = MockConfigEntry(
domain=DOMAIN, data={CONF_USERNAME: "mock", CONF_PASSWORD: "mock"}
)

94
tests/components/powerwall/test_config_flow.py
View File

@ -2,17 +2,23 @@
from unittest.mock import patch
from tesla_powerwall import MissingAttributeError, PowerwallUnreachableError
from tesla_powerwall import (
AccessDeniedError,
MissingAttributeError,
PowerwallUnreachableError,
)
from homeassistant import config_entries, setup
from homeassistant.components.dhcp import HOSTNAME, IP_ADDRESS, MAC_ADDRESS
from homeassistant.components.powerwall.const import DOMAIN
from homeassistant.const import CONF_IP_ADDRESS
from homeassistant.const import CONF_IP_ADDRESS, CONF_PASSWORD
from .mocks import _mock_powerwall_side_effect, _mock_powerwall_site_name
from tests.common import MockConfigEntry
VALID_CONFIG = {CONF_IP_ADDRESS: "1.2.3.4", CONF_PASSWORD: "00GGX"}
async def test_form_source_user(hass):
"""Test we get config flow setup form as a user."""
@ -36,13 +42,13 @@ async def test_form_source_user(hass):
) as mock_setup_entry:
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{CONF_IP_ADDRESS: "1.2.3.4"},
VALID_CONFIG,
)
await hass.async_block_till_done()
assert result2["type"] == "create_entry"
assert result2["title"] == "My site"
assert result2["data"] == {CONF_IP_ADDRESS: "1.2.3.4"}
assert result2["data"] == VALID_CONFIG
assert len(mock_setup.mock_calls) == 1
assert len(mock_setup_entry.mock_calls) == 1
@ -61,11 +67,32 @@ async def test_form_cannot_connect(hass):
):
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{CONF_IP_ADDRESS: "1.2.3.4"},
VALID_CONFIG,
)
assert result2["type"] == "form"
assert result2["errors"] == {"base": "cannot_connect"}
assert result2["errors"] == {CONF_IP_ADDRESS: "cannot_connect"}
async def test_invalid_auth(hass):
"""Test we handle invalid auth error."""
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
)
mock_powerwall = _mock_powerwall_side_effect(site_info=AccessDeniedError("any"))
with patch(
"homeassistant.components.powerwall.config_flow.Powerwall",
return_value=mock_powerwall,
):
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
VALID_CONFIG,
)
assert result2["type"] == "form"
assert result2["errors"] == {CONF_PASSWORD: "invalid_auth"}
async def test_form_unknown_exeption(hass):
@ -81,8 +108,7 @@ async def test_form_unknown_exeption(hass):
return_value=mock_powerwall,
):
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{CONF_IP_ADDRESS: "1.2.3.4"},
result["flow_id"], VALID_CONFIG
)
assert result2["type"] == "form"
@ -105,7 +131,7 @@ async def test_form_wrong_version(hass):
):
result3 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{CONF_IP_ADDRESS: "1.2.3.4"},
VALID_CONFIG,
)
assert result3["type"] == "form"
@ -178,16 +204,54 @@ async def test_dhcp_discovery(hass):
) as mock_setup_entry:
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
CONF_IP_ADDRESS: "1.1.1.1",
},
VALID_CONFIG,
)
await hass.async_block_till_done()
assert result2["type"] == "create_entry"
assert result2["title"] == "Some site"
assert result2["data"] == {
CONF_IP_ADDRESS: "1.1.1.1",
}
assert result2["data"] == VALID_CONFIG
assert len(mock_setup.mock_calls) == 1
assert len(mock_setup_entry.mock_calls) == 1
async def test_form_reauth(hass):
"""Test reauthenticate."""
entry = MockConfigEntry(
domain=DOMAIN,
data=VALID_CONFIG,
unique_id="1.2.3.4",
)
entry.add_to_hass(hass)
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": "reauth"}, data=entry.data
)
assert result["type"] == "form"
assert result["errors"] == {}
mock_powerwall = await _mock_powerwall_site_name(hass, "My site")
with patch(
"homeassistant.components.powerwall.config_flow.Powerwall",
return_value=mock_powerwall,
), patch(
"homeassistant.components.powerwall.async_setup", return_value=True
) as mock_setup, patch(
"homeassistant.components.powerwall.async_setup_entry",
return_value=True,
) as mock_setup_entry:
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{
CONF_IP_ADDRESS: "1.2.3.4",
CONF_PASSWORD: "new-test-password",
},
)
await hass.async_block_till_done()
assert result2["type"] == "abort"
assert result2["reason"] == "reauth_successful"
assert len(mock_setup.mock_calls) == 1
assert len(mock_setup_entry.mock_calls) == 1

41
tests/components/tesla/test_config_flow.py
View File

@ -48,6 +48,8 @@ async def test_form(hass):
assert result2["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
assert result2["title"] == "test@email.com"
assert result2["data"] == {
CONF_USERNAME: "test@email.com",
CONF_PASSWORD: "test",
CONF_TOKEN: "test-refresh-token",
CONF_ACCESS_TOKEN: "test-access-token",
}
@ -95,7 +97,12 @@ async def test_form_cannot_connect(hass):
async def test_form_repeat_identifier(hass):
"""Test we handle repeat identifiers."""
entry = MockConfigEntry(domain=DOMAIN, title="test-username", data={}, options=None)
entry = MockConfigEntry(
domain=DOMAIN,
title="test-username",
data={"username": "test-username", "password": "test-password"},
options=None,
)
entry.add_to_hass(hass)
result = await hass.config_entries.flow.async_init(
@ -110,8 +117,36 @@ async def test_form_repeat_identifier(hass):
{CONF_USERNAME: "test-username", CONF_PASSWORD: "test-password"},
)
assert result2["type"] == "form"
assert result2["errors"] == {CONF_USERNAME: "already_configured"}
assert result2["type"] == "abort"
assert result2["reason"] == "already_configured"
async def test_form_reauth(hass):
"""Test we handle reauth."""
entry = MockConfigEntry(
domain=DOMAIN,
title="test-username",
data={"username": "test-username", "password": "same"},
options=None,
)
entry.add_to_hass(hass)
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_REAUTH},
data={"username": "test-username"},
)
with patch(
"homeassistant.components.tesla.config_flow.TeslaAPI.connect",
return_value=("test-refresh-token", "test-access-token"),
):
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{CONF_USERNAME: "test-username", CONF_PASSWORD: "new-password"},
)
assert result2["type"] == "abort"
assert result2["reason"] == "reauth_successful"
async def test_import(hass):

30
tests/helpers/test_significant_change.py
View File

@ -5,7 +5,6 @@ from homeassistant.components.sensor import DEVICE_CLASS_BATTERY
from homeassistant.const import ATTR_DEVICE_CLASS, STATE_UNAVAILABLE, STATE_UNKNOWN
from homeassistant.core import State
from homeassistant.helpers import significant_change
from homeassistant.setup import async_setup_component
@pytest.fixture(name="checker")
@ -26,8 +25,6 @@ async def checker_fixture(hass):
async def test_signicant_change(hass, checker):
"""Test initialize helper works."""
assert await async_setup_component(hass, "sensor", {})
ent_id = "test_domain.test_entity"
attrs = {ATTR_DEVICE_CLASS: DEVICE_CLASS_BATTERY}
@ -48,3 +45,30 @@ async def test_signicant_change(hass, checker):
# State turned unavailable
assert checker.async_is_significant_change(State(ent_id, "100", attrs))
assert checker.async_is_significant_change(State(ent_id, STATE_UNAVAILABLE, attrs))
async def test_significant_change_extra(hass, checker):
"""Test extra significant checker works."""
ent_id = "test_domain.test_entity"
attrs = {ATTR_DEVICE_CLASS: DEVICE_CLASS_BATTERY}
assert checker.async_is_significant_change(State(ent_id, "100", attrs), extra_arg=1)
assert checker.async_is_significant_change(State(ent_id, "200", attrs), extra_arg=1)
# Reset the last significiant change to 100 to repeat test but with
# extra checker installed.
assert checker.async_is_significant_change(State(ent_id, "100", attrs), extra_arg=1)
def extra_significant_check(
hass, old_state, old_attrs, old_extra_arg, new_state, new_attrs, new_extra_arg
):
return old_extra_arg != new_extra_arg
checker.extra_significant_check = extra_significant_check
# This is normally a significant change (100 -> 200), but the extra arg check marks it
# as insignificant.
assert not checker.async_is_significant_change(
State(ent_id, "200", attrs), extra_arg=1
)
assert checker.async_is_significant_change(State(ent_id, "200", attrs), extra_arg=2)