async def async_step_pin(self, user_input=None):
"""Handle second part of config flow, if required."""
error = None
if user_input:
if self.controller.update_saved_pin(user_input[CONF_PIN]):
try:
vol.Match(r"[0-9]{4}")(user_input[CONF_PIN])
await self.controller.test_pin()
except vol.Invalid:
error = {"base": "bad_pin_format"}
except InvalidPIN:
error = {"base": "incorrect_pin"}
else:
_LOGGER.debug("PIN successfully tested")
self.config_data.update(user_input)
return self.async_create_entry(
title=self.config_data[CONF_USERNAME],
data=self.config_data)
return self.async_show_form(step_id="pin",
data_schema=PIN_SCHEMA,
errors=error)
async def async_step_two_factor_validate(self, user_input=None):
"""Validate received 2FA code with Subaru."""
error = None
if user_input:
try:
vol.Match(r"^[0-9]{6}$")(user_input[CONF_VALIDATION_CODE])
if await self.controller.submit_auth_code(
user_input[CONF_VALIDATION_CODE]):
if self.controller.is_pin_required():
return await self.async_step_pin()
return self.async_create_entry(
title=self.config_data[CONF_USERNAME],
data=self.config_data)
error = {"base": "incorrect_validation_code"}
except vol.Invalid:
error = {"base": "bad_validation_code_format"}
data_schema = vol.Schema({vol.Required(CONF_VALIDATION_CODE): str})
return self.async_show_form(step_id="two_factor_validate",
data_schema=data_schema,
errors=error)
def get_product_version():
SCHEMA = vv.Schema(
{
vv.Required(u'id'):
vv.All(basestring),
vv.Required(u'version'):
vv.All(basestring, vv.Match(purchaser_services.VERSION_PATTERN))
},
extra=True)
def process(req):
args = req.args
ps = dict()
if u'id' in args:
ps[u'id'] = args.get(u'id')
if u'version' in args:
ps[u'version'] = args.get(u'version')
validate_params(SCHEMA, ps)
ctx = context(req)
return publisher_services.get_product(ctx, ps.get(u'id'),
ps.get(u'version'))
return api_do(flask.request, process)
"i_min",
"i_max",
"f_min",
"f_max",
"s_min",
"s_max",
"p_min",
"p_max",
)
RE_DOCKER_IMAGE = re.compile(
r"^([a-zA-Z\-\.:\d{}]+/)*?([\-\w{}]+)/([\-\w{}]+)$")
RE_DOCKER_IMAGE_BUILD = re.compile(
r"^([a-zA-Z\-\.:\d{}]+/)*?([\-\w{}]+)/([\-\w{}]+)(:[\.\-\w{}]+)?$")
SCHEMA_ELEMENT = vol.Match(RE_SCHEMA_ELEMENT)
MACHINE_ALL = [
"intel-nuc",
"odroid-c2",
"odroid-n2",
"odroid-xu",
"qemuarm-64",
"qemuarm",
"qemux86-64",
"qemux86",
"raspberrypi",
"raspberrypi2",
"raspberrypi3-64",
"raspberrypi3",
"raspberrypi4-64",
"""Validate that if a parameter name is provided, bitmask is not as well."""
if isinstance(val[const.ATTR_CONFIG_PARAMETER], str) and (val.get(
const.ATTR_CONFIG_PARAMETER_BITMASK)):
raise vol.Invalid(
"Don't include a bitmask when a parameter name is specified",
path=[
const.ATTR_CONFIG_PARAMETER,
const.ATTR_CONFIG_PARAMETER_BITMASK
],
)
return val
# Validates that a bitmask is provided in hex form and converts it to decimal
# int equivalent since that's what the library uses
BITMASK_SCHEMA = vol.All(cv.string, vol.Lower, vol.Match(r"^(0x)?[0-9a-f]+$"),
lambda value: int(value, 16))
class ZWaveServices:
"""Class that holds our services (Zwave Commands) that should be published to hass."""
def __init__(self, hass: HomeAssistant, ent_reg: EntityRegistry):
"""Initialize with hass object."""
self._hass = hass
self._ent_reg = ent_reg
@callback
def async_register(self) -> None:
"""Register all our services."""
self._hass.services.async_register(
const.DOMAIN,
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN:
cv.schema_with_slug_keys(
vol.Schema({
# pylint: disable=no-value-for-parameter
vol.Optional(CONF_TITLE):
cv.string,
vol.Optional(CONF_ICON):
cv.icon,
vol.Optional(CONF_REQUIRE_ADMIN, default=False):
cv.boolean,
vol.Required(CONF_URL):
vol.Any(
vol.Match(CONF_RELATIVE_URL_REGEX,
msg=CONF_RELATIVE_URL_ERROR_MSG),
vol.Url(),
),
}))
},
extra=vol.ALLOW_EXTRA,
)
async def async_setup(opp, config):
"""Set up the iFrame frontend panels."""
for url_path, info in config[DOMAIN].items():
opp.components.frontend.async_register_built_in_panel(
"iframe",
info.get(CONF_TITLE),
info.get(CONF_ICON),
from ruamel import yaml
import voluptuous as V
from chaperone.cutil.env import Environment, ENV_CONFIG_DIR, ENV_SERVICE
from chaperone.cutil.errors import ChParameterError
from chaperone.cutil.logging import info, warn, debug
from chaperone.cutil.misc import lazydict, lookup_user, get_signal_number
@V.message('not an executable file', cls=V.FileInvalid)
@V.truth
def IsExecutable(v):
return os.path.isfile(v) and os.access(v, os.X_OK)
_config_schema = V.Any(
{ V.Match('^.+\.service$'): {
'after': str,
'before': str,
V.Required('command'): str,
'directory': str,
'debug': bool,
'enabled': V.Any(bool, str),
'env_inherit': [ str ],
'env_set': { str: str },
'env_unset': [ str ],
'exit_kills': bool,
'gid': V.Any(str, int),
'ignore_failures': bool,
'interval': str,
'kill_signal': str,
'optional': bool,
V_FLOAT = 'float'
V_BOOL = 'bool'
V_EMAIL = 'email'
V_URL = 'url'
V_PORT = 'port'
V_MATCH = 'match'
RE_SCHEMA_ELEMENT = re.compile(
r"^(?:"
r"|str|bool|email|url|port"
r"|int(?:\((?P<i_min>\d+)?,(?P<i_max>\d+)?\))?"
r"|float(?:\((?P<f_min>[\d\.]+)?,(?P<f_max>[\d\.]+)?\))?"
r"|match\((?P<match>.*)\)"
r")\??$")
SCHEMA_ELEMENT = vol.Match(RE_SCHEMA_ELEMENT)
ARCH_ALL = [ARCH_ARMHF, ARCH_AARCH64, ARCH_AMD64, ARCH_I386]
STARTUP_ALL = [
STARTUP_ONCE, STARTUP_INITIALIZE, STARTUP_SYSTEM, STARTUP_SERVICES,
STARTUP_APPLICATION
]
PRIVILEGED_ALL = [
PRIVILEGED_NET_ADMIN,
PRIVILEGED_SYS_ADMIN,
PRIVILEGED_SYS_RAWIO,
PRIVILEGED_IPC_LOCK,
PRIVILEGED_SYS_TIME,
PRIVILEGED_SYS_NICE,
import re
import voluptuous as vol
import pytz
from .const import (ATTR_IMAGE, ATTR_LAST_VERSION, ATTR_CHANNEL, ATTR_TIMEZONE,
ATTR_ADDONS_CUSTOM_LIST, ATTR_PASSWORD, ATTR_HOMEASSISTANT,
ATTR_HASSIO, ATTR_BOOT, ATTR_LAST_BOOT, ATTR_SSL,
ATTR_PORT, ATTR_WATCHDOG, ATTR_WAIT_BOOT, ATTR_UUID,
CHANNEL_STABLE, CHANNEL_BETA, CHANNEL_DEV)
RE_REPOSITORY = re.compile(r"^(?P<url>[^#]+)(?:#(?P<branch>[\w\-]+))?$")
NETWORK_PORT = vol.All(vol.Coerce(int), vol.Range(min=1, max=65535))
WAIT_BOOT = vol.All(vol.Coerce(int), vol.Range(min=1, max=60))
DOCKER_IMAGE = vol.Match(r"^[\w{}]+/[\-\w{}]+$")
ALSA_DEVICE = vol.Maybe(vol.Match(r"\d+,\d+"))
CHANNELS = vol.In([CHANNEL_STABLE, CHANNEL_BETA, CHANNEL_DEV])
def validate_repository(repository):
"""Validate a valide repository."""
data = RE_REPOSITORY.match(repository)
if not data:
raise vol.Invalid("No valid repository format!")
# Validate URL
# pylint: disable=no-value-for-parameter
vol.Url()(data.group('url'))
return repository
vol.Optional(CONF_REFRESH_DELAY, default=DEFAULT_CONF_REFRESH_DELAY):
cv.positive_int
})
SIGNAL_REFRESH_ENTITY_FORMAT = 'zwave_refresh_entity_{}'
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN:
vol.Schema({
vol.Optional(CONF_AUTOHEAL, default=DEFAULT_CONF_AUTOHEAL):
cv.boolean,
vol.Optional(CONF_CONFIG_PATH):
cv.string,
vol.Optional(CONF_NETWORK_KEY):
vol.All(cv.string, vol.Match(r'(0x\w\w,\s?){15}0x\w\w')),
vol.Optional(CONF_DEVICE_CONFIG, default={}):
vol.Schema({cv.entity_id: DEVICE_CONFIG_SCHEMA_ENTRY}),
vol.Optional(CONF_DEVICE_CONFIG_GLOB, default={}):
vol.Schema({cv.string: DEVICE_CONFIG_SCHEMA_ENTRY}),
vol.Optional(CONF_DEVICE_CONFIG_DOMAIN, default={}):
vol.Schema({cv.string: DEVICE_CONFIG_SCHEMA_ENTRY}),
vol.Optional(CONF_DEBUG, default=DEFAULT_DEBUG):
cv.boolean,
vol.Optional(CONF_POLLING_INTERVAL,
default=DEFAULT_POLLING_INTERVAL):
cv.positive_int,
vol.Optional(CONF_USB_STICK_PATH):
cv.string,
}),
},
def get_schema(self):
alert_format = {
# could enforce "evaulator"/"operator"/"query" on this...
v.Required("conditions"):
v.All(list),
v.Required("frequency", default="60s"):
v.All(str),
v.Required("name"):
v.All(str),
v.Required("executionErrorState", default="alerting"):
(v.Any("alerting", "keep_state")),
v.Required("noDataState", default="no_data"):
(v.Any("no_data", "alerting", "ok", "keep_state")),
v.Optional("notifications", default=[]):
v.All(list),
}
yaxes_format = [{
v.Optional("decimals"):
v.All(int),
v.Optional("format", default="short"):
Base.formats,
v.Optional("label", default=""):
v.All(str),
v.Optional("logBase", default=1):
v.All(int, v.Range(min=1)),
v.Optional("max"):
v.All(int),
v.Optional("min"):
v.All(int),
v.Optional("show", default=True):
v.All(bool),
}]
legend = {
v.Optional("alignAsTable", default=False): v.All(bool),
v.Optional("avg", default=False): v.All(bool),
v.Optional("current", default=False): v.All(bool),
v.Optional("max", default=False): v.All(bool),
v.Optional("min", default=False): v.All(bool),
v.Optional("rightSide", default=False): v.All(bool),
v.Optional("show", default=False): v.All(bool),
v.Optional("total", default=False): v.All(bool),
v.Optional("values", default=False): v.All(bool),
v.Optional("sortDesc", default=False): v.All(bool),
v.Optional("sort"): v.All(str),
}
null_point_modes = v.Any("connected", "null", "null as zero")
value_types = v.Any("individual", "cumulative")
tooltip = {
v.Required("query_as_alias", default=True): v.All(bool),
v.Required("shared", default=True): v.All(bool),
v.Required("value_type", default="cumulative"): v.All(value_types),
v.Optional("sort"): v.Range(min=0, max=2),
}
series_override = {
v.Required("alias"): v.All(str, v.Length(min=1)),
v.Optional("bars"): v.All(bool),
v.Optional("dashes"): v.All(bool),
v.Optional("lines"): v.All(bool),
v.Optional("fill"): v.All(int, v.Range(min=0, max=10)),
v.Optional("width"): v.All(int, v.Range(min=1, max=10)),
v.Optional("nullPointMode"): v.All(null_point_modes),
v.Optional("fillBelowTo"): v.All(str),
v.Optional("steppedLine"): v.All(bool),
v.Optional("points"): v.All(bool),
v.Optional("pointsradius"): v.All(int, v.Range(min=1, max=5)),
v.Optional("stack"): v.All(v.Any(bool, "A", "B", "C", "D")),
v.Optional("color"): v.All(str),
v.Optional("aliasColors", default={}): v.All(dict),
v.Optional("yaxis"): v.All(int, v.Range(min=1, max=2)),
v.Optional("zindex"): v.All(int, v.Range(min=-3, max=3)),
v.Optional("transform"): v.All(str),
v.Optional("legend"): v.All(bool),
v.Optional("hideTooltip"): v.All(bool),
v.Optional("lineWidth"): v.All(int),
v.Optional("dashLength"): v.All(int),
v.Optional("spaceLength"): v.All(int),
v.Optional("pointradius"): v.All(int),
}
series_overrides = [series_override]
graph = {
v.Optional("alert"): v.All(alert_format),
v.Required("bars", default=False): v.All(bool),
v.Optional("datasource"): v.All(str),
v.Optional("decimals"): v.All(int),
v.Required("fill", default=1): v.All(int),
v.Optional("hideTimeOverride"): v.All(bool),
v.Optional("leftYAxisLabel"): v.All(str, v.Length(min=1)),
v.Optional("legend"): v.All(legend),
v.Required("lines", default=True): v.All(bool),
v.Required("linewidth", default=1): v.All(int),
v.Optional("minSpan"): v.All(int, v.Range(min=0, max=12)),
v.Optional("nullPointMode"): v.All(null_point_modes),
v.Required("percentage", default=False): v.All(bool),
v.Required("pointradius", default=5): v.All(int),
v.Optional("dashLength"): v.All(int),
v.Required("points", default=False): v.All(bool),
v.Optional("repeat"): v.All(str),
v.Optional("rightYAxisLabel"): v.All(str, v.Length(min=1)),
v.Optional("seriesOverrides"): v.All(series_overrides,
v.Length(min=1)),
v.Required("stack", default=False): v.All(bool),
v.Required("steppedLine", default=False): v.All(bool),
v.Required("targets", default=[]): v.All(list),
v.Optional("thresholds", default=[]): v.All(list),
v.Optional("timeFrom"): v.All(v.Match(r"[1-9]+[0-9]*[smhdw]")),
v.Optional("timeShift"): v.All(v.Match(r"[1-9]+[0-9]*[smhdw]")),
v.Optional("tooltip"): v.All(tooltip),
v.Required("x-axis", default=True): v.All(bool),
v.Required("y-axis", default=True): v.All(bool),
v.Optional("y_formats"): v.All([Base.formats],
v.Length(min=2, max=2)),
v.Optional("yaxes"): v.All(yaxes_format, v.Length(min=2, max=2)),
}
graph.update(self.base)
return v.Schema(graph, extra=True)
"""A validator to be run after schedule creation to ensure
each path contains at least one rule with an expression or value.
A ValueError is raised when this check fails."""
for path in sched.unfold():
if path.is_final and not list(path.rules_with_expr_or_value):
raise ValueError(
"No expression or value specified along the path {}.".format(
path))
return sched
########## MISCELLANEOUS
ENTITY_ID_SCHEMA = vol.Schema(vol.Match(r"^[A-Za-z_]+\.[A-Za-z0-9_]+$"))
PYTHON_VAR_SCHEMA = vol.Schema(vol.Match(r"^[a-zA-Z_]+[a-zA-Z0-9_]*$"))
RANGE_STRING_SCHEMA = vol.Schema(
vol.All(
vol.Any(
int,
vol.Match(r"^ *\d+( *\- *\d+)?( *\, *\d+( *\- *\d+)?)* *$"),
),
util.expand_range_string,
))
PARTIAL_DATE_SCHEMA = vol.Schema({
vol.Optional("year"):
vol.All(int, vol.Range(min=1970, max=9999)),
vol.Optional("month"):
vol.All(int, vol.Range(min=1, max=12)),
vol.Optional("day"):
def _single_validate(self, typ: str, value: Any, key: str):
"""Validate a single element."""
# if required argument
if value is None:
raise vol.Invalid(
f"Missing required option '{key}' in {self._name} ({self._slug})"
) from None
# Lookup secret
if str(value).startswith("!secret "):
secret: str = value.partition(" ")[2]
value = self.sys_homeassistant.secrets.get(secret)
if value is None:
raise vol.Invalid(
f"Unknown secret '{secret}' in {self._name} ({self._slug})"
) from None
# parse extend data from type
match = RE_SCHEMA_ELEMENT.match(typ)
if not match:
raise vol.Invalid(
f"Unknown type '{typ}' in {self._name} ({self._slug})"
) from None
# prepare range
range_args = {}
for group_name in _SCHEMA_LENGTH_PARTS:
group_value = match.group(group_name)
if group_value:
range_args[group_name[2:]] = float(group_value)
if typ.startswith(_STR) or typ.startswith(_PASSWORD):
if typ.startswith(_PASSWORD) and value:
self.pwned.add(hashlib.sha1(str(value).encode()).hexdigest())
return vol.All(str(value), vol.Range(**range_args))(value)
elif typ.startswith(_INT):
return vol.All(vol.Coerce(int), vol.Range(**range_args))(value)
elif typ.startswith(_FLOAT):
return vol.All(vol.Coerce(float), vol.Range(**range_args))(value)
elif typ.startswith(_BOOL):
return vol.Boolean()(value)
elif typ.startswith(_EMAIL):
return vol.Email()(value)
elif typ.startswith(_URL):
return vol.Url()(value)
elif typ.startswith(_PORT):
return network_port(value)
elif typ.startswith(_MATCH):
return vol.Match(match.group("match"))(str(value))
elif typ.startswith(_LIST):
return vol.In(match.group("list").split("|"))(str(value))
elif typ.startswith(_DEVICE):
try:
device = self.sys_hardware.get_by_path(Path(value))
except HardwareNotFound:
raise vol.Invalid(
f"Device '{value}' does not exist in {self._name} ({self._slug})"
) from None
# Have filter
if match.group("filter"):
str_filter = match.group("filter")
device_filter = _create_device_filter(str_filter)
if device not in self.sys_hardware.filter_devices(
**device_filter):
raise vol.Invalid(
f"Device '{value}' don't match the filter {str_filter}! in {self._name} ({self._slug})"
)
# Device valid
self.devices.add(device)
return str(device.path)
raise vol.Invalid(
f"Fatal error for option '{key}' with type '{typ}' in {self._name} ({self._slug})"
) from None
CONF_SERIAL_PORT,
CONF_SLEEP_TUNE,
DOMAIN,
FIRMATA_MANUFACTURER,
PIN_MODE_ANALOG,
PIN_MODE_INPUT,
PIN_MODE_OUTPUT,
PIN_MODE_PULLUP,
PIN_MODE_PWM,
)
_LOGGER = logging.getLogger(__name__)
DATA_CONFIGS = "board_configs"
ANALOG_PIN_SCHEMA = vol.All(cv.string, vol.Match(r"^A[0-9]+$"))
SWITCH_SCHEMA = vol.Schema(
{
vol.Required(CONF_NAME): cv.string,
# Both digital and analog pins may be used as digital output
vol.Required(CONF_PIN): vol.Any(cv.positive_int, ANALOG_PIN_SCHEMA),
vol.Required(CONF_PIN_MODE): PIN_MODE_OUTPUT,
vol.Optional(CONF_INITIAL_STATE, default=False): cv.boolean,
vol.Optional(CONF_NEGATE_STATE, default=False): cv.boolean,
},
required=True,
)
LIGHT_SCHEMA = vol.Schema(
{
@v.message('wrong TxHash field value')
def isTxHash(arg):
try:
value = re.sub(r'^0x', '', arg)
int_arg = int(value, 16)
if not int_arg > 0:
raise v.Invalid('value is zero')
else:
return value
except ValueError as e:
raise v.Invalid(e)
isIpfsBase58Hash = v.All(str, v.Length(min=46, max=46),
v.Match(r'^[a-zA-Z0-9]+$'))
isHexAddress = v.All(str, v.Length(min=42, max=42),
v.Match(r'^0x[a-fA-F0-9]+$'))
isSubAddress = v.All(str, v.Length(min=48, max=48),
v.Match(r'^4[a-zA-Z0-9]+$'))
isEnsName = v.All(
str,
v.Any(v.Match(r'^.+\.eth$'), v.Match(r'^.+\.sid$'),
v.Match(r'^.+\.test$')))
isAddress = v.Any(isEnsName, isHexAddress, isSubAddress)
schemaAskBid = v.All(
v.Any(
v.Schema({v.Required('validatorFee'): v.All(int)},
extra=v.ALLOW_EXTRA),
v.Schema({v.Required('lighthouseFee'): v.All(int)},
from homeassistant.helpers.aiohttp_client import async_get_clientsession
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity_platform import AddEntitiesCallback
from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
_LOGGER = logging.getLogger(__name__)
CONF_ALLOW_UNREACHABLE = "allow_unreachable"
DEFAULT_TIMEOUT = 5
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_HOST):
cv.string,
vol.Required(CONF_PIN):
vol.All(vol.Coerce(str), vol.Match(r"\d{4}")),
vol.Optional(CONF_ALLOW_UNREACHABLE, default=True):
cv.boolean,
vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT):
cv.positive_int,
})
ERROR_STATE = [
"blade-blocked",
"repositioning-error",
"wire-bounced",
"blade-blocked",
"outside-wire",
"mower-lifted",
"alarm-6",
"upside-down",
"luminance": "luminance",
"measuredTemperature": "measured_temperature",
"occupancyTrigger": "occupancy_trigger",
"setback": "setback",
"setTemperature": "set_temperature",
"wakeupInterval": "wakeup_interval",
}
SCAN_INTERVAL = timedelta(seconds=60)
MAC_ADDRESS_REGEXP = r"^([0-9A-F]{2}:){5}([0-9A-F]{2})$"
V1_API_SCHEMA = vol.Schema(
{
vol.Required(CONF_TOKEN): cv.string,
vol.Required(CONF_MAC): vol.Match(MAC_ADDRESS_REGEXP),
}
)
V3_API_SCHEMA = vol.Schema(
{
vol.Required(CONF_HOST): cv.string,
vol.Required(CONF_USERNAME): cv.string,
vol.Required(CONF_PASSWORD): cv.string,
vol.Optional(CONF_MAC): vol.Match(MAC_ADDRESS_REGEXP),
}
)
CONFIG_SCHEMA = vol.Schema(
{DOMAIN: vol.Any(V3_API_SCHEMA, V1_API_SCHEMA)}, extra=vol.ALLOW_EXTRA
)
ATTR_ZONE_MODE = "mode"
V_FLOAT = 'float'
V_BOOL = 'bool'
V_EMAIL = 'email'
V_URL = 'url'
V_PORT = 'port'
V_MATCH = 'match'
RE_SCHEMA_ELEMENT = re.compile(
r"^(?:"
r"|str|bool|email|url|port"
r"|int(?:\((?P<i_min>\d+)?,(?P<i_max>\d+)?\))?"
r"|float(?:\((?P<f_min>[\d\.]+)?,(?P<f_max>[\d\.]+)?\))?"
r"|match\((?P<match>.*)\)"
r")\??$")
SCHEMA_ELEMENT = vol.Match(RE_SCHEMA_ELEMENT)
ARCH_ALL = [ARCH_ARMHF, ARCH_AARCH64, ARCH_AMD64, ARCH_I386]
STARTUP_ALL = [
STARTUP_ONCE, STARTUP_INITIALIZE, STARTUP_SYSTEM, STARTUP_SERVICES,
STARTUP_APPLICATION
]
PRIVILEGED_ALL = ["NET_ADMIN", "SYS_ADMIN", "SYS_RAWIO"]
BASE_IMAGE = {
ARCH_ARMHF: "homeassistant/armhf-base:latest",
ARCH_AARCH64: "homeassistant/aarch64-base:latest",
ARCH_I386: "homeassistant/i386-base:latest",
ARCH_AMD64: "homeassistant/amd64-base:latest",
BaseNotificationService,
)
from openpeerpower.components.twilio import DATA_TWILIO
import openpeerpower.helpers.config_validation as cv
_LOGGER = logging.getLogger(__name__)
CONF_FROM_NUMBER = "from_number"
ATTR_MEDIAURL = "media_url"
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_FROM_NUMBER):
vol.All(
cv.string,
vol.Match(r"^\+?[1-9]\d{1,14}$|"
r"^(?=.{1,11}$)[a-zA-Z0-9\s]*"
r"[a-zA-Z][a-zA-Z0-9\s]*$"
r"^(?:[a-zA-Z]+)\:?\+?[1-9]\d{1,14}$|"),
)
})
def get_service(opp, config, discovery_info=None):
"""Get the Twilio SMS notification service."""
return TwilioSMSNotificationService(opp.data[DATA_TWILIO],
config[CONF_FROM_NUMBER])
class TwilioSMSNotificationService(BaseNotificationService):
"""Implement the notification service for the Twilio SMS service."""
def __init__(self, twilio_client, from_number):
"""Initialize the service."""
class ConfigSchema(object):
server = {v.Required('name'): str,
v.Required('url'): str,
v.Required('username'): str,
'password': str,
'verify-ssl': bool,
'ssl-ca-path': str,
'dburi': str,
v.Required('git-root'): str,
'git-url': str,
'log-file': str,
'socket': str,
'auth-type': v.Any('basic', 'digest', 'form'),
}
servers = [server]
sort_by = v.Any('number', 'updated', 'last-seen')
text_replacement = {'text': v.Any(str,
{'color': str,
v.Required('text'): str})}
link_replacement = {'link': {v.Required('url'): str,
v.Required('text'): str}}
search_replacement = {'search': {v.Required('query'): str,
v.Required('text'): str}}
replacement = v.Any(text_replacement, link_replacement, search_replacement)
palette = {v.Required('name'): str,
v.Match('(?!name)'): [str]}
palettes = [palette]
commentlink = {v.Required('match'): str,
v.Required('replacements'): [replacement],
'test-result': str}
commentlinks = [commentlink]
dashboard = {v.Required('name'): str,
v.Required('query'): str,
v.Optional('sort-by'): sort_by,
v.Optional('reverse'): bool,
v.Required('key'): str}
dashboards = [dashboard]
reviewkey_approval = {v.Required('category'): str,
v.Required('value'): int}
reviewkey = {v.Required('approvals'): [reviewkey_approval],
'submit': bool,
v.Required('key'): str}
reviewkeys = [reviewkey]
hide_comment = {v.Required('author'): str}
hide_comments = [hide_comment]
change_list_options = {'sort-by': sort_by,
'reverse': bool}
keymap = {v.Required('name'): str,
v.Match('(?!name)'): v.Any([[str], str], [str], str)}
keymaps = [keymap]
def getSchema(self, data):
schema = v.Schema({v.Required('servers'): self.servers,
'palettes': self.palettes,
'palette': str,
'keymaps': self.keymaps,
'keymap': str,
'commentlinks': self.commentlinks,
'dashboards': self.dashboards,
'reviewkeys': self.reviewkeys,
'change-list-query': str,
'diff-view': str,
'hide-comments': self.hide_comments,
'thread-changes': bool,
'display-times-in-utc': bool,
'handle-mouse': bool,
'breadcrumbs': bool,
'change-list-options': self.change_list_options,
'expire-age': str,
})
return schema
"measuredTemperature": "measured_temperature",
"occupancyTrigger": "occupancy_trigger",
"setback": "setback",
"setTemperature": "set_temperature",
"wakeupInterval": "wakeup_interval",
}
SCAN_INTERVAL = timedelta(seconds=60)
MAC_ADDRESS_REGEXP = r"^([0-9A-F]{2}:){5}([0-9A-F]{2})$"
V1_API_SCHEMA = vol.Schema({
vol.Required(CONF_TOKEN):
cv.string,
vol.Required(CONF_MAC):
vol.Match(MAC_ADDRESS_REGEXP),
})
V3_API_SCHEMA = vol.Schema({
vol.Required(CONF_HOST):
cv.string,
vol.Required(CONF_USERNAME):
cv.string,
vol.Required(CONF_PASSWORD):
cv.string,
vol.Optional(CONF_MAC):
vol.Match(MAC_ADDRESS_REGEXP),
})
CONFIG_SCHEMA = vol.Schema({DOMAIN: vol.Any(V3_API_SCHEMA, V1_API_SCHEMA)},
extra=vol.ALLOW_EXTRA)
ATTR_ZONE_MODE = "mode"
ATTR_SSL,
ATTR_TIMEZONE,
ATTR_UUID,
ATTR_WAIT_BOOT,
ATTR_WATCHDOG,
CHANNEL_BETA,
CHANNEL_DEV,
CHANNEL_STABLE,
)
from .utils.validate import validate_timezone
RE_REPOSITORY = re.compile(r"^(?P<url>[^#]+)(?:#(?P<branch>[\w\-]+))?$")
NETWORK_PORT = vol.All(vol.Coerce(int), vol.Range(min=1, max=65535))
WAIT_BOOT = vol.All(vol.Coerce(int), vol.Range(min=1, max=60))
DOCKER_IMAGE = vol.Match(r"^[\w{}]+/[\-\w{}]+$")
ALSA_DEVICE = vol.Maybe(vol.Match(r"\d+,\d+"))
CHANNELS = vol.In([CHANNEL_STABLE, CHANNEL_BETA, CHANNEL_DEV])
UUID_MATCH = vol.Match(r"^[0-9a-f]{32}$")
SHA256 = vol.Match(r"^[0-9a-f]{64}$")
TOKEN = vol.Match(r"^[0-9a-f]{32,256}$")
LOG_LEVEL = vol.In(["debug", "info", "warning", "error", "critical"])
def validate_repository(repository):
"""Validate a valid repository."""
data = RE_REPOSITORY.match(repository)
if not data:
raise vol.Invalid("No valid repository format!")
# Validate URL
vol.Coerce(str),
vol.Required(ATTR_SLUG):
vol.Coerce(str),
vol.Required(ATTR_DESCRIPTON):
vol.Coerce(str),
vol.Optional(ATTR_URL):
vol.Url(),
vol.Optional(ATTR_ARCH, default=ARCH_ALL): [vol.In(ARCH_ALL)],
vol.Required(ATTR_STARTUP):
vol.All(_migrate_startup, vol.In(STARTUP_ALL)),
vol.Required(ATTR_BOOT):
vol.In([BOOT_AUTO, BOOT_MANUAL]),
vol.Optional(ATTR_PORTS):
DOCKER_PORTS,
vol.Optional(ATTR_WEBUI):
vol.Match(r"^(?:https?):\/\/\[HOST\]:\[PORT:\d+\].*$"),
vol.Optional(ATTR_HOST_NETWORK, default=False):
vol.Boolean(),
vol.Optional(ATTR_DEVICES): [vol.Match(r"^(.*):(.*):([rwm]{1,3})$")],
vol.Optional(ATTR_TMPFS):
vol.Match(r"^size=(\d)*[kmg](,uid=\d{1,4})?(,rw)?$"),
vol.Optional(ATTR_MAP, default=[]): [vol.Match(MAP_VOLUME)],
vol.Optional(ATTR_ENVIRONMENT): {
vol.Match(r"\w*"): vol.Coerce(str)
},
vol.Optional(ATTR_PRIVILEGED): [vol.In(PRIVILEGED_ALL)],
vol.Required(ATTR_OPTIONS):
dict,
vol.Required(ATTR_SCHEMA):
vol.Any(
vol.Schema({
_SCHEMA_LENGTH_PARTS = (
"i_min",
"i_max",
"f_min",
"f_max",
"s_min",
"s_max",
"p_min",
"p_max",
)
RE_DOCKER_IMAGE_BUILD = re.compile(
r"^([a-zA-Z\-\.:\d{}]+/)*?([\-\w{}]+)/([\-\w{}]+)(:[\.\-\w{}]+)?$"
)
SCHEMA_ELEMENT = vol.Match(RE_SCHEMA_ELEMENT)
RE_MACHINE = re.compile(
r"^!?(?:"
r"|intel-nuc"
r"|odroid-c2"
r"|odroid-c4"
r"|odroid-n2"
r"|odroid-xu"
r"|qemuarm-64"
r"|qemuarm"
r"|qemux86-64"
r"|qemux86"
r"|raspberrypi"
r"|raspberrypi2"
r"|raspberrypi3-64"
vol.Optional(CONF_REFRESH_DELAY, default=DEFAULT_CONF_REFRESH_DELAY):
cv.positive_int,
})
SIGNAL_REFRESH_ENTITY_FORMAT = "zwave_refresh_entity_{}"
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN:
vol.Schema({
vol.Optional(CONF_AUTOHEAL, default=DEFAULT_CONF_AUTOHEAL):
cv.boolean,
vol.Optional(CONF_CONFIG_PATH):
cv.string,
vol.Optional(CONF_NETWORK_KEY):
vol.All(cv.string, vol.Match(r"(0x\w\w,\s?){15}0x\w\w")),
vol.Optional(CONF_DEVICE_CONFIG, default={}):
vol.Schema({cv.entity_id: DEVICE_CONFIG_SCHEMA_ENTRY}),
vol.Optional(CONF_DEVICE_CONFIG_GLOB, default={}):
vol.Schema({cv.string: DEVICE_CONFIG_SCHEMA_ENTRY}),
vol.Optional(CONF_DEVICE_CONFIG_DOMAIN, default={}):
vol.Schema({cv.string: DEVICE_CONFIG_SCHEMA_ENTRY}),
vol.Optional(CONF_DEBUG, default=DEFAULT_DEBUG):
cv.boolean,
vol.Optional(CONF_POLLING_INTERVAL,
default=DEFAULT_POLLING_INTERVAL):
cv.positive_int,
vol.Optional(CONF_USB_STICK_PATH):
cv.string,
})
},
ATTR_UUID,
ATTR_VERSION,
ATTR_WAIT_BOOT,
ATTR_WATCHDOG,
LogLevel,
UpdateChannels,
)
from .utils.validate import validate_timezone
RE_REPOSITORY = re.compile(r"^(?P<url>[^#]+)(?:#(?P<branch>[\w\-]+))?$")
# pylint: disable=no-value-for-parameter
# pylint: disable=invalid-name
network_port = vol.All(vol.Coerce(int), vol.Range(min=1, max=65535))
wait_boot = vol.All(vol.Coerce(int), vol.Range(min=1, max=60))
docker_image = vol.Match(r"^[\w{}]+/[\-\w{}]+$")
uuid_match = vol.Match(r"^[0-9a-f]{32}$")
sha256 = vol.Match(r"^[0-9a-f]{64}$")
token = vol.Match(r"^[0-9a-f]{32,256}$")
def simple_version(value: Union[str, int, None]) -> Optional[str]:
"""Validate main version handling."""
if not isinstance(value, (str, int)):
return None
elif isinstance(value, int):
return str(value)
elif value.isnumeric() or value == "dev":
return value
return None
vol.Coerce(str),
vol.Required(ATTR_SLUG):
vol.Coerce(str),
vol.Required(ATTR_DESCRIPTON):
vol.Coerce(str),
vol.Optional(ATTR_URL):
vol.Url(),
vol.Optional(ATTR_ARCH, default=ARCH_ALL): [vol.In(ARCH_ALL)],
vol.Required(ATTR_STARTUP):
vol.In(
[STARTUP_BEFORE, STARTUP_AFTER, STARTUP_ONCE, STARTUP_INITIALIZE]),
vol.Required(ATTR_BOOT):
vol.In([BOOT_AUTO, BOOT_MANUAL]),
vol.Optional(ATTR_PORTS):
dict,
vol.Optional(ATTR_DEVICES): [vol.Match(r"^(.*):(.*):([rwm]{1,3})$")],
vol.Optional(ATTR_MAP, default=[]): [vol.Match(MAP_VOLUME)],
vol.Optional(ATTR_ENVIRONMENT): {
vol.Match(r"\w*"): vol.Coerce(str)
},
vol.Required(ATTR_OPTIONS):
dict,
vol.Required(ATTR_SCHEMA): {
vol.Coerce(str):
vol.Any(ADDON_ELEMENT,
[vol.Any(ADDON_ELEMENT, {vol.Coerce(str): ADDON_ELEMENT})])
},
vol.Optional(ATTR_IMAGE):
vol.Match(r"\w*/\w*"),
},
extra=vol.ALLOW_EXTRA)
CODE_SENSOR_SETTINGS_SCHEMA = vol.Schema(
{
vol.Required(ATTR_SEN_SET_LOCK_CODE): int,
vol.Required(ATTR_SEN_SET_USER_NAME): str,
vol.Optional(ATTR_SEN_SET_BY_ACCESS_COUNT):
vol.Schema(ACCESS_COUNT_SCHEMA),
vol.Optional(ATTR_SEN_SET_BY_DATE_RANGE):
vol.Schema(DATE_RANGE_SCHEMA),
vol.Optional(ATTR_SEN_SET_BY_DOW): vol.Schema(DOW_SCHEMA),
vol.Required(ATTR_SEN_SET_NOTIFICATION, default=False): bool
},
extra=vol.REMOVE_EXTRA)
CODE_SENSOR_SCHEMA = vol.Schema(
{
vol.Required(ATTR_SENSOR_SLOT_ENABLED, default=False): bool,
vol.Required(ATTR_SENSOR_COUNT, default=0): int,
vol.Optional(ATTR_SENSOR_ICON): str,
vol.Optional(ATTR_SENSOR_FRIENDLY_NAME): str,
vol.Optional(ATTR_SENSOR_SETTINGS):
vol.Schema(CODE_SENSOR_SETTINGS_SCHEMA)
},
extra=vol.REMOVE_EXTRA)
SLOT_SETTINGS_SCHEMA = vol.Schema({
vol.Required(ATTR_ENTITY_ID):
vol.All(cv.entity_id, vol.Match(r'^sensor\..*_code_slot_\d*$')),
vol.Required(ATTR_SENSOR_SETTINGS):
vol.Schema(CODE_SENSOR_SETTINGS_SCHEMA)
})
from homeassistant.components.notify import (
ATTR_TARGET,
PLATFORM_SCHEMA,
BaseNotificationService,
)
from homeassistant.components.twilio import DATA_TWILIO
import homeassistant.helpers.config_validation as cv
_LOGGER = logging.getLogger(__name__)
CONF_FROM_NUMBER = "from_number"
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_FROM_NUMBER):
vol.All(cv.string, vol.Match(r"^\+?[1-9]\d{1,14}$"))
})
def get_service(hass, config, discovery_info=None):
"""Get the Twilio Call notification service."""
return TwilioCallNotificationService(hass.data[DATA_TWILIO],
config[CONF_FROM_NUMBER])
class TwilioCallNotificationService(BaseNotificationService):
"""Implement the notification service for the Twilio Call service."""
def __init__(self, twilio_client, from_number):
"""Initialize the service."""
self.client = twilio_client
self.from_number = from_number
from homeassistant.helpers.entity import Entity
from homeassistant.components.switch import (PLATFORM_SCHEMA)
from homeassistant.const import (CONF_HOST, CONF_PIN, CONF_TIMEOUT)
from homeassistant.helpers.aiohttp_client import (async_get_clientsession)
_LOGGER = logging.getLogger(__name__)
CONF_ALLOW_UNREACHABLE = 'allow_unreachable'
DEFAULT_TIMEOUT = 5
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_HOST):
cv.string,
vol.Required(CONF_PIN):
vol.All(vol.Coerce(str), vol.Match(r'\d{4}')),
vol.Optional(CONF_ALLOW_UNREACHABLE, default=True):
cv.boolean,
vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT):
cv.positive_int,
})
ERROR_STATE = [
'blade-blocked', 'repositioning-error', 'wire-bounced', 'blade-blocked',
'outside-wire', 'mower-lifted', 'alarm-6', 'upside-down', 'alarm-8',
'collision-sensor-blocked', 'mower-tilted', 'charge-error', 'battery-error'
]
@asyncio.coroutine
def async_setup_platform(hass,
