import openpeerpower.helpers.config_validation as cv from openpeerpower.util.dt import utc_from_timestamp _LOGGER = logging.getLogger(__name__) DOMAIN = "nextbus" CONF_AGENCY = "agency" CONF_ROUTE = "route" CONF_STOP = "stop" ICON = "mdi:bus" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_AGENCY): cv.string, vol.Required(CONF_ROUTE): cv.string, vol.Required(CONF_STOP): cv.string, vol.Optional(CONF_NAME): cv.string, }) def listify(maybe_list): """Return list version of whatever value is passed in. This is used to provide a consistent way of interacting with the JSON results from the API. There are several attributes that will either missing if there are no values, a single dictionary if there is only one value, and a list if there are multiple. """ if maybe_list is None: return [] if isinstance(maybe_list, list):
["Last Build Duration", TIME_SECONDS, "mdi:timelapse"], "last_build_finished_at": ["Last Build Finished At", "", "mdi:timetable"], "last_build_started_at": ["Last Build Started At", "", "mdi:timetable"], "last_build_state": ["Last Build State", "", "mdi:github"], "state": ["State", "", "mdi:github"], } NOTIFICATION_ID = "travisci" NOTIFICATION_TITLE = "Travis CI Sensor Setup" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_API_KEY): cv.string, vol.Required(CONF_MONITORED_CONDITIONS, default=list(SENSOR_TYPES)): vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]), vol.Required(CONF_BRANCH, default=DEFAULT_BRANCH_NAME): cv.string, vol.Optional(CONF_REPOSITORY, default=[]): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_SCAN_INTERVAL, default=SCAN_INTERVAL): cv.time_period, }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the Travis CI sensor.""" token = config.get(CONF_API_KEY) repositories = config.get(CONF_REPOSITORY) branch = config.get(CONF_BRANCH) try:
DEFAULT_NAME = "Web scrape" DEFAULT_VERIFY_SSL = True PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_RESOURCE): cv.string, vol.Required(CONF_SELECT): cv.string, vol.Optional(CONF_ATTR): cv.string, vol.Optional(CONF_INDEX, default=0): cv.positive_int, vol.Optional(CONF_AUTHENTICATION): vol.In([HTTP_BASIC_AUTHENTICATION, HTTP_DIGEST_AUTHENTICATION]), vol.Optional(CONF_HEADERS): vol.Schema({cv.string: cv.string}), vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_PASSWORD): cv.string, vol.Optional(CONF_UNIT_OF_MEASUREMENT): cv.string, vol.Optional(CONF_USERNAME): cv.string, vol.Optional(CONF_VALUE_TEMPLATE): cv.template, vol.Optional(CONF_VERIFY_SSL, default=DEFAULT_VERIFY_SSL): cv.boolean, }) async def async_setup_platform(opp,
ATTR_ICON: None, ATTR_ID: SENSOR_PREHEATER_POWER_CURRENT, }, ATTR_PREHEATER_POWER_TOTAL: { ATTR_DEVICE_CLASS: DEVICE_CLASS_ENERGY, ATTR_LABEL: "Preheater power total", ATTR_UNIT: ENERGY_KILO_WATT_HOUR, ATTR_ICON: None, ATTR_ID: SENSOR_PREHEATER_POWER_TOTAL, }, } PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Optional(CONF_RESOURCES, default=[]): vol.All( cv.ensure_list, [vol.In(SENSOR_TYPES)] ) } ) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the ComfoConnect fan platform.""" ccb = opp.data[DOMAIN] sensors = [] for resource in config[CONF_RESOURCES]: sensors.append( ComfoConnectSensor( name=f"{ccb.name} {SENSOR_TYPES[resource][ATTR_LABEL]}", ccb=ccb,
"mined_blocks": ["Mined Blocks", None], "blocks_size": ["Block size", None], "total_fees_btc": ["Total fees", "BTC"], "total_btc_sent": ["Total sent", "BTC"], "estimated_btc_sent": ["Estimated sent", "BTC"], "total_btc": ["Total", "BTC"], "total_blocks": ["Total Blocks", None], "next_retarget": ["Next retarget", None], "estimated_transaction_volume_usd": ["Est. Transaction volume", "USD"], "miners_revenue_btc": ["Miners revenue", "BTC"], "market_price_usd": ["Market price", "USD"], } PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_DISPLAY_OPTIONS, default=[]): vol.All(cv.ensure_list, [vol.In(OPTION_TYPES)]), vol.Optional(CONF_CURRENCY, default=DEFAULT_CURRENCY): cv.string, }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the Bitcoin sensors.""" currency = config[CONF_CURRENCY] if currency not in exchangerates.get_ticker(): _LOGGER.warning("Currency %s is not available. Using USD", currency) currency = DEFAULT_CURRENCY data = BitcoinData() dev = []
ENERGY_KILO_WATT_HOUR, ), "summation_received": ( "Eagle-200 Total Meter Energy Received", ENERGY_KILO_WATT_HOUR, ), "summation_total": ( "Eagle-200 Net Meter Energy (Delivered minus Received)", ENERGY_KILO_WATT_HOUR, ), } PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Required(CONF_IP_ADDRESS): cv.string, vol.Required(CONF_CLOUD_ID): cv.string, vol.Required(CONF_INSTALL_CODE): cv.string, } ) def hwtest(cloud_id, install_code, ip_address): """Try API call 'get_network_info' to see if target device is Legacy or Eagle-200.""" reader = LeagleReader(cloud_id, install_code, ip_address) response = reader.get_network_info() # Branch to test if target is Legacy Model if ( "NetworkInfo" in response and response["NetworkInfo"].get("ModelId", None) == "Z109-EAGLE" ):
ATTR_DEVICE = "device" ATTR_MODEL = "model" DEFAULT_HOST = "localhost" DEFAULT_PORT = 7634 DEFAULT_NAME = "HD Temperature" DEFAULT_TIMEOUT = 5 SCAN_INTERVAL = timedelta(minutes=1) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_DISKS, default=[]): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_HOST, default=DEFAULT_HOST): cv.string, vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the HDDTemp sensor.""" name = config.get(CONF_NAME) host = config.get(CONF_HOST) port = config.get(CONF_PORT) disks = config.get(CONF_DISKS) hddtemp = HddTempData(host, port) hddtemp.update()
from openpeerpower.components.sensor import PLATFORM_SCHEMA, SensorEntity from openpeerpower.const import ( CONF_NAME, CONF_OFFSET, DEVICE_DEFAULT_NAME, TEMP_FAHRENHEIT, ) _LOGGER = logging.getLogger(__name__) CONF_SCALE = "scale" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_NAME, default=DEVICE_DEFAULT_NAME): vol.Coerce(str), vol.Optional(CONF_SCALE, default=1): vol.Coerce(float), vol.Optional(CONF_OFFSET, default=0): vol.Coerce(float), }) TEMPER_SENSORS = [] def get_temper_devices(): """Scan the Temper devices from temperusb.""" return TemperHandler().get_devices() def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the Temper sensors.""" temp_unit = opp.config.units.temperature_unit
DEFAULT_ICON = "mdi:desktop-classic" RESOURCE_SCHEMA = vol.Any( { vol.Required(CONF_DATA_GROUP): cv.string, vol.Required(CONF_ELEMENT): cv.string, vol.Optional(CONF_ICON, default=DEFAULT_ICON): cv.icon, vol.Optional(CONF_INVERT, default=False): cv.boolean, } ) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Optional(CONF_HOST, default=DEFAULT_HOST): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port, vol.Required(CONF_RESOURCES): vol.Schema({cv.string: RESOURCE_SCHEMA}), } ) async def async_setup_platform(opp, config, async_add_entities, discovery_info=None): """Set up the Netdata sensor.""" name = config.get(CONF_NAME) host = config.get(CONF_HOST) port = config.get(CONF_PORT) resources = config.get(CONF_RESOURCES) session = async_get_clientsession(opp) netdata = NetdataData(Netdata(host, opp.loop, session, port=port))
_LOGGER = logging.getLogger(__name__) ATTRIBUTION = "Data provided by blockchain.com" CONF_ADDRESSES = "addresses" DEFAULT_NAME = "Bitcoin Balance" ICON = "mdi:currency-btc" SCAN_INTERVAL = timedelta(minutes=5) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Required(CONF_ADDRESSES): [cv.string], vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, } ) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the Blockchain.com sensors.""" addresses = config[CONF_ADDRESSES] name = config[CONF_NAME] for address in addresses: if not validate_address(address): _LOGGER.error("Bitcoin address is not valid: %s", address) return False
CONF_DEVICE, CONF_NAME, DEVICE_CLASS_POWER, POWER_WATT, ) import openpeerpower.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) DEFAULT_ADDRESS = 2 DEFAULT_NAME = "Solar PV" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Required(CONF_DEVICE): cv.string, vol.Optional(CONF_ADDRESS, default=DEFAULT_ADDRESS): cv.positive_int, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, } ) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the Aurora ABB PowerOne device.""" devices = [] comport = config[CONF_DEVICE] address = config[CONF_ADDRESS] name = config[CONF_NAME] _LOGGER.debug("Intitialising com port=%s address=%s", comport, address) client = AuroraSerialClient(address, comport, parity="N", timeout=1)
_LOGGER = logging.getLogger(__name__) ATTR_CLIMB = "climb" ATTR_ELEVATION = "elevation" ATTR_GPS_TIME = "gps_time" ATTR_SPEED = "speed" DEFAULT_HOST = "localhost" DEFAULT_NAME = "GPS" DEFAULT_PORT = 2947 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_HOST, default=DEFAULT_HOST): cv.string, vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port, }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the GPSD component.""" name = config.get(CONF_NAME) host = config.get(CONF_HOST) port = config.get(CONF_PORT) # Will hopefully be possible with the next gps3 update # https://github.com/wadda/gps3/issues/11 # from gps3 import gps3 # try:
import voluptuous as vol from openpeerpower.components.sensor import PLATFORM_SCHEMA, SensorEntity from openpeerpower.const import CONF_PASSWORD, CONF_USERNAME import openpeerpower.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) ICON = "mdi:rss" SENSOR_NAME = "Pocketcasts unlistened episodes" SCAN_INTERVAL = timedelta(minutes=5) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_PASSWORD): cv.string, vol.Required(CONF_USERNAME): cv.string }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the pocketcasts platform for sensors.""" username = config.get(CONF_USERNAME) password = config.get(CONF_PASSWORD) try: api = pocketcasts.PocketCast(email=username, password=password) _LOGGER.debug("Found %d podcasts", len(api.subscriptions)) add_entities([PocketCastsSensor(api)], True) except OSError as err: _LOGGER.error("Connection to server failed: %s", err) return False
_LOGGER = logging.getLogger(__name__) ATTR_MENTION = "mention" ATTR_ROOM = "room" ATTR_USERNAME = "******" DEFAULT_NAME = "Gitter messages" DEFAULT_ROOM = "openpeerpower/openpeerpower" ICON = "mdi:message-cog" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Required(CONF_API_KEY): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_ROOM, default=DEFAULT_ROOM): cv.string, } ) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the Gitter sensor.""" name = config.get(CONF_NAME) api_key = config.get(CONF_API_KEY) room = config.get(CONF_ROOM) gitter = GitterClient(api_key) try: username = gitter.auth.get_my_id["name"]
"Currently Used Download Bandwidth", DATA_RATE_MEGABITS_PER_SECOND, "mdi:download", ], "current_up_bandwidth": [ "Currently Used Upload Bandwidth", DATA_RATE_MEGABITS_PER_SECOND, "mdi:upload", ], "uptime": ["Uptime", None, "mdi:clock"], "number_of_reboots": ["Number of reboot", None, "mdi:restart"], } PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_MONITORED_VARIABLES): vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]), vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the Bbox sensor.""" # Create a data fetcher to support all of the configured sensors. Then make # the first call to init the data. try: bbox_data = BboxData() bbox_data.update() except requests.exceptions.HTTPError as error: _LOGGER.error(error) return False
CONF_SERVER = "server" CONF_FOLDER = "folder" CONF_SEARCH = "search" CONF_CHARSET = "charset" DEFAULT_PORT = 993 ICON = "mdi:email-outline" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Optional(CONF_NAME): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Required(CONF_SERVER): cv.string, vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port, vol.Optional(CONF_CHARSET, default="utf-8"): cv.string, vol.Optional(CONF_FOLDER, default="INBOX"): cv.string, vol.Optional(CONF_SEARCH, default="UnSeen UnDeleted"): cv.string, } ) async def async_setup_platform(opp, config, async_add_entities, discovery_info=None): """Set up the IMAP platform.""" sensor = ImapSensor( config.get(CONF_NAME), config.get(CONF_USERNAME), config.get(CONF_PASSWORD), config.get(CONF_SERVER), config.get(CONF_PORT),
EVENT_OPENPEERPOWER_STOP, STATE_IDLE, ) import openpeerpower.helpers.config_validation as cv _LOGGER = logging.getLogger(__name__) DEFAULT_NAME = "Modem CallerID" ICON = "mdi:phone-classic" DEFAULT_DEVICE = "/dev/ttyACM0" STATE_RING = "ring" STATE_CALLERID = "callerid" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_DEVICE, default=DEFAULT_DEVICE): cv.string, }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up modem caller ID sensor platform.""" name = config.get(CONF_NAME) port = config.get(CONF_DEVICE) modem = bm(port) if modem.state == modem.STATE_FAILED: _LOGGER.error("Unable to initialize modem") return
CONF_TRACKING_NUMBER, DEFAULT_NAME, DOMAIN, ICON, MIN_TIME_BETWEEN_UPDATES, REMOVE_TRACKING_SERVICE_SCHEMA, SERVICE_ADD_TRACKING, SERVICE_REMOVE_TRACKING, UPDATE_TOPIC, ) _LOGGER: Final = logging.getLogger(__name__) PLATFORM_SCHEMA: Final = BASE_PLATFORM_SCHEMA.extend({ vol.Required(CONF_API_KEY): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, }) async def async_setup_platform( opp: OpenPeerPower, config: ConfigType, async_add_entities: AddEntitiesCallback, discovery_info: DiscoveryInfoType | None = None, ) -> None: """Set up the AfterShip sensor platform.""" apikey = config[CONF_API_KEY] name = config[CONF_NAME] session = async_get_clientsession(opp)
def validate_station(station): """Check that the station ID is well-formed.""" if station is None: return if not re.fullmatch(r"[A-Z]{2}/s0000\d{3}", station): raise vol.error.Invalid('Station ID must be of the form "XX/s0000###"') return station PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_LANGUAGE, default="english"): vol.In(["english", "french"]), vol.Optional(CONF_STATION): validate_station, vol.Inclusive(CONF_LATITUDE, "latlon"): cv.latitude, vol.Inclusive(CONF_LONGITUDE, "latlon"): cv.longitude, }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the Environment Canada sensor.""" if config.get(CONF_STATION): ec_data = ECData(station_id=config[CONF_STATION], language=config.get(CONF_LANGUAGE)) else: lat = config.get(CONF_LATITUDE, opp.config.latitude) lon = config.get(CONF_LONGITUDE, opp.config.longitude)
ATTR_FOLLOW = "following" ATTR_FOLLOW_SINCE = "following_since" ATTR_FOLLOWING = "followers" ATTR_VIEWS = "views" CONF_CHANNELS = "channels" ICON = "mdi:twitch" STATE_OFFLINE = "offline" STATE_STREAMING = "streaming" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_CLIENT_ID): cv.string, vol.Required(CONF_CHANNELS): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_TOKEN): cv.string, }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the Twitch platform.""" channels = config[CONF_CHANNELS] client_id = config[CONF_CLIENT_ID] oauth_token = config.get(CONF_TOKEN) client = TwitchClient(client_id, oauth_token) try: client.ingests.get_server_list() except HTTPError:
STATE_SPRING: STATE_AUTUMN, STATE_AUTUMN: STATE_SPRING, STATE_SUMMER: STATE_WINTER, } SEASON_ICONS = { STATE_SPRING: "mdi:flower", STATE_SUMMER: "mdi:sunglasses", STATE_AUTUMN: "mdi:leaf", STATE_WINTER: "mdi:snowflake", } PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Optional(CONF_TYPE, default=TYPE_ASTRONOMICAL): vol.In(VALID_TYPES), vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, } ) def setup_platform(opp, config, add_entities, discovery_info=None): """Display the current season.""" if None in (opp.config.latitude, opp.config.longitude): _LOGGER.error("Latitude or longitude not set in Open Peer Power config") return False latitude = util.convert(opp.config.latitude, float) _type = config.get(CONF_TYPE) name = config.get(CONF_NAME) if latitude < 0:
"type": SENSOR_TYPE_ILLUMINANCE, }, { "path": "EDS0068/humidity", "name": "Humidity", "type": SENSOR_TYPE_HUMIDITY, }, ], } PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_NAMES): { cv.string: cv.string }, vol.Optional(CONF_MOUNT_DIR, default=DEFAULT_SYSBUS_MOUNT_DIR): cv.string, vol.Optional(CONF_HOST): cv.string, vol.Optional(CONF_PORT, default=DEFAULT_OWSERVER_PORT): cv.port, }) def get_sensor_types(device_sub_type: str) -> dict[str, Any]: """Return the proper info array for the device type.""" if "HobbyBoard" in device_sub_type: return HOBBYBOARD_EF if "EDS" in device_sub_type: return EDS_SENSORS return DEVICE_SENSORS
DEFAULT_NAME = "SHT31" DEFAULT_I2C_ADDRESS = 0x44 SENSOR_TEMPERATURE = "temperature" SENSOR_HUMIDITY = "humidity" SENSOR_TYPES = (SENSOR_TEMPERATURE, SENSOR_HUMIDITY) MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=10) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Optional(CONF_I2C_ADDRESS, default=DEFAULT_I2C_ADDRESS): vol.All( vol.Coerce(int), vol.Range(min=0x44, max=0x45) ), vol.Optional(CONF_MONITORED_CONDITIONS, default=list(SENSOR_TYPES)): vol.All( cv.ensure_list, [vol.In(SENSOR_TYPES)] ), vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, } ) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the sensor platform.""" i2c_address = config.get(CONF_I2C_ADDRESS) sensor = SHT31(address=i2c_address) try: if sensor.read_status() is None:
from pmsensor import serial_pm as pm import voluptuous as vol from openpeerpower.components.sensor import PLATFORM_SCHEMA from openpeerpower.const import CONF_NAME import openpeerpower.helpers.config_validation as cv from openpeerpower.helpers.entity import Entity _LOGGER = logging.getLogger(__name__) CONF_BRAND = "brand" CONF_SERIAL_DEVICE = "serial_device" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_BRAND): cv.string, vol.Required(CONF_SERIAL_DEVICE): cv.string, vol.Optional(CONF_NAME): cv.string, }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the available PM sensors.""" try: coll = pm.PMDataCollector(config.get(CONF_SERIAL_DEVICE), pm.SUPPORTED_SENSORS[config.get(CONF_BRAND)]) except KeyError: _LOGGER.error( "Brand %s not supported\n supported brands: %s", config.get(CONF_BRAND), pm.SUPPORTED_SENSORS.keys(), )
cond[CONF_DEVICE] = DEFAULT_DEVICE return config PLATFORM_SCHEMA = vol.Schema( vol.All( PLATFORM_SCHEMA.extend( { vol.Required(CONF_RESOURCE): cv.url, vol.Required(CONF_MONITORED_CONDITIONS): vol.All( cv.ensure_list, [ { vol.Required(CONF_SENSOR_TYPE): vol.In(SENSOR_TYPES), vol.Optional(CONF_SCOPE, default=DEFAULT_SCOPE): vol.In( SCOPE_TYPES ), vol.Optional(CONF_DEVICE): vol.All( vol.Coerce(int), vol.Range(min=0) ), } ], ), } ), _device_id_validator, ) ) async def async_setup_platform(opp, config, async_add_entities, discovery_info=None):
STATE_TALKING, UNKOWN_NAME, ) _LOGGER = logging.getLogger(__name__) SCAN_INTERVAL = timedelta(hours=3) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_HOST, default=DEFAULT_HOST): cv.string, vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port, vol.Optional(CONF_USERNAME, default=DEFAULT_USERNAME): cv.string, vol.Optional(CONF_PASSWORD): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_PHONEBOOK, default=DEFAULT_PHONEBOOK): cv.positive_int, vol.Optional(CONF_PREFIXES): vol.All(cv.ensure_list, [cv.string]), }) async def async_setup_platform(opp, config, async_add_entities, discovery_info=None): """Import the platform into a config entry.""" opp.async_create_task(
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_BASEOID): cv.string, vol.Optional(CONF_ACCEPT_ERRORS, default=False): cv.boolean, vol.Optional(CONF_COMMUNITY, default=DEFAULT_COMMUNITY): cv.string, vol.Optional(CONF_DEFAULT_VALUE): cv.string, vol.Optional(CONF_HOST, default=DEFAULT_HOST): cv.string, vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port, vol.Optional(CONF_UNIT_OF_MEASUREMENT): cv.string, vol.Optional(CONF_VALUE_TEMPLATE): cv.template, vol.Optional(CONF_VERSION, default=DEFAULT_VERSION): vol.In(SNMP_VERSIONS), vol.Optional(CONF_USERNAME): cv.string, vol.Optional(CONF_AUTH_KEY): cv.string, vol.Optional(CONF_AUTH_PROTOCOL, default=DEFAULT_AUTH_PROTOCOL): vol.In(MAP_AUTH_PROTOCOLS), vol.Optional(CONF_PRIV_KEY): cv.string, vol.Optional(CONF_PRIV_PROTOCOL, default=DEFAULT_PRIV_PROTOCOL): vol.In(MAP_PRIV_PROTOCOLS), })
} PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_HOST): cv.string, vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string, vol.Optional(CONF_MONITORED_VARIABLES, default=[]): vol.All( cv.ensure_list, [ vol.Schema({ vol.Required(CONF_NAME): cv.string, vol.Required(CONF_SENSOR_TYPE): vol.All(cv.string, vol.In(SENSOR_TYPES)), vol.Optional(CONF_UNIT_OF_MEASUREMENT): cv.string, vol.Optional(CONF_VALUE_TEMPLATE): cv.template, }) ], ), vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port, })
DEFAULT_RADIUS_IN_KM = 20.0 DEFAULT_UNIT_OF_MEASUREMENT = "Events" DOMAIN = "geo_rss_events" SCAN_INTERVAL = timedelta(minutes=5) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Required(CONF_URL): cv.string, vol.Optional(CONF_LATITUDE): cv.latitude, vol.Optional(CONF_LONGITUDE): cv.longitude, vol.Optional(CONF_RADIUS, default=DEFAULT_RADIUS_IN_KM): vol.Coerce(float), vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Optional(CONF_CATEGORIES, default=[]): vol.All(cv.ensure_list, [cv.string]), vol.Optional(CONF_UNIT_OF_MEASUREMENT, default=DEFAULT_UNIT_OF_MEASUREMENT): cv.string, }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the GeoRSS component.""" latitude = config.get(CONF_LATITUDE, opp.config.latitude) longitude = config.get(CONF_LONGITUDE, opp.config.longitude) url = config.get(CONF_URL)
from openpeerpower.components.sensor import PLATFORM_SCHEMA, SensorEntity from openpeerpower.const import ATTR_ATTRIBUTION, CONF_ADDRESS, CONF_NAME, CONF_TOKEN import openpeerpower.helpers.config_validation as cv ATTRIBUTION = "Data provided by etherscan.io" CONF_TOKEN_ADDRESS = "token_address" SCAN_INTERVAL = timedelta(minutes=5) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_ADDRESS): cv.string, vol.Optional(CONF_NAME): cv.string, vol.Optional(CONF_TOKEN): cv.string, vol.Optional(CONF_TOKEN_ADDRESS): cv.string, }) def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the Etherscan.io sensors.""" address = config.get(CONF_ADDRESS) name = config.get(CONF_NAME) token = config.get(CONF_TOKEN) token_address = config.get(CONF_TOKEN_ADDRESS) if token: token = token.upper()