STATE_UNLOCKED) from homeassistant.helpers.event import async_call_later from homeassistant.core import callback REQUIREMENTS = ['kiwiki-client==0.1.1'] _LOGGER = logging.getLogger(__name__) ATTR_TYPE = 'hardware_type' ATTR_PERMISSION = 'permission' ATTR_CAN_INVITE = 'can_invite_others' UNLOCK_MAINTAIN_TIME = 5 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 KIWI lock platform.""" from kiwiki import KiwiClient, KiwiException try: kiwi = KiwiClient(config[CONF_USERNAME], config[CONF_PASSWORD]) except KiwiException as exc: _LOGGER.error(exc) return available_locks = kiwi.get_locks() if not available_locks: # No locks found; abort setup routine. _LOGGER.info("No KIWI locks found in your account.")
"""Support for Sesame, by CANDY HOUSE.""" from __future__ import annotations import pysesame2 import voluptuous as vol from homeassistant.components.lock import PLATFORM_SCHEMA, LockEntity from homeassistant.const import ATTR_BATTERY_LEVEL, ATTR_DEVICE_ID, CONF_API_KEY import homeassistant.helpers.config_validation as cv from homeassistant.helpers.typing import ConfigType ATTR_SERIAL_NO = "serial" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({vol.Required(CONF_API_KEY): cv.string}) def setup_platform(hass, config: ConfigType, add_entities, discovery_info=None): """Set up the Sesame platform.""" api_key = config.get(CONF_API_KEY) add_entities( [SesameDevice(sesame) for sesame in pysesame2.get_sesames(api_key)], update_before_add=True, ) class SesameDevice(LockEntity): """Representation of a Sesame device.""" def __init__(self, sesame: pysesame2.Sesame) -> None: """Initialize the Sesame device."""
_LOGGER = logging.getLogger(__name__) CONF_LOCK = "lock" CONF_UNLOCK = "unlock" DEFAULT_NAME = "Template Lock" DEFAULT_OPTIMISTIC = False PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Required(CONF_LOCK): cv.SCRIPT_SCHEMA, vol.Required(CONF_UNLOCK): cv.SCRIPT_SCHEMA, vol.Required(CONF_VALUE_TEMPLATE): cv.template, vol.Optional(CONF_AVAILABILITY_TEMPLATE): cv.template, vol.Optional(CONF_OPTIMISTIC, default=DEFAULT_OPTIMISTIC): cv.boolean, }) async def async_setup_platform(hass, config, async_add_devices, discovery_info=None): """Set up the Template lock.""" device = config.get(CONF_NAME) value_template = config.get(CONF_VALUE_TEMPLATE)
from homeassistant.components.lock import (LockDevice, PLATFORM_SCHEMA) from homeassistant.const import (CONF_HOST, CONF_PORT, CONF_TOKEN) from homeassistant.util import Throttle import homeassistant.helpers.config_validation as cv REQUIREMENTS = ['pynuki==1.2'] _LOGGER = logging.getLogger(__name__) DEFAULT_PORT = 8080 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port, vol.Required(CONF_TOKEN): cv.string }) MIN_TIME_BETWEEN_SCANS = timedelta(seconds=30) MIN_TIME_BETWEEN_FORCED_SCANS = timedelta(seconds=5) # pylint: disable=unused-argument def setup_platform(hass, config, add_devices, discovery_info=None): """Setup the Demo lock platform.""" from pynuki import NukiBridge bridge = NukiBridge(config.get(CONF_HOST), config.get(CONF_TOKEN)) add_devices([NukiLock(lock) for lock in bridge.locks])
from typing import Callable # noqa import voluptuous as vol import homeassistant.helpers.config_validation as cv from homeassistant.components.lock import LockDevice, PLATFORM_SCHEMA from homeassistant.const import ( ATTR_BATTERY_LEVEL, CONF_EMAIL, CONF_PASSWORD, STATE_LOCKED, STATE_UNLOCKED) from homeassistant.helpers.typing import ConfigType REQUIREMENTS = ['pysesame==0.1.0'] ATTR_DEVICE_ID = 'device_id' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_EMAIL): cv.string, vol.Required(CONF_PASSWORD): cv.string }) # pylint: disable=unused-argument def setup_platform( hass, config: ConfigType, add_devices: Callable[[list], None], discovery_info=None): """Set up the Sesame platform.""" import pysesame email = config.get(CONF_EMAIL) password = config.get(CONF_PASSWORD) add_devices([SesameDevice(sesame) for sesame in pysesame.get_sesames(email, password)],
# Import the device class from the component that you want to support from homeassistant.components.lock import PLATFORM_SCHEMA, SUPPORT_OPEN, LockEntity from homeassistant.const import ATTR_BATTERY_LEVEL, ATTR_ID, CONF_PASSWORD, CONF_USERNAME, STATE_LOCKED, STATE_UNLOCKED ATTR_NUMERIC_STATE = "numeric_state" ATTR_SUPPORT_PULLSPING = "support_pullspring" ATTR_DURATION_PULLSPRING = "duration_pullspring" ATTR_CONNECTED = "connected" ATTR_CHARGING = "charging" _LOGGER = logging.getLogger(__name__) # Validation of the user's configuration PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_USERNAME, default='admin'): cv.string, vol.Required(CONF_PASSWORD): cv.string, }) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the Tedee Lock platform.""" try: #_LOGGER.error("Creds: %s, %s", config[CONF_USERNAME], config[CONF_PASSWORD]) tedee = TedeeClient(config[CONF_USERNAME], config[CONF_PASSWORD]) except TedeeClientException as exc: _LOGGER.error(exc) return available_locks = tedee.get_locks() _LOGGER.debug("available_locks: %s", available_locks) if not available_locks:
"""Lockitron lock platform.""" import logging import requests import voluptuous as vol import homeassistant.helpers.config_validation as cv from homeassistant.components.lock import LockDevice, PLATFORM_SCHEMA from homeassistant.const import CONF_ACCESS_TOKEN, CONF_ID _LOGGER = logging.getLogger(__name__) DOMAIN = 'lockitron' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_ACCESS_TOKEN): cv.string, vol.Required(CONF_ID): cv.string }) BASE_URL = 'https://api.lockitron.com' API_STATE_URL = BASE_URL + '/v2/locks/{}?access_token={}' API_ACTION_URL = BASE_URL + '/v2/locks/{}?access_token={}&state={}' def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the Lockitron platform.""" access_token = config.get(CONF_ACCESS_TOKEN) device_id = config.get(CONF_ID) response = requests.get(API_STATE_URL.format(device_id, access_token), timeout=5) if response.status_code == 200: add_entities( [Lockitron(response.json()['state'], access_token, device_id)])
import logging import voluptuous as vol import requests from datetime import datetime, timedelta import homeassistant.helpers.config_validation as cv from homeassistant.components.lock import LockDevice, PLATFORM_SCHEMA from homeassistant.const import CONF_ACCESS_TOKEN, CONF_ID, CONF_USERNAME, CONF_PASSWORD _LOGGER = logging.getLogger(__name__) DOMAIN = "doorman" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_ACCESS_TOKEN): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Required(CONF_ID): cv.string, }) BASE_URL = "https://mob.yalehomesystem.co.uk/yapi" API_LOGIN_URL = BASE_URL + "/o/token/" API_STATE_URL = BASE_URL + "/api/panel/cycle/" API_HISTORY_URL = BASE_URL + "/api/event/report/?page_num=1&set_utc=1" SCAN_INTERVAL = timedelta(seconds=10) STATE_ENUM = { "1816": "device_status.lock", # Locked after a failed lock "1815": "device_status.unlock", # Failed to lock "1807": "device_status.lock", # Auto-relocked "1801": "device_status.unlock", # Unlock from inside "1802": "device_status.unlock", # Unlock from outside, token or keypad,
""" import logging import requests import voluptuous as vol import homeassistant.helpers.config_validation as cv from homeassistant.components.lock import LockDevice, PLATFORM_SCHEMA from homeassistant.const import CONF_ACCESS_TOKEN, CONF_ID _LOGGER = logging.getLogger(__name__) DOMAIN = 'lockitron' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_ACCESS_TOKEN): cv.string, vol.Required(CONF_ID): cv.string }) BASE_URL = 'https://api.lockitron.com' API_STATE_URL = BASE_URL + '/v2/locks/{}?access_token={}' API_ACTION_URL = BASE_URL + '/v2/locks/{}?access_token={}&state={}' # pylint: disable=unused-argument def setup_platform(hass, config, add_devices, discovery_info=None): """Setup the Lockitron platform.""" access_token = config.get(CONF_ACCESS_TOKEN) device_id = config.get(CONF_ID) response = requests.get(API_STATE_URL.format(device_id, access_token)) if response.status_code == 200: add_devices([Lockitron(response.json()['state'], access_token, device_id)])
from homeassistant.components.lock import LockDevice, PLATFORM_SCHEMA from homeassistant.const import CONF_EMAIL, CONF_PASSWORD, STATE_LOCKED, STATE_UNLOCKED import homeassistant.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) CONF_LOCK_ID = "lock_id" CONF_MAX_RETRIES = "max_retries" CONF_RETRY_DELAY = "retry_delay" # Validation of the user's configuration PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_EMAIL): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Required(CONF_LOCK_ID): cv.string, vol.Optional(CONF_MAX_RETRIES, default=3): cv.positive_int, vol.Optional(CONF_RETRY_DELAY, default=2): cv.positive_int }) def setup_platform(hass, config, add_devices, discovery_info=None): """Setup the Kevo platform.""" from pykevoplus import KevoLock # Assign configuration variables. The configuration check takes care they are # present. email = config.get(CONF_EMAIL) password = config.get(CONF_PASSWORD)
CONF_PROTOCOL = "protocol" CONF_PASSWORD= "******" CONF_HOST = "host" CONF_UNLOCK_TIMEOUT = "lock_timeout" CONF_NAME = "name" DEFAULT_NAME = "Door" DEFAULT_HOST = "192.168.0.202" DEFAULT_STATE = STATE_LOCKED DEFAULT_PASSWORD = "******" DEFAULT_UNLOCK_TIMEOUT = 15 DEFAULT_PROTOCOL = "udp" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Required(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Required(CONF_HOST, default=DEFAULT_HOST): cv.string, vol.Required(CONF_PASSWORD, default=DEFAULT_PASSWORD): cv.string, vol.Required(CONF_PROTOCOL, default=DEFAULT_PROTOCOL): vol.In(["tcp", "udp"]), vol.Optional(CONF_UNLOCK_TIMEOUT, default=DEFAULT_UNLOCK_TIMEOUT): cv.positive_int, } ) async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up the Demo lock platform.""" host = config.get(CONF_HOST) name = config.get(CONF_NAME) password = config.get(CONF_PASSWORD) if config.get(CONF_PROTOCOL) == "udp": force_udp = True else: force_udp = False unlock_timeout = config.get(CONF_UNLOCK_TIMEOUT) async_add_entities(
TEMPLATE_ENTITY_AVAILABILITY_SCHEMA_LEGACY, TemplateEntity, rewrite_common_legacy_to_modern_conf, ) CONF_LOCK = "lock" CONF_UNLOCK = "unlock" DEFAULT_NAME = "Template Lock" DEFAULT_OPTIMISTIC = False PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Optional(CONF_NAME): cv.string, vol.Required(CONF_LOCK): cv.SCRIPT_SCHEMA, vol.Required(CONF_UNLOCK): cv.SCRIPT_SCHEMA, vol.Required(CONF_VALUE_TEMPLATE): cv.template, vol.Optional(CONF_OPTIMISTIC, default=DEFAULT_OPTIMISTIC): cv.boolean, vol.Optional(CONF_UNIQUE_ID): cv.string, } ).extend(TEMPLATE_ENTITY_AVAILABILITY_SCHEMA_LEGACY.schema) async def _async_create_entities(hass, config): """Create the Template lock.""" config = rewrite_common_legacy_to_modern_conf(config) return [TemplateLock(hass, config, config.get(CONF_UNIQUE_ID))] async def async_setup_platform( hass: HomeAssistant, config: ConfigType,
from datetime import timedelta from subprocess import Popen, TimeoutExpired import voluptuous as vol import homeassistant.helpers.config_validation as cv from homeassistant.components.lock import LockDevice, PLATFORM_SCHEMA from homeassistant.const import CONF_FILE_PATH, CONF_TIMEOUT _LOGGER = logging.getLogger(__name__) DOMAIN = 'august' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_FILE_PATH): cv.string, vol.Optional(CONF_TIMEOUT, default=timedelta(seconds=10)): vol.All(cv.time_period, cv.positive_timedelta) }) # pylint: disable=unused-argument def setup_platform(hass, config, add_devices, discovery_info=None): """Setup the August platform.""" config_file_path = config.get(CONF_FILE_PATH) timeout = config.get(CONF_TIMEOUT) if os.path.exists(config_file_path): add_devices([August(config_file_path, timeout)]) else: _LOGGER.error('Error retrieving August lock config file {} during init' .format(config_file_path))
from homeassistant.exceptions import TemplateError from homeassistant.helpers.event import async_track_state_change from homeassistant.helpers.script import Script _LOGGER = logging.getLogger(__name__) CONF_LOCK = 'lock' CONF_UNLOCK = 'unlock' DEFAULT_NAME = 'Template Lock' DEFAULT_OPTIMISTIC = False PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Required(CONF_LOCK): cv.SCRIPT_SCHEMA, vol.Required(CONF_UNLOCK): cv.SCRIPT_SCHEMA, vol.Required(CONF_VALUE_TEMPLATE): cv.template, vol.Optional(CONF_OPTIMISTIC, default=DEFAULT_OPTIMISTIC): cv.boolean }) async def async_setup_platform(hass, config, async_add_devices, discovery_info=None): """Set up the Template lock.""" name = config.get(CONF_NAME) value_template = config.get(CONF_VALUE_TEMPLATE) value_template.hass = hass value_template_entity_ids = value_template.extract_entities() if value_template_entity_ids == MATCH_ALL: _LOGGER.warning(
import voluptuous as vol # Import the device class from the component that you want to support from homeassistant.components.lock import LockDevice, PLATFORM_SCHEMA from homeassistant.const import CONF_EMAIL, CONF_PASSWORD, STATE_LOCKED, STATE_UNLOCKED import homeassistant.helpers.config_validation as cv # Home Assistant depends on 3rd party packages for API specific code. REQUIREMENTS = ['pykevocontrol==2.0.0'] _LOGGER = logging.getLogger(__name__) # Validation of the user's configuration PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_EMAIL): cv.string, vol.Required(CONF_PASSWORD): cv.string, }) def setup_platform(hass, config, add_devices, discovery_info=None): """Setup the Kevo platform.""" from pykevoplus import Kevo # Assign configuration variables. The configuration check takes care they are # present. email = config.get(CONF_EMAIL) password = config.get(CONF_PASSWORD) # Setup connection with devices/cloud kevos = Kevo.GetLocks(email, password)
ATTR_BATTERY_CRITICAL = 'battery_critical' ATTR_NUKI_ID = 'nuki_id' ATTR_UNLATCH = 'unlatch' MIN_TIME_BETWEEN_FORCED_SCANS = timedelta(seconds=5) MIN_TIME_BETWEEN_SCANS = timedelta(seconds=30) NUKI_DATA = 'nuki' SERVICE_LOCK_N_GO = 'nuki_lock_n_go' SERVICE_UNLATCH = 'nuki_unlatch' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port, vol.Required(CONF_TOKEN): cv.string }) LOCK_N_GO_SERVICE_SCHEMA = vol.Schema({ vol.Optional(ATTR_ENTITY_ID): cv.entity_ids, vol.Optional(ATTR_UNLATCH, default=False): cv.boolean }) UNLATCH_SERVICE_SCHEMA = vol.Schema({ vol.Optional(ATTR_ENTITY_ID): cv.entity_ids }) def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the Nuki lock platform."""
SCHEMA, MAP, DUMMY_IP, DUMMY_TOKEN, ) import copy TYPE = 'lock' _LOGGER = logging.getLogger(__name__) SCAN_INTERVAL = timedelta(seconds=10) DEFAULT_NAME = "Generic MIoT " + TYPE DATA_KEY = TYPE + '.' + DOMAIN PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( SCHEMA ) # pylint: disable=unused-argument @asyncio.coroutine async def async_setup_platform(hass, config, async_add_devices, discovery_info=None): """Set up the light from config.""" if DATA_KEY not in hass.data: hass.data[DATA_KEY] = {} host = config.get(CONF_HOST) token = config.get(CONF_TOKEN) mapping = config.get(CONF_MAPPING) params = config.get(CONF_CONTROL_PARAMS) mappingnew = {}
from homeassistant.helpers import config_validation as cv, entity_registry as er from homeassistant.helpers.entity_platform import AddEntitiesCallback from homeassistant.helpers.event import async_track_state_change_event from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType from . import GroupEntity DEFAULT_NAME = "Lock Group" # No limit on parallel updates to enable a group calling another group PARALLEL_UPDATES = 0 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_ENTITIES): cv.entities_domain(DOMAIN), vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_UNIQUE_ID): cv.string, }) _LOGGER = logging.getLogger(__name__) async def async_setup_platform( hass: HomeAssistant, config: ConfigType, async_add_entities: AddEntitiesCallback, discovery_info: DiscoveryInfoType | None = None, ) -> None: """Set up the Lock Group platform.""" async_add_entities([