def setup(opp, config):
"""Establish connection to MAX! Cube."""
if DATA_KEY not in opp.data:
opp.data[DATA_KEY] = {}
connection_failed = 0
gateways = config[DOMAIN][CONF_GATEWAYS]
for gateway in gateways:
host = gateway[CONF_HOST]
port = gateway[CONF_PORT]
scan_interval = gateway[CONF_SCAN_INTERVAL].total_seconds()
try:
cube = MaxCube(host, port, now=now)
opp.data[DATA_KEY][host] = MaxCubeHandle(cube, scan_interval)
except timeout as ex:
_LOGGER.error("Unable to connect to Max!Cube gateway: %s", str(ex))
opp.components.persistent_notification.create(
f"Error: {ex}<br />You will need to restart Open Peer Power after fixing.",
title=NOTIFICATION_TITLE,
notification_id=NOTIFICATION_ID,
)
connection_failed += 1
if connection_failed >= len(gateways):
return False
load_platform(opp, "climate", DOMAIN, {}, config)
load_platform(opp, "binary_sensor", DOMAIN, {}, config)
return True
def autosetup_ihc_products(opp: OpenPeerPower, config, ihc_controller, controller_id):
"""Auto setup of IHC products from the IHC project file."""
project_xml = ihc_controller.get_project()
if not project_xml:
_LOGGER.error("Unable to read project from IHC controller")
return False
project = ElementTree.fromstring(project_xml)
# If an auto setup file exist in the configuration it will override
yaml_path = opp.config.path(AUTO_SETUP_YAML)
if not os.path.isfile(yaml_path):
yaml_path = os.path.join(os.path.dirname(__file__), AUTO_SETUP_YAML)
yaml = load_yaml_config_file(yaml_path)
try:
auto_setup_conf = AUTO_SETUP_SCHEMA(yaml)
except vol.Invalid as exception:
_LOGGER.error("Invalid IHC auto setup data: %s", exception)
return False
groups = project.findall(".//group")
for platform in PLATFORMS:
platform_setup = auto_setup_conf[platform]
discovery_info = get_discovery_info(platform_setup, groups, controller_id)
if discovery_info:
discovery.load_platform(opp, platform, DOMAIN, discovery_info, config)
return True
def setup(opp, base_config):
"""Set up the Fibaro Component."""
gateways = base_config[DOMAIN][CONF_GATEWAYS]
opp.data[FIBARO_CONTROLLERS] = {}
def stop_fibaro(event):
"""Stop Fibaro Thread."""
_LOGGER.info("Shutting down Fibaro connection")
for controller in opp.data[FIBARO_CONTROLLERS].values():
controller.disable_state_handler()
opp.data[FIBARO_DEVICES] = {}
for platform in PLATFORMS:
opp.data[FIBARO_DEVICES][platform] = []
for gateway in gateways:
controller = FibaroController(gateway)
if controller.connect():
opp.data[FIBARO_CONTROLLERS][controller.hub_serial] = controller
for platform in PLATFORMS:
opp.data[FIBARO_DEVICES][platform].extend(
controller.fibaro_devices[platform])
if opp.data[FIBARO_CONTROLLERS]:
for platform in PLATFORMS:
discovery.load_platform(opp, platform, DOMAIN, {}, base_config)
for controller in opp.data[FIBARO_CONTROLLERS].values():
controller.enable_state_handler()
opp.bus.listen_once(EVENT_OPENPEERPOWER_STOP, stop_fibaro)
return True
return False
def setup(opp, config):
"""Set up Eufy devices."""
if CONF_USERNAME in config[DOMAIN] and CONF_PASSWORD in config[DOMAIN]:
data = lakeside.get_devices(config[DOMAIN][CONF_USERNAME],
config[DOMAIN][CONF_PASSWORD])
for device in data:
kind = device["type"]
if kind not in EUFY_DISPATCH:
continue
discovery.load_platform(opp, EUFY_DISPATCH[kind], DOMAIN, device,
config)
for device_info in config[DOMAIN][CONF_DEVICES]:
kind = device_info["type"]
if kind not in EUFY_DISPATCH:
continue
device = {}
device["address"] = device_info["address"]
device["code"] = device_info["access_token"]
device["type"] = device_info["type"]
device["name"] = device_info["name"]
discovery.load_platform(opp, EUFY_DISPATCH[kind], DOMAIN, device,
config)
return True
def _load_entities(self):
sensor_info = []
for pidx, printer in enumerate(self.printers):
for sensor_type in self.sensors:
info = {}
info["sensor_type"] = sensor_type
info["printer_id"] = pidx
info["name"] = printer.slug
info["printer_name"] = self.conf_name
known = f"{printer.slug}-{sensor_type}"
if known in self._known_entities:
continue
methods = API_PRINTER_METHODS[sensor_type]
if "temp_data" in methods["state"].values():
prop_data = getattr(printer, methods["attribute"])
if prop_data is None:
continue
for idx, _ in enumerate(prop_data):
prop_info = info.copy()
prop_info["temp_id"] = idx
sensor_info.append(prop_info)
else:
info["temp_id"] = None
sensor_info.append(info)
self._known_entities.add(known)
if not sensor_info:
return
load_platform(self._opp, "sensor", DOMAIN, sensor_info, self.config)
def setup(opp, opp_config):
"""Set up global ECoalController instance same for sensors and switches."""
conf = opp_config[DOMAIN]
host = conf[CONF_HOST]
username = conf[CONF_USERNAME]
passwd = conf[CONF_PASSWORD]
# Creating ECoalController instance makes HTTP request to controller.
ecoal_contr = ECoalController(host, username, passwd)
if ecoal_contr.version is None:
# Wrong credentials nor network config
_LOGGER.error(
"Unable to read controller status from %s@%s (wrong host/credentials)",
username,
host,
)
return False
_LOGGER.debug("Detected controller version: %r @%s", ecoal_contr.version,
host)
opp.data[DATA_ECOAL_BOILER] = ecoal_contr
# Setup switches
switches = conf[CONF_SWITCHES][CONF_MONITORED_CONDITIONS]
load_platform(opp, "switch", DOMAIN, switches, opp_config)
# Setup temp sensors
sensors = conf[CONF_SENSORS][CONF_MONITORED_CONDITIONS]
load_platform(opp, "sensor", DOMAIN, sensors, opp_config)
return True
def setup(opp, base_config):
"""Start Homeworks controller."""
def hw_callback(msg_type, values):
"""Dispatch state changes."""
_LOGGER.debug("callback: %s, %s", msg_type, values)
addr = values[0]
signal = f"homeworks_entity_{addr}"
dispatcher_send(opp, signal, msg_type, values)
config = base_config.get(DOMAIN)
controller = Homeworks(config[CONF_HOST], config[CONF_PORT], hw_callback)
opp.data[HOMEWORKS_CONTROLLER] = controller
def cleanup(event):
controller.close()
opp.bus.listen_once(EVENT_OPENPEERPOWER_STOP, cleanup)
dimmers = config[CONF_DIMMERS]
load_platform(opp, "light", DOMAIN, {CONF_DIMMERS: dimmers}, base_config)
for key_config in config[CONF_KEYPADS]:
addr = key_config[CONF_ADDR]
name = key_config[CONF_NAME]
HomeworksKeypadEvent(opp, addr, name)
return True
def setup(opp, config):
"""Set up the ComfoConnect bridge."""
conf = config[DOMAIN]
host = conf[CONF_HOST]
name = conf[CONF_NAME]
token = conf[CONF_TOKEN]
user_agent = conf[CONF_USER_AGENT]
pin = conf[CONF_PIN]
# Run discovery on the configured ip
bridges = Bridge.discover(host)
if not bridges:
_LOGGER.error("Could not connect to ComfoConnect bridge on %s", host)
return False
bridge = bridges[0]
_LOGGER.info("Bridge found: %s (%s)", bridge.uuid.hex(), bridge.host)
# Setup ComfoConnect Bridge
ccb = ComfoConnectBridge(opp, bridge, name, token, user_agent, pin)
opp.data[DOMAIN] = ccb
# Start connection with bridge
ccb.connect()
# Schedule disconnect on shutdown
def _shutdown(_event):
ccb.disconnect()
opp.bus.listen_once(EVENT_OPENPEERPOWER_STOP, _shutdown)
# Load platforms
discovery.load_platform(opp, "fan", DOMAIN, {}, config)
return True
def load_module(platform, idx, module_conf):
"""Set up the KIRA module and load platform."""
# note: module_name is not the OPP device name. it's just a unique name
# to ensure the component and platform can share information
module_name = ("%s_%d" % (DOMAIN, idx)) if idx else DOMAIN
device_name = module_conf.get(CONF_NAME, DOMAIN)
port = module_conf.get(CONF_PORT, DEFAULT_PORT)
host = module_conf.get(CONF_HOST, DEFAULT_HOST)
if platform == CONF_SENSOR:
module = pykira.KiraReceiver(host, port)
module.start()
else:
module = pykira.KiraModule(host, port)
opp.data[DOMAIN][platform][module_name] = module
for code in codes:
code_tuple = (code.get(CONF_NAME),
code.get(CONF_DEVICE, STATE_UNKNOWN))
module.registerCode(code_tuple, code.get(CONF_CODE))
discovery.load_platform(opp, platform, DOMAIN, {
"name": module_name,
"device": device_name
}, config)
def setup(opp, config):
"""Set up the Coinbase component.
Will automatically setup sensors to support
wallets discovered on the network.
"""
api_key = config[DOMAIN][CONF_API_KEY]
api_secret = config[DOMAIN][CONF_API_SECRET]
account_currencies = config[DOMAIN].get(CONF_ACCOUNT_CURRENCIES)
exchange_currencies = config[DOMAIN][CONF_EXCHANGE_CURRENCIES]
opp.data[DATA_COINBASE] = coinbase_data = CoinbaseData(api_key, api_secret)
if not hasattr(coinbase_data, "accounts"):
return False
for account in coinbase_data.accounts:
if account_currencies is None or account.currency in account_currencies:
load_platform(opp, "sensor", DOMAIN, {"account": account}, config)
for currency in exchange_currencies:
if currency not in coinbase_data.exchange_rates.rates:
_LOGGER.warning("Currency %s not found", currency)
continue
native = coinbase_data.exchange_rates.currency
load_platform(
opp,
"sensor",
DOMAIN,
{
"native_currency": native,
"exchange_currency": currency
},
config,
)
return True
def setup(opp, config):
"""Set up the eBusd component."""
_LOGGER.debug("Integration setup started")
conf = config[DOMAIN]
name = conf[CONF_NAME]
circuit = conf[CONF_CIRCUIT]
monitored_conditions = conf.get(CONF_MONITORED_CONDITIONS)
server_address = (conf.get(CONF_HOST), conf.get(CONF_PORT))
try:
ebusdpy.init(server_address)
opp.data[DOMAIN] = EbusdData(server_address, circuit)
sensor_config = {
CONF_MONITORED_CONDITIONS: monitored_conditions,
"client_name": name,
"sensor_types": SENSOR_TYPES[circuit],
}
load_platform(opp, "sensor", DOMAIN, sensor_config, config)
opp.services.register(DOMAIN, SERVICE_EBUSD_WRITE,
opp.data[DOMAIN].write)
_LOGGER.debug("Ebusd integration setup completed")
return True
except (socket.timeout, OSError):
return False
def get_manual_configuration(opp, config, conf, ihc_controller, controller_id):
"""Get manual configuration for IHC devices."""
for platform in PLATFORMS:
discovery_info = {}
if platform in conf:
platform_setup = conf.get(platform)
for sensor_cfg in platform_setup:
name = sensor_cfg[CONF_NAME]
device = {
"ihc_id": sensor_cfg[CONF_ID],
"ctrl_id": controller_id,
"product": {
"name": name,
"note": sensor_cfg.get(CONF_NOTE) or "",
"position": sensor_cfg.get(CONF_POSITION) or "",
},
"product_cfg": {
"type": sensor_cfg.get(CONF_TYPE),
"inverting": sensor_cfg.get(CONF_INVERTING),
"off_id": sensor_cfg.get(CONF_OFF_ID),
"on_id": sensor_cfg.get(CONF_ON_ID),
"dimmable": sensor_cfg.get(CONF_DIMMABLE),
"unit_of_measurement": sensor_cfg.get(CONF_UNIT_OF_MEASUREMENT),
},
}
discovery_info[name] = device
if discovery_info:
discovery.load_platform(opp, platform, DOMAIN, discovery_info, config)
def setup(opp, config):
"""Set up the Nextcloud integration."""
# Fetch Nextcloud Monitor api data
conf = config[DOMAIN]
try:
ncm = NextcloudMonitor(conf[CONF_URL], conf[CONF_USERNAME], conf[CONF_PASSWORD])
except NextcloudMonitorError:
_LOGGER.error("Nextcloud setup failed - Check configuration")
opp.data[DOMAIN] = get_data_points(ncm.data)
opp.data[DOMAIN]["instance"] = conf[CONF_URL]
def nextcloud_update(event_time):
"""Update data from nextcloud api."""
try:
ncm.update()
except NextcloudMonitorError:
_LOGGER.error("Nextcloud update failed")
return False
opp.data[DOMAIN] = get_data_points(ncm.data)
opp.data[DOMAIN]["instance"] = conf[CONF_URL]
# Update sensors on time interval
track_time_interval(opp, nextcloud_update, conf[CONF_SCAN_INTERVAL])
for platform in PLATFORMS:
discovery.load_platform(opp, platform, DOMAIN, {}, config)
return True
async def async_setup(opp, config):
"""Set up the iOS component."""
conf = config.get(DOMAIN)
ios_config = await opp.async_add_executor_job(
load_json, opp.config.path(CONFIGURATION_FILE))
if ios_config == {}:
ios_config[ATTR_DEVICES] = {}
ios_config[CONF_USER] = conf or {}
if CONF_PUSH not in ios_config[CONF_USER]:
ios_config[CONF_USER][CONF_PUSH] = {}
opp.data[DOMAIN] = ios_config
# No entry support for notify component yet
discovery.load_platform(opp, "notify", DOMAIN, {}, config)
if conf is not None:
opp.async_create_task(
opp.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_IMPORT}))
return True
def setup(opp, config):
"""Set up the QVR Pro component."""
conf = config[DOMAIN]
user = conf[CONF_USERNAME]
password = conf[CONF_PASSWORD]
host = conf[CONF_HOST]
port = conf[CONF_PORT]
excluded_channels = conf[CONF_EXCLUDE_CHANNELS]
try:
qvrpro = Client(user, password, host, port=port)
channel_resp = qvrpro.get_channel_list()
except InsufficientPermissionsError:
_LOGGER.error("User must have Surveillance Management permission")
return False
except AuthenticationError:
_LOGGER.error("Authentication failed")
return False
except RequestsConnectionError:
_LOGGER.error("Error connecting to QVR server")
return False
channels = []
for channel in channel_resp["channels"]:
if channel["channel_index"] + 1 in excluded_channels:
continue
channels.append(channel)
opp.data[DOMAIN] = {"channels": channels, "client": qvrpro}
load_platform(opp, CAMERA_DOMAIN, DOMAIN, {}, config)
# Register services
def handle_start_record(call):
guid = call.data[SERVICE_CHANNEL_GUID]
qvrpro.start_recording(guid)
def handle_stop_record(call):
guid = call.data[SERVICE_CHANNEL_GUID]
qvrpro.stop_recording(guid)
opp.services.register(
DOMAIN,
SERVICE_START_RECORD,
handle_start_record,
schema=SERVICE_CHANNEL_RECORD_SCHEMA,
)
opp.services.register(
DOMAIN,
SERVICE_STOP_RECORD,
handle_stop_record,
schema=SERVICE_CHANNEL_RECORD_SCHEMA,
)
return True
def setup(opp, config):
"""Set up the IOTA component."""
iota_config = config[DOMAIN]
for platform in IOTA_PLATFORMS:
load_platform(opp, platform, DOMAIN, iota_config, config)
return True
def test_platform(self, mock_setup_component):
"""Test discover platform method."""
calls = []
@callback
def platform_callback(platform, info):
"""Platform callback method."""
calls.append((platform, info))
run_callback_threadsafe(
self.opp.loop,
discovery.async_listen_platform,
self.opp,
"test_component",
platform_callback,
).result()
discovery.load_platform(
self.opp,
"test_component",
"test_platform",
"discovery info",
{"test_component": {}},
)
self.opp.block_till_done()
assert mock_setup_component.called
assert mock_setup_component.call_args[0] == (
self.opp,
"test_component",
{
"test_component": {}
},
)
self.opp.block_till_done()
discovery.load_platform(
self.opp,
"test_component_2",
"test_platform",
"discovery info",
{"test_component": {}},
)
self.opp.block_till_done()
assert len(calls) == 1
assert calls[0] == ("test_platform", "discovery info")
dispatcher_send(
self.opp,
discovery.SIGNAL_PLATFORM_DISCOVERED,
{
"service":
discovery.EVENT_LOAD_PLATFORM.format("test_component")
},
)
self.opp.block_till_done()
assert len(calls) == 1
def setup(opp, config):
"""Set up the Egardia platform."""
conf = config[DOMAIN]
username = conf.get(CONF_USERNAME)
password = conf.get(CONF_PASSWORD)
host = conf.get(CONF_HOST)
port = conf.get(CONF_PORT)
version = conf.get(CONF_VERSION)
rs_enabled = conf.get(CONF_REPORT_SERVER_ENABLED)
rs_port = conf.get(CONF_REPORT_SERVER_PORT)
try:
device = opp.data[EGARDIA_DEVICE] = egardiadevice.EgardiaDevice(
host, port, username, password, "", version)
except requests.exceptions.RequestException:
_LOGGER.error("An error occurred accessing your Egardia device. "
"Please check configuration")
return False
except egardiadevice.UnauthorizedError:
_LOGGER.error("Unable to authorize. Wrong password or username")
return False
# Set up the egardia server if enabled
if rs_enabled:
_LOGGER.debug("Setting up EgardiaServer")
try:
if EGARDIA_SERVER not in opp.data:
server = egardiaserver.EgardiaServer("", rs_port)
bound = server.bind()
if not bound:
raise OSError(
"Binding error occurred while starting EgardiaServer.")
opp.data[EGARDIA_SERVER] = server
server.start()
def handle_stop_event(event):
"""Handle Open Peer Power stop event."""
server.stop()
# listen to Open Peer Power stop event
opp.bus.listen_once(EVENT_OPENPEERPOWER_STOP, handle_stop_event)
except OSError:
_LOGGER.error(
"Binding error occurred while starting EgardiaServer")
return False
discovery.load_platform(opp,
"alarm_control_panel",
DOMAIN,
discovered=conf,
opp_config=config)
# Get the sensors from the device and add those
sensors = device.getsensors()
discovery.load_platform(opp, "binary_sensor", DOMAIN,
{ATTR_DISCOVER_DEVICES: sensors}, config)
return True
def setup(opp, base_config):
"""Set up the Lutron integration."""
opp.data[LUTRON_BUTTONS] = []
opp.data[LUTRON_CONTROLLER] = None
opp.data[LUTRON_DEVICES] = {
"light": [],
"cover": [],
"switch": [],
"scene": [],
"binary_sensor": [],
}
config = base_config.get(DOMAIN)
opp.data[LUTRON_CONTROLLER] = Lutron(config[CONF_HOST],
config[CONF_USERNAME],
config[CONF_PASSWORD])
opp.data[LUTRON_CONTROLLER].load_xml_db()
opp.data[LUTRON_CONTROLLER].connect()
_LOGGER.info("Connected to main repeater at %s", config[CONF_HOST])
# Sort our devices into types
for area in opp.data[LUTRON_CONTROLLER].areas:
for output in area.outputs:
if output.type == "SYSTEM_SHADE":
opp.data[LUTRON_DEVICES]["cover"].append((area.name, output))
elif output.is_dimmable:
opp.data[LUTRON_DEVICES]["light"].append((area.name, output))
else:
opp.data[LUTRON_DEVICES]["switch"].append((area.name, output))
for keypad in area.keypads:
for button in keypad.buttons:
# If the button has a function assigned to it, add it as a scene
if button.name != "Unknown Button" and button.button_type in (
"SingleAction",
"Toggle",
"SingleSceneRaiseLower",
"MasterRaiseLower",
):
# Associate an LED with a button if there is one
led = next(
(led for led in keypad.leds
if led.number == button.number),
None,
)
opp.data[LUTRON_DEVICES]["scene"].append(
(area.name, keypad.name, button, led))
opp.data[LUTRON_BUTTONS].append(
LutronButton(opp, area.name, keypad, button))
if area.occupancy_group is not None:
opp.data[LUTRON_DEVICES]["binary_sensor"].append(
(area.name, area.occupancy_group))
for platform in PLATFORMS:
discovery.load_platform(opp, platform, DOMAIN, {}, base_config)
return True
def setup(opp, config):
"""Set up the PCA switch platform."""
for platform in ELV_PLATFORMS:
discovery.load_platform(opp, platform, DOMAIN,
{"device": config[DOMAIN][CONF_DEVICE]},
config)
return True
def setup(opp, config):
"""Set up the Danfoss Air component."""
conf = config[DOMAIN]
opp.data[DOMAIN] = DanfossAir(conf[CONF_HOST])
for platform in PLATFORMS:
discovery.load_platform(opp, platform, DOMAIN, {}, config)
return True
def _new_device(device):
"""Handle new devices which are detected by HDMI network."""
key = f"{DOMAIN}.{device.name}"
opp.data[key] = device
ent_platform = base_config[DOMAIN][CONF_TYPES].get(key, platform)
discovery.load_platform(
opp,
ent_platform,
DOMAIN,
discovered={ATTR_NEW: [key]},
opp_config=base_config,
)
async def test_setup_does_discovery(mock_setup_component, mock_setup, opp):
"""Test setup for discovery."""
component = EntityComponent(_LOGGER, DOMAIN, opp)
component.setup({})
discovery.load_platform(
opp, DOMAIN, "platform_test", {"msg": "discovery_info"}, {DOMAIN: {}}
)
await opp.async_block_till_done()
assert mock_setup.called
assert ("platform_test", {}, {"msg": "discovery_info"}) == mock_setup.call_args[0]
def setup(opp, config):
"""Set up the Ecovacs component."""
_LOGGER.debug("Creating new Ecovacs component")
opp.data[ECOVACS_DEVICES] = []
ecovacs_api = EcoVacsAPI(
ECOVACS_API_DEVICEID,
config[DOMAIN].get(CONF_USERNAME),
EcoVacsAPI.md5(config[DOMAIN].get(CONF_PASSWORD)),
config[DOMAIN].get(CONF_COUNTRY),
config[DOMAIN].get(CONF_CONTINENT),
)
devices = ecovacs_api.devices()
_LOGGER.debug("Ecobot devices: %s", devices)
for device in devices:
_LOGGER.info(
"Discovered Ecovacs device on account: %s with nickname %s",
device["did"],
device["nick"],
)
vacbot = VacBot(
ecovacs_api.uid,
ecovacs_api.REALM,
ecovacs_api.resource,
ecovacs_api.user_access_token,
device,
config[DOMAIN].get(CONF_CONTINENT).lower(),
monitor=True,
)
opp.data[ECOVACS_DEVICES].append(vacbot)
def stop(event: object) -> None:
"""Shut down open connections to Ecovacs XMPP server."""
for device in opp.data[ECOVACS_DEVICES]:
_LOGGER.info(
"Shutting down connection to Ecovacs device %s", device.vacuum["did"]
)
device.disconnect()
# Listen for OPP stop to disconnect.
opp.bus.listen_once(EVENT_OPENPEERPOWER_STOP, stop)
if opp.data[ECOVACS_DEVICES]:
_LOGGER.debug("Starting vacuum components")
discovery.load_platform(opp, "vacuum", DOMAIN, {}, config)
return True
def setup(opp, config):
"""Set up the streamlabs water integration."""
conf = config[DOMAIN]
api_key = conf.get(CONF_API_KEY)
location_id = conf.get(CONF_LOCATION_ID)
client = streamlabswater.StreamlabsClient(api_key)
locations = client.get_locations().get("locations")
if locations is None:
_LOGGER.error("Unable to retrieve locations. Verify API key")
return False
if location_id is None:
location = locations[0]
location_id = location["locationId"]
_LOGGER.info("Streamlabs Water Monitor auto-detected location_id=%s",
location_id)
else:
location = next(
(loc for loc in locations if location_id == loc["locationId"]),
None)
if location is None:
_LOGGER.error("Supplied location_id is invalid")
return False
location_name = location["name"]
opp.data[DOMAIN] = {
"client": client,
"location_id": location_id,
"location_name": location_name,
}
for platform in PLATFORMS:
discovery.load_platform(opp, platform, DOMAIN, {}, config)
def set_away_mode(service):
"""Set the StreamLabsWater Away Mode."""
away_mode = service.data.get(ATTR_AWAY_MODE)
client.update_location(location_id, away_mode)
opp.services.register(DOMAIN,
SERVICE_SET_AWAY_MODE,
set_away_mode,
schema=SET_AWAY_MODE_SCHEMA)
return True
def test_discover_notify(self, mock_demo_get_service):
"""Test discovery of notify demo platform."""
assert notify.DOMAIN not in self.opp.config.components
discovery.load_platform(self.opp, "notify", "demo",
{"test_key": "test_val"}, {"notify": {}})
self.opp.block_till_done()
assert notify.DOMAIN in self.opp.config.components
assert mock_demo_get_service.called
assert mock_demo_get_service.mock_calls[0][1] == (
self.opp,
{},
{
"test_key": "test_val"
},
)
def setup(opp, config):
"""Set up the BloomSky integration."""
api_key = config[DOMAIN][CONF_API_KEY]
try:
bloomsky = BloomSky(api_key, opp.config.units.is_metric)
except RuntimeError:
return False
opp.data[DOMAIN] = bloomsky
for platform in PLATFORMS:
discovery.load_platform(opp, platform, DOMAIN, {}, config)
return True
def setup(opp, config):
"""Set up the STIEBEL ELTRON unit.
Will automatically load climate platform.
"""
name = config[DOMAIN][CONF_NAME]
modbus_client = opp.data[MODBUS_DOMAIN][config[DOMAIN][CONF_HUB]]
opp.data[DOMAIN] = {
"name": name,
"ste_data": StiebelEltronData(name, modbus_client),
}
discovery.load_platform(opp, "climate", DOMAIN, {}, config)
return True
def setup(opp, config):
"""Set up the OctoPrint component."""
printers = opp.data[DOMAIN] = {}
success = False
if DOMAIN not in config:
# Skip the setup if there is no configuration present
return True
for printer in config[DOMAIN]:
name = printer[CONF_NAME]
protocol = "https" if printer[CONF_SSL] else "http"
base_url = (
f"{protocol}://{printer[CONF_HOST]}:{printer[CONF_PORT]}"
f"{printer[CONF_PATH]}api/"
)
api_key = printer[CONF_API_KEY]
number_of_tools = printer[CONF_NUMBER_OF_TOOLS]
bed = printer[CONF_BED]
try:
octoprint_api = OctoPrintAPI(base_url, api_key, bed, number_of_tools)
printers[base_url] = octoprint_api
octoprint_api.get("printer")
octoprint_api.get("job")
except requests.exceptions.RequestException as conn_err:
_LOGGER.error("Error setting up OctoPrint API: %r", conn_err)
continue
sensors = printer[CONF_SENSORS][CONF_MONITORED_CONDITIONS]
load_platform(
opp,
"sensor",
DOMAIN,
{"name": name, "base_url": base_url, "sensors": sensors},
config,
)
b_sensors = printer[CONF_BINARY_SENSORS][CONF_MONITORED_CONDITIONS]
load_platform(
opp,
"binary_sensor",
DOMAIN,
{"name": name, "base_url": base_url, "sensors": b_sensors},
config,
)
success = True
return success
def setup(opp, config):
"""Set up Tahoma integration."""
conf = config[DOMAIN]
username = conf.get(CONF_USERNAME)
password = conf.get(CONF_PASSWORD)
exclude = conf.get(CONF_EXCLUDE)
try:
api = TahomaApi(username, password)
except RequestException:
_LOGGER.exception("Error when trying to log in to the Tahoma API")
return False
try:
api.get_setup()
devices = api.get_devices()
scenes = api.get_action_groups()
except RequestException:
_LOGGER.exception("Error when getting devices from the Tahoma API")
return False
opp.data[DOMAIN] = {
"controller": api,
"devices": defaultdict(list),
"scenes": []
}
for device in devices:
_device = api.get_device(device)
if all(ext not in _device.type for ext in exclude):
device_type = map_tahoma_device(_device)
if device_type is None:
_LOGGER.warning(
"Unsupported type %s for Tahoma device %s",
_device.type,
_device.label,
)
continue
opp.data[DOMAIN]["devices"][device_type].append(_device)
for scene in scenes:
opp.data[DOMAIN]["scenes"].append(scene)
for platform in PLATFORMS:
discovery.load_platform(opp, platform, DOMAIN, {}, config)
return True
