import voluptuous as vol from openpeerpower.components.binary_sensor import ( DEVICE_CLASSES_SCHEMA, PLATFORM_SCHEMA, BinarySensorEntity, ) from openpeerpower.const import CONF_DEVICE_CLASS, CONF_NAME import openpeerpower.helpers.config_validation as cv DEFAULT_NAME = "Random Binary Sensor" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA, }) async def async_setup_platform(opp, config, async_add_entities, discovery_info=None): """Set up the Random binary sensor.""" name = config.get(CONF_NAME) device_class = config.get(CONF_DEVICE_CLASS) async_add_entities([RandomSensor(name, device_class)], True)
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)), }) async def async_setup_platform(opp, config, async_add_entities, discovery_info=None): """Set up the FFmpeg noise binary sensor."""
_LOGGER = logging.getLogger(__name__) ATTR_AFTER = "after" ATTR_BEFORE = "before" ATTR_NEXT_UPDATE = "next_update" CONF_AFTER_OFFSET = "after_offset" CONF_BEFORE_OFFSET = "before_offset" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_AFTER): vol.Any(cv.time, vol.All(vol.Lower, cv.sun_event)), vol.Required(CONF_BEFORE): vol.Any(cv.time, vol.All(vol.Lower, cv.sun_event)), vol.Required(CONF_NAME): cv.string, vol.Optional(CONF_AFTER_OFFSET, default=timedelta(0)): cv.time_period, vol.Optional(CONF_BEFORE_OFFSET, default=timedelta(0)): cv.time_period, }) async def async_setup_platform(opp, config, async_add_entities, discovery_info=None): """Set up the ToD sensors.""" if opp.config.time_zone is None: _LOGGER.error("Timezone is not set in Open Peer Power configuration") return
# attr to check SENSOR_TYPES = { SENSOR_PRESENCE: "Presence", SENSOR_MOTION: "Motion", SENSOR_DOOR: "Door", SENSOR_COLD: "Cold", SENSOR_HEAT: "Heat", SENSOR_DRY: "Too dry", SENSOR_WET: "Too wet", SENSOR_LIGHT: "Light", SENSOR_MOISTURE: "Leak", SENSOR_BATTERY: "Low Battery", } PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_MONITORED_CONDITIONS, default=[]): vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]) }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the platform for a WirelessTags.""" platform = opp.data.get(WIRELESSTAG_DOMAIN) sensors = [] tags = platform.tags for tag in tags.values(): allowed_sensor_types = tag.supported_binary_events_types for sensor_type in config.get(CONF_MONITORED_CONDITIONS): if sensor_type in allowed_sensor_types: sensors.append( WirelessTagBinarySensor(platform, tag, sensor_type))
"Flevoland", "Friesland", "Gelderland", "Groningen", "Limburg", "Noord-Brabant", "Noord-Holland", "Overijssel", "Utrecht", "Zeeland", "Zuid-Holland", ] PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_PROVINCE): vol.In(PROVINCES), vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the Stookalert binary sensor platform.""" province = config[CONF_PROVINCE] name = config[CONF_NAME] api_handler = stookalert.stookalert(province) add_entities([StookalertBinarySensor(name, api_handler)], update_before_add=True) class StookalertBinarySensor(BinarySensorEntity): """An implementation of RIVM Stookalert."""
CUSTOMIZE_SCHEMA = vol.Schema({ vol.Optional(CONF_IGNORED, default=DEFAULT_IGNORED): cv.boolean, vol.Optional(CONF_DELAY, default=DEFAULT_DELAY): cv.positive_int, }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_NAME): cv.string, vol.Required(CONF_HOST): cv.string, vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port, vol.Optional(CONF_SSL, default=False): cv.boolean, vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Optional(CONF_CUSTOMIZE, default={}): vol.Schema({cv.string: CUSTOMIZE_SCHEMA}), }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the Hikvision binary sensor devices.""" name = config.get(CONF_NAME) host = config.get(CONF_HOST) port = config.get(CONF_PORT) username = config.get(CONF_USERNAME)
ATTR_CREATED, ATTR_IPV4_ADDRESS, ATTR_IPV6_ADDRESS, ATTR_MEMORY, ATTR_NODE_ID, ATTR_NODE_NAME, ATTR_REGION, ATTR_VCPUS, CONF_NODES, DATA_LINODE, ) _LOGGER = logging.getLogger(__name__) DEFAULT_NAME = "Node" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( {vol.Required(CONF_NODES): vol.All(cv.ensure_list, [cv.string])}) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the Linode droplet sensor.""" linode = opp.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(LinodeBinarySensor(linode, node_id))
import voluptuous as vol from openpeerpower.components.binary_sensor import ( DEVICE_CLASS_MOISTURE, PLATFORM_SCHEMA, BinarySensorEntity, ) from openpeerpower.const import CONF_MONITORED_CONDITIONS import openpeerpower.helpers.config_validation as cv from . import DOMAIN SENSOR_TYPES = {"Rain": DEVICE_CLASS_MOISTURE, "Night": None} PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_MONITORED_CONDITIONS, default=list(SENSOR_TYPES)): vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]) }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the available BloomSky weather binary sensors.""" # Default needed in case of discovery if discovery_info is not None: return sensors = config[CONF_MONITORED_CONDITIONS] bloomsky = opp.data[DOMAIN] for device in bloomsky.devices.values(): for variable in sensors: add_entities([BloomSkySensor(bloomsky, device, variable)], True)
"""Support for binary sensor using Orange Pi GPIO.""" from openpeerpower.components.binary_sensor import PLATFORM_SCHEMA, BinarySensorEntity from . import edge_detect, read_input, setup_input, setup_mode from .const import CONF_INVERT_LOGIC, CONF_PIN_MODE, CONF_PORTS, PORT_SCHEMA PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(PORT_SCHEMA) async def async_setup_platform(opp, config, async_add_entities, discovery_info=None): """Set up the Orange Pi GPIO platform.""" binary_sensors = [] invert_logic = config[CONF_INVERT_LOGIC] pin_mode = config[CONF_PIN_MODE] ports = config[CONF_PORTS] setup_mode(pin_mode) for port_num, port_name in ports.items(): binary_sensors.append( OPiGPIOBinarySensor(opp, port_name, port_num, invert_logic)) async_add_entities(binary_sensors) class OPiGPIOBinarySensor(BinarySensorEntity): """Represent a binary sensor that uses Orange Pi GPIO.""" def __init__(self, opp, name, port, invert_logic):
DEFAULT_HYSTERESIS = 0.0 POSITION_ABOVE = "above" POSITION_BELOW = "below" POSITION_IN_RANGE = "in_range" POSITION_UNKNOWN = "unknown" TYPE_LOWER = "lower" TYPE_RANGE = "range" TYPE_UPPER = "upper" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Required(CONF_ENTITY_ID): cv.entity_id, vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA, vol.Optional(CONF_HYSTERESIS, default=DEFAULT_HYSTERESIS): vol.Coerce(float), vol.Optional(CONF_LOWER): vol.Coerce(float), vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_UPPER): vol.Coerce(float), } ) async def async_setup_platform(opp, config, async_add_entities, discovery_info=None): """Set up the Threshold sensor.""" entity_id = config.get(CONF_ENTITY_ID) name = config.get(CONF_NAME) lower = config.get(CONF_LOWER) upper = config.get(CONF_UPPER) hysteresis = config.get(CONF_HYSTERESIS) device_class = config.get(CONF_DEVICE_CLASS)
CONF_SETTLE_TIME = "settle_time" DEFAULT_INVERT_LOGIC = False DEFAULT_SETTLE_TIME = 20 PORT_SCHEMA = vol.Schema({ vol.Optional(CONF_NAME): cv.string, vol.Optional(CONF_SETTLE_TIME, default=DEFAULT_SETTLE_TIME): cv.positive_int, vol.Optional(CONF_INVERT_LOGIC, default=DEFAULT_INVERT_LOGIC): cv.boolean, }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_PORTS, default={}): vol.Schema({cv.positive_int: PORT_SCHEMA}) }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the PiFace Digital Input devices.""" binary_sensors = [] ports = config.get(CONF_PORTS) for port, port_entity in ports.items(): name = port_entity.get(CONF_NAME) settle_time = port_entity[CONF_SETTLE_TIME] / 1000 invert_logic = port_entity[CONF_INVERT_LOGIC] binary_sensors.append( RPiPFIOBinarySensor(opp, port, name, settle_time, invert_logic)) add_entities(binary_sensors, True)
_LOGGER = logging.getLogger(__name__) PLATFORM_SCHEMA = vol.All( cv.deprecated(CONF_COILS, CONF_INPUTS), PLATFORM_SCHEMA.extend( { vol.Required(CONF_INPUTS): [ vol.All( cv.deprecated(CALL_TYPE_COIL, CONF_ADDRESS), vol.Schema( { vol.Required(CONF_ADDRESS): cv.positive_int, vol.Required(CONF_NAME): cv.string, vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA, vol.Optional(CONF_HUB, default=DEFAULT_HUB): cv.string, vol.Optional(CONF_SLAVE): cv.positive_int, vol.Optional( CONF_INPUT_TYPE, default=CALL_TYPE_COIL ): vol.In([CALL_TYPE_COIL, CALL_TYPE_DISCRETE]), } ), ) ] } ), ) async def async_setup_platform( opp: OpenPeerPower,
from openpeerpower.helpers import config_validation as cv from openpeerpower.helpers.event import track_point_in_time from openpeerpower.util import dt as dt_util CONF_VARIABLE = "variable" CONF_RESET_DELAY_SEC = "reset_delay_sec" DEFAULT_NAME = "Pilight Binary Sensor" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_VARIABLE): cv.string, vol.Required(CONF_PAYLOAD): vol.Schema(dict), vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_PAYLOAD_ON, default="on"): vol.Any(cv.positive_int, cv.small_float, cv.string), vol.Optional(CONF_PAYLOAD_OFF, default="off"): vol.Any(cv.positive_int, cv.small_float, cv.string), vol.Optional(CONF_DISARM_AFTER_TRIGGER, default=False): cv.boolean, vol.Optional(CONF_RESET_DELAY_SEC, default=30): cv.positive_int, }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up Pilight Binary Sensor.""" disarm = config.get(CONF_DISARM_AFTER_TRIGGER) if disarm: add_entities([ PilightTriggerSensor(
import openpeerpower.helpers.config_validation as cv from openpeerpower.util import Throttle _LOGGER = logging.getLogger(__name__) ATTR_ISS_NEXT_RISE = "next_rise" ATTR_ISS_NUMBER_PEOPLE_SPACE = "number_of_people_in_space" DEFAULT_NAME = "ISS" DEFAULT_DEVICE_CLASS = "visible" MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=60) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_SHOW_ON_MAP, default=False): cv.boolean, }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the ISS sensor.""" if None in (opp.config.latitude, opp.config.longitude): _LOGGER.error( "Latitude or longitude not set in Open Peer Power config") return False try: iss_data = IssData(opp.config.latitude, opp.config.longitude) iss_data.update() except requests.exceptions.HTTPError as error:
CONF_I2CADDR = "i2c_address" CONF_BITS = "bits" DEFAULT_INVERT_LOGIC = False DEFAULT_BITS = 24 DEFAULT_BUS = 1 DEFAULT_ADDR = 0x20 _SENSORS_SCHEMA = vol.Schema({cv.positive_int: cv.string}) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_PINS): _SENSORS_SCHEMA, vol.Optional(CONF_I2CBUS, default=DEFAULT_BUS): cv.positive_int, vol.Optional(CONF_I2CADDR, default=DEFAULT_ADDR): cv.positive_int, vol.Optional(CONF_BITS, default=DEFAULT_BITS): cv.positive_int, vol.Optional(CONF_INVERT_LOGIC, default=DEFAULT_INVERT_LOGIC): cv.boolean, }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the IO expander devices.""" pins = config[CONF_PINS] binary_sensors = [] pi4ioe5v9xxxx.setup( i2c_bus=config[CONF_I2CBUS], i2c_addr=config[CONF_I2CADDR],
val = entity_cfg.pop(from_key) if isinstance(val, str): val = template.Template(val) entity_cfg[to_key] = val if CONF_NAME not in entity_cfg: entity_cfg[CONF_NAME] = template.Template(object_id) sensors.append(entity_cfg) return sensors PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_SENSORS): cv.schema_with_slug_keys(LEGACY_BINARY_SENSOR_SCHEMA), }) @callback def _async_create_template_tracking_entities(async_add_entities, opp, definitions: list[dict], unique_id_prefix: str | None): """Create the template binary sensors.""" sensors = [] for entity_conf in definitions: # Still available on legacy object_id = entity_conf.get(CONF_OBJECT_ID) value = entity_conf[CONF_STATE]
cv.positive_int, vol.Required(CONF_NAME): cv.string, vol.Optional(CONF_INVERT_LOGIC, default=DEFAULT_INVERT_LOGIC): cv.boolean, vol.Optional(CONF_DEVICE_CLASS, default=DEFAULT_DEVICE_CLASS): cv.string, }]) _I2C_HATS_SCHEMA = vol.Schema([{ vol.Required(CONF_BOARD): vol.In(I2C_HAT_NAMES), vol.Required(CONF_ADDRESS): vol.Coerce(int), vol.Required(CONF_CHANNELS): _CHANNELS_SCHEMA, }]) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( {vol.Optional(CONF_I2C_HATS): _I2C_HATS_SCHEMA}) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the raspihats binary_sensor devices.""" I2CHatBinarySensor.I2C_HATS_MANAGER = opp.data[I2C_HATS_MANAGER] binary_sensors = [] i2c_hat_configs = config.get(CONF_I2C_HATS) for i2c_hat_config in i2c_hat_configs: address = i2c_hat_config[CONF_ADDRESS] board = i2c_hat_config[CONF_BOARD] try: I2CHatBinarySensor.I2C_HATS_MANAGER.register_board(board, address) for channel_config in i2c_hat_config[CONF_CHANNELS]: binary_sensors.append( I2CHatBinarySensor(
PLATFORM_SCHEMA, BinarySensorEntity, ) from openpeerpower.const import CONF_DEVICE_CLASS, CONF_ID, CONF_NAME import openpeerpower.helpers.config_validation as cv from .device import EnOceanEntity DEFAULT_NAME = "EnOcean binary sensor" DEPENDENCIES = ["enocean"] EVENT_BUTTON_PRESSED = "button_pressed" 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, vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA, }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the Binary Sensor platform for EnOcean.""" dev_id = config.get(CONF_ID) dev_name = config.get(CONF_NAME) device_class = config.get(CONF_DEVICE_CLASS) add_entities([EnOceanBinarySensor(dev_id, dev_name, device_class)]) class EnOceanBinarySensor(EnOceanEntity, BinarySensorEntity):
from openpeerpower.const import CONF_ENTITY_NAMESPACE, CONF_MONITORED_CONDITIONS import openpeerpower.helpers.config_validation as cv from . import DEFAULT_ENTITY_NAMESPACE, DOMAIN as SKYBELL_DOMAIN, SkybellDevice SCAN_INTERVAL = timedelta(seconds=10) # Sensor types: Name, device_class, event SENSOR_TYPES = { "button": ["Button", DEVICE_CLASS_OCCUPANCY, "device:sensor:button"], "motion": ["Motion", DEVICE_CLASS_MOTION, "device:sensor:motion"], } 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(SENSOR_TYPES)]), }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the platform for a Skybell device.""" skybell = opp.data.get(SKYBELL_DOMAIN) sensors = [] for sensor_type in config.get(CONF_MONITORED_CONDITIONS): for device in skybell.get_devices(): sensors.append(SkybellBinarySensor(device, sensor_type)) add_entities(sensors, True)
from .const import CONF_COMMAND_TIMEOUT, DEFAULT_TIMEOUT, DOMAIN, PLATFORMS from .sensor import CommandSensorData DEFAULT_NAME = "Binary Command Sensor" DEFAULT_PAYLOAD_ON = "ON" DEFAULT_PAYLOAD_OFF = "OFF" SCAN_INTERVAL = timedelta(seconds=60) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Required(CONF_COMMAND): 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_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA, vol.Optional(CONF_VALUE_TEMPLATE): cv.template, vol.Optional(CONF_COMMAND_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int, } ) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the Command line Binary Sensor.""" setup_reload_service(opp, DOMAIN, PLATFORMS) name = config.get(CONF_NAME) command = config.get(CONF_COMMAND) payload_off = config.get(CONF_PAYLOAD_OFF)
CONF_ZONE_TYPES = "zone_types" DEFAULT_HOST = "localhost" DEFAULT_NAME = "Alarm" DEFAULT_PORT = "5007" DEFAULT_SSL = False SCAN_INTERVAL = datetime.timedelta(seconds=10) ZONE_TYPES_SCHEMA = vol.Schema({cv.positive_int: vol.In(DEVICE_CLASSES)}) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_EXCLUDE_ZONES, default=[]): vol.All(cv.ensure_list, [cv.positive_int]), vol.Optional(CONF_HOST, default=DEFAULT_HOST): cv.string, vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port, vol.Optional(CONF_ZONE_TYPES, default={}): ZONE_TYPES_SCHEMA, }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the Concord232 binary sensor platform.""" host = config[CONF_HOST] port = config[CONF_PORT] exclude = config[CONF_EXCLUDE_ZONES] zone_types = config[CONF_ZONE_TYPES] sensors = []
PARALLEL_UPDATES = 0 PING_MATCHER = re.compile( r"(?P<min>\d+.\d+)\/(?P<avg>\d+.\d+)\/(?P<max>\d+.\d+)\/(?P<mdev>\d+.\d+)") PING_MATCHER_BUSYBOX = re.compile( r"(?P<min>\d+.\d+)\/(?P<avg>\d+.\d+)\/(?P<max>\d+.\d+)") WIN32_PING_MATCHER = re.compile( r"(?P<min>\d+)ms.+(?P<max>\d+)ms.+(?P<avg>\d+)ms") PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Optional(CONF_NAME): cv.string, vol.Optional(CONF_PING_COUNT, default=DEFAULT_PING_COUNT): vol.Range(min=1, max=100), }) async def async_setup_platform(opp, config, async_add_entities, discovery_info=None) -> None: """Set up the Ping Binary sensor.""" host = config[CONF_HOST] count = config[CONF_PING_COUNT] name = config.get(CONF_NAME, f"{DEFAULT_NAME} {host}") privileged = opp.data[DOMAIN][PING_PRIVS] if privileged is None:
MODE_DOWN = "DOWN" MODE_DISABLED = "DISABLED" DEFAULT_INVERT_LOGIC = False DEFAULT_I2C_ADDRESS = 0x20 DEFAULT_I2C_BUS = 1 DEFAULT_PULL_MODE = MODE_DISABLED _SENSORS_SCHEMA = vol.Schema({cv.positive_int: cv.string}) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_PINS): _SENSORS_SCHEMA, vol.Optional(CONF_INVERT_LOGIC, default=DEFAULT_INVERT_LOGIC): cv.boolean, vol.Optional(CONF_PULL_MODE, default=DEFAULT_PULL_MODE): vol.All(vol.Upper, vol.In([MODE_UP, MODE_DOWN, MODE_DISABLED])), vol.Optional(CONF_I2C_ADDRESS, default=DEFAULT_I2C_ADDRESS): vol.Coerce(int), vol.Optional(CONF_I2C_BUS, default=DEFAULT_I2C_BUS): cv.positive_int, }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the PCAL9535A binary sensors.""" pull_mode = config[CONF_PULL_MODE] invert_logic = config[CONF_INVERT_LOGIC] i2c_address = config[CONF_I2C_ADDRESS] bus = config[CONF_I2C_BUS] pcal = PCAL9535A(bus, i2c_address)
from openpeerpower.const import ( CONF_DEVICE_CLASS, CONF_FORCE_UPDATE, CONF_NAME, CONF_RESOURCE, CONF_RESOURCE_TEMPLATE, CONF_VALUE_TEMPLATE, ) from openpeerpower.exceptions import PlatformNotReady import openpeerpower.helpers.config_validation as cv from . import async_get_config_and_coordinator, create_rest_data_from_config from .entity import RestEntity from .schema import BINARY_SENSOR_SCHEMA, RESOURCE_SCHEMA PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({**RESOURCE_SCHEMA, **BINARY_SENSOR_SCHEMA}) PLATFORM_SCHEMA = vol.All( cv.has_at_least_one_key(CONF_RESOURCE, CONF_RESOURCE_TEMPLATE), PLATFORM_SCHEMA ) async def async_setup_platform(opp, config, async_add_entities, discovery_info=None): """Set up the REST binary sensor.""" # Must update the sensor now (including fetching the rest resource) to # ensure it's updating its state. if discovery_info is not None: conf, coordinator, rest = await async_get_config_and_coordinator( opp, BINARY_SENSOR_DOMAIN, discovery_info ) else:
DEFAULT_BOUNCETIME, DEFAULT_INVERT_LOGIC, DEFAULT_PULL_MODE, ) from .. import remote_rpi_gpio CONF_PORTS = "ports" _SENSORS_SCHEMA = vol.Schema({cv.positive_int: cv.string}) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Required(CONF_PORTS): _SENSORS_SCHEMA, vol.Optional(CONF_INVERT_LOGIC, default=DEFAULT_INVERT_LOGIC): cv.boolean, vol.Optional(CONF_BOUNCETIME, default=DEFAULT_BOUNCETIME): cv.positive_int, vol.Optional(CONF_PULL_MODE, default=DEFAULT_PULL_MODE): cv.string, }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the Raspberry PI GPIO devices.""" address = config["host"] invert_logic = config[CONF_INVERT_LOGIC] pull_mode = config[CONF_PULL_MODE] ports = config["ports"] bouncetime = config[CONF_BOUNCETIME] / 1000
ATTRIBUTION = "Information provided by MeteoAlarm" CONF_COUNTRY = "country" CONF_LANGUAGE = "language" CONF_PROVINCE = "province" DEFAULT_NAME = "meteoalarm" SCAN_INTERVAL = timedelta(minutes=30) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_COUNTRY): cv.string, vol.Required(CONF_PROVINCE): cv.string, vol.Optional(CONF_LANGUAGE, default="en"): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the MeteoAlarm binary sensor platform.""" country = config[CONF_COUNTRY] province = config[CONF_PROVINCE] language = config[CONF_LANGUAGE] name = config[CONF_NAME] try:
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]), }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the Workday sensor.""" add_holidays = config.get(CONF_ADD_HOLIDAYS) remove_holidays = config.get(CONF_REMOVE_HOLIDAYS) country = config[CONF_COUNTRY]
CONF_NAME, CONF_PIN, CONF_RESOURCE, HTTP_OK, ) import openpeerpower.helpers.config_validation as cv from openpeerpower.util import Throttle _LOGGER = logging.getLogger(__name__) MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=30) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Required(CONF_RESOURCE): cv.url, vol.Optional(CONF_NAME): cv.string, vol.Required(CONF_PIN): cv.string, vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA, } ) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the aREST binary sensor.""" resource = config[CONF_RESOURCE] pin = config[CONF_PIN] device_class = config.get(CONF_DEVICE_CLASS) try: response = requests.get(resource, timeout=10).json() except requests.exceptions.MissingSchema: _LOGGER.error(
from openpeerpower.components.binary_sensor import PLATFORM_SCHEMA, BinarySensorEntity from openpeerpower.const import CONF_NAME import openpeerpower.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) CONF_LOCATION = "location" DEFAULT_NAME = "Taps Aff" SCAN_INTERVAL = timedelta(minutes=30) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Required(CONF_LOCATION): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, } ) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the Taps Aff binary sensor.""" name = config.get(CONF_NAME) location = config.get(CONF_LOCATION) taps_aff_data = TapsAffData(location) add_entities([TapsAffSensor(taps_aff_data, name)], True) class TapsAffSensor(BinarySensorEntity):
CONF_RESET = "reset" CONF_CHANGES = "changes" CONF_REPEAT_TIME = "repeat_time" DEFAULT_NAME = "FFmpeg Motion" 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_RESET, default=10): vol.All(vol.Coerce(int), vol.Range(min=1)), vol.Optional(CONF_CHANGES, default=10): vol.All(vol.Coerce(float), vol.Range(min=0, max=99)), vol.Inclusive(CONF_REPEAT, "repeat"): vol.All(vol.Coerce(int), vol.Range(min=1)), vol.Inclusive(CONF_REPEAT_TIME, "repeat"): vol.All(vol.Coerce(int), vol.Range(min=1)), }) async def async_setup_platform(opp, config, async_add_entities, discovery_info=None): """Set up the FFmpeg binary motion sensor."""