ALLOWED_WATERING_TIME, ATTRIBUTION, CONF_WATERING_TIME, DATA_RAINCLOUD, DEFAULT_WATERING_TIME, SWITCHES, RainCloudEntity, ) _LOGGER = logging.getLogger(__name__) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Optional(CONF_MONITORED_CONDITIONS, default=list(SWITCHES)): vol.All( cv.ensure_list, [vol.In(SWITCHES)] ), vol.Optional(CONF_WATERING_TIME, default=DEFAULT_WATERING_TIME): vol.All( vol.In(ALLOWED_WATERING_TIME) ), } ) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up a sensor for a raincloud device.""" raincloud = hass.data[DATA_RAINCLOUD].data default_watering_timer = config.get(CONF_WATERING_TIME) sensors = [] for sensor_type in config.get(CONF_MONITORED_CONDITIONS): # create a sensor for each zone managed by faucet for controller in raincloud.controllers:
from homeassistant.components.switch import (SwitchDevice, PLATFORM_SCHEMA) from homeassistant.const import (CONF_SWITCHES, CONF_ZONE, CONF_FRIENDLY_NAME, CONF_TRIGGER_TIME, CONF_SCAN_INTERVAL) from homeassistant.helpers import config_validation as cv DEPENDENCIES = ['rainbird'] DOMAIN = 'rainbird' _LOGGER = logging.getLogger(__name__) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_SWITCHES, default={}): vol.Schema({ cv.string: { vol.Optional(CONF_FRIENDLY_NAME): cv.string, vol.Required(CONF_ZONE): cv.string, vol.Required(CONF_TRIGGER_TIME): cv.string, vol.Optional(CONF_SCAN_INTERVAL): cv.string, }, }), }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up Rain Bird switches over a Rain Bird controller.""" controller = hass.data[DATA_RAINBIRD] devices = [] for dev_id, switch in config.get(CONF_SWITCHES).items(): devices.append(RainBirdSwitch(controller, switch, dev_id)) add_devices(devices, True)
_LOGGER = logging.getLogger(__name__) DEFAULT_NAME = 'Xiaomi Miio Switch' DATA_KEY = 'switch.xiaomi_miio' CONF_MODEL = 'model' MODEL_POWER_STRIP_V2 = 'zimi.powerstrip.v2' MODEL_PLUG_V3 = 'chuangmi.plug.v3' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Required(CONF_TOKEN): vol.All(cv.string, vol.Length(min=32, max=32)), vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_MODEL): vol.In( ['chuangmi.plug.v1', 'qmi.powerstrip.v1', 'zimi.powerstrip.v2', 'chuangmi.plug.m1', 'chuangmi.plug.v2', 'chuangmi.plug.v3', ]), }) ATTR_POWER = 'power' ATTR_TEMPERATURE = 'temperature' ATTR_LOAD_POWER = 'load_power' ATTR_MODEL = 'model' ATTR_MODE = 'mode' ATTR_POWER_MODE = 'power_mode' ATTR_WIFI_LED = 'wifi_led' ATTR_POWER_PRICE = 'power_price'
import homeassistant.helpers.config_validation as cv from homeassistant.components.switch import (SwitchDevice, PLATFORM_SCHEMA) from homeassistant.components.linode import ( CONF_NODES, ATTR_CREATED, ATTR_NODE_ID, ATTR_NODE_NAME, ATTR_IPV4_ADDRESS, ATTR_IPV6_ADDRESS, ATTR_MEMORY, ATTR_REGION, ATTR_VCPUS, DATA_LINODE) _LOGGER = logging.getLogger(__name__) DEPENDENCIES = ['linode'] DEFAULT_NAME = 'Node' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_NODES): vol.All(cv.ensure_list, [cv.string]), }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the Linode Node switch.""" linode = hass.data.get(DATA_LINODE) nodes = config.get(CONF_NODES) dev = [] for node in nodes: node_id = linode.get_node_id(node) if node_id is None: _LOGGER.error("Node %s is not available", node) return dev.append(LinodeSwitch(linode, node_id))
LOAD_CMD = "load-module module-loopback sink={0} source={1}" MIN_TIME_BETWEEN_FORCED_SCANS = timedelta(milliseconds=100) MIN_TIME_BETWEEN_SCANS = timedelta(seconds=10) MOD_REGEX = r"index: ([0-9]+)\s+name: <module-loopback>" \ r"\s+argument: (?=<.*sink={0}.*>)(?=<.*source={1}.*>)" UNLOAD_CMD = "unload-module {0}" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_SINK_NAME): cv.string, vol.Required(CONF_SOURCE_NAME): cv.string, vol.Optional(CONF_BUFFER_SIZE, default=DEFAULT_BUFFER_SIZE): cv.positive_int, vol.Optional(CONF_HOST, default=DEFAULT_HOST): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port, vol.Optional(CONF_TCP_TIMEOUT, default=DEFAULT_TCP_TIMEOUT): cv.positive_int, }) # pylint: disable=unused-argument def setup_platform(hass, config, add_devices, discovery_info=None): """Read in all of our configuration, and initialize the loopback switch.""" name = config.get(CONF_NAME) sink_name = config.get(CONF_SINK_NAME) source_name = config.get(CONF_SOURCE_NAME) host = config.get(CONF_HOST) port = config.get(CONF_PORT)
DEFAULT_PROTOCOL = 1 DEFAULT_SIGNAL_REPETITIONS = 10 SWITCH_SCHEMA = vol.Schema({ vol.Required(CONF_CODE_OFF): vol.All(cv.ensure_list_csv, [cv.positive_int]), vol.Required(CONF_CODE_ON): vol.All(cv.ensure_list_csv, [cv.positive_int]), vol.Optional(CONF_PULSELENGTH): cv.positive_int, vol.Optional(CONF_SIGNAL_REPETITIONS, default=DEFAULT_SIGNAL_REPETITIONS): cv.positive_int, vol.Optional(CONF_PROTOCOL, default=DEFAULT_PROTOCOL): cv.positive_int, }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_GPIO): cv.positive_int, vol.Required(CONF_SWITCHES): vol.Schema({cv.string: SWITCH_SCHEMA}), }) # pylint: disable=no-member def setup_platform(hass, config, add_entities, discovery_info=None): """Find and return switches controlled by a generic RF device via GPIO.""" import rpi_rf from threading import RLock gpio = config.get(CONF_GPIO) rfdevice = rpi_rf.RFDevice(gpio) rfdevice_lock = RLock() switches = config.get(CONF_SWITCHES) devices = []
# Standard Fritz Box IP DEFAULT_HOST = 'fritz.box' ATTR_CURRENT_CONSUMPTION = 'current_consumption' ATTR_CURRENT_CONSUMPTION_UNIT = 'current_consumption_unit' ATTR_CURRENT_CONSUMPTION_UNIT_VALUE = 'W' ATTR_TOTAL_CONSUMPTION = 'total_consumption' ATTR_TOTAL_CONSUMPTION_UNIT = 'total_consumption_unit' ATTR_TOTAL_CONSUMPTION_UNIT_VALUE = 'kWh' ATTR_TEMPERATURE_UNIT = 'temperature_unit' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_HOST, default=DEFAULT_HOST): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string, }) def setup_platform(hass, config, add_devices, discovery_info=None): """Add all switches connected to Fritz Box.""" from fritzhome.fritz import FritzBox host = config.get(CONF_HOST) username = config.get(CONF_USERNAME) password = config.get(CONF_PASSWORD) # Log into Fritz Box fritz = FritzBox(host, username, password) try:
""" import voluptuous as vol import homeassistant.helpers.config_validation as cv from homeassistant.components.gc100 import DATA_GC100, CONF_PORTS from homeassistant.components.switch import (PLATFORM_SCHEMA) from homeassistant.helpers.entity import ToggleEntity from homeassistant.const import DEVICE_DEFAULT_NAME DEPENDENCIES = ['gc100'] _SWITCH_SCHEMA = vol.Schema({ cv.string: cv.string, }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( {vol.Required(CONF_PORTS): vol.All(cv.ensure_list, [_SWITCH_SCHEMA])}) # pylint: disable=unused-argument def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the GC100 devices.""" switches = [] ports = config.get(CONF_PORTS) for port in ports: for port_addr, port_name in port.items(): switches.append( GC100Switch(port_name, port_addr, hass.data[DATA_GC100])) add_devices(switches, True) class GC100Switch(ToggleEntity):
SWITCH_SCHEMA = vol.Schema({ vol.Optional(CONF_COMMAND_OFF, default="true"): cv.string, vol.Optional(CONF_COMMAND_ON, default="true"): cv.string, vol.Optional(CONF_COMMAND_STATE): cv.string, vol.Optional(CONF_FRIENDLY_NAME): cv.string, vol.Optional(CONF_VALUE_TEMPLATE): cv.template, vol.Optional(CONF_COMMAND_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int, }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( {vol.Required(CONF_SWITCHES): cv.schema_with_slug_keys(SWITCH_SCHEMA)}) def setup_platform(hass, config, add_entities, discovery_info=None): """Find and return switches controlled by shell commands.""" devices = config.get(CONF_SWITCHES, {}) switches = [] for object_id, device_config in devices.items(): value_template = device_config.get(CONF_VALUE_TEMPLATE) if value_template is not None: value_template.hass = hass switches.append( CommandSwitch(
from homeassistant.const import (CONF_NAME, CONF_HOST, CONF_TIMEOUT, STATE_OFF, STATE_ON) import homeassistant.helpers.config_validation as cv from homeassistant.helpers.aiohttp_client import async_get_clientsession LOGGING = logging.getLogger(__name__) CONF_RELAY = 'relay' DEFAULT_NAME = 'Blebox switchBox' DEFAULT_RELAY = 0 DEFAULT_TIMEOUT = 10 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Optional(CONF_NAME): cv.string, vol.Optional(CONF_RELAY, default=DEFAULT_RELAY): cv.positive_int, vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int, }) @asyncio.coroutine def async_setup_platform(hass, config, async_add_devices, discovery_info=None): name = config.get(CONF_NAME) host = config.get(CONF_HOST) relay = config.get(CONF_RELAY) timeout = config.get(CONF_TIMEOUT) switch = BleboxSwitchBoxSwitch(name, host, relay, timeout) yield from switch.async_relay_init(hass)
_LOGGER = logging.getLogger(__name__) DOMAIN = 'warsignal' POLY_MQTT_DOMAIN = 'poly_mqtt_json' POLY_ZIGBEE_DOMAIN = 'poly_zb_uart' POLY_ZIGBEE_SERVICE = 'send_d' EVENT_ZIGBEE_RECV = 'zigbee_data_event' #open 0x80,0x0,0x9c,0xa5,0x6,0x44,0x9c,0xa5,0x60,0x2,0x1,0xa1 mac 9c a5 CMD_OPEN = [0x80, 0x0, 0x9c, 0xa5, 0x6, 0x44, 0x9c, 0xa5, 0x60, 0x2, 0x1, 0xa1] #close 0x80,0x0,0x9c,0xa5,0x6,0x44,0x9c,0xa5,0x60,0x2,0x0,0xa0 mac 9c a5 CMD_CLOSE = [0x80, 0x0, 0x9c, 0xa5, 0x6, 0x44, 0x9c, 0xa5, 0x60, 0x2, 0x0, 0xa0] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional('name'): cv.string }) def setup_platform(hass, config, add_devices, discovery_info=None): """ Setup the Polyhome warsignal platform. """ warsignals = [] if discovery_info is not None: # Not using hostname, as it seems to vary. device = {'name': discovery_info['name'], 'mac': discovery_info['mac']} warsignals.append(PolyWarsignal(hass, device, None)) else: for mac, device_config in config['devices'].items(): device = {'name': device_config['name'], 'mac': mac} warsignals.append(PolyWarsignal(hass, device, device_config))
# jorisroovers: don't install pyHS100 from pip, we use our own copy #REQUIREMENTS = ['pyHS100==0.3.0'] _LOGGER = logging.getLogger(__name__) ATTR_TOTAL_ENERGY_KWH = 'total_energy_kwh' ATTR_CURRENT_A = 'current_a' CONF_LEDS = 'enable_leds' DEFAULT_NAME = 'TP-Link Switch' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_LEDS): cv.boolean, }) # pylint: disable=unused-argument def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the TPLink switch platform.""" from pyHS100 import SmartPlug host = config.get(CONF_HOST) name = config.get(CONF_NAME) leds_on = config.get(CONF_LEDS) add_devices([SmartPlugSwitch(SmartPlug(host), name, leds_on)], True)
CONF_PULL_MODE = 'pull_mode' CONF_PINS = 'pins' CONF_INVERT_LOGIC = 'invert_logic' CONF_I2C_ADDRESS = 'i2c_address' DEFAULT_INVERT_LOGIC = False DEFAULT_I2C_ADDRESS = 0x20 _SWITCHES_SCHEMA = vol.Schema({ cv.positive_int: cv.string, }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_PINS): _SWITCHES_SCHEMA, vol.Optional(CONF_INVERT_LOGIC, default=DEFAULT_INVERT_LOGIC): cv.boolean, vol.Optional(CONF_I2C_ADDRESS, default=DEFAULT_I2C_ADDRESS): vol.Coerce(int), }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the MCP23017 devices.""" import board import busio import adafruit_mcp230xx invert_logic = config.get(CONF_INVERT_LOGIC) i2c_address = config.get(CONF_I2C_ADDRESS) i2c = busio.I2C(board.SCL, board.SDA)
DEFAULT_NAME = "REST Switch" DEFAULT_TIMEOUT = 10 DEFAULT_VERIFY_SSL = True SUPPORT_REST_METHODS = ["post", "put", "patch"] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Required(CONF_RESOURCE): cv.url, vol.Optional(CONF_STATE_RESOURCE): cv.url, vol.Optional(CONF_HEADERS): {cv.string: cv.template}, vol.Optional(CONF_PARAMS): {cv.string: cv.template}, vol.Optional(CONF_BODY_OFF, default=DEFAULT_BODY_OFF): cv.template, vol.Optional(CONF_BODY_ON, default=DEFAULT_BODY_ON): cv.template, vol.Optional(CONF_IS_ON_TEMPLATE): cv.template, vol.Optional(CONF_METHOD, default=DEFAULT_METHOD): vol.All( vol.Lower, vol.In(SUPPORT_REST_METHODS) ), vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA, vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int, vol.Inclusive(CONF_USERNAME, "authentication"): cv.string, vol.Inclusive(CONF_PASSWORD, "authentication"): cv.string, vol.Optional(CONF_VERIFY_SSL, default=DEFAULT_VERIFY_SSL): cv.boolean, } ) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up the RESTful switch.""" body_off = config.get(CONF_BODY_OFF) body_on = config.get(CONF_BODY_ON)
"""Support for ZoneMinder switches.""" import logging import voluptuous as vol from homeassistant.components.switch import (SwitchDevice, PLATFORM_SCHEMA) from homeassistant.components.zoneminder import DOMAIN as ZONEMINDER_DOMAIN from homeassistant.const import (CONF_COMMAND_ON, CONF_COMMAND_OFF) import homeassistant.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) DEPENDENCIES = ['zoneminder'] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_COMMAND_ON): cv.string, vol.Required(CONF_COMMAND_OFF): cv.string, }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the ZoneMinder switch platform.""" from zoneminder.monitor import MonitorState on_state = MonitorState(config.get(CONF_COMMAND_ON)) off_state = MonitorState(config.get(CONF_COMMAND_OFF)) switches = [] for zm_client in hass.data[ZONEMINDER_DOMAIN].values(): monitors = zm_client.get_monitors() if not monitors: _LOGGER.warning("Could not fetch monitors from ZoneMinder") return
_LOGGER = logging.getLogger(__name__) MIN_TIME_BETWEEN_SCANS = timedelta(seconds=10) MIN_TIME_BETWEEN_FORCED_SCANS = timedelta(milliseconds=100) MIN_TIME_TO_WAIT = timedelta(seconds=5) MIN_TIME_TO_LOCK_UPDATE = 5 SWITCH_TYPES = { "clean": ["Clean", None, None], "dock": ["Dock", None, None], "find": ["Find", None, None], } PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({vol.Optional(CONF_HOST): cv.string}) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the ThinkingCleaner platform.""" host = config.get(CONF_HOST) if host: devices = [ThinkingCleaner(host, "unknown")] else: discovery = Discovery() devices = discovery.discover() @util.Throttle(MIN_TIME_BETWEEN_SCANS, MIN_TIME_BETWEEN_FORCED_SCANS) def update_devices(): """Update all devices.""" for device_object in devices:
# Commands known to the projector CMD_DICT = { LAMP: '* 0 Lamp ?\r', LAMP_HOURS: '* 0 Lamp\r', INPUT_SOURCE: '* 0 Src ?\r', ECO_MODE: '* 0 IR 052\r', MODEL: '* 0 IR 035\r', STATE_ON: '* 0 IR 001\r', STATE_OFF: '* 0 IR 002\r', } PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_FILENAME): cv.isdevice, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int, vol.Optional(CONF_WRITE_TIMEOUT, default=DEFAULT_WRITE_TIMEOUT): cv.positive_int, }) def setup_platform(hass, config, add_devices, discovery_info=None): """Connect with serial port and return Acer Projector.""" serial_port = config.get(CONF_FILENAME) name = config.get(CONF_NAME) timeout = config.get(CONF_TIMEOUT) write_timeout = config.get(CONF_WRITE_TIMEOUT) add_devices([AcerSwitch(serial_port, name, timeout, write_timeout)], True)
DEFAULT_NAME = 'Xiaomi Miio Switch' DATA_KEY = 'switch.xiaomi_miio' CONF_MODEL = 'model' MODEL_POWER_STRIP_V2 = 'zimi.powerstrip.v2' MODEL_PLUG_V3 = 'chuangmi.plug.v3' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Required(CONF_TOKEN): vol.All(cv.string, vol.Length(min=32, max=32)), vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_MODEL): vol.In([ 'chuangmi.plug.v1', 'qmi.powerstrip.v1', 'zimi.powerstrip.v2', 'chuangmi.plug.m1', 'chuangmi.plug.v2', 'chuangmi.plug.v3', ]), }) ATTR_POWER = 'power' ATTR_TEMPERATURE = 'temperature' ATTR_LOAD_POWER = 'load_power' ATTR_MODEL = 'model' ATTR_MODE = 'mode' ATTR_POWER_MODE = 'power_mode'
import voluptuous as vol from homeassistant.components.switch import PLATFORM_SCHEMA from homeassistant.const import (CONF_NAME, CONF_ID) from homeassistant.components import enocean from homeassistant.helpers.entity import ToggleEntity import homeassistant.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) DEFAULT_NAME = 'EnOcean Switch' DEPENDENCIES = ['enocean'] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_ID): vol.All(cv.ensure_list, [vol.Coerce(int)]), vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the EnOcean switch platform.""" dev_id = config.get(CONF_ID) devname = config.get(CONF_NAME) add_devices([EnOceanSwitch(dev_id, devname)]) class EnOceanSwitch(enocean.EnOceanDevice, ToggleEntity): """Representation of an EnOcean switch device.""" def __init__(self, dev_id, devname):
Device = namedtuple("Device", ["netio", "entities"]) DEVICES: dict[str, Device] = {} MIN_TIME_BETWEEN_SCANS = timedelta(seconds=10) REQ_CONF = [CONF_HOST, CONF_OUTLETS] URL_API_NETIO_EP = "/api/netio/{host}" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Required(CONF_PORT, default=DEFAULT_PORT): cv.port, vol.Required(CONF_USERNAME, default=DEFAULT_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Optional(CONF_OUTLETS): { cv.string: cv.string }, }) def setup_platform( hass: HomeAssistant, config: ConfigType, add_entities: AddEntitiesCallback, discovery_info: DiscoveryInfoType | None = None, ) -> None: """Set up the Netio platform."""
from . import DEFAULT_ENTITY_NAMESPACE, DOMAIN as SKYBELL_DOMAIN, SkybellDevice DEPENDENCIES = ['skybell'] _LOGGER = logging.getLogger(__name__) # Switch types: Name SWITCH_TYPES = { 'do_not_disturb': ['Do Not Disturb'], 'motion_sensor': ['Motion Sensor'], } PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_ENTITY_NAMESPACE, default=DEFAULT_ENTITY_NAMESPACE): cv.string, vol.Required(CONF_MONITORED_CONDITIONS, default=[]): vol.All(cv.ensure_list, [vol.In(SWITCH_TYPES)]), }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the platform for a Skybell device.""" skybell = hass.data.get(SKYBELL_DOMAIN) sensors = [] for switch_type in config.get(CONF_MONITORED_CONDITIONS): for device in skybell.get_devices(): sensors.append(SkybellSwitch(device, switch_type)) add_entities(sensors, True)
MIN_TIME_BETWEEN_FORCED_SCANS = timedelta(milliseconds=100) MIN_TIME_BETWEEN_SCANS = timedelta(seconds=10) MOD_REGEX = r"index: ([0-9]+)\s+name: <module-loopback>" \ r"\s+argument: (?=<.*sink={0}.*>)(?=<.*source={1}.*>)" UNLOAD_CMD = "unload-module {0}" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_SINK_NAME): cv.string, vol.Required(CONF_SOURCE_NAME): cv.string, vol.Optional(CONF_BUFFER_SIZE, default=DEFAULT_BUFFER_SIZE): cv.positive_int, vol.Optional(CONF_HOST, default=DEFAULT_HOST): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port, vol.Optional(CONF_TCP_TIMEOUT, default=DEFAULT_TCP_TIMEOUT): cv.positive_int, }) # pylint: disable=unused-argument def setup_platform(hass, config, add_devices, discovery_info=None): """Read in all of our configuration, and initialize the loopback switch.""" name = config.get(CONF_NAME) sink_name = config.get(CONF_SINK_NAME) source_name = config.get(CONF_SOURCE_NAME)
DEFAULT_PORT = 1234 DEFAULT_USERNAME = '******' DEPENDENCIES = ['http'] Device = namedtuple('device', ['netio', 'entities']) DEVICES = {} MIN_TIME_BETWEEN_SCANS = timedelta(seconds=10) REQ_CONF = [CONF_HOST, CONF_OUTLETS] URL_API_NETIO_EP = '/api/netio/{host}' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Required(CONF_PORT, default=DEFAULT_PORT): cv.port, vol.Required(CONF_USERNAME, default=DEFAULT_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Optional(CONF_OUTLETS): {cv.string: cv.string}, }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the Netio platform.""" from pynetio import Netio host = config.get(CONF_HOST) username = config.get(CONF_USERNAME) password = config.get(CONF_PASSWORD) port = config.get(CONF_PORT) if not DEVICES:
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_BASEOID): cv.string, vol.Optional(CONF_COMMAND_OID): cv.string, vol.Optional(CONF_COMMAND_PAYLOAD_ON): cv.string, vol.Optional(CONF_COMMAND_PAYLOAD_OFF): cv.string, vol.Optional(CONF_COMMUNITY, default=DEFAULT_COMMUNITY): cv.string, vol.Optional(CONF_HOST, default=DEFAULT_HOST): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_PAYLOAD_OFF, default=DEFAULT_PAYLOAD_OFF): cv.string, vol.Optional(CONF_PAYLOAD_ON, default=DEFAULT_PAYLOAD_ON): cv.string, vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port, vol.Optional(CONF_VERSION, default=DEFAULT_VERSION): vol.In(SNMP_VERSIONS), vol.Optional(CONF_USERNAME): cv.string, vol.Optional(CONF_AUTH_KEY): cv.string, vol.Optional(CONF_AUTH_PROTOCOL, default=DEFAULT_AUTH_PROTOCOL): vol.In(MAP_AUTH_PROTOCOLS), vol.Optional(CONF_PRIV_KEY): cv.string, vol.Optional(CONF_PRIV_PROTOCOL, default=DEFAULT_PRIV_PROTOCOL): vol.In(MAP_PRIV_PROTOCOLS), })
from homeassistant.components.switch import (SwitchDevice, PLATFORM_SCHEMA) from homeassistant.const import (CONF_HOST, CONF_NAME) import homeassistant.helpers.config_validation as cv REQUIREMENTS = ['pyHS100==0.2.4.2'] _LOGGER = logging.getLogger(__name__) ATTR_CURRENT_CONSUMPTION = 'Current consumption' ATTR_TOTAL_CONSUMPTION = 'Total consumption' ATTR_DAILY_CONSUMPTION = 'Daily consumption' ATTR_VOLTAGE = 'Voltage' ATTR_CURRENT = 'Current' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Optional(CONF_NAME): cv.string, }) # pylint: disable=unused-argument def setup_platform(hass, config, add_devices, discovery_info=None): """Setup the TPLink switch platform.""" from pyHS100 import SmartPlug host = config.get(CONF_HOST) name = config.get(CONF_NAME) add_devices([SmartPlugSwitch(SmartPlug(host), name)], True) class SmartPlugSwitch(SwitchDevice): """Representation of a TPLink Smart Plug switch."""
ATTR_COMPONENT = 'component' ATTR_COMPONENT_VERSION = 'component_version' SCAN_INTERVAL = timedelta(seconds=30) ICON = 'mdi:docker' COMPONENT_NAME = 'hadockermon' COMPONENT_VERSION = '1.0.2' TIMEOUT = 5 _LOGGER = logging.getLogger(__name__) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Optional(CONF_PORT, default='8126'): cv.string, vol.Optional(CONF_STATS, default='False'): cv.string, vol.Optional(CONF_EXCLUDE, default=None): vol.All(cv.ensure_list, [cv.string]), }) def setup_platform(hass, config, add_devices_callback, discovery_info=None): baseurl = 'http://' + config.get(CONF_HOST) + ':' + config.get(CONF_PORT) fetchcontainers = baseurl + '/containers' containers = requests.get(fetchcontainers).json() exclude = config.get(CONF_EXCLUDE) dev = [] num = 0 for items in containers: containername = containers[num]['Names'][0] container = str(containername[1:]) num = num + 1
_LOGGER = logging.getLogger(__name__) CONF_FUNCTIONS = 'functions' CONF_PINS = 'pins' DEFAULT_NAME = 'aREST switch' PIN_FUNCTION_SCHEMA = vol.Schema({ vol.Optional(CONF_NAME): cv.string, }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_RESOURCE): cv.url, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_PINS, default={}): vol.Schema({cv.string: PIN_FUNCTION_SCHEMA}), vol.Optional(CONF_FUNCTIONS, default={}): vol.Schema({cv.string: PIN_FUNCTION_SCHEMA}), }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the aREST switches.""" resource = config.get(CONF_RESOURCE) try: response = requests.get(resource, timeout=10) except requests.exceptions.MissingSchema: _LOGGER.error("Missing resource or schema in configuration. " "Add http:// to your URL") return False
ATTR_SEVERITY = 'severity' ATTR_HEADLINE = 'headline' ATTR_INSTRUCTION = 'instruction' ATTR_DESCRIPTION = 'description' DEFAULT_INTERVAL = timedelta(seconds=120) ICON = 'mdi:weather-hurricane' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_ZONEID, default=DEFAULT_ZONEID): cv.string, vol.Optional(CONF_LATITUDE): cv.latitude, vol.Optional(CONF_LONGITUDE): cv.longitude, vol.Optional(CONF_URGENCY): cv.string, vol.Optional(CONF_SEVERITY): cv.string, vol.Optional(CONF_SCAN_INTERVAL, default=DEFAULT_INTERVAL): vol.All(cv.time_period, cv.positive_timedelta), }) def setup_platform(hass, config, add_entities, discovery_info=None): zoneid = str(config.get(CONF_ZONEID)) latitude = config.get(CONF_LATITUDE, hass.config.latitude) longitude = config.get(CONF_LONGITUDE, hass.config.longitude) event_urgency = str(config.get(CONF_URGENCY)) event_severity = str(config.get(CONF_SEVERITY)) update_interval = config.get(CONF_SCAN_INTERVAL, DEFAULT_INTERVAL)
import aiohttp from homeassistant.components.switch import (SwitchDevice, PLATFORM_SCHEMA) from homeassistant.const import CONF_PASSWORD, CONF_USERNAME, CONF_TOKEN from homeassistant.helpers.aiohttp_client import async_get_clientsession import homeassistant.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) HOOK_ENDPOINT = 'https://api.gethook.io/v1/' TIMEOUT = 10 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Exclusive(CONF_PASSWORD, 'hook_secret', msg='hook: provide ' + 'username/password OR token'): cv.string, vol.Exclusive(CONF_TOKEN, 'hook_secret', msg='hook: provide ' + 'username/password OR token'): cv.string, vol.Inclusive(CONF_USERNAME, 'hook_auth'): cv.string, vol.Inclusive(CONF_PASSWORD, 'hook_auth'): cv.string, }) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up Hook by getting the access token and list of actions.""" username = config.get(CONF_USERNAME) password = config.get(CONF_PASSWORD) token = config.get(CONF_TOKEN) websession = async_get_clientsession(hass) # If password is set in config, prefer it over token if username is not None and password is not None: try:
CONF_FRIENDLY_NAME, CONF_SWITCHES, CONF_VALUE_TEMPLATE, CONF_COMMAND_OFF, CONF_COMMAND_ON, CONF_COMMAND_STATE) import homeassistant.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) SWITCH_SCHEMA = vol.Schema({ vol.Optional(CONF_COMMAND_OFF, default='true'): cv.string, vol.Optional(CONF_COMMAND_ON, default='true'): cv.string, vol.Optional(CONF_COMMAND_STATE): cv.string, vol.Optional(CONF_FRIENDLY_NAME): cv.string, vol.Optional(CONF_VALUE_TEMPLATE): cv.template, }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_SWITCHES): vol.Schema({cv.slug: SWITCH_SCHEMA}), }) # pylint: disable=unused-argument def setup_platform(hass, config, add_devices, discovery_info=None): """Find and return switches controlled by shell commands.""" devices = config.get(CONF_SWITCHES, {}) switches = [] for device_name, device_config in devices.items(): value_template = device_config.get(CONF_VALUE_TEMPLATE) if value_template is not None: value_template.hass = hass
_LOGGER = logging.getLogger(__name__) DEPENDENCIES = ['bbb_gpio'] CONF_PINS = 'pins' CONF_INITIAL = 'initial' CONF_INVERT_LOGIC = 'invert_logic' PIN_SCHEMA = vol.Schema({ vol.Required(CONF_NAME): cv.string, vol.Optional(CONF_INITIAL, default=False): cv.boolean, vol.Optional(CONF_INVERT_LOGIC, default=False): cv.boolean, }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_PINS, default={}): vol.Schema({cv.string: PIN_SCHEMA}), }) # pylint: disable=unused-argument def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the BeagleBone Black GPIO devices.""" pins = config.get(CONF_PINS) switches = [] for pin, params in pins.items(): switches.append(BBBGPIOSwitch(pin, params)) add_devices(switches) class BBBGPIOSwitch(ToggleEntity):
REQUIREMENTS = ['wakeonlan==0.2.2'] _LOGGER = logging.getLogger(__name__) CONF_MAC_ADDRESS = 'mac_address' CONF_OFF_ACTION = 'turn_off' DEFAULT_NAME = 'Wake on LAN' DEFAULT_PING_TIMEOUT = 1 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_MAC_ADDRESS): cv.string, vol.Optional(CONF_HOST): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_OFF_ACTION): cv.SCRIPT_SCHEMA, }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up a wake on lan switch.""" name = config.get(CONF_NAME) host = config.get(CONF_HOST) mac_address = config.get(CONF_MAC_ADDRESS) off_action = config.get(CONF_OFF_ACTION) add_devices([WOLSwitch(hass, name, host, mac_address, off_action)])
_LOGGER = logging.getLogger(__name__) CONF_PINS = 'pins' CONF_TYPE = 'digital' CONF_NEGATE = 'negate' CONF_INITIAL = 'initial' PIN_SCHEMA = vol.Schema({ vol.Required(CONF_NAME): cv.string, vol.Optional(CONF_INITIAL, default=False): cv.boolean, vol.Optional(CONF_NEGATE, default=False): cv.boolean, }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_PINS, default={}): vol.Schema({cv.positive_int: PIN_SCHEMA}), }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the Arduino platform.""" # Verify that Arduino board is present if arduino.BOARD is None: _LOGGER.error("A connection has not been made to the Arduino board") return False pins = config.get(CONF_PINS) switches = [] for pinnum, pin in pins.items(): switches.append(ArduinoSwitch(pinnum, pin))
DEFAULT_TIMEOUT = 3 DATA_KEY = "switch.orvibo_asyncio" SERVICE_DISCOVERY = 'orvibo_asyncio_switch_discovery' DISCOVERY_COMMAND_SCHEMA = vol.Schema({ vol.Optional(CONF_TIMEOUT, default=10): vol.All(int, vol.Range(min=5)), vol.Optional(CONF_BROADCAST_ADDRESS, default='255.255.255.255'): cv.string, }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Optional(CONF_MAC): cv.string, vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): vol.All(int, vol.Range(min=1)), vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string }) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up S20 switches.""" S20 = get_orvibo_class(hass.data, 'S20') PORT = hass.data[ORVIBO_ASYNCIO_DATA_KEY]["PORT"] if DATA_KEY not in hass.data:
from homeassistant.const import ( CONF_FRIENDLY_NAME, CONF_SWITCHES, CONF_VALUE_TEMPLATE, CONF_COMMAND_OFF, CONF_COMMAND_ON, CONF_COMMAND_STATE) _LOGGER = logging.getLogger(__name__) SWITCH_SCHEMA = vol.Schema({ vol.Optional(CONF_COMMAND_OFF, default='true'): cv.string, vol.Optional(CONF_COMMAND_ON, default='true'): cv.string, vol.Optional(CONF_COMMAND_STATE): cv.string, vol.Optional(CONF_FRIENDLY_NAME): cv.string, vol.Optional(CONF_VALUE_TEMPLATE): cv.template, }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_SWITCHES): cv.schema_with_slug_keys(SWITCH_SCHEMA), }) def setup_platform(hass, config, add_entities, discovery_info=None): """Find and return switches controlled by shell commands.""" devices = config.get(CONF_SWITCHES, {}) switches = [] for object_id, device_config in devices.items(): value_template = device_config.get(CONF_VALUE_TEMPLATE) if value_template is not None: value_template.hass = hass switches.append(
ATTR_TOTAL_CONSUMPTION = "total_consumption" CONF_USE_LEGACY_PROTOCOL = "use_legacy_protocol" DEFAULT_NAME = "D-Link Smart Plug W215" DEFAULT_PASSWORD = "" DEFAULT_USERNAME = "******" SCAN_INTERVAL = timedelta(minutes=2) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Required(CONF_HOST): cv.string, vol.Required(CONF_PASSWORD, default=DEFAULT_PASSWORD): cv.string, vol.Required(CONF_USERNAME, default=DEFAULT_USERNAME): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_USE_LEGACY_PROTOCOL, default=False): cv.boolean, } ) def setup_platform( hass: HomeAssistant, config: ConfigType, add_entities: AddEntitiesCallback, discovery_info: DiscoveryInfoType | None = None, ) -> None: """Set up a D-Link Smart Plug.""" host = config[CONF_HOST]
REQUIREMENTS = ['https://github.com/mweinelt/anel-pwrctrl/archive/' 'ed26e8830e28a2bfa4260a9002db23ce3e7e63d7.zip' '#anel_pwrctrl==0.0.1'] _LOGGER = logging.getLogger(__name__) CONF_PORT_RECV = 'port_recv' CONF_PORT_SEND = 'port_send' MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=5) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_PORT_RECV): cv.port, vol.Required(CONF_PORT_SEND): cv.port, vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Optional(CONF_HOST): cv.string, }) # pylint: disable=unused-variable def setup_platform(hass, config, add_devices, discovery_info=None): """Set up PwrCtrl devices/switches.""" host = config.get(CONF_HOST, None) username = config.get(CONF_USERNAME) password = config.get(CONF_PASSWORD) port_recv = config.get(CONF_PORT_RECV) port_send = config.get(CONF_PORT_SEND) from anel_pwrctrl import DeviceMaster
from homeassistant.components.knx import ATTR_DISCOVER_DEVICES, DATA_KNX from homeassistant.components.switch import PLATFORM_SCHEMA, SwitchDevice from homeassistant.const import CONF_NAME from homeassistant.core import callback import homeassistant.helpers.config_validation as cv CONF_ADDRESS = 'address' CONF_STATE_ADDRESS = 'state_address' DEFAULT_NAME = 'KNX Switch' DEPENDENCIES = ['knx'] 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, }) async def async_setup_platform(hass, config, async_add_devices, discovery_info=None): """Set up switch(es) for KNX platform.""" if discovery_info is not None: async_add_devices_discovery(hass, discovery_info, async_add_devices) else: async_add_devices_config(hass, config, async_add_devices)
DEFAULT_METHOD = 'post' DEFAULT_BODY_OFF = 'OFF' DEFAULT_BODY_ON = 'ON' DEFAULT_NAME = 'REST Switch' DEFAULT_TIMEOUT = 10 SUPPORT_REST_METHODS = ['post', 'put'] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_RESOURCE): cv.url, vol.Optional(CONF_HEADERS): {cv.string: cv.string}, vol.Optional(CONF_BODY_OFF, default=DEFAULT_BODY_OFF): cv.template, vol.Optional(CONF_BODY_ON, default=DEFAULT_BODY_ON): cv.template, vol.Optional(CONF_IS_ON_TEMPLATE): cv.template, vol.Optional(CONF_METHOD, default=DEFAULT_METHOD): vol.All(vol.Lower, vol.In(SUPPORT_REST_METHODS)), vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int, vol.Inclusive(CONF_USERNAME, 'authentication'): cv.string, vol.Inclusive(CONF_PASSWORD, 'authentication'): cv.string, }) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up the RESTful switch.""" body_off = config.get(CONF_BODY_OFF) body_on = config.get(CONF_BODY_ON) is_on_template = config.get(CONF_IS_ON_TEMPLATE) method = config.get(CONF_METHOD)
from time import time import json from venv import logger from websocket import create_connection SWITCH_SCHEMA = vol.Schema({ vol.Optional(CONF_ID, default=1): cv.string, vol.Optional(CONF_FRIENDLY_NAME): cv.string, }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_NAME): cv.string, vol.Optional(CONF_ICON): cv.icon, vol.Required(CONF_HOST): cv.string, vol.Optional(CONF_ID, default=1): cv.string, vol.Optional(CONF_SWITCHES, default={}): vol.Schema({cv.slug: SWITCH_SCHEMA}), }) def set_sonoff_state(host, state): timestamp = str(time()).replace('.', '') ws = create_connection("ws://" + host + ":8081/") initiate_session_message_json = json.dumps({ "action": "userOnline", "ts": timestamp, "version": 6,
import homeassistant.helpers.config_validation as cv from homeassistant.components.raincloud import ( ALLOWED_WATERING_TIME, CONF_ATTRIBUTION, CONF_WATERING_TIME, DATA_RAINCLOUD, DEFAULT_WATERING_TIME, RainCloudEntity, SWITCHES) from homeassistant.components.switch import SwitchDevice, PLATFORM_SCHEMA from homeassistant.const import ( CONF_MONITORED_CONDITIONS, ATTR_ATTRIBUTION) DEPENDENCIES = ['raincloud'] _LOGGER = logging.getLogger(__name__) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_MONITORED_CONDITIONS, default=list(SWITCHES)): vol.All(cv.ensure_list, [vol.In(SWITCHES)]), vol.Optional(CONF_WATERING_TIME, default=DEFAULT_WATERING_TIME): vol.All(vol.In(ALLOWED_WATERING_TIME)), }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up a sensor for a raincloud device.""" raincloud = hass.data[DATA_RAINCLOUD].data default_watering_timer = config.get(CONF_WATERING_TIME) sensors = [] for sensor_type in config.get(CONF_MONITORED_CONDITIONS): # create a sensor for each zone managed by faucet for zone in raincloud.controller.faucet.zones: sensors.append( RainCloudSwitch(default_watering_timer,
SWITCH_TYPES = { 'lights': 'Lights', 'filter': 'Filter', 'filter_low_speed': 'Filter Low Speed', 'aux_1': 'Aux 1', 'aux_2': 'Aux 2', 'aux_3': 'Aux 3', 'aux_4': 'Aux 4', 'aux_5': 'Aux 5', 'aux_6': 'Aux 6', 'aux_7': 'Aux 7', } PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_MONITORED_CONDITIONS, default=list(SWITCH_TYPES)): vol.All(cv.ensure_list, [vol.In(SWITCH_TYPES)]), }) async def async_setup_platform( hass, config, async_add_entities, discovery_info=None): """Set up the switch platform.""" switches = [] processor = hass.data[aq.DOMAIN] for switch_type in config.get(CONF_MONITORED_CONDITIONS): switches.append(AquaLogicSwitch(processor, switch_type)) async_add_entities(switches)
COILS_SCHEMA = vol.Schema({ vol.Required(CALL_TYPE_COIL): cv.positive_int, vol.Required(CONF_NAME): cv.string, vol.Required(CONF_SLAVE): cv.positive_int, vol.Optional(CONF_HUB, default=DEFAULT_HUB): cv.string, }) PLATFORM_SCHEMA = vol.All( cv.has_at_least_one_key(CONF_COILS, CONF_REGISTERS), PLATFORM_SCHEMA.extend({ vol.Optional(CONF_COILS): [COILS_SCHEMA], vol.Optional(CONF_REGISTERS): [REGISTERS_SCHEMA], }), ) async def async_setup_platform(hass: HomeAssistant, config: ConfigType, async_add_entities, discovery_info=None): """Read configuration and create Modbus switches.""" switches = [] # check for old config: if discovery_info is None: _LOGGER.warning( "Switch configuration is deprecated, will be removed in a future release"
from homeassistant.components.switch import (SwitchDevice, PLATFORM_SCHEMA) from homeassistant.const import ( ATTR_ENTITY_ID, ATTR_STATE, CONF_NAME, CONF_DEVICES) import homeassistant.helpers.config_validation as cv ATTR_SCENARIO_ID = 'scenario_id' DEPENDENCIES = ['scsgate'] CONF_TRADITIONAL = 'traditional' CONF_SCENARIO = 'scenario' CONF_SCS_ID = 'scs_id' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_DEVICES): cv.schema_with_slug_keys(scsgate.SCSGATE_SCHEMA), }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the SCSGate switches.""" logger = logging.getLogger(__name__) _setup_traditional_switches( logger=logger, config=config, add_entities_callback=add_entities) _setup_scenario_switches(logger=logger, config=config, hass=hass) def _setup_traditional_switches(logger, config, add_entities_callback): """Add traditional SCSGate switches."""
from scsgate.messages import ScenarioTriggeredMessage, StateMessage from scsgate.tasks import ToggleStatusTask import voluptuous as vol from homeassistant.components.switch import PLATFORM_SCHEMA, SwitchEntity from homeassistant.const import ATTR_ENTITY_ID, ATTR_STATE, CONF_DEVICES, CONF_NAME import homeassistant.helpers.config_validation as cv from . import CONF_SCS_ID, DOMAIN, SCSGATE_SCHEMA ATTR_SCENARIO_ID = "scenario_id" CONF_TRADITIONAL = "traditional" CONF_SCENARIO = "scenario" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( {vol.Required(CONF_DEVICES): cv.schema_with_slug_keys(SCSGATE_SCHEMA)}) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the SCSGate switches.""" logger = logging.getLogger(__name__) scsgate = hass.data[DOMAIN] _setup_traditional_switches( logger=logger, config=config, scsgate=scsgate, add_entities_callback=add_entities, ) _setup_scenario_switches(logger=logger,
from homeassistant.components.knx import ATTR_DISCOVER_DEVICES, DATA_KNX from homeassistant.components.switch import PLATFORM_SCHEMA, SwitchDevice from homeassistant.const import CONF_NAME from homeassistant.core import callback import homeassistant.helpers.config_validation as cv CONF_ADDRESS = 'address' CONF_STATE_ADDRESS = 'state_address' DEFAULT_NAME = 'KNX Switch' DEPENDENCIES = ['knx'] 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, }) @asyncio.coroutine def async_setup_platform(hass, config, async_add_devices, discovery_info=None): """Set up switch(es) for KNX platform.""" if DATA_KNX not in hass.data or not hass.data[DATA_KNX].initialized: return if discovery_info is not None: async_add_devices_discovery(hass, discovery_info, async_add_devices) else: async_add_devices_config(hass, config, async_add_devices)
DEPENDENCIES = ['rpi_gpio'] CONF_PULL_MODE = 'pull_mode' CONF_PORTS = 'ports' CONF_INVERT_LOGIC = 'invert_logic' DEFAULT_INVERT_LOGIC = False _SWITCHES_SCHEMA = vol.Schema({ cv.positive_int: cv.string, }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_PORTS): _SWITCHES_SCHEMA, vol.Optional(CONF_INVERT_LOGIC, default=DEFAULT_INVERT_LOGIC): cv.boolean, }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the Raspberry PI GPIO devices.""" invert_logic = config.get(CONF_INVERT_LOGIC) switches = [] ports = config.get(CONF_PORTS) for port, name in ports.items(): switches.append(RPiGPIOSwitch(name, port, invert_logic)) add_entities(switches)
For more details about this platform, please refer to the documentation at https://home-assistant.io/components/switch.vesync/ """ import logging import voluptuous as vol from homeassistant.components.switch import (SwitchDevice, PLATFORM_SCHEMA) from homeassistant.const import (CONF_USERNAME, CONF_PASSWORD) import homeassistant.helpers.config_validation as cv REQUIREMENTS = ['pyvesync_v2==0.9.6'] _LOGGER = logging.getLogger(__name__) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string, }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the VeSync switch platform.""" from pyvesync_v2.vesync import VeSync switches = [] manager = VeSync(config.get(CONF_USERNAME), config.get(CONF_PASSWORD)) if not manager.login(): _LOGGER.error("Unable to login to VeSync") return
from homeassistant.components.switch import PLATFORM_SCHEMA, SwitchDevice from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME import homeassistant.helpers.config_validation as cv from homeassistant.util import Throttle _LOGGER = logging.getLogger(__name__) CONF_PORT_RECV = "port_recv" CONF_PORT_SEND = "port_send" MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=5) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_PORT_RECV): cv.port, vol.Required(CONF_PORT_SEND): cv.port, vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Optional(CONF_HOST): cv.string, }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up PwrCtrl devices/switches.""" host = config.get(CONF_HOST) username = config[CONF_USERNAME] password = config[CONF_PASSWORD] port_recv = config[CONF_PORT_RECV] port_send = config[CONF_PORT_SEND] try: master = DeviceMaster(
_LOGGER = logging.getLogger(__name__) _VALID_STATES = [STATE_ON, STATE_OFF, 'true', 'false'] ON_ACTION = 'turn_on' OFF_ACTION = 'turn_off' SWITCH_SCHEMA = vol.Schema({ vol.Required(CONF_VALUE_TEMPLATE): cv.template, vol.Required(ON_ACTION): cv.SCRIPT_SCHEMA, vol.Required(OFF_ACTION): cv.SCRIPT_SCHEMA, vol.Optional(ATTR_FRIENDLY_NAME): cv.string, vol.Optional(ATTR_ENTITY_ID, default=MATCH_ALL): cv.entity_ids }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_SWITCHES): vol.Schema({cv.slug: SWITCH_SCHEMA}), }) # pylint: disable=unused-argument def setup_platform(hass, config, add_devices, discovery_info=None): """Setup the Template switch.""" switches = [] for device, device_config in config[CONF_SWITCHES].items(): friendly_name = device_config.get(ATTR_FRIENDLY_NAME, device) state_template = device_config[CONF_VALUE_TEMPLATE] on_action = device_config[ON_ACTION] off_action = device_config[OFF_ACTION] entity_ids = device_config[ATTR_ENTITY_ID]
CONF_STOPID = 'stopid' ATTR_DESTINATION = 'destination' ATTR_LINE = 'line' ATTR_STOPID = 'stopid' ATTR_COMPONENT = 'component' ATTR_COMPONENT_VERSION = 'component_version' SCAN_INTERVAL = timedelta(seconds=10) ICON = 'mdi:bus' COMPONENT_NAME = 'ruter' COMPONENT_VERSION = '1.0.0' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_STOPID): cv.string, }) _LOGGER = logging.getLogger(__name__) def setup_platform(hass, config, add_devices, discovery_info=None): stopid = config.get(CONF_STOPID) add_devices([RuterSensor(stopid)]) class RuterSensor(Entity): def __init__(self, stopid): self._state = None self._line = None self._destination = None self._stopid = stopid self._component = COMPONENT_NAME
_LOGGER = logging.getLogger(__name__) DEFAULT_SSL = True DEFAULT_VERIFY_SSL = True SWITCH_MODELS = [ 'Outlet', 'Output 5v', 'Output 12v', 'Output 24v', ] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Optional(CONF_PORT): cv.port, vol.Optional(CONF_SSL, default=DEFAULT_SSL): cv.boolean, vol.Optional(CONF_VERIFY_SSL, default=DEFAULT_VERIFY_SSL): cv.boolean, }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up mFi sensors.""" host = config.get(CONF_HOST) username = config.get(CONF_USERNAME) password = config.get(CONF_PASSWORD) use_tls = config.get(CONF_SSL) verify_tls = config.get(CONF_VERIFY_SSL) default_port = 6443 if use_tls else 6080 port = int(config.get(CONF_PORT, default_port))
CONF_INVERT = 'invert' DEFAULT_NAME = 'Denkovi switch' PIN_FUNCTION_SCHEMA = vol.Schema({ vol.Optional(CONF_NAME): cv.string, vol.Optional(CONF_INVERT, default=False): cv.boolean, }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_RESOURCE): cv.url, vol.Required(CONF_PASSWORD): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_RELAYS, default={}): vol.Schema({cv.string: PIN_FUNCTION_SCHEMA}) }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the Denkovi switches.""" resource = config.get(CONF_RESOURCE) password = config.get(CONF_PASSWORD) try: denkoviModule = DenkoviModule(resource, password) except DenkoviException as e: _LOGGER.error(str(e))
import logging import voluptuous as vol import homeassistant.helpers.config_validation as cv from homeassistant.components.switch import (SwitchDevice, PLATFORM_SCHEMA, ) from homeassistant.const import (CONF_NAME, CONF_HOST, CONF_TOKEN, ) from homeassistant.exceptions import PlatformNotReady _LOGGER = logging.getLogger(__name__) DEFAULT_NAME = 'Xiaomi Miio Switch' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Required(CONF_TOKEN): vol.All(cv.string, vol.Length(min=32, max=32)), vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, }) REQUIREMENTS = ['python-miio==0.3.1'] ATTR_POWER = 'power' ATTR_TEMPERATURE = 'temperature' ATTR_LOAD_POWER = 'load_power' ATTR_MODEL = 'model' SUCCESS = ['ok'] # pylint: disable=unused-argument @asyncio.coroutine def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
from homeassistant.const import CONF_HOST, CONF_NAME, CONF_PASSWORD, CONF_USERNAME import homeassistant.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) DOMAIN = "edimax" DEFAULT_NAME = "Edimax Smart Plug" DEFAULT_PASSWORD = "******" DEFAULT_USERNAME = "******" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_PASSWORD, default=DEFAULT_PASSWORD): cv.string, vol.Optional(CONF_USERNAME, default=DEFAULT_USERNAME): cv.string, }) def setup_platform(hass, config, add_entities, discovery_info=None): """Find and return Edimax Smart Plugs.""" host = config.get(CONF_HOST) auth = (config.get(CONF_USERNAME), config.get(CONF_PASSWORD)) name = config.get(CONF_NAME) add_entities([SmartPlugSwitch(SmartPlug(host, auth), name)], True)
import homeassistant.helpers.config_validation as cv REQUIREMENTS = ['pyHS100==0.3.2'] _LOGGER = logging.getLogger(__name__) ATTR_TOTAL_ENERGY_KWH = 'total_energy_kwh' ATTR_CURRENT_A = 'current_a' CONF_LEDS = 'enable_leds' DEFAULT_NAME = 'TP-Link Switch' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_LEDS): cv.boolean, }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the TPLink switch platform.""" from pyHS100 import SmartPlug host = config.get(CONF_HOST) name = config.get(CONF_NAME) leds_on = config.get(CONF_LEDS) add_devices([SmartPlugSwitch(SmartPlug(host), name, leds_on)], True) class SmartPlugSwitch(SwitchDevice):
_LOGGER = logging.getLogger(__name__) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_DEVICE_DEFAULTS, default=DEVICE_DEFAULTS_SCHEMA({})): DEVICE_DEFAULTS_SCHEMA, vol.Optional(CONF_DEVICES, default={}): { cv.string: vol.Schema({ vol.Optional(CONF_NAME): cv.string, vol.Optional(CONF_ALIASES, default=[]): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_GROUP_ALIASES, default=[]): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_NOGROUP_ALIASES, default=[]): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_FIRE_EVENT): cv.boolean, vol.Optional(CONF_SIGNAL_REPETITIONS): vol.Coerce(int), vol.Optional(CONF_GROUP, default=True): cv.boolean, # deprecated config options vol.Optional(CONF_ALIASSES): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_GROUP_ALIASSES): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_NOGROUP_ALIASSES): vol.All(cv.ensure_list, [cv.string]), }) }, }, extra=vol.ALLOW_EXTRA) def devices_from_config(domain_config):
_LOGGER = logging.getLogger(__name__) CONF_SERVER = "server" DEFAULT_HOST = "localhost" DEFAULT_NAME = "Plex" DEFAULT_PORT = 32400 MIN_TIME_BETWEEN_UPDATES = timedelta(minutes=1) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Optional(CONF_HOST, default=DEFAULT_HOST): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_PASSWORD): cv.string, vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port, vol.Optional(CONF_SERVER): cv.string, vol.Optional(CONF_USERNAME): cv.string, } ) # pylint: disable=unused-argument def setup_platform(hass, config, add_devices, discovery_info=None): """Setup the Plex sensor.""" name = config.get(CONF_NAME) plex_user = config.get(CONF_USERNAME) plex_password = config.get(CONF_PASSWORD) plex_server = config.get(CONF_SERVER) plex_host = config.get(CONF_HOST) plex_port = config.get(CONF_PORT)
SWITCH_SCHEMA = vol.Schema({ vol.Required(CONF_CODE_OFF): cv.positive_int, vol.Required(CONF_CODE_ON): cv.positive_int, vol.Optional(CONF_PULSELENGTH): cv.positive_int, vol.Optional(CONF_SIGNAL_REPETITIONS, default=DEFAULT_SIGNAL_REPETITIONS): cv.positive_int, vol.Optional(CONF_PROTOCOL, default=DEFAULT_PROTOCOL): cv.positive_int, }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_GPIO): cv.positive_int, vol.Required(CONF_SWITCHES): vol.Schema({cv.string: SWITCH_SCHEMA}), }) # pylint: disable=unused-argument, import-error def setup_platform(hass, config, add_devices, discovery_info=None): """Find and return switches controlled by a generic RF device via GPIO.""" from . import rpi_rf gpio = config.get(CONF_GPIO) rfdevice = rpi_rf.RFDevice(gpio) switches = config.get(CONF_SWITCHES) devices = [] for dev_name, properties in list(switches.items()):