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([
