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