"so2": ATTR_SULFUR_DIOXIDE,
}
ATTRIBUTION = "Data provided by the World Air Quality Index project"
CONF_LOCATIONS = "locations"
CONF_STATIONS = "stations"
SCAN_INTERVAL = timedelta(minutes=5)
TIMEOUT = 10
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Optional(CONF_STATIONS):
cv.ensure_list,
vol.Required(CONF_TOKEN):
cv.string,
vol.Required(CONF_LOCATIONS):
cv.ensure_list,
})
async def async_setup_platform(opp,
config,
async_add_entities,
discovery_info=None):
"""Set up the requested World Air Quality Index locations."""
token = config.get(CONF_TOKEN)
station_filter = config.get(CONF_STATIONS)
locations = config.get(CONF_LOCATIONS)
CONF_VISIBILITY_TEMPLATE = "visibility_template"
CONF_FORECAST_TEMPLATE = "forecast_template"
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_NAME):
cv.string,
vol.Required(CONF_CONDITION_TEMPLATE):
cv.template,
vol.Required(CONF_TEMPERATURE_TEMPLATE):
cv.template,
vol.Required(CONF_HUMIDITY_TEMPLATE):
cv.template,
vol.Optional(CONF_ATTRIBUTION_TEMPLATE):
cv.template,
vol.Optional(CONF_PRESSURE_TEMPLATE):
cv.template,
vol.Optional(CONF_WIND_SPEED_TEMPLATE):
cv.template,
vol.Optional(CONF_WIND_BEARING_TEMPLATE):
cv.template,
vol.Optional(CONF_OZONE_TEMPLATE):
cv.template,
vol.Optional(CONF_VISIBILITY_TEMPLATE):
cv.template,
vol.Optional(CONF_FORECAST_TEMPLATE):
cv.template,
vol.Optional(CONF_UNIQUE_ID):
cv.string,
})
async def async_setup_platform(opp,
vol.Optional(CONF_COLOR_ACTION): cv.SCRIPT_SCHEMA,
vol.Optional(CONF_WHITE_VALUE_TEMPLATE): cv.template,
vol.Optional(CONF_WHITE_VALUE_ACTION): cv.SCRIPT_SCHEMA,
vol.Inclusive(CONF_EFFECT_LIST_TEMPLATE, "effect"): cv.template,
vol.Inclusive(CONF_EFFECT_TEMPLATE, "effect"): cv.template,
vol.Inclusive(CONF_EFFECT_ACTION, "effect"): cv.SCRIPT_SCHEMA,
vol.Optional(CONF_MAX_MIREDS_TEMPLATE): cv.template,
vol.Optional(CONF_MIN_MIREDS_TEMPLATE): cv.template,
vol.Optional(CONF_SUPPORTS_TRANSITION): cv.template,
vol.Optional(CONF_UNIQUE_ID): cv.string,
}
),
)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{vol.Required(CONF_LIGHTS): cv.schema_with_slug_keys(LIGHT_SCHEMA)}
)
async def _async_create_entities(opp, config):
"""Create the Template Lights."""
lights = []
for device, device_config in config[CONF_LIGHTS].items():
friendly_name = device_config.get(CONF_FRIENDLY_NAME, device)
state_template = device_config.get(CONF_VALUE_TEMPLATE)
icon_template = device_config.get(CONF_ICON_TEMPLATE)
entity_picture_template = device_config.get(CONF_ENTITY_PICTURE_TEMPLATE)
availability_template = device_config.get(CONF_AVAILABILITY_TEMPLATE)
unique_id = device_config.get(CONF_UNIQUE_ID)
import voluptuous as vol
from openpeerpower.components.sensor import SensorEntity
import openpeerpower.helpers.config_validation as cv
from openpeerpower.helpers.config_validation import PLATFORM_SCHEMA
SCAN_INTERVAL = timedelta(hours=12)
CONF_ZIP = "zip"
CONF_WASTE_TYPE = "waste_type"
CONF_NAME = "name"
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_ZIP):
cv.positive_int,
vol.Required(CONF_WASTE_TYPE, default="waste"):
cv.string,
vol.Optional(CONF_NAME):
cv.string,
})
def setup_platform(opp, config, add_entities, discovery_info=None):
"""Set up the sensor platform."""
api_connector = OpenERZConnector(config[CONF_ZIP], config[CONF_WASTE_TYPE])
add_entities([OpenERZSensor(api_connector, config.get(CONF_NAME))], True)
class OpenERZSensor(SensorEntity):
"""Representation of a Sensor."""
def __init__(self, api_connector, name):
"""Initialize the sensor."""
| SUPPORT_VOLUME_STEP
| SUPPORT_TURN_ON
| SUPPORT_PAUSE
| SUPPORT_SELECT_SOURCE)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_HOST):
cv.string,
vol.Optional(CONF_NAME, default=DEFAULT_NAME):
cv.string,
vol.Optional(CONF_PORT, default=DEFAULT_PORT):
cv.port,
vol.Optional(CONF_USERNAME, default=DEFAULT_USERNAME):
cv.string,
vol.Optional(CONF_PASSWORD, default=DEFAULT_PASSWORD):
cv.string,
vol.Optional(CONF_SSL, default=DEFAULT_SSL):
cv.boolean,
vol.Optional(CONF_USE_CHANNEL_ICON, default=DEFAULT_USE_CHANNEL_ICON):
cv.boolean,
vol.Optional(CONF_DEEP_STANDBY, default=DEFAULT_DEEP_STANDBY):
cv.boolean,
vol.Optional(CONF_MAC_ADDRESS, default=DEFAULT_MAC_ADDRESS):
cv.string,
vol.Optional(CONF_SOURCE_BOUQUET, default=DEFAULT_SOURCE_BOUQUET):
cv.string,
})
def setup_platform(opp, config, add_devices, discovery_info=None):
"""Set up of an enigma2 media player."""
if discovery_info:
def test_validate_platform_config(self, caplog):
"""Test validating platform configuration."""
platform_schema = PLATFORM_SCHEMA.extend({"hello": str})
platform_schema_base = PLATFORM_SCHEMA_BASE.extend({})
mock_integration(
self.opp,
MockModule("platform_conf",
platform_schema_base=platform_schema_base),
)
mock_entity_platform(
self.opp,
"platform_conf.whatever",
MockPlatform(platform_schema=platform_schema),
)
with assert_setup_component(0):
assert setup.setup_component(
self.opp,
"platform_conf",
{
"platform_conf": {
"platform": "not_existing",
"hello": "world"
}
},
)
self.opp.data.pop(setup.DATA_SETUP)
self.opp.config.components.remove("platform_conf")
with assert_setup_component(1):
assert setup.setup_component(
self.opp,
"platform_conf",
{"platform_conf": {
"platform": "whatever",
"hello": "world"
}},
)
self.opp.data.pop(setup.DATA_SETUP)
self.opp.config.components.remove("platform_conf")
with assert_setup_component(1):
assert setup.setup_component(
self.opp,
"platform_conf",
{
"platform_conf": [{
"platform": "whatever",
"hello": "world"
}]
},
)
self.opp.data.pop(setup.DATA_SETUP)
self.opp.config.components.remove("platform_conf")
# Any falsey platform config will be ignored (None, {}, etc)
with assert_setup_component(0) as config:
assert setup.setup_component(self.opp, "platform_conf",
{"platform_conf": None})
assert "platform_conf" in self.opp.config.components
assert not config["platform_conf"] # empty
assert setup.setup_component(self.opp, "platform_conf",
{"platform_conf": {}})
assert "platform_conf" in self.opp.config.components
assert not config["platform_conf"] # empty
[ATTR_CARBON_DIOXIDE, CONCENTRATION_PARTS_PER_MILLION, "mdi:molecule-co2"],
"voc": [
ATTR_VOLATILE_ORGANIC_COMPOUNDS,
CONCENTRATION_PARTS_PER_BILLION,
"mdi:cloud",
],
"allpollu": [ATTR_FOOBOT_INDEX, PERCENTAGE, "mdi:percent"],
}
SCAN_INTERVAL = timedelta(minutes=10)
PARALLEL_UPDATES = 1
TIMEOUT = 10
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_TOKEN): cv.string,
vol.Required(CONF_USERNAME): cv.string
})
async def async_setup_platform(opp,
config,
async_add_entities,
discovery_info=None):
"""Set up the devices associated with the account."""
token = config.get(CONF_TOKEN)
username = config.get(CONF_USERNAME)
client = FoobotClient(token,
username,
async_get_clientsession(opp),
timeout=TIMEOUT)