DEFAULT_COLOR = [255, 255, 255] DEFAULT_BRIGHTNESS = 255 DEFAULT_COLOR_TEMP_MODE = 'absolute' DEFAULT_MIN_KELVIN = 2700 # 370 mireds DEFAULT_MAX_KELVIN = 6000 # 166 mireds class ColorTempModes(Enum): """Color temperature modes for config validation.""" absolute = "DPT-7.600" relative = "DPT-5.001" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_ADDRESS): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_STATE_ADDRESS): cv.string, vol.Optional(CONF_BRIGHTNESS_ADDRESS): cv.string, vol.Optional(CONF_BRIGHTNESS_STATE_ADDRESS): cv.string, vol.Optional(CONF_COLOR_ADDRESS): cv.string, vol.Optional(CONF_COLOR_STATE_ADDRESS): cv.string, vol.Optional(CONF_COLOR_TEMP_ADDRESS): cv.string,
STATE_HEAT, SUPPORT_FAN_MODE, SUPPORT_OPERATION_MODE, SUPPORT_SWING_MODE, SUPPORT_TARGET_TEMPERATURE) from homeassistant.const import (ATTR_TEMPERATURE, CONF_PASSWORD, CONF_USERNAME, STATE_OFF, STATE_UNKNOWN, TEMP_CELSIUS) from homeassistant.exceptions import PlatformNotReady REQUIREMENTS = ['pyintesishome==0.8'] _LOGGER = logging.getLogger(__name__) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string }) # Return cached results if last scan time was less than this value. # If a persistent connection is established for the controller, changes to # values are in realtime. SCAN_INTERVAL = timedelta(seconds=300) IH_FAN_AUTO = 'Auto' IH_FAN_QUIET = 'Quiet' IH_FAN_LOW = 'Low' IH_FAN_MEDIUM = 'Medium' IH_FAN_HIGH = 'High' IH_SWING_WIDGET = 42
"""Config flow for Bosch Smart Home Controller integration.""" import logging import voluptuous as vol from homeassistant import config_entries, core, exceptions from homeassistant.const import CONF_ICON, CONF_IP_ADDRESS, CONF_NAME from .const import CONF_SSL_CERTIFICATE # pylint:disable=unused-import from .const import CONF_SSL_KEY, DOMAIN _LOGGER = logging.getLogger(__name__) DATA_SCHEMA = vol.Schema({ vol.Required(CONF_NAME, default="Home"): str, vol.Required(CONF_IP_ADDRESS): str, vol.Required(CONF_SSL_CERTIFICATE): str, vol.Required(CONF_SSL_KEY): str, vol.Optional(CONF_ICON): str, }) async def validate_input(hass: core.HomeAssistant, data): """Validate the user input allows us to connect. Data has the keys from DATA_SCHEMA with values provided by the user. """ from boschshcpy import SHCSession session = await hass.async_add_executor_job( SHCSession,
from blumate.const import (CONF_HOST, CONF_PLATFORM, CONF_NAME, CONF_PORT, ATTR_UNIT_OF_MEASUREMENT) from blumate.util import Throttle REQUIREMENTS = ['pysnmp==4.3.2'] _LOGGER = logging.getLogger(__name__) DEFAULT_NAME = "SNMP" DEFAULT_COMMUNITY = "public" DEFAULT_PORT = "161" CONF_COMMUNITY = "community" CONF_BASEOID = "baseoid" PLATFORM_SCHEMA = vol.Schema({ vol.Required(CONF_PLATFORM): 'snmp', vol.Optional(CONF_NAME): vol.Coerce(str), vol.Required(CONF_HOST): vol.Coerce(str), vol.Optional(CONF_PORT): vol.Coerce(int), vol.Optional(CONF_COMMUNITY): vol.Coerce(str), vol.Required(CONF_BASEOID): vol.Coerce(str), vol.Optional(ATTR_UNIT_OF_MEASUREMENT): vol.Coerce(str), })
ZAKB_URL = 'https://www.zakb.de/online-service/online-service/abfallkalender/' COLLECTIONS = { 'R': 'Restabfallbehälter', 'B': 'Bioabfallbehälter', 'P': 'Papierbehälter', 'G': 'Gelber Sack' } CONF_OFFSET = "offset" CONF_TOWN = "town" CONF_STREET = "street" CONF_STREET_NR = "street_nr" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_TOWN): cv.string, vol.Required(CONF_STREET): cv.string, vol.Required(CONF_STREET_NR): cv.string, vol.Optional(CONF_OFFSET, default=timedelta(hours=6)): cv.time_period, vol.Optional(CONF_SCAN_INTERVAL, default=timedelta(hours=3)): cv.time_period }) def setup_platform(hass, config, add_devices, discovery_info=None): scan_interval = config.get(CONF_SCAN_INTERVAL) _LOGGER.info('scan_interval: {}'.format(scan_interval)) calendar_devices = [] for collection in COLLECTIONS: device_data = {
_LOGGER = logging.getLogger(__name__) # Domain and component constants and validation DOMAIN = "google_keep" SHOPPING_LIST_DOMAIN = "shopping_list" CONF_USERNAME = '******' # Google account username CONF_PASSWORD = '******' # Google App password, https://myaccount.google.com/apppasswords CONF_LIST_NAME = 'list_name' # Default Google Keep list title DEFAULT_LIST_NAME = 'Grocery' CONFIG_SCHEMA = vol.Schema( { DOMAIN: vol.Schema( { vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Optional(CONF_LIST_NAME, default=DEFAULT_LIST_NAME): cv.string, }), }, extra=vol.ALLOW_EXTRA) # Service constants and validation SERVICE_LIST_NAME = 'title' # Title of the Google Keep list to create or update, string SERVICE_LIST_ITEM = 'things' # Things(s) to add to the list SERVICE_LIST_SCHEMA = vol.Schema({ vol.Optional(SERVICE_LIST_NAME): cv.string, vol.Required(SERVICE_LIST_ITEM):
const.SPECIFIC_TYPE_CLASS_C_MOTOR_CONTROL, const.SPECIFIC_TYPE_MOTOR_MULTIPOSITION, const.SPECIFIC_TYPE_SECURE_BARRIER_ADDON, const.SPECIFIC_TYPE_SECURE_DOOR ], [ const.COMMAND_CLASS_SWITCH_BINARY, const.COMMAND_CLASS_BARRIER_OPERATOR, const.COMMAND_CLASS_SWITCH_MULTILEVEL ], const.TYPE_WHATEVER, const.GENRE_USER), ('climate', [const.GENERIC_TYPE_THERMOSTAT], [const.SPECIFIC_TYPE_WHATEVER], [const.COMMAND_CLASS_THERMOSTAT_SETPOINT], const.TYPE_WHATEVER, const.GENRE_WHATEVER), ] RENAME_NODE_SCHEMA = vol.Schema({ vol.Required(ATTR_ENTITY_ID): cv.entity_id, vol.Required(const.ATTR_NAME): cv.string, }) SET_CONFIG_PARAMETER_SCHEMA = vol.Schema({ vol.Required(const.ATTR_NODE_ID): vol.Coerce(int), vol.Required(const.ATTR_CONFIG_PARAMETER): vol.Coerce(int), vol.Required(const.ATTR_CONFIG_VALUE): vol.Coerce(int), vol.Optional(const.ATTR_CONFIG_SIZE): vol.Coerce(int) }) CHANGE_ASSOCIATION_SCHEMA = vol.Schema({ vol.Required(const.ATTR_ASSOCIATION): cv.string,
async def setup_ws_api(hass): """Set up WS API handlers.""" websocket_api.async_register_command(hass, hacs_settings) websocket_api.async_register_command(hass, hacs_config) websocket_api.async_register_command(hass, hacs_repositories) websocket_api.async_register_command(hass, hacs_repository) websocket_api.async_register_command(hass, hacs_repository_data) websocket_api.async_register_command(hass, check_local_path) websocket_api.async_register_command(hass, hacs_status) websocket_api.async_register_command(hass, acknowledge_critical_repository) websocket_api.async_register_command(hass, get_critical_repositories) @websocket_api.async_response @websocket_api.websocket_command({ vol.Required("type"): "hacs/settings", vol.Optional("action"): cv.string, vol.Optional("category"): cv.string, }) async def hacs_settings(hass, connection, msg): """Handle get media player cover command.""" action = msg["action"] Hacs().logger.debug(f"WS action '{action}'") if action == "set_fe_grid": Hacs().configuration.frontend_mode = "Grid" elif action == "set_fe_table": Hacs().configuration.frontend_mode = "Table" elif action == "set_fe_compact_true":
LightEntity, LightEntityFeature, ) from homeassistant.const import CONF_HOST, CONF_NAME, CONF_PORT from homeassistant.core import HomeAssistant import homeassistant.helpers.config_validation as cv from homeassistant.helpers.entity_platform import AddEntitiesCallback from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType import homeassistant.util.color as color_util DEFAULT_NAME = "iGlo Light" DEFAULT_PORT = 8080 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, } ) def setup_platform( hass: HomeAssistant, config: ConfigType, add_entities: AddEntitiesCallback, discovery_info: DiscoveryInfoType | None = None, ) -> None: """Set up the iGlo lights.""" host = config.get(CONF_HOST) name = config.get(CONF_NAME)
"past_day_m10_earthquakes", "past_day_all_earthquakes", "past_week_significant_earthquakes", "past_week_m45_earthquakes", "past_week_m25_earthquakes", "past_week_m10_earthquakes", "past_week_all_earthquakes", "past_month_significant_earthquakes", "past_month_m45_earthquakes", "past_month_m25_earthquakes", "past_month_m10_earthquakes", "past_month_all_earthquakes", ] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_FEED_TYPE): vol.In(VALID_FEED_TYPES), vol.Optional(CONF_LATITUDE): cv.latitude, vol.Optional(CONF_LONGITUDE): cv.longitude, vol.Optional(CONF_RADIUS, default=DEFAULT_RADIUS_IN_KM): vol.Coerce(float), vol.Optional(CONF_MINIMUM_MAGNITUDE, default=DEFAULT_MINIMUM_MAGNITUDE): cv.positive_float, }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the USGS Earthquake Hazards Program Feed platform.""" scan_interval = config.get(CONF_SCAN_INTERVAL, SCAN_INTERVAL)
ATTR_AWAY_TEMP, ATTR_COMFORT_TEMP, ATTR_ROOM_NAME, ATTR_SLEEP_TEMP, DOMAIN, MAX_TEMP, MIN_TEMP, SERVICE_SET_ROOM_TEMP, ) _LOGGER = logging.getLogger(__name__) SUPPORT_FLAGS = SUPPORT_TARGET_TEMPERATURE | SUPPORT_FAN_MODE PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( {vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string} ) SET_ROOM_TEMP_SCHEMA = vol.Schema( { vol.Required(ATTR_ROOM_NAME): cv.string, vol.Optional(ATTR_AWAY_TEMP): cv.positive_int, vol.Optional(ATTR_COMFORT_TEMP): cv.positive_int, vol.Optional(ATTR_SLEEP_TEMP): cv.positive_int, } ) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up the Mill heater.""" mill_data_connection = Mill(
CONF_SOURCE, CONF_ENTITY_ID, CONF_NAME) from homeassistant.components.image_processing.microsoft_face_identify import ( ImageProcessingFaceEntity) import homeassistant.helpers.config_validation as cv REQUIREMENTS = ['face_recognition==0.2.0'] _LOGGER = logging.getLogger(__name__) ATTR_NAME = 'name' CONF_FACES = 'faces' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_FACES): { cv.string: cv.isfile }, }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the Dlib Face detection platform.""" entities = [] for camera in config[CONF_SOURCE]: entities.append( DlibFaceIdentifyEntity(camera[CONF_ENTITY_ID], config[CONF_FACES], camera.get(CONF_NAME))) add_devices(entities)
cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_TRAVEL_TIME, default=None): cv.positive_int, # vol.Optional(CONF_POS_SENSOR, default=None): cv.entity_id, vol.Optional(CONF_POS_SENSOR, ): cv.entity_id, }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_COVERS, default={}): vol.Schema({cv.slug: COVERS_SCHEMA}), vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int, vol.Required(CONF_HOST): cv.string, vol.Required(CONF_MAC): cv.string, }) @asyncio.coroutine def async_setup_platform(hass, config, async_add_devices, discovery_info=None): import broadlink devices = config.get(CONF_COVERS) ip_addr = config.get(CONF_HOST) mac_addr = binascii.unhexlify( config.get(CONF_MAC).encode().replace(b':', b''))
CONF_ALLOW_LIGHTIFY_NODES = "allow_lightify_nodes" CONF_ALLOW_LIGHTIFY_GROUPS = "allow_lightify_groups" CONF_ALLOW_LIGHTIFY_SENSORS = "allow_lightify_sensors" CONF_ALLOW_LIGHTIFY_SWITCHES = "allow_lightify_switches" CONF_INTERVAL_LIGHTIFY_STATUS = "interval_lightify_status" CONF_INTERVAL_LIGHTIFY_CONF = "interval_lightify_conf" DEFAULT_ALLOW_LIGHTIFY_NODES = True DEFAULT_ALLOW_LIGHTIFY_GROUPS = True DEFAULT_ALLOW_LIGHTIFY_SENSORS = True DEFAULT_ALLOW_LIGHTIFY_SWITCHES = True DEFAULT_INTERVAL_LIGHTIFY_STATUS = 5 DEFAULT_INTERVAL_LIGHTIFY_CONF = 3600 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Optional(CONF_ALLOW_LIGHTIFY_NODES, default=DEFAULT_ALLOW_LIGHTIFY_NODES): cv.boolean, vol.Optional(CONF_ALLOW_LIGHTIFY_GROUPS, default=DEFAULT_ALLOW_LIGHTIFY_GROUPS): cv.boolean, vol.Optional(CONF_ALLOW_LIGHTIFY_SENSORS, default=DEFAULT_ALLOW_LIGHTIFY_SENSORS): cv.boolean, vol.Optional(CONF_ALLOW_LIGHTIFY_SWITCHES, default=DEFAULT_ALLOW_LIGHTIFY_SWITCHES): cv.boolean, vol.Optional(CONF_INTERVAL_LIGHTIFY_STATUS, default=DEFAULT_INTERVAL_LIGHTIFY_STATUS):
cv.string: cv.string }}), vol.Optional(CONF_EXTRA_HTML_URL): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_EXTRA_HTML_URL_ES5): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_JS_VERSION, default=JS_DEFAULT_OPTION): vol.In(JS_OPTIONS) }), }, extra=vol.ALLOW_EXTRA) SERVICE_SET_THEME = 'set_theme' SERVICE_RELOAD_THEMES = 'reload_themes' SERVICE_SET_THEME_SCHEMA = vol.Schema({ vol.Required(CONF_NAME): cv.string, }) WS_TYPE_GET_PANELS = 'get_panels' SCHEMA_GET_PANELS = websocket_api.BASE_COMMAND_MESSAGE_SCHEMA.extend({ vol.Required('type'): WS_TYPE_GET_PANELS, }) WS_TYPE_GET_THEMES = 'frontend/get_themes' SCHEMA_GET_THEMES = websocket_api.BASE_COMMAND_MESSAGE_SCHEMA.extend({ vol.Required('type'): WS_TYPE_GET_THEMES, }) WS_TYPE_GET_TRANSLATIONS = 'frontend/get_translations' SCHEMA_GET_TRANSLATIONS = websocket_api.BASE_COMMAND_MESSAGE_SCHEMA.extend({ vol.Required('type'): WS_TYPE_GET_TRANSLATIONS,
# pylint: disable=no-value-for-parameter SCHEMA_HASSIO_CONFIG = vol.Schema({ vol.Optional(ATTR_TIMEZONE, default='UTC'): validate_timezone, vol.Optional(ATTR_LAST_BOOT): vol.Coerce(str), vol.Optional(ATTR_ADDONS_CUSTOM_LIST, default=[ "https://github.com/hassio-addons/repository", ]): REPOSITORIES, vol.Optional(ATTR_WAIT_BOOT, default=5): WAIT_BOOT, }, extra=vol.REMOVE_EXTRA) SCHEMA_DISCOVERY = vol.Schema([ vol.Schema({ vol.Required(ATTR_UUID): UUID_MATCH, vol.Required(ATTR_ADDON): vol.Coerce(str), vol.Required(ATTR_SERVICE): SERVICE_ALL, vol.Required(ATTR_CONFIG): vol.Maybe(dict), }, extra=vol.REMOVE_EXTRA) ]) SCHEMA_DISCOVERY_CONFIG = vol.Schema({ vol.Optional(ATTR_DISCOVERY, default=list): schema_or(SCHEMA_DISCOVERY), }, extra=vol.REMOVE_EXTRA) SCHEMA_AUTH_CONFIG = vol.Schema({ SHA256: SHA256 })
try: raw_value = value.encode("utf-8") except UnicodeError as err: raise vol.Invalid( "The country name or the abbreviation must be a valid UTF-8 string." ) from err if not raw_value: raise vol.Invalid("Country name or the abbreviation must not be empty.") if value not in all_supported_countries: raise vol.Invalid("Country is not supported.") return value PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Required(CONF_COUNTRY): valid_country, vol.Optional(CONF_EXCLUDES, default=DEFAULT_EXCLUDES): vol.All( cv.ensure_list, [vol.In(ALLOWED_DAYS)] ), vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_OFFSET, default=DEFAULT_OFFSET): vol.Coerce(int), vol.Optional(CONF_PROVINCE): cv.string, vol.Optional(CONF_WORKDAYS, default=DEFAULT_WORKDAYS): vol.All( cv.ensure_list, [vol.In(ALLOWED_DAYS)] ), vol.Optional(CONF_ADD_HOLIDAYS): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_REMOVE_HOLIDAYS): vol.All(cv.ensure_list, [cv.string]), } )
from homeassistant.components.binary_sensor import PLATFORM_SCHEMA, BinarySensorDevice from homeassistant.const import CONF_NAME import homeassistant.helpers.config_validation as cv from homeassistant.helpers.entity import Entity from . import DOMAIN _LOGGER = logging.getLogger(__name__) CONF_PINS = "pins" CONF_PULLUP = "pullup" CONF_NEGATE = "negate" PIN_SCHEMA = vol.Schema({ vol.Required(CONF_NAME): cv.string, vol.Optional(CONF_PULLUP, default=False): cv.boolean, vol.Optional(CONF_NEGATE, default=False): cv.boolean }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( {vol.Required(CONF_PINS): vol.Schema({cv.positive_int: PIN_SCHEMA})}) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the Arduino platform.""" board = hass.data[DOMAIN] pins = config[CONF_PINS] sensors = []
async def async_step_user(self, user_input=None): errors = {} if self._async_current_entries(): return self.async_abort(reason="single_instance_allowed") if user_input is not None: _LOGGER.info ("user_input: %s", user_input) # Validate user input #valid = await is_valid(user_input) #if valid: #title = f"{self.info[CONF_HOST]} - {self.device_id}" title = f"Uhome Uponor" prefix = user_input.get(CONF_PREFIX) if user_input.get(CONF_PREFIX) else "" return self.async_create_entry( title=title, data={ "host": user_input[CONF_HOST], "prefix": prefix, }, ) return self.async_show_form( step_id="user", data_schema=vol.Schema( { vol.Required(CONF_HOST): str, vol.Optional(CONF_PREFIX): str, } ), errors=errors ) # @staticmethod # @callback # def async_get_options_flow( # config_entry: ConfigEntry, # ) -> UhomeuponorOptionsFlowHandler: # """Options callback for uponor.""" # return UhomeuponorOptionsFlowHandler(config_entry) # class UhomeuponorOptionsFlowHandler(config_entries.OptionsFlow): # """Config flow options for uponor.""" # def __init__(self, entry: ConfigEntry) -> None: # """Initialize AccuWeather options flow.""" # self.config_entry = entry # async def async_step_init(self, user_input=None): # """Manage the options.""" # return await self.async_step_user() # async def async_step_user(self, user_input=None): # errors = {} # if user_input is not None: # _LOGGER.info ("Aqui debemos hacer algo con user_input: %s", user_input) # # Validate user input # #valid = await is_valid(user_input) # #if valid: # #title = f"{self.info[CONF_HOST]} - {self.device_id}" # title = f"Uhome Uponor" # return self.async_create_entry( # title=title, # data={ # "host": user_input[CONF_HOST], # "prefix": user_input[CONF_PREFIX], # }, # ) # return self.async_show_form( # step_id="user", # data_schema=vol.Schema( # { # vol.Required(CONF_HOST): str, # vol.Optional(CONF_PREFIX): str, # } # ), errors=errors # ) # class UhomeuponorDicoveryFlow(DiscoveryFlowHandler[Awaitable[bool]], domain=DOMAIN): # """Discovery flow handler.""" # VERSION = 1 # def __init__(self) -> None: # """Set up config flow.""" # super().__init__( # DOMAIN, # "Uponor Checker", # _async_supported, # ) # async def async_step_onboarding( # self, data: dict[str, Any] | None = None # ) -> FlowResult: # """Handle a flow initialized by onboarding.""" # has_devices = await self._discovery_function(self.hass) # if not has_devices: # return self.async_abort(reason="no_devices_found") # return self.async_create_entry(title=self._title, data={})
ATTR_USER_ID = "user_id" CONF_DEVICE_TRACKERS = "device_trackers" CONF_USER_ID = "user_id" CONF_PICTURE = "picture" DOMAIN = "person" STORAGE_KEY = DOMAIN STORAGE_VERSION = 2 # Device tracker states to ignore IGNORE_STATES = (STATE_UNKNOWN, STATE_UNAVAILABLE) PERSON_SCHEMA = vol.Schema( { vol.Required(CONF_ID): cv.string, vol.Required(CONF_NAME): cv.string, vol.Optional(CONF_USER_ID): cv.string, vol.Optional(CONF_DEVICE_TRACKERS, default=[]): vol.All( cv.ensure_list, cv.entities_domain(DEVICE_TRACKER_DOMAIN) ), vol.Optional(CONF_PICTURE): cv.string, } ) CONFIG_SCHEMA = vol.Schema( { vol.Optional(DOMAIN, default=[]): vol.All( cv.ensure_list, cv.remove_falsy, [PERSON_SCHEMA] ) },
CONF_INITIAL_STATE) from homeassistant.const import CONF_NAME DEPENDENCIES = ['ffmpeg'] _LOGGER = logging.getLogger(__name__) CONF_PEAK = 'peak' CONF_DURATION = 'duration' CONF_RESET = 'reset' DEFAULT_NAME = 'FFmpeg Noise' DEFAULT_INIT_STATE = True PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_INPUT): cv.string, vol.Optional(CONF_INITIAL_STATE, default=DEFAULT_INIT_STATE): cv.boolean, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_EXTRA_ARGUMENTS): cv.string, vol.Optional(CONF_OUTPUT): cv.string, vol.Optional(CONF_PEAK, default=-30): vol.Coerce(int), vol.Optional(CONF_DURATION, default=1): vol.All(vol.Coerce(int), vol.Range(min=1)), vol.Optional(CONF_RESET, default=10): vol.All(vol.Coerce(int), vol.Range(min=1)), }) @asyncio.coroutine def async_setup_platform(hass, config, async_add_devices, discovery_info=None): """Create the binary sensor."""
from homeassistant.components.alarm_control_panel import PLATFORM_SCHEMA from homeassistant.const import (CONF_PASSWORD, CONF_USERNAME, STATE_ALARM_ARMED_AWAY, STATE_ALARM_ARMED_HOME, STATE_ALARM_ARMED_NIGHT, STATE_ALARM_DISARMED, STATE_ALARM_ARMING, STATE_ALARM_DISARMING, STATE_UNKNOWN, CONF_NAME) REQUIREMENTS = ['total_connect_client==0.11'] _LOGGER = logging.getLogger(__name__) DEFAULT_NAME = 'Total Connect' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_PASSWORD): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up a TotalConnect control panel.""" name = config.get(CONF_NAME) username = config.get(CONF_USERNAME) password = config.get(CONF_PASSWORD) total_connect = TotalConnect(name, username, password)
from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady from homeassistant.helpers import config_entry_oauth2_flow, config_validation as cv from homeassistant.helpers.typing import ConfigType from . import api, config_flow from .const import NEATO_CONFIG, NEATO_DOMAIN, NEATO_LOGIN from .hub import NeatoHub _LOGGER = logging.getLogger(__name__) CONFIG_SCHEMA = vol.Schema( { NEATO_DOMAIN: vol.Schema( { vol.Required(CONF_CLIENT_ID): cv.string, vol.Required(CONF_CLIENT_SECRET): cv.string, } ) }, extra=vol.ALLOW_EXTRA, ) PLATFORMS = [Platform.CAMERA, Platform.VACUUM, Platform.SWITCH, Platform.SENSOR] async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool: """Set up the Neato component.""" hass.data[NEATO_DOMAIN] = {} if NEATO_DOMAIN not in config:
ATTR_HOME_NAME = "home_name" ATTR_PERSONS = "persons" ATTR_IS_KNOWN = "is_known" ATTR_FACE_URL = "face_url" ATTR_SNAPSHOT_URL = "snapshot_url" ATTR_VIGNETTE_URL = "vignette_url" ATTR_SCHEDULE = "schedule" MIN_TIME_BETWEEN_UPDATES = timedelta(minutes=5) MIN_TIME_BETWEEN_EVENT_UPDATES = timedelta(seconds=5) CONFIG_SCHEMA = vol.Schema( { DOMAIN: vol.Schema({ vol.Required(CONF_API_KEY): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Required(CONF_SECRET_KEY): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Optional(CONF_WEBHOOKS, default=DEFAULT_WEBHOOKS): cv.boolean, vol.Optional(CONF_DISCOVERY, default=DEFAULT_DISCOVERY): cv.boolean, }) }, extra=vol.ALLOW_EXTRA, )
CONF_COUNTER = 'counter' CONF_DEFAULT_COUNTER = 1 CONF_ACTION = 'action' CONF_RESET_AFTER = 'reset_after' CONF__ACTION = 'turn_off_action' DEFAULT_NAME = 'KNX Binary Sensor' DEPENDENCIES = ['knx'] AUTOMATION_SCHEMA = vol.Schema({ vol.Optional(CONF_HOOK, default=CONF_DEFAULT_HOOK): cv.string, vol.Optional(CONF_COUNTER, default=CONF_DEFAULT_COUNTER): cv.port, vol.Required(CONF_ACTION): cv.SCRIPT_SCHEMA }) AUTOMATIONS_SCHEMA = vol.All(cv.ensure_list, [AUTOMATION_SCHEMA]) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_ADDRESS): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_DEVICE_CLASS): cv.string, vol.Optional(CONF_SIGNIFICANT_BIT, default=CONF_DEFAULT_SIGNIFICANT_BIT): cv.positive_int, vol.Optional(CONF_RESET_AFTER):
_LOGGER = logging.getLogger(__name__) ATTR_EXTERNAL_ID = "external_id" DEFAULT_RADIUS_IN_KM = 20.0 DEFAULT_UNIT_OF_MEASUREMENT = "km" SCAN_INTERVAL = timedelta(minutes=5) SIGNAL_DELETE_ENTITY = "geo_json_events_delete_{}" SIGNAL_UPDATE_ENTITY = "geo_json_events_update_{}" SOURCE = "geo_json_events" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_URL): cv.string, vol.Optional(CONF_LATITUDE): cv.latitude, vol.Optional(CONF_LONGITUDE): cv.longitude, vol.Optional(CONF_RADIUS, default=DEFAULT_RADIUS_IN_KM): vol.Coerce(float), }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the GeoJSON Events platform.""" url = config[CONF_URL] scan_interval = config.get(CONF_SCAN_INTERVAL, SCAN_INTERVAL) coordinates = (
BAD_CONDITIONS, CONF_DAYS, CONF_WEATHER, DEFAULT_DAYS, DEFAULT_NAME, DOMAIN, ICON, STARTUP_MESSAGE, ) _LOGGER = logging.getLogger(__name__) PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend( { vol.Required(CONF_WEATHER): cv.entity_id, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_DAYS, default=DEFAULT_DAYS): cv.positive_int, } ) # pylint: disable=unused-argument async def async_setup_platform( hass: HomeAssistant, config, async_add_entities, discovery_info=None ): """Set up the Car Wash sensor.""" # Print startup message _LOGGER.info(STARTUP_MESSAGE) name = config.get(CONF_NAME)
from homeassistant.const import (CONF_NAME, CONF_PASSWORD, CONF_URL, CONF_USERNAME) import homeassistant.helpers.config_validation as cv from homeassistant.util import Throttle, dt _LOGGER = logging.getLogger(__name__) CONF_DEVICE_ID = 'device_id' CONF_CALENDARS = 'calendars' CONF_CUSTOM_CALENDARS = 'custom_calendars' CONF_CALENDAR = 'calendar' CONF_SEARCH = 'search' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ # pylint: disable=no-value-for-parameter vol.Required(CONF_URL): vol.Url(), vol.Optional(CONF_CALENDARS, default=[]): vol.All(cv.ensure_list, vol.Schema([cv.string])), vol.Inclusive(CONF_USERNAME, 'authentication'): cv.string, vol.Inclusive(CONF_PASSWORD, 'authentication'): cv.string, vol.Optional(CONF_CUSTOM_CALENDARS, default=[]): vol.All( cv.ensure_list, vol.Schema([ vol.Schema({ vol.Required(CONF_CALENDAR): cv.string, vol.Required(CONF_NAME): cv.string, vol.Required(CONF_SEARCH): cv.string,
] DEFAULT_NAME = "Train {}" CONF_NAME = 'train_name' CONF_STATION_ID = 'station_id' CONF_STATION_NAME = 'station_name' CONF_TRAIN_ID = 'train_id' ARRIVED_STRING = 'Arrived' CANCELLED_STRING = 'Cancelled' NOT_DEPARTED_STRING = "Not departed yet" NO_INFORMATION_STRING = "No information for this train now" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_TRAIN_ID): cv.string, vol.Required(CONF_STATION_ID): cv.string, vol.Optional(CONF_NAME): cv.string, }) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up the ViaggiaTreno platform.""" train_id = config.get(CONF_TRAIN_ID) station_id = config.get(CONF_STATION_ID) name = config.get(CONF_NAME) if not name: name = DEFAULT_NAME.format(train_id) async_add_entities([ViaggiaTrenoSensor(train_id, station_id, name)])
DOMAIN = 'kira' _LOGGER = logging.getLogger(__name__) DEFAULT_HOST = "0.0.0.0" DEFAULT_PORT = 65432 CONF_REPEAT = "repeat" CONF_REMOTES = "remotes" CONF_SENSOR = "sensor" CONF_REMOTE = "remote" CODES_YAML = '{}_codes.yaml'.format(DOMAIN) CODE_SCHEMA = vol.Schema({ vol.Required(CONF_NAME): cv.string, vol.Required(CONF_CODE): cv.string, vol.Optional(CONF_TYPE): cv.string, vol.Optional(CONF_DEVICE): cv.string, vol.Optional(CONF_REPEAT): cv.positive_int, }) SENSOR_SCHEMA = vol.Schema({ vol.Optional(CONF_NAME, default=DOMAIN): vol.Exclusive(cv.string, "sensors"), vol.Optional(CONF_HOST, default=DEFAULT_HOST): cv.string, vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port, })