async def get_bridge(hass, host, username=None):
"""Create a bridge object and verify authentication."""
import aiohue
bridge = aiohue.Bridge(
host,
username=username,
websession=aiohttp_client.async_get_clientsession(hass))
try:
with async_timeout.timeout(5):
# Create username if we don't have one
if not username:
await bridge.create_user('home-assistant')
# Initialize bridge (and validate our username)
await bridge.initialize()
return bridge
except (aiohue.LinkButtonNotPressed, aiohue.Unauthorized):
LOGGER.warning("Connected to Hue at %s but not registered.", host)
raise AuthenticationRequired
except (asyncio.TimeoutError, aiohue.RequestError):
LOGGER.error("Error connecting to the Hue bridge at %s", host)
raise CannotConnect
except aiohue.AiohueException:
LOGGER.exception('Unknown Hue linking error occurred')
raise AuthenticationRequired
async def async_step_link(self, user_input=None):
"""Attempt to link with the Hue bridge."""
import aiohue
errors = {}
if user_input is not None:
bridge = aiohue.Bridge(self.host, websession=self._websession)
try:
with async_timeout.timeout(5):
# Create auth token
await bridge.create_user('home-assistant')
# Fetches name and id
await bridge.initialize()
except (asyncio.TimeoutError, aiohue.RequestError,
aiohue.LinkButtonNotPressed):
errors['base'] = 'Failed to register, please try again.'
except aiohue.AiohueException:
errors['base'] = 'Unknown linking error occurred.'
_LOGGER.exception('Uknown Hue linking error occurred')
else:
return self.async_create_entry(title=bridge.config.name,
data={
'host': bridge.host,
'bridge_id':
bridge.config.bridgeid,
'username': bridge.username,
})
return self.async_show_form(
step_id='link',
title='Link Hub',
description=CONFIG_INSTRUCTIONS,
errors=errors,
)
async def get_bridge(hass, host, username=None):
"""Create a bridge object and verify authentication."""
bridge = aiohue.Bridge(
host,
username=username,
websession=aiohttp_client.async_get_clientsession(hass))
try:
with async_timeout.timeout(10):
# Create username if we don't have one
if not username:
device_name = unicode_slug.slugify(hass.config.location_name,
max_length=19)
await bridge.create_user(f"home-assistant#{device_name}")
# Initialize bridge (and validate our username)
await bridge.initialize()
return bridge
except (aiohue.LinkButtonNotPressed, aiohue.Unauthorized):
raise AuthenticationRequired
except (asyncio.TimeoutError, aiohue.RequestError):
raise CannotConnect
except aiohue.AiohueException:
LOGGER.exception("Unknown Hue linking error occurred")
raise AuthenticationRequired
async def async_setup(self):
"""Set up a phue bridge based on host parameter."""
import aiohue
api = aiohue.Bridge(self.host,
username=self.username,
websession=aiohttp_client.async_get_clientsession(
self.hass))
try:
with async_timeout.timeout(5):
# Initialize bridge and validate our username
if not self.username:
await api.create_user('home-assistant')
await api.initialize()
except (aiohue.LinkButtonNotPressed, aiohue.Unauthorized):
_LOGGER.warning("Connected to Hue at %s but not registered.",
self.host)
self.async_request_configuration()
return
except (asyncio.TimeoutError, aiohue.RequestError):
_LOGGER.error("Error connecting to the Hue bridge at %s",
self.host)
return
except aiohue.AiohueException:
_LOGGER.exception('Unknown Hue linking error occurred')
self.async_request_configuration()
return
except Exception: # pylint: disable=broad-except
_LOGGER.exception("Unknown error connecting with Hue bridge at %s",
self.host)
return
self.hass.data[DOMAIN][self.host] = self
# If we came here and configuring this host, mark as done
if self.config_request_id:
request_id = self.config_request_id
self.config_request_id = None
self.hass.components.configurator.async_request_done(request_id)
self.username = api.username
# Save config file
await self.hass.async_add_job(
save_json, self.hass.config.path(self.filename),
{self.host: {
'username': api.username
}})
self.api = api
self.hass.async_add_job(
discovery.async_load_platform(self.hass, 'light', DOMAIN,
{'host': self.host}))
self.hass.services.async_register(DOMAIN,
SERVICE_HUE_SCENE,
self.hue_activate_scene,
schema=SCENE_SCHEMA)
async def async_setup(self, tries=0):
"""Set up a phue bridge based on host parameter."""
host = self.host
hass = self.hass
bridge = aiohue.Bridge(
host,
username=self.config_entry.data["username"],
websession=aiohttp_client.async_get_clientsession(hass),
)
try:
await authenticate_bridge(hass, bridge)
except AuthenticationRequired:
# Usernames can become invalid if hub is reset or user removed.
# We are going to fail the config entry setup and initiate a new
# linking procedure. When linking succeeds, it will remove the
# old config entry.
create_config_flow(hass, host)
return False
except CannotConnect as err:
LOGGER.error("Error connecting to the Hue bridge at %s", host)
raise ConfigEntryNotReady from err
except Exception: # pylint: disable=broad-except
LOGGER.exception("Unknown error connecting with Hue bridge at %s",
host)
return False
self.api = bridge
self.sensor_manager = SensorManager(self)
hass.async_create_task(
hass.config_entries.async_forward_entry_setup(
self.config_entry, "light"))
hass.async_create_task(
hass.config_entries.async_forward_entry_setup(
self.config_entry, "binary_sensor"))
hass.async_create_task(
hass.config_entries.async_forward_entry_setup(
self.config_entry, "sensor"))
hass.services.async_register(DOMAIN,
SERVICE_HUE_SCENE,
self.hue_activate_scene,
schema=SCENE_SCHEMA)
self.parallel_updates_semaphore = asyncio.Semaphore(
3 if self.api.config.modelid == "BSB001" else 10)
self.unsub_config_entry_listener = self.config_entry.add_update_listener(
_update_listener)
self.authorized = True
return True
def _async_get_bridge(self, host: str, bridge_id: Optional[str] = None):
"""Return a bridge object."""
if bridge_id is not None:
bridge_id = normalize_bridge_id(bridge_id)
return aiohue.Bridge(
host,
websession=aiohttp_client.async_get_clientsession(self.hass),
bridge_id=bridge_id,
)
async def update_hue_run(self, websession):
try:
entriesJson = open('/config/.storage/core.config_entries', )
response = json.load(entriesJson)
for entry in response["data"]["entries"]:
if entry["title"] == "Philips hue":
break
bridge = aiohue.Bridge(
entry["data"]["host"],
username=entry["data"]["username"],
websession=websession,
)
except Exception as e:
raise e
if bridge is None:
bridges = await discover_nupnp(websession)
if self._hue_bridge is not None:
bridge = aiohue.Bridge(
self._hue_bridge,
username=self._hue_username,
websession=websession,
)
else:
bridges = await discover_nupnp(websession)
bridge = bridges[0]
bridge.username = self._hue_username
await bridge.initialize()
for id in bridge.scenes:
scene = bridge.scenes[id]
if self._hue_keyword in scene.name:
color_temp = self._calc_ct()
lightstates = await scene.lightstates
for light_id in scene.lights:
await scene.set_lightstate(id=light_id,
on=lightstates[light_id]["on"],
bri=round(self._brightness),
ct=color_temp)
async def connect(self):
self.bridge = aiohue.Bridge(
self.config["host"],
username=self.config[USERNAME],
websession=aiohttp.ClientSession(),
)
try:
if not self.config[USERNAME]:
await self.bridge.create_user("riva")
await self.bridge.initialize()
except aiohue.Unauthorized:
pass
except aiohue.LinkButtonNotPressed:
pass
async def async_setup(self, tries=0):
"""Set up a phue bridge based on host parameter."""
host = self.host
opp = self.opp
bridge = aiohue.Bridge(
host,
username=self.config_entry.data["username"],
websession=aiohttp_client.async_get_clientsession(opp),
)
try:
await authenticate_bridge(opp, bridge)
except AuthenticationRequired:
# Usernames can become invalid if hub is reset or user removed.
# We are going to fail the config entry setup and initiate a new
# linking procedure. When linking succeeds, it will remove the
# old config entry.
create_config_flow(opp, host)
return False
except CannotConnect as err:
raise ConfigEntryNotReady(
f"Error connecting to the Hue bridge at {host}") from err
except Exception: # pylint: disable=broad-except
LOGGER.exception("Unknown error connecting with Hue bridge at %s",
host)
return False
self.api = bridge
if bridge.sensors is not None:
self.sensor_manager = SensorManager(self)
opp.data.setdefault(DOMAIN, {})[self.config_entry.entry_id] = self
opp.config_entries.async_setup_platforms(self.config_entry, PLATFORMS)
self.parallel_updates_semaphore = asyncio.Semaphore(
3 if self.api.config.modelid == "BSB001" else 10)
self.reset_jobs.append(
self.config_entry.add_update_listener(_update_listener))
self.reset_jobs.append(
asyncio.create_task(self._subscribe_events()).cancel)
self.authorized = True
return True
