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,