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,
})
